environmentlogger.java

来自「RESIN 3.2 最新源码」· Java 代码 · 共 685 行 · 第 1/2 页

  }

  /**
   * Returns the use-parent-handlers
   */
  public boolean getUseParentHandlers()
  {
    Boolean value = _useParentHandlers.get();

    if (value != null)
      return Boolean.TRUE.equals(value);
    else
      return true;
  }

  /**
   * Sets the use-parent-handlers
   */
  public void setUseParentHandlers(boolean useParentHandlers)
  {
    _useParentHandlers.set(new Boolean(useParentHandlers));
  }

  /**
   * Classloader init callback
   */
  public void classLoaderInit(DynamicClassLoader env)
  {
  }

  /**
   * Classloader destroy callback
   */
  public void classLoaderDestroy(DynamicClassLoader loader)
  {
    removeLoader(loader);

    _localHandlers.remove(loader);

    HandlerEntry ownHandlers = _ownHandlers.getLevel(loader);
    if (ownHandlers != null)
      _ownHandlers.remove(loader);

    if (ownHandlers != null)
      ownHandlers.destroy();

    _localLevel.remove(loader);

    updateAssignedLevel();
    updateHandlerLevel();
  }

  /**
   * Application API to set the level.
   *
   * @param level the logging level to set for the logger.
   */
  public void setLevel(Level level)
  {
    _localLevel.set(level);
    
    if (level != null) {
      ClassLoader loader = Thread.currentThread().getContextClassLoader();

      addLoader(loader);
    }

    updateAssignedLevel();
  }

  /**
   * Adds a class loader to the list of dependency  loaders.
   */
  private void addLoader(ClassLoader loader)
  {
    boolean hasLoader = false;
    for (int i = _loaders.size() - 1; i >= 0; i--) {
      WeakReference<ClassLoader> ref = _loaders.get(i);
      ClassLoader refLoader = ref.get();

      if (refLoader == null)
        _loaders.remove(i);

      if (refLoader == loader)
	return;
    }

    _loaders.add(new WeakReference<ClassLoader>(loader));
    Environment.addClassLoaderListener(this, loader);
  }

  /**
   * Returns the logger's assigned level.
   */
  public Level getLevel()
  {
    if (_hasLocalLevel) {
      Level level = _localLevel.get();

      if (level != null) {
	return level;
      }
    }

    return null;
  }

  /**
   * Returns the assigned level, calculated through the normal
   * Logger rules, i.e. if unassigned, use the parent's value.
   */
  private Level getAssignedLevel()
  {
    for (Logger log = this; log != null; log = log.getParent()) {
      Level level = log.getLevel();

      if (level != null)
	return level;
    }

    return Level.INFO;
  }

  /**
   * Sets the level, updating any children.
   */
  private void setHandlerLevel(Level level)
  {
    if (_handlerLevel.intValue() <= level.intValue())
      return;

    _handlerLevel = level;
    
    setEffectiveLevel();

    synchronized (this) {
      for (int i = _children.size() - 1; i >= 0; i--) {
        WeakReference<EnvironmentLogger> ref = _children.get(i);
        EnvironmentLogger child = ref.get();

        if (child != null) {
	  // XXX: use parent handlers
          if (_handlerLevel.intValue() < child._handlerLevel.intValue())
            child.setHandlerLevel(level);
        }
        else
          _children.remove(i);
      }
    }
  }

  /**
   * Recalculate the dynamic assigned levels.
   */
  private synchronized void updateAssignedLevel()
  {
    Level oldAssignedLevel = _assignedLevel;
    
    _assignedLevel = Level.INFO;
    _hasLocalLevel = false;

    if (_parent != null) {
      _assignedLevel = _parent.getAssignedLevel();
    }

    for (int i = _loaders.size() - 1; i >= 0; i--) {
      WeakReference<ClassLoader> ref = _loaders.get(i);
      ClassLoader loader = ref.get();

      if (loader == null)
        _loaders.remove(i);

      for (; loader != null; loader = loader.getParent()) {
        if (loader instanceof EnvironmentClassLoader) {
          EnvironmentClassLoader envLoader = (EnvironmentClassLoader) loader;

	  updateClassLoaderLevel(envLoader);
        }
      }
      
      updateClassLoaderLevel(ClassLoader.getSystemClassLoader());
    }

    setEffectiveLevel();

    // If this level has become changed permission, need to update all children
    // since they may depend on this value
    if (oldAssignedLevel.intValue() != _assignedLevel.intValue()) {
      for (int i = _children.size() - 1; i >= 0; i--) {
        WeakReference<EnvironmentLogger> ref = _children.get(i);
        EnvironmentLogger child = ref.get();

        if (child != null)
          child.updateAssignedLevel();
        else
          _children.remove(i);
      }
    }
  }

  private void updateClassLoaderLevel(ClassLoader loader)
  {
    Level localLevel = _localLevel.get(loader);

    if (localLevel != null) {
      if (! _hasLocalLevel)
	_assignedLevel = localLevel;
      else if (localLevel.intValue() < _assignedLevel.intValue())
	_assignedLevel = localLevel;
	    
      _hasLocalLevel = true;
    }
  }

  /**
   * Recalculate the handler level levels.
   */
  private synchronized void updateHandlerLevel()
  {
    Level oldHandlerLevel = _handlerLevel;
    
    _handlerLevel = Level.OFF;

    if (_parent != null)
      _handlerLevel = _parent.getHandlerLevel();

    for (int i = _loaders.size() - 1; i >= 0; i--) {
      WeakReference<ClassLoader> ref = _loaders.get(i);
      ClassLoader loader = ref.get();

      if (loader == null)
        _loaders.remove(i);

      for (; loader != null; loader = loader.getParent()) {
        if (loader instanceof EnvironmentClassLoader) {
          EnvironmentClassLoader envLoader = (EnvironmentClassLoader) loader;
	  
          Handler []handlers = _localHandlers.getLevel(envLoader);

          for (int j = 0; handlers != null && j < handlers.length; j++) {
            if (handlers[j].getLevel() != null) {
              Level subLevel = handlers[j].getLevel();

	      if (subLevel.intValue() < _handlerLevel.intValue())
		_handlerLevel = subLevel;
            }
          }
        }
      }
    }

    setEffectiveLevel();

    // If this level has become less permissive, need to update all children
    // since they may depend on this value
    if (oldHandlerLevel.intValue() < _handlerLevel.intValue()) {
      for (int i = _children.size() - 1; i >= 0; i--) {
        WeakReference<EnvironmentLogger> ref = _children.get(i);
        EnvironmentLogger child = ref.get();

        if (child != null)
          child.updateHandlerLevel();
        else
          _children.remove(i);
      }
    }
  }

  /**
   * Sets the static effective logging level.  Use the coarsest level.
   */
  private void setEffectiveLevel()
  {
    if (_handlerLevel.intValue() < _assignedLevel.intValue())
      super.setLevel(_assignedLevel);
    else
      super.setLevel(_handlerLevel);
  }

  /**
   * Removes the specified loader.
   */
  private synchronized void removeLoader(ClassLoader loader)
  {
    int i;
    for (i = _loaders.size() - 1; i >= 0; i--) {
      WeakReference<ClassLoader> ref = _loaders.get(i);
      ClassLoader refLoader = ref.get();

      if (refLoader == null)
        _loaders.remove(i);
      else if (refLoader == loader)
        _loaders.remove(i);
    }
  }

  public String toString()
  {
    return "EnvironmentLogger[" + getName() + "]";
  }

  /**
   * Encapsulates the handler for this logger, keeping a reference in
   * the local environment to avoid GC.
   */
  static class HandlerEntry {
    private final EnvironmentLogger _logger;
    private ArrayList<Handler> _handlers = new ArrayList<Handler>();

    HandlerEntry(EnvironmentLogger logger)
    {
      _logger = logger;
    }

    void addHandler(Handler handler)
    {
      _handlers.add(handler);
    }

    void removeHandler(Handler handler)
    {
      _handlers.remove(handler);
    }

    void destroy()
    {
      ArrayList<Handler> handlers = _handlers;
      _handlers = null;
      
      for (int i = 0; handlers != null && i < handlers.size(); i++) {
	Handler handler = handlers.get(i);

	try {
	  handler.close();
	} catch (Throwable e) {
	  e.printStackTrace();
	}
      }
    }
  }
}