/**
* Instantiate an object given a class name. Check that the <code>className</code> is a subclass
* of <code>superClass</code>. If that test fails or the object could not be instantiated, then
* <code>defaultValue</code> 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
*/
public static Object instantiateByClassName(
String className, Class superClass, Object defaultValue) {
if (className != null) {
try {
Class classObj = Loader.loadClass(className);
if (!superClass.isAssignableFrom(classObj)) {
LogLog.error(
"A \""
+ className
+ "\" object is not assignable to a \""
+ superClass.getName()
+ "\" variable.");
LogLog.error("The class \"" + superClass.getName() + "\" was loaded by ");
LogLog.error("[" + superClass.getClassLoader() + "] whereas object of type ");
LogLog.error(
"\"" + classObj.getName() + "\" was loaded by [" + classObj.getClassLoader() + "].");
return defaultValue;
}
return classObj.newInstance();
} catch (Exception e) {
LogLog.error("Could not instantiate class [" + className + "].", e);
}
}
return defaultValue;
}
@AfterClass
public static void afterClassResetLogging() {
// Unfortunately, this code "knows" how log4j was set up in testing
// Thsi is fragile.
URL configURL = Loader.getResource("log4j.properties");
new PropertyConfigurator().doConfigure(configURL, LogManager.getLoggerRepository());
}
/**
* Initialize log4j logging using the Tolven appender specification.
*
* <p>Note: This method should <i>not</i> be called within an environment such as JBoss that has a
* separate log4j configuration. In that case, the TolvenLogger will use the appender
* configuration supplied by that environment.
*
* @param log4jConfiguration The name of the file containing the log4j configuration. If null, the
* a file named tolven-log4j.xml on the classpath will be used.
* @param logFilename The name of the log file. This file will be created if it does not already
* exist. If null, a default file named <code>${user.dir}/tolven.log</code> will be used.
*/
public static void initialize(String log4jConfiguration, String logFilename) {
try {
File logFile;
if (logFilename != null) {
logFile = new File(logFilename);
} else {
logFile = new File(DEFAULT_LOG_FILE);
}
System.setProperty(LOG_FILE_PROPERTY, logFile.getAbsolutePath());
logFile.getParentFile().mkdirs();
logFile.createNewFile();
defaultInitialize();
Logger.getRootLogger()
.info(
"Start log4j - Configuration: "
+ log4jConfiguration
+ ", logFileName: "
+ logFile.getAbsolutePath());
BasicConfigurator.resetConfiguration();
URL configURL;
try {
configURL = new URL(log4jConfiguration);
} catch (Exception e) {
configURL = Loader.getResource(log4jConfiguration);
}
DOMConfigurator.configure(configURL);
} catch (Exception e) {
throw new RuntimeException(
"Exception while initializing Tolven log4j. log4jConfiguration: "
+ log4jConfiguration
+ " logFilename: "
+ logFilename,
e);
}
}
/**
* 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;
}
public void init() {
// TODO Auto-generated method stub
System.out.println(
"*** "
+ "["
+ IfrendCoreLoggerLoader.class.getName()
+ "] "
+ "loading the Log4j log loader...");
String pack = IfrendCoreLoggerLoader.class.getPackage().getName();
// URL url = Loader.getResource("com/isg/iloan/logger/log4j.properties");
URL url = Loader.getResource(pack.replace('.', '/') + "/log4j.properties");
System.out.println("URL:" + url.getPath());
PropertyConfigurator.configure(url);
System.out.println(
"*** "
+ "["
+ IfrendCoreLoggerLoader.class.getName()
+ "] "
+ "loading the Log4j log loader...finished!");
}
public static URL configure() {
final String log4jConfig = System.getProperty("log4j.configuration");
if (log4jConfig != null) {
// Log4j environment variable found, the LogManager will take care of
// itself, don't bother reinitializing
// This is what the LogManager does to find the resource.
URL configUrl = null;
try {
configUrl = new URL(log4jConfig);
} catch (MalformedURLException mue) {
configUrl = Loader.getResource(log4jConfig);
}
Preconditions.checkState(configUrl != null, "Invalid config URL: %s", log4jConfig);
return configUrl;
}
for (final String logFile : DEFAULT_LOG_FILES) {
final URL configUrl = Log4jConfigurator.class.getResource(logFile);
if (configUrl != null) {
LogManager.resetConfiguration();
DOMConfigurator.configure(configUrl);
final Log log = Log.findLog();
log.info("Configured logging from '%s'", configUrl);
return configUrl;
}
}
BasicConfigurator.configure();
final Log log = Log.findLog();
log.warn("No logging configuration, falling back to default!");
return null;
}
private MDC() {
java1 = Loader.isJava1();
if (!java1) {
tlm = new ThreadLocalMap();
}
}
public static void main(String[] args) throws InterruptedException {
System.setProperty("log4j.defaultInitOverride", String.valueOf(true));
final URL log4jProps = Loader.getResource("example/log4jDirectoryProcessors.properties");
PropertyConfigurator.configure(log4jProps);
final Logger logger = LoggerFactory.getLogger(Main.class);
logger.info("Log4j Config loaded from " + log4jProps.toString());
final StateManager stateManager = new StateManager();
final State1 state1 = new State1(new File("C:\\Users\\niket\\dirprocs\\state1"));
final FailedState2 failedState2 =
new FailedState2(new File("C:\\Users\\niket\\dirprocs\\failedState2"));
final State2 state2 = new State2(new File("C:\\Users\\niket\\dirprocs\\state2"));
final State3 state3 = new State3(new File("C:\\Users\\niket\\dirprocs\\state3"));
final FailedState3 failedState3 =
new FailedState3(new File("C:\\Users\\niket\\dirprocs\\failedState3"));
final State1Processor processor1 = new State1Processor();
final State2Processor processor2 = new State2Processor();
stateManager.addDefinition(
state1, processor1, new HashSet<>(Arrays.asList(new State[] {failedState2, state2})));
stateManager.addDefinition(
state2, processor2, new HashSet<>(Arrays.asList(new State[] {state3, failedState3})));
final LoggerObserver logger1 = new LoggerObserver();
stateManager.addObserver(state1, state2, logger1);
stateManager.addObserver(state1, failedState2, logger1);
stateManager.addObserver(state2, state3, logger1);
stateManager.addObserver(state2, failedState3, logger1);
final UIObserver uiObserver = new UIObserver();
stateManager.addObserver(state1, state2, uiObserver);
stateManager.addObserver(state1, failedState2, uiObserver);
stateManager.addObserver(state2, state3, uiObserver);
stateManager.addObserver(state2, failedState3, uiObserver);
stateManager.addProcessorThreads(processor1, 1);
stateManager.addProcessorThreads(processor2, 1);
stateManager.startAll();
TimeUnit.SECONDS.sleep(5);
stateManager.stopProcessor(State1Processor.class);
TimeUnit.SECONDS.sleep(5);
stateManager.startProcessor(State1Processor.class);
TimeUnit.SECONDS.sleep(5);
stateManager.updateState(new State1(new File("C:\\Users\\niket\\dirprocs\\state4")));
TimeUnit.SECONDS.sleep(5);
stateManager.disableProcessor(State2Processor.class);
TimeUnit.SECONDS.sleep(5);
stateManager.enableProcessor(State2Processor.class, 3);
TimeUnit.SECONDS.sleep(30);
stateManager.shutdown();
}