environmentlogger.java

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

/*
 * Copyright (c) 1998-2008 Caucho Technology -- all rights reserved
 *
 * This file is part of Resin(R) Open Source
 *
 * Each copy or derived work must preserve the copyright notice and this
 * notice unmodified.
 *
 * Resin Open Source is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * Resin Open Source is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, or any warranty
 * of NON-INFRINGEMENT.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Resin Open Source; if not, write to the
 *
 *   Free Software Foundation, Inc.
 *   59 Temple Place, Suite 330
 *   Boston, MA 02111-1307  USA
 *
 * @author Scott Ferguson
 */

package com.caucho.log;

import com.caucho.loader.ClassLoaderListener;
import com.caucho.loader.DynamicClassLoader;
import com.caucho.loader.Environment;
import com.caucho.loader.EnvironmentClassLoader;
import com.caucho.loader.EnvironmentLocal;

import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.logging.Logger;

/**
 * Proxy logger that understands the environment.
 */
class EnvironmentLogger extends Logger implements ClassLoaderListener {
  // The custom local handlers
  private final EnvironmentLocal<Logger> _localLoggers
    = new EnvironmentLocal<Logger>();
  
  // The environment handlers for the Logger
  private final EnvironmentLocal<Handler[]> _localHandlers
    = new EnvironmentLocal<Handler[]>();
  
  // The environment handlers owned by the Logger
  private final EnvironmentLocal<HandlerEntry> _ownHandlers
    = new EnvironmentLocal<HandlerEntry>();

  // The use-parent-handlers value
  private final EnvironmentLocal<Boolean> _useParentHandlers
    = new EnvironmentLocal<Boolean>();

  private boolean _hasLocalLevel;
  
  // Application level override
  private final EnvironmentLocal<Level> _localLevel
    = new EnvironmentLocal<Level>();

  private EnvironmentLogger _parent;

  // The finest assigned level accessible from this logger
  private Level _assignedLevel = Level.INFO;
  
  // The finest handler level accessible from this logger
  private Level _handlerLevel = Level.OFF;

  // Can be a weak reference because any configuration in an
  // environment will be held in the EnvironmentLocal.
  private final ArrayList<WeakReference<EnvironmentLogger>> _children
    = new ArrayList<WeakReference<EnvironmentLogger>>();
  
  // Weak list of all the class loaders
  private final ArrayList<WeakReference<ClassLoader>> _loaders
    = new ArrayList<WeakReference<ClassLoader>>();
  
  public EnvironmentLogger(String name, String resourceBundleName)
  {
    super(name, resourceBundleName);
  }

  /**
   * Sets the logger's parent.  This should only be called by the LogManager
   * code.
   */
  public void setParent(Logger parent)
  {
    if (parent.equals(_parent))
      return;
    
    super.setParent(parent);

    if (parent instanceof EnvironmentLogger) {
      _parent = (EnvironmentLogger) parent;

      _assignedLevel = _parent.getAssignedLevel();
      _handlerLevel = _parent.getHandlerLevel();

      setEffectiveLevel();
      
      _parent.addChild(this);
    }
  }

  private Level getHandlerLevel()
  {
    return _handlerLevel;
  }

  /**
   * Adds a new logger as a child, triggered by a setParent.
   */
  void addChild(EnvironmentLogger child)
  {
    _children.add(new WeakReference<EnvironmentLogger>(child));
  }

  /**
   * Adds a handler.
   */
  public synchronized void addHandler(Handler handler)
  {
    ClassLoader loader = Thread.currentThread().getContextClassLoader();

    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)
        hasLoader = true;

      if (isParentLoader(loader, refLoader))
        addHandler(handler, refLoader);
    }

    if (! hasLoader) {
      _loaders.add(new WeakReference<ClassLoader>(loader));
      addHandler(handler, loader);
      Environment.addClassLoaderListener(this, loader);
    }

    HandlerEntry ownHandlers = _ownHandlers.get();
    if (ownHandlers == null) {
      ownHandlers = new HandlerEntry(this);
      _ownHandlers.set(ownHandlers);
    }
    
    ownHandlers.addHandler(handler);
  }

  /**
   * Adds a new handler with a given classloader context.
   */
  private void addHandler(Handler handler, ClassLoader loader)
  {
    // handlers ordered by level
    ArrayList<Handler> handlers = new ArrayList<Handler>();

    handlers.add(handler);

    for (ClassLoader ptr = loader; ptr != null; ptr = ptr.getParent()) {
      Handler []localHandlers = _localHandlers.getLevel(ptr);

      if (localHandlers != null) {
        for (int i = 0; i < localHandlers.length; i++) {
	  int p = handlers.indexOf(localHandlers[i]);

	  if (p < 0) {
	    handlers.add(localHandlers[i]);
	  }
	  else {
	    Handler oldHandler = handlers.get(p);

	    if (localHandlers[i].getLevel().intValue()
		< oldHandler.getLevel().intValue()) {
	      handlers.set(p, localHandlers[i]);
	    }
	  }
        }
      }
    }

    Handler []newHandlers = new Handler[handlers.size()];
    handlers.toArray(newHandlers);

    _localHandlers.set(newHandlers);

    setHandlerLevel(handler.getLevel());
  }

  /**
   * Removes a handler.
   */
  public synchronized void removeHandler(Handler handler)
  {
    ClassLoader loader = Thread.currentThread().getContextClassLoader();

    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 (isParentLoader(loader, refLoader))
        removeHandler(handler, refLoader);
    }

    HandlerEntry ownHandlers = _ownHandlers.get();
    if (ownHandlers != null)
      ownHandlers.removeHandler(handler);
  }

  private void removeHandler(Handler handler, ClassLoader loader)
  {
    ArrayList<Handler> handlers = new ArrayList<Handler>();

    for (ClassLoader ptr = loader; ptr != null; ptr = ptr.getParent()) {
      Handler []localHandlers = _localHandlers.getLevel(ptr);

      if (localHandlers != null) {
        for (int i = 0; i < localHandlers.length; i++) {
	  if (! localHandlers[i].equals(handler)) {
	    int p = handlers.indexOf(localHandlers[i]);

	    if (p < 0) {
	      handlers.add(localHandlers[i]);
	    }
	    else {
	      Handler oldHandler = handlers.get(p);

	      if (localHandlers[i].getLevel().intValue()
		  < oldHandler.getLevel().intValue()) {
		handlers.set(p, localHandlers[i]);
	      }
	    }
	  }
        }
      }
    }

    Handler []newHandlers = new Handler[handlers.size()];
    handlers.toArray(newHandlers);

    _localHandlers.set(newHandlers);

    setHandlerLevel(handler.getLevel());
  }

  /**
   * Returns true if 'parent' is a parent classloader of 'child'.
   *
   * @param parent the classloader to test as a parent.
   * @param child the classloader to test as a child.
   */
  private boolean isParentLoader(ClassLoader parent, ClassLoader child)
  {
    for (; child != null; child = child.getParent()) {
      if (child == parent)
        return true;
    }

    return false;
  }

  /**
   * Sets a custom logger if possible
   */
  boolean addLogger(Logger logger)
  {
    if (logger.getClass().getName().startsWith("java"))
      return false;
    
    Logger oldLogger = _localLoggers.get();

    if (oldLogger != null)
      return false;

    _localLoggers.set(logger);
    //logger.setParent(_parent);

    return true;
  }

  /**
   * Gets the custom logger if possible
   */
  Logger getLogger()
  {
    return _localLoggers.get();
  }

  /**
   * Logs the message.
   */
  public void log(LogRecord record)
  {
    if (record == null)
      return;
    
    if (_hasLocalLevel) {
      Level level = _localLevel.get();

      if (level != null && record.getLevel().intValue() < level.intValue())
	return;
    }

    for (Logger ptr = this; ptr != null; ptr = ptr.getParent()) {
      Handler handlers[] = ptr.getHandlers();

      if (handlers != null) {
	for (int i = 0; i < handlers.length; i++) {
	  handlers[i].publish(record);
	}
      }

      if (! ptr.getUseParentHandlers())
	break;
    }
  }

  /**
   * Returns the handlers.
   */
  public Handler []getHandlers()
  {
    return _localHandlers.get();