org.apache.logging.log4j.core.util.OptionConverter Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of log4j-core Show documentation
Show all versions of log4j-core Show documentation
The Apache Log4j Implementation
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache license, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the license for the specific language governing permissions and
* limitations under the license.
*/
package org.apache.logging.log4j.core.util;
import java.io.InterruptedIOException;
import java.util.Locale;
import java.util.Properties;
import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.core.lookup.StrSubstitutor;
import org.apache.logging.log4j.status.StatusLogger;
/**
* A convenience class to convert property values to specific types.
*/
public final class OptionConverter {
private static final Logger LOGGER = StatusLogger.getLogger();
private static final int ONE_K = 1024;
/**
* OptionConverter is a static class.
*/
private OptionConverter() {
}
public static String[] concatenateArrays(final String[] l, final String[] r) {
final int len = l.length + r.length;
final String[] a = new String[len];
System.arraycopy(l, 0, a, 0, l.length);
System.arraycopy(r, 0, a, l.length, r.length);
return a;
}
public static String convertSpecialChars(final String s) {
char c;
final int len = s.length();
final StringBuilder sbuf = new StringBuilder(len);
int i = 0;
while (i < len) {
c = s.charAt(i++);
if (c == '\\') {
c = s.charAt(i++);
switch (c) {
case 'n':
c = '\n';
break;
case 'r':
c = '\r';
break;
case 't':
c = '\t';
break;
case 'f':
c = '\f';
break;
case 'b':
c = '\b';
break;
case '"':
c = '\"';
break;
case '\'':
c = '\'';
break;
case '\\':
c = '\\';
break;
default:
// there is no default case.
}
}
sbuf.append(c);
}
return sbuf.toString();
}
public static Object instantiateByKey(final Properties props, final String key, final Class superClass,
final Object defaultValue) {
// Get the value of the property in string form
final String className = findAndSubst(key, props);
if (className == null) {
LOGGER.error("Could not find value for key {}", key);
return defaultValue;
}
// Trim className to avoid trailing spaces that cause problems.
return OptionConverter.instantiateByClassName(className.trim(), superClass,
defaultValue);
}
/**
* If value is "true", then {@code true} is
* returned. If value is "false", then
* {@code false} is returned. Otherwise, default is
* returned.
*
* Case of value is unimportant.
* @param value The value to convert.
* @param defaultValue The default value.
* @return true or false, depending on the value and/or default.
*/
public static boolean toBoolean(final String value, final boolean defaultValue) {
if (value == null) {
return defaultValue;
}
final String trimmedVal = value.trim();
if ("true".equalsIgnoreCase(trimmedVal)) {
return true;
}
if ("false".equalsIgnoreCase(trimmedVal)) {
return false;
}
return defaultValue;
}
/**
* Convert the String value to an int.
* @param value The value as a String.
* @param defaultValue The default value.
* @return The value as an int.
*/
public static int toInt(final String value, final int defaultValue) {
if (value != null) {
final String s = value.trim();
try {
return Integer.parseInt(s);
} catch (final NumberFormatException e) {
LOGGER.error("[{}] is not in proper int form.", s, e);
}
}
return defaultValue;
}
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;
}
// no class name specified : use standard Level class
return 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;
}
LOGGER.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, 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) {
LOGGER.warn("custom level class [" + clazz + "] not found.");
} catch(NoSuchMethodException e) {
LOGGER.warn("custom level class [" + clazz + "]"
+ " does not have a class function toLevel(String, Level)", e);
} catch(java.lang.reflect.InvocationTargetException e) {
if (e.getTargetException() instanceof InterruptedException
|| e.getTargetException() instanceof InterruptedIOException) {
Thread.currentThread().interrupt();
}
LOGGER.warn("custom level class [" + clazz + "]" + " could not be instantiated", e);
} catch(ClassCastException e) {
LOGGER.warn("class [" + clazz + "] is not a subclass of org.apache.log4j.Level", e);
} catch(IllegalAccessException e) {
LOGGER.warn("class ["+clazz+ "] cannot be instantiated due to access restrictions", e);
} catch(RuntimeException e) {
LOGGER.warn("class ["+clazz+"], level [" + levelName + "] conversion failed.", e);
}
return result;
}
/**
*
* @param value The size of the file as a String.
* @param defaultValue The default value.
* @return The size of the file as a long.
*/
public static long toFileSize(final String value, final long defaultValue) {
if (value == null) {
return defaultValue;
}
String str = value.trim().toUpperCase(Locale.ENGLISH);
long multiplier = 1;
int index;
if ((index = str.indexOf("KB")) != -1) {
multiplier = ONE_K;
str = str.substring(0, index);
} else if ((index = str.indexOf("MB")) != -1) {
multiplier = ONE_K * ONE_K;
str = str.substring(0, index);
} else if ((index = str.indexOf("GB")) != -1) {
multiplier = ONE_K * ONE_K * ONE_K;
str = str.substring(0, index);
}
try {
return Long.parseLong(str) * multiplier;
} catch (final NumberFormatException e) {
LOGGER.error("[{}] is not in proper int form.", str);
LOGGER.error("[{}] not in expected format.", value, e);
}
return defaultValue;
}
/**
* Find the value corresponding to key in
* props. Then perform variable substitution on the
* found value.
* @param key The key to locate.
* @param props The properties.
* @return The String after substitution.
*/
public static String findAndSubst(final String key, final Properties props) {
final String value = props.getProperty(key);
if (value == null) {
return null;
}
try {
return substVars(value, props);
} catch (final IllegalArgumentException e) {
LOGGER.error("Bad option value [{}].", value, e);
return value;
}
}
/**
* Instantiate an object given a class name. Check that the
* className is a subclass of
* superClass. If that test fails or the object could
* not be instantiated, then defaultValue is returned.
*
* @param className The fully qualified class name of the object to instantiate.
* @param superClass The class to which the new object should belong.
* @param defaultValue The object to return in case of non-fulfillment
* @return The created object.
*/
public static Object instantiateByClassName(final String className, final Class superClass,
final Object defaultValue) {
if (className != null) {
try {
final Class classObj = Loader.loadClass(className);
if (!superClass.isAssignableFrom(classObj)) {
LOGGER.error("A \"{}\" object is not assignable to a \"{}\" variable.", className,
superClass.getName());
LOGGER.error("The class \"{}\" was loaded by [{}] whereas object of type [{}] was loaded by [{}].",
superClass.getName(), superClass.getClassLoader(), classObj.getTypeName(), classObj.getName());
return defaultValue;
}
return classObj.newInstance();
} catch (final Exception e) {
LOGGER.error("Could not instantiate class [{}].", className, e);
}
}
return defaultValue;
}
/**
* Perform variable substitution in string val from the
* values of keys found in the system propeties.
*
* The variable substitution delimiters are ${ and }.
*
* For example, if the System properties contains "key=value", then
* the call
*
* String s = OptionConverter.substituteVars("Value of key is ${key}.");
*
*
* will set the variable s to "Value of key is value.".
*
* If no value could be found for the specified key, then the
* props parameter is searched, if the value could not
* be found there, then substitution defaults to the empty string.
*
* For example, if system properties contains no value for the key
* "inexistentKey", then the call
*
*
* String s = OptionConverter.subsVars("Value of inexistentKey is [${inexistentKey}]");
*
*
* will set s to "Value of inexistentKey is []"
*
* An {@link java.lang.IllegalArgumentException} is thrown if
* val contains a start delimeter "${" which is not
* balanced by a stop delimeter "}".
*
* @param val The string on which variable substitution is performed.
* @param props The properties to use for substitution.
* @return The String after substitution.
* @throws IllegalArgumentException if val is malformed.
*/
public static String substVars(final String val, final Properties props) throws
IllegalArgumentException {
return StrSubstitutor.replace(val, props);
}
}