/**
* Converts a standard or custom priority level to a Level object.
*
* <p>If <code>value</code> is of form "level#classname", then the specified class' toLevel method
* is called to process the specified level string; if no '#' character is present, then the
* default {@link org.apache.log4j.Level} class is used to process the level value.
*
* <p>As a special case, if the <code>value</code> parameter is equal to the string "NULL", then
* the value <code>null</code> will be returned.
*
* <p>If any error occurs while converting the value to a level, the <code>defaultValue</code>
* parameter, which may be <code>null</code>, is returned.
*
* <p>Case of <code>value</code> is insignificant for the level level, but is significant for the
* class name part, if present.
*
* @since 1.1
*/
public static Level toLevel(String value, Level defaultValue) {
if (value == null) return defaultValue;
value = value.trim();
int hashIndex = value.indexOf('#');
if (hashIndex == -1) {
if ("NULL".equalsIgnoreCase(value)) {
return null;
} else {
// no class name specified : use standard Level class
return (Level) Level.toLevel(value, defaultValue);
}
}
Level result = defaultValue;
String clazz = value.substring(hashIndex + 1);
String levelName = value.substring(0, hashIndex);
// This is degenerate case but you never know.
if ("NULL".equalsIgnoreCase(levelName)) {
return null;
}
LogLog.debug("toLevel" + ":class=[" + clazz + "]" + ":pri=[" + levelName + "]");
try {
Class customLevel = Loader.loadClass(clazz);
// get a ref to the specified class' static method
// toLevel(String, org.apache.log4j.Level)
Class[] paramTypes = new Class[] {String.class, org.apache.log4j.Level.class};
java.lang.reflect.Method toLevelMethod = customLevel.getMethod("toLevel", paramTypes);
// now call the toLevel method, passing level string + default
Object[] params = new Object[] {levelName, defaultValue};
Object o = toLevelMethod.invoke(null, params);
result = (Level) o;
} catch (ClassNotFoundException e) {
LogLog.warn("custom level class [" + clazz + "] not found.");
} catch (NoSuchMethodException e) {
LogLog.warn(
"custom level class ["
+ clazz
+ "]"
+ " does not have a constructor which takes one string parameter",
e);
} catch (java.lang.reflect.InvocationTargetException e) {
LogLog.warn("custom level class [" + clazz + "]" + " could not be instantiated", e);
} catch (ClassCastException e) {
LogLog.warn("class [" + clazz + "] is not a subclass of org.apache.log4j.Level", e);
} catch (IllegalAccessException e) {
LogLog.warn("class [" + clazz + "] cannot be instantiated due to access restrictions", e);
} catch (Exception e) {
LogLog.warn("class [" + clazz + "], level [" + levelName + "] conversion failed.", e);
}
return result;
}
/**
* Very similar to <code>System.getProperty</code> except that the {@link SecurityException} is
* hidden.
*
* @param key The key to search for.
* @param def The default value to return.
* @return the string value of the system property, or the default value if there is no property
* with that key.
* @since 1.1
*/
public static String getSystemproperty(String key, String def) {
try {
return System.getProperty(key, def);
} catch (Throwable e) { // MS-Java throws com.ms.security.SecurityExceptionEx
LogLog.debug("Was not allowed to read system property \"" + key + "\".");
return def;
}
}
/**
* This method will search for <code>resource</code> in different places. The search order is as
* follows:
*
* <ol>
* <p>
* <li>Search for <code>resource</code> using the thread context class loader under Java2. If
* that fails, search for <code>resource</code> using the class loader that loaded this
* class (<code>Loader</code>). Under JDK 1.1, only the the class loader that loaded this
* class (<code>Loader</code>) is used.
* <p>
* <li>Try one last time with <code>ClassLoader.getSystemResource(resource)</code>, that is is
* using the system class loader in JDK 1.2 and virtual machine's built-in class loader in
* JDK 1.1.
* </ol>
*/
public static URL getResource(String resource) {
ClassLoader classLoader = null;
URL url = null;
try {
if (!java1) {
classLoader = getTCL();
if (classLoader != null) {
LogLog.debug(
"Trying to find [" + resource + "] using context classloader " + classLoader + ".");
url = classLoader.getResource(resource);
if (url != null) {
return url;
}
}
}
// We could not find resource. Ler us now try with the
// classloader that loaded this class.
classLoader = Loader.class.getClassLoader();
if (classLoader != null) {
LogLog.debug("Trying to find [" + resource + "] using " + classLoader + " class loader.");
url = classLoader.getResource(resource);
if (url != null) {
return url;
}
}
} catch (Throwable t) {
LogLog.warn(TSTR, t);
}
// Last ditch attempt: get the resource from the class path. It
// may be the case that clazz was loaded by the Extentsion class
// loader which the parent of the system class loader. Hence the
// code below.
LogLog.debug("Trying to find [" + resource + "] using ClassLoader.getSystemResource().");
return ClassLoader.getSystemResource(resource);
}
/**
* Configure log4j given a URL.
*
* <p>The url must point to a file or resource which will be interpreted by a new instance of a
* log4j configurator.
*
* <p>All configurations steps are taken on the <code>hierarchy</code> passed as a parameter.
*
* <p>
*
* @param url The location of the configuration file or resource.
* @param clazz The classname, of the log4j configurator which will parse the file or resource at
* <code>url</code>. This must be a subclass of {@link Configurator}, or null. If this value
* is null then a default configurator of {@link PropertyConfigurator} is used, unless the
* filename pointed to by <code>url</code> ends in '.xml', in which case {@link
* org.apache.log4j.xml.DOMConfigurator} is used.
* @param hierarchy The {@link org.apache.log4j.Hierarchy} to act on.
* @since 1.1.4
*/
public static void selectAndConfigure(URL url, String clazz, LoggerRepository hierarchy) {
Configurator configurator = null;
String filename = url.getFile();
if (clazz == null && filename != null && filename.endsWith(".xml")) {
clazz = "org.apache.log4j.xml.DOMConfigurator";
}
if (clazz != null) {
LogLog.debug("Preferred configurator class: " + clazz);
configurator = (Configurator) instantiateByClassName(clazz, Configurator.class, null);
if (configurator == null) {
LogLog.error("Could not instantiate configurator [" + clazz + "].");
return;
}
} else {
configurator = new PropertyConfigurator();
}
configurator.doConfigure(url, hierarchy);
}
protected void checkAndConfigure() {
boolean fileExists;
try {
fileExists = file.exists();
} catch (SecurityException e) {
LogLog.warn("Was not allowed to read check file existance, file:[" + filename + "].");
interrupted = true; // there is no point in continuing
return;
}
if (fileExists) {
long l = file.lastModified(); // this can also throw a SecurityException
if (l > lastModif) { // however, if we reached this point this
lastModif = l; // is very unlikely.
doOnChange();
warnedAlready = false;
}
} else {
if (!warnedAlready) {
LogLog.debug("[" + filename + "] does not exist.");
warnedAlready = true;
}
}
}
void dump() {
LogLog.debug("min=" + min + ", max=" + max + ", leftAlign=" + leftAlign);
}
