LogManager maintains a hierarchical namespace
* of Logger objects and manages properties for configuring the logging
* framework. There exists only one single LogManager
* per virtual machine. This instance can be retrieved using the
* static method {@link #getLogManager()}.
*
* Configuration Process: The global LogManager
* object is created and configured when the class
* java.util.logging.LogManager is initialized.
* The configuration process includes the subsequent steps:
*
*
java.util.logging.manager
* is set to the name of a subclass of
* java.util.logging.LogManager, an instance of
* that subclass is created and becomes the global LogManager.
* Otherwise, a new instance of LogManager is created.LogManager constructor tries to create
* a new instance of the class specified by the system
* property java.util.logging.config.class.
* Typically, the constructor of this class will call
* LogManager.getLogManager().readConfiguration(java.io.InputStream)
* for configuring the logging framework.
* The configuration process stops at this point if
* the system property java.util.logging.config.class
* is set (irrespective of whether the class constructor
* could be called or an exception was thrown).java.util.logging.config.class
* is not set, the configuration parameters are read in from
* a file and passed to
* {@link #readConfiguration(java.io.InputStream)}.
* The name and location of this file are specified by the system
* property java.util.logging.config.file.java.util.logging.config.file
* is not set, however, the contents of the URL
* "{gnu.classpath.home.url}/logging.properties" are passed to
* {@link #readConfiguration(java.io.InputStream)}.
* Here, "{gnu.classpath.home.url}" stands for the value of
* the system property gnu.classpath.home.url.listener has not been registered previously,
* nothing happens. Also, no exception is thrown if
* listener is null.
*/
public synchronized void removePropertyChangeListener(PropertyChangeListener listener)
{
if (listener != null)
pcs.removePropertyChangeListener(listener);
}
/**
* Adds a named logger. If a logger with the same name has
* already been registered, the method returns false
* without adding the logger.
*
* The The task of configuring the framework is then delegated to
* {@link #readConfiguration(java.io.InputStream)}, which will
* notify registered listeners after having read the properties.
*
* @throws SecurityException if a security manager exists and
* the caller is not granted the permission to control
* the logging infrastructure, or if the caller is
* not granted the permission to read the configuration
* file.
*
* @throws IOException if there is a problem reading in the
* configuration file.
*/
public synchronized void readConfiguration()
throws IOException, SecurityException
{
String path;
InputStream inputStream;
path = System.getProperty("java.util.logging.config.file");
if ((path == null) || (path.length() == 0))
{
String url = (System.getProperty("gnu.classpath.home.url")
+ "/logging.properties");
inputStream = new URL(url).openStream();
}
else
{
inputStream = new java.io.FileInputStream(path);
}
try
{
readConfiguration(inputStream);
}
finally
{
/* Close the stream in order to save
* resources such as file descriptors.
*/
inputStream.close();
}
}
public synchronized void readConfiguration(InputStream inputStream)
throws IOException, SecurityException
{
Properties newProperties;
Enumeration keys;
checkAccess();
newProperties = new Properties();
newProperties.load(inputStream);
this.properties = newProperties;
keys = newProperties.propertyNames();
while (keys.hasMoreElements())
{
String key = (String) keys.nextElement();
String value = newProperties.getProperty(key);
if (value == null)
continue;
if (key.endsWith(".level"))
{
String loggerName = key.substring(0, key.length() - 6);
Logger logger = getLogger(loggerName);
if (logger != null)
{
try
{
logger.setLevel(Level.parse(value));
}
catch (Exception _)
{
}
continue;
}
}
}
/* The API specification does not talk about the
* property name that is distributed with the
* PropertyChangeEvent. With test code, it could
* be determined that the Sun J2SE 1.4 reference
* implementation uses null for the property name.
*/
pcs.firePropertyChange(null, null, null);
}
/**
* Returns the value of a configuration property as a String.
*/
public synchronized String getProperty(String name)
{
if (properties != null)
return properties.getProperty(name);
else
return null;
}
/**
* Returns the value of a configuration property as an integer.
* This function is a helper used by the Classpath implementation
* of java.util.logging, it is not specified in the
* logging API.
*
* @param name the name of the configuration property.
*
* @param defaultValue the value that will be returned if the
* property is not defined, or if its value is not an integer
* number.
*/
static int getIntProperty(String name, int defaultValue)
{
try
{
return Integer.parseInt(getLogManager().getProperty(name));
}
catch (Exception ex)
{
return defaultValue;
}
}
/**
* Returns the value of a configuration property as an integer,
* provided it is inside the acceptable range.
* This function is a helper used by the Classpath implementation
* of java.util.logging, it is not specified in the
* logging API.
*
* @param name the name of the configuration property.
*
* @param minValue the lowest acceptable value.
*
* @param maxValue the highest acceptable value.
*
* @param defaultValue the value that will be returned if the
* property is not defined, or if its value is not an integer
* number, or if it is less than the minimum value,
* or if it is greater than the maximum value.
*/
static int getIntPropertyClamped(String name, int defaultValue,
int minValue, int maxValue)
{
int val = getIntProperty(name, defaultValue);
if ((val < minValue) || (val > maxValue))
val = defaultValue;
return val;
}
/**
* Returns the value of a configuration property as a boolean.
* This function is a helper used by the Classpath implementation
* of java.util.logging, it is not specified in the
* logging API.
*
* @param name the name of the configuration property.
*
* @param defaultValue the value that will be returned if the
* property is not defined, or if its value is neither
* LogManager only keeps weak references
* to registered loggers. Therefore, names can become available
* after automatic garbage collection.
*
* @param logger the logger to be added.
*
* @return trueif logger was added,
* false otherwise.
*
* @throws NullPointerException if name is
* null.
*/
public synchronized boolean addLogger(Logger logger)
{
/* To developers thinking about to remove the 'synchronized'
* declaration from this method: Please read the comment
* in java.util.logging.Logger.getLogger(String, String)
* and make sure that whatever you change wrt. synchronization
* does not endanger thread-safety of Logger.getLogger.
* The current implementation of Logger.getLogger assumes
* that LogManager does its synchronization on the globally
* shared instance of LogManager.
*/
String name;
WeakReference ref;
/* This will throw a NullPointerException if logger is null,
* as required by the API specification.
*/
name = logger.getName();
ref = (WeakReference) loggers.get(name);
if (ref != null)
{
if (ref.get() != null)
return false;
/* There has been a logger under this name in the past,
* but it has been garbage collected.
*/
loggers.remove(ref);
}
/* Adding a named logger requires a security permission. */
if ((name != null) && !name.equals(""))
checkAccess();
Logger parent = findAncestor(logger);
loggers.put(name, new WeakReference(logger));
if (parent != logger.getParent())
logger.setParent(parent);
/* It can happen that existing loggers should be children of
* the newly added logger. For example, assume that there
* already exist loggers under the names "", "foo", and "foo.bar.baz".
* When adding "foo.bar", the logger "foo.bar.baz" should change
* its parent to "foo.bar".
*/
if (parent != rootLogger)
{
for (Iterator iter = loggers.keySet().iterator(); iter.hasNext();)
{
Logger possChild = (Logger) ((WeakReference) loggers.get(iter.next())).get();
if ((possChild == null) || (possChild == logger) || (possChild.getParent() != parent))
continue;
if (!possChild.getName().startsWith(name))
continue;
if (possChild.getName().charAt(name.length()) != '.')
continue;
possChild.setParent(logger);
}
}
return true;
}
/**
* Finds the closest ancestor for a logger among the currently
* registered ones. For example, if the currently registered
* loggers have the names "", "foo", and "foo.bar", the result for
* "foo.bar.baz" will be the logger whose name is "foo.bar".
*
* @param child a logger for whose name no logger has been
* registered.
*
* @return the closest ancestor for child,
* or null if child
* is the root logger.
*
* @throws NullPointerException if child
* is null.
*/
private synchronized Logger findAncestor(Logger child)
{
String childName = child.getName();
Logger best = rootLogger;
int bestNameLength = 0;
Logger cand;
String candName;
int candNameLength;
if (child == rootLogger)
return null;
for (Iterator iter = loggers.keySet().iterator(); iter.hasNext();)
{
candName = (String) iter.next();
candNameLength = candName.length();
if ((candNameLength > bestNameLength)
&& childName.startsWith(candName)
&& (childName.charAt(candNameLength) == '.'))
{
cand = (Logger) ((WeakReference) loggers.get(candName)).get();
if ((cand == null) || (cand == child))
continue;
bestNameLength = candName.length();
best = cand;
}
}
return best;
}
/**
* Returns a Logger given its name.
*
* @param name the name of the logger.
*
* @return a named Logger, or null if there is no
* logger with that name.
*
* @throw java.lang.NullPointerException if name
* is null.
*/
public synchronized Logger getLogger(String name)
{
WeakReference ref;
/* Throw a NullPointerException if name is null. */
name.getClass();
ref = (WeakReference) loggers.get(name);
if (ref != null)
return (Logger) ref.get();
else
return null;
}
/**
* Returns an Enumeration of currently registered Logger names.
* Since other threads can register loggers at any time, the
* result could be different any time this method is called.
*
* @return an Enumeration with the names of the currently
* registered Loggers.
*/
public synchronized Enumeration getLoggerNames()
{
return Collections.enumeration(loggers.keySet());
}
/**
* Resets the logging configuration by removing all handlers for
* registered named loggers and setting their level to null.
* The level of the root logger will be set to Level.INFO.
*
* @throws SecurityException if a security manager exists and
* the caller is not granted the permission to control
* the logging infrastructure.
*/
public synchronized void reset()
throws SecurityException
{
/* Throw a SecurityException if the caller does not have the
* permission to control the logging infrastructure.
*/
checkAccess();
properties = new Properties();
Iterator iter = loggers.values().iterator();
while (iter.hasNext())
{
WeakReference ref;
Logger logger;
ref = (WeakReference) iter.next();
if (ref != null)
{
logger = (Logger) ref.get();
if (logger == null)
iter.remove();
else if (logger != rootLogger)
logger.setLevel(null);
}
}
rootLogger.setLevel(Level.INFO);
}
/**
* Configures the logging framework by reading a configuration file.
* The name and location of this file are specified by the system
* property java.util.logging.config.file. If this
* property is not set, the URL
* "{gnu.classpath.home.url}/logging.properties" is taken, where
* "{gnu.classpath.home.url}" stands for the value of the system
* property gnu.classpath.home.url.
*
* "true" nor "false".
*/
static boolean getBooleanProperty(String name, boolean defaultValue)
{
try
{
return (new Boolean(getLogManager().getProperty(name)))
.booleanValue();
}
catch (Exception ex)
{
return defaultValue;
}
}
/**
* Returns the value of a configuration property as a Level.
* This function is a helper used by the Classpath implementation
* of java.util.logging, it is not specified in the
* logging API.
*
* @param propertyName the name of the configuration property.
*
* @param defaultValue the value that will be returned if the
* property is not defined, or if
* {@link Level.parse(java.lang.String)} does not like
* the property value.
*/
static Level getLevelProperty(String propertyName, Level defaultValue)
{
try
{
return Level.parse(getLogManager().getProperty(propertyName));
}
catch (Exception ex)
{
return defaultValue;
}
}
/**
* Returns the value of a configuration property as a Class.
* This function is a helper used by the Classpath implementation
* of java.util.logging, it is not specified in the
* logging API.
*
* @param propertyName the name of the configuration property.
*
* @param defaultValue the value that will be returned if the
* property is not defined, or if it does not specify
* the name of a loadable class.
*/
static final Class getClassProperty(String propertyName, Class defaultValue)
{
Class usingClass = null;
try
{
String propertyValue = logManager.getProperty(propertyName);
if (propertyValue != null)
usingClass = Class.forName(propertyValue);
if (usingClass != null)
return usingClass;
}
catch (Exception _)
{
}
return defaultValue;
}
static final Object getInstanceProperty(String propertyName,
Class ofClass,
Class defaultClass)
{
Class klass = getClassProperty(propertyName, defaultClass);
if (klass == null)
return null;
try
{
Object obj = klass.newInstance();
if (ofClass.isInstance(obj))
return obj;
}
catch (Exception _)
{
}
if (defaultClass == null)
return null;
try
{
return defaultClass.newInstance();
}
catch (java.lang.InstantiationException ex)
{
throw new RuntimeException(ex.getMessage());
}
catch (java.lang.IllegalAccessException ex)
{
throw new RuntimeException(ex.getMessage());
}
}
/**
* An instance of LoggingPermission("control")
* that is shared between calls to checkAccess().
*/
private static final LoggingPermission controlPermission
= new LoggingPermission("control", null);
/**
* Checks whether the current security context allows changing
* the configuration of the logging framework. For the security
* context to be trusted, it has to be granted
* a LoggingPermission("control").
*
* @throws SecurityException if a security manager exists and
* the caller is not granted the permission to control
* the logging infrastructure.
*/
public void checkAccess()
throws SecurityException
{
SecurityManager sm = System.getSecurityManager();
if (sm != null)
sm.checkPermission(controlPermission);
}
/**
* Creates a new instance of a class specified by name.
*
* @param className the name of the class of which a new instance
* should be created.
*
* @param ofClass the class to which the new instance should
* be either an instance or an instance of a subclass.
* FIXME: This description is just terrible.
*
* @return the new instance, or null if
* className is null, if no class
* with that name could be found, if there was an error
* loading that class, or if the constructor of the class
* has thrown an exception.
*/
static final Object createInstance(String className, Class ofClass)
{
Class klass;
if ((className == null) || (className.length() == 0))
return null;
try
{
klass = Class.forName(className);
if (!ofClass.isAssignableFrom(klass))
return null;
return klass.newInstance();
}
catch (Exception _)
{
return null;
}
catch (java.lang.LinkageError _)
{
return null;
}
}
}