public ConsoleManager(GlowServer server) {
this.server = server;
// install Ansi code handler, which makes colors work on Windows
AnsiConsole.systemInstall();
for (Handler h : logger.getHandlers()) {
logger.removeHandler(h);
}
// used until/unless gui is created
consoleHandler = new FancyConsoleHandler();
// consoleHandler.setFormatter(new DateOutputFormatter(CONSOLE_DATE));
logger.addHandler(consoleHandler);
// todo: why is this here?
Runtime.getRuntime().addShutdownHook(new ServerShutdownThread());
// reader must be initialized before standard streams are changed
try {
reader = new ConsoleReader();
} catch (IOException ex) {
logger.log(Level.SEVERE, "Exception initializing console reader", ex);
}
reader.addCompleter(new CommandCompleter());
// set system output streams
System.setOut(new PrintStream(new LoggerOutputStream(Level.INFO), true));
System.setErr(new PrintStream(new LoggerOutputStream(Level.WARNING), true));
}
public static synchronized void createLoggers(boolean reinit) {
if (m_initialized == true && reinit == false) {
return;
}
if (!m_initialized) {
Logger.getLogger("").removeHandler(Logger.getLogger("").getHandlers()[0]);
}
if (m_initialized) {
m_severeLogger.removeHandler(m_severeLogger.getHandlers()[0]);
m_nonSevereLogger.removeHandler(m_nonSevereLogger.getHandlers()[0]);
}
Handler severeHandler = new AMyConsoleHandler(System.err);
severeHandler.setFormatter(new SingleLineFormatter());
m_severeLogger.addHandler(severeHandler);
m_severeLogger.setLevel(getLoggingLevel());
Handler nonSevereHandler = new AMyConsoleHandler(System.out);
nonSevereHandler.setFormatter(new SingleLineFormatter());
m_nonSevereLogger.addHandler(nonSevereHandler);
m_nonSevereLogger.setLevel(getLoggingLevel());
m_initialized = true;
}
public static void installCustomFormatter() {
final boolean installCustomFormatter =
Boolean.parseBoolean(
OSystemVariableResolver.resolveSystemVariables(
"${" + ENV_INSTALL_CUSTOM_FORMATTER + "}", "true"));
if (!installCustomFormatter) return;
try {
// ASSURE TO HAVE THE ORIENT LOG FORMATTER TO THE CONSOLE EVEN IF NO CONFIGURATION FILE IS
// TAKEN
final Logger log = Logger.getLogger("");
if (log.getHandlers().length == 0) {
// SET DEFAULT LOG FORMATTER
final Handler h = new ConsoleHandler();
h.setFormatter(new OLogFormatter());
log.addHandler(h);
} else {
for (Handler h : log.getHandlers()) {
if (h instanceof ConsoleHandler
&& !h.getFormatter().getClass().equals(OLogFormatter.class))
h.setFormatter(new OLogFormatter());
}
}
} catch (Exception e) {
System.err.println(
"Error while installing custom formatter. Logging could be disabled. Cause: "
+ e.toString());
}
}
private static void addOrSetHandler(final Handler handler) {
if (LOGGER.getHandlers().length == 0) {
LOGGER.addHandler(handler);
} else {
LOGGER.getHandlers()[0] = handler;
}
}
public void testReset() throws SecurityException, IOException {
// mock LogManager
mockManager.readConfiguration(EnvironmentHelper.PropertiesToInputStream(props));
assertNotNull(mockManager.getProperty("handlers"));
Logger foo = new MockLogger(FOO, null);
assertNull(foo.getLevel());
assertEquals(0, foo.getHandlers().length);
foo.setLevel(Level.ALL);
foo.addHandler(new ConsoleHandler());
assertTrue(mockManager.addLogger(foo));
assertEquals(Level.WARNING, foo.getLevel());
assertEquals(2, foo.getHandlers().length);
// reset
mockManager.reset();
// properties is cleared
assertNull(mockManager.getProperty("handlers"));
// level is null
assertNull(foo.getLevel());
// handlers are all closed
assertEquals(0, foo.getHandlers().length);
// for root logger
manager.reset();
assertNull(manager.getProperty("handlers"));
Logger root = manager.getLogger("");
// level reset to info
assertEquals(Level.INFO, root.getLevel());
// also close root's handler
assertEquals(0, root.getHandlers().length);
}
public static void main(String[] args) {
LogManager manager = LogManager.getLogManager();
Logger root = manager.getLogger("");
checkPropertyNull(manager);
assertEquals(1, root.getHandlers().length);
assertEquals(Level.OFF, root.getLevel());
try {
manager.readConfiguration();
} catch (Exception e) {
e.printStackTrace();
}
checkPropertyNull(manager);
assertEquals(1, root.getHandlers().length);
assertEquals(Level.OFF, root.getLevel());
try {
manager.readConfiguration();
} catch (Exception e) {
e.printStackTrace();
}
checkPropertyNull(manager);
assertEquals(1, root.getHandlers().length);
assertEquals(Level.OFF, root.getLevel());
manager.reset();
checkPropertyNull(manager);
assertEquals(0, root.getHandlers().length);
assertEquals(Level.INFO, root.getLevel());
try {
manager.readConfiguration();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* Searches the logger parent hierarchy of the provided {@code Logger} until a parent is found
* who has {@code Handler} instances, and then adds those handlers to the provided logger. Note
* that this method also modifies the logger to not use its parent handlers in order to prevent
* duplicate log entries.
*/
private void attachParentHandlers() {
Logger parent = this;
do {
parent = parent.getParent();
} while (parent != null && parent.getHandlers().length == 0);
if (parent == null) {
// NOTE: this case should never happen since we would
// eventually hit the LogManager$RootLogger which by default
// has a Handler. However a developer could feasibly adjust
// some settings so that the RootLogger had no handler and none
// of the child Loggers did as well.
return;
}
// Add all of the parent handlers to this Logger so that we can
// later wrap it.
Handler[] arr = parent.getHandlers();
for (Handler h : arr) {
addHandler(h);
}
// Now that we are using the same handler as the parent, avoid
// propagating the call to the parent Logger as this will result in
// duplicate log entries to the handler.
setUseParentHandlers(false);
}
public void testReadConfigurationInputStream_root() throws IOException {
InputStream stream = EnvironmentHelper.PropertiesToInputStream(props);
manager.readConfiguration(EnvironmentHelper.PropertiesToInputStream(props));
Logger logger = new MockLogger("testReadConfigurationInputStream_root.foo", null);
Logger root = manager.getLogger("");
Logger logger2 = Logger.getLogger("testReadConfigurationInputStream_root.foo2");
manager.addLogger(logger);
assertNull(logger.getLevel());
assertEquals(0, logger.getHandlers().length);
assertSame(root, logger.getParent());
assertNull(logger2.getLevel());
assertEquals(0, logger2.getHandlers().length);
assertSame(root, logger2.getParent());
// if (!hasConfigClass) {
assertEquals(Level.FINE, root.getLevel());
assertEquals(2, root.getHandlers().length);
// }
// after read stream
manager.readConfiguration(stream);
assertEquals(Level.FINE, root.getLevel());
assertEquals(2, root.getHandlers().length);
assertNull(logger.getLevel());
assertEquals(0, logger.getHandlers().length);
stream.close();
}
public void testReadConfigurationUpdatesRootLoggersHandlers() throws IOException {
Properties properties = new Properties();
LogManager.getLogManager()
.readConfiguration(EnvironmentHelper.PropertiesToInputStream(properties));
Logger root = Logger.getLogger("");
assertEquals(0, root.getHandlers().length);
properties.put("handlers", "java.util.logging.ConsoleHandler");
LogManager.getLogManager()
.readConfiguration(EnvironmentHelper.PropertiesToInputStream(properties));
assertEquals(1, root.getHandlers().length);
}
public static File[] getFilesThreadLocal() {
List<File> files = new ArrayList<File>();
Logger logger = Logger.getLogger("");
Handler[] handlers = logger.getHandlers();
getFilesThreadLocal(handlers, files);
return files.toArray(new File[files.size()]);
}
public void preprocess(Run run) {
File logFile = new File(getRunDir(run), "genetik.log");
try {
SimpleFileHandler fh = new SimpleFileHandler(logFile);
fh.setFormatter(new CompactFormatter());
Logger logger = Logger.getLogger(GenetikConstants.LOGGER);
logger.setLevel(Level.INFO);
logger.setUseParentHandlers(false);
Handler handlers[] = logger.getHandlers();
logger.addHandler(fh);
for (Handler h : handlers) {
logger.removeHandler(h);
if (h instanceof SimpleFileHandler) h.close(); // close our old one
}
} catch (Exception exp) {
throw new IllegalArgumentException(
"Unable to create log file at " + logFile.getAbsolutePath());
}
super.preprocess(run);
}
/** Aktiviert das Logging zum Level FINEST. */
private static void activateFinestLogging() {
Handler[] handlers;
ConsoleHandler consoleHandler;
Logger rootLogger, archiLogger;
rootLogger = Logger.getLogger("");
archiLogger = Logger.getLogger("de.unistuttgart.architeuthis");
// log-Level für alle Logger von Architeuthis setzen
archiLogger.setLevel(Level.FINEST);
// der DefaultHandler hängt am root-Logger
handlers = rootLogger.getHandlers();
// einen ConsoleHandler finden:
consoleHandler = null;
for (int i = 0; i < handlers.length; i++) {
if (handlers[i] instanceof ConsoleHandler) {
consoleHandler = (ConsoleHandler) handlers[i];
}
}
// Wenn kein ConsoleHandler am root-Logger vorhanden ist, einen
// anhängen.
if (consoleHandler == null) {
consoleHandler = new java.util.logging.ConsoleHandler();
Logger.getLogger("").addHandler(consoleHandler);
}
consoleHandler.setLevel(Level.FINEST);
}
private static void setLevel(final Level level) {
LOGGER.setLevel(level);
for (final Handler each : LOGGER.getHandlers()) {
each.setLevel(level);
}
}
public void testReadConfigurationDoesNotUpdateOtherLoggers() throws IOException {
Properties properties = new Properties();
LogManager.getLogManager()
.readConfiguration(EnvironmentHelper.PropertiesToInputStream(properties));
Logger logger = Logger.getLogger("testReadConfigurationDoesNotUpdateOtherLoggers");
assertEquals(0, logger.getHandlers().length);
properties.put(
"testReadConfigurationDoesNotUpdateOtherLoggers.handlers",
"java.util.logging.ConsoleHandler");
LogManager.getLogManager()
.readConfiguration(EnvironmentHelper.PropertiesToInputStream(properties));
assertEquals(0, logger.getHandlers().length);
}
// -------------------------------------------------------- Private Methods
private void resetLoggers(
ClassLoaderLogManagerClassLoaderLogInfo clClassLoaderLogManagerClassLoaderLogInfo) {
// This differs from LogManager#resetLogger() in that we close not all
// handlers of all loggers, but only those that are present in our
// ClassLoaderClassLoaderLogManagerClassLoaderLogInfo#handlers list. That is because our
// #addLogger(..)
// method can use handlers from the parent class loaders, and closing
// handlers that the current class loader does not own would be not
// good.
synchronized (clClassLoaderLogManagerClassLoaderLogInfo) {
for (Logger logger : clClassLoaderLogManagerClassLoaderLogInfo.getLoggers().values()) {
Handler[] handlers = logger.getHandlers();
for (Handler handler : handlers) {
logger.removeHandler(handler);
}
}
for (Handler handler : clClassLoaderLogManagerClassLoaderLogInfo.getHandlers().values()) {
try {
handler.close();
} catch (Exception e) {
// Ignore
}
}
clClassLoaderLogManagerClassLoaderLogInfo.getHandlers().clear();
}
}
static {
Formatter formatter = new SingleLineFormatter();
Logger rootLogger = Logger.getLogger("");
for (Handler h : rootLogger.getHandlers()) {
h.setFormatter(formatter);
}
}
public void stop() {
running = false;
for (Handler handler : logger.getHandlers()) {
handler.flush();
handler.close();
}
}
/** @param args */
public static void main(String[] args) {
// Logger logger = Logger.getLogger(MyJdkLog.class.toString());
Logger logger = Logger.getLogger("");
logger.setLevel(Level.FINE);
Logger sublogger = Logger.getLogger("a.b.c");
sublogger.setLevel(Level.FINEST);
sublogger.log(Level.FINE, "sfsdf");
// System.out.println("(MyLog32.java:11) 2011-09-03 14:31:26,873 [DEBUG] This is a 'DEBUG' test
// message");
Handler[] handlers = logger.getHandlers();
System.out.println("handlers size :" + handlers.length);
for (int i = 0; i < handlers.length; i++) {
System.out.println(handlers[i].getClass());
System.out.println(handlers[i].getFormatter().getClass());
}
handlers[0].setFormatter(new MyFormatter());
// logger.info("MyJdkLog.............");
// logger.log(Level.WARNING, "fsodjfoaf....");
MyLoggerUtil.printDebug("com.logger.test.MyJdkLog", "11111message");
// StackTraceElement[] stackTraceElements= throwable.getStackTrace();
// System.out.println("size :"+stackTraceElements.length);
// stackTraceElements[0].getLineNumber();
// String str = "" + "(" + stackTraceElements[0].getFileName()+":" +
// stackTraceElements[0].getLineNumber()+")";
// System.out.println(str);
}
private void startInternal(BundleContext bundleContext) {
// register the LogReaderService
LogReaderServiceImpl logReader = new LogReaderServiceImpl(100);
String readerServiceName = LogReaderService.class.getName();
m_registrationLogReaderService =
bundleContext.registerService(readerServiceName, logReader, null);
// Tracking for the EventAdmin
try {
m_eventAdmin = new EventAdminTracker(bundleContext);
} catch (NoClassDefFoundError e) {
// If we hit a NoClassDefFoundError, this means the event admin package is not available,
// so use a dummy poster
m_eventAdmin =
new EventAdminPoster() {
public void postEvent(
Bundle bundle,
int level,
LogEntry entry,
String message,
Throwable exception,
ServiceReference sr,
Map context) {}
public void destroy() {}
};
}
// register the Pax Logging service
m_paxLogging =
new PaxLoggingServiceImpl(bundleContext, logReader.getAccessDelegate(), m_eventAdmin);
Hashtable<String, String> serviceProperties = new Hashtable<String, String>();
serviceProperties.put(Constants.SERVICE_ID, "org.ops4j.pax.logging.configuration");
serviceProperties.put(Constants.SERVICE_PID, CONFIGURATION_PID);
m_RegistrationPaxLogging =
bundleContext.registerService(LOG_SERVICE_INTERFACE_NAMES, m_paxLogging, serviceProperties);
// Add a global handler for all JDK Logging (java.util.logging).
if (!Boolean.valueOf(bundleContext.getProperty("org.ops4j.pax.logging.skipJUL"))) {
LogManager manager = LogManager.getLogManager();
manager.reset();
// clear out old handlers
Logger rootLogger = manager.getLogger("");
Handler[] handlers = rootLogger.getHandlers();
for (Handler handler : handlers) {
rootLogger.removeHandler(handler);
}
rootLogger.setFilter(null);
m_JdkHandler = new JdkHandler(m_paxLogging);
rootLogger.addHandler(m_JdkHandler);
}
m_frameworkHandler = new FrameworkHandler(m_paxLogging);
bundleContext.addBundleListener(m_frameworkHandler);
bundleContext.addFrameworkListener(m_frameworkHandler);
bundleContext.addServiceListener(m_frameworkHandler);
}
/** Configure CB4J logger. */
private void configureCB4JLogger() {
logger.setUseParentHandlers(false);
ConsoleHandler consoleHandler = new ConsoleHandler();
consoleHandler.setFormatter(new LogFormatter());
if (logger.getHandlers().length == 0) {
logger.addHandler(consoleHandler);
}
}
/** Registera global logger listener. */
public void registerLoggerHandler() {
for (Handler handler : rootLogger.getHandlers()) {
rootLogger.removeHandler(handler);
}
loggerHandler = new ConsoleLoggerHandler();
rootLogger.addHandler(loggerHandler);
}
/** Initialize the {@code VmRuntimeFileLogHandler} by installing it on the root logger. */
public static void init() throws IOException {
Logger rootLogger = Logger.getLogger("");
for (Handler handler : rootLogger.getHandlers()) {
if (handler instanceof VmRuntimeFileLogHandler) {
return; // Already installed.
}
}
rootLogger.addHandler(new VmRuntimeFileLogHandler());
}
public void stop() {
running = false;
for (Handler handler : logger.getHandlers()) {
handler.flush();
handler.close();
}
if (jFrame != null) {
jFrame.dispose();
}
}
private boolean bridgeHandlerInstalled() {
Logger rootLogger = LogManager.getLogManager().getLogger("");
Handler[] handlers = rootLogger.getHandlers();
for (Handler handler : handlers) {
if (handler instanceof SLF4JBridgeHandler) {
return true;
}
}
return false;
}
/**
* @TODO: This is a bit dirty here, better would be to ask the resources class for the static
* logger, but this would result in too much new interfaces.
*/
protected LogFileLogHandler getBaseHandler() {
for (int i = 0; i < logger.getHandlers().length; i++) {
Handler handler = logger.getHandlers()[i];
if (handler instanceof LogFileLogHandler) {
LogFileLogHandler logHandler = (LogFileLogHandler) handler;
return logHandler;
}
}
return null;
}
/* (non-Javadoc)
* @see org.osgi.framework.BundleActivator#start(org.osgi.framework.BundleContext)
*/
@Override
public void start(BundleContext bundleContext) throws Exception {
mLogger.debug("earlyStartup slf4j SLF4JBridgeHandler...");
java.util.logging.Logger rootLogger = LogManager.getLogManager().getLogger("");
Handler[] handlers = rootLogger.getHandlers();
for (Handler handler : handlers) {
rootLogger.removeHandler(handler);
}
org.slf4j.bridge.SLF4JBridgeHandler.install();
}
/**
* Sets the level of all muCommander loggers, namely {@link AppLogger}, {@link FileLogger} and
* {@link CommonsLogger}.
*
* @param level the new log level
*/
public static void updateLogLevel(Level level) {
// Set the level of muCommander loggers.
// Note: non-muCommander loggers default to the level defined in the JRE's logging.properties.
CommonsLogger.getLogger().setLevel(level);
FileLogger.getLogger().setLevel(level);
AppLogger.getLogger().setLevel(level);
Logger rootLogger = LogManager.getLogManager().getLogger("");
Handler handlers[] = rootLogger.getHandlers();
for (Handler handler : handlers) handler.setLevel(level);
}
private static void setVlog(Logger logger, LogLevel logLevel) {
final Level newLevel = logLevel.getLevel();
logger.setLevel(newLevel);
do {
for (Handler handler : logger.getHandlers()) {
Level handlerLevel = handler.getLevel();
if (newLevel.intValue() < handlerLevel.intValue()) {
handler.setLevel(newLevel);
}
}
} while (logger.getUseParentHandlers() && (logger = logger.getParent()) != null);
}
public void testGetProperty() throws SecurityException, IOException {
// //FIXME: move it to exec
// manager.readConfiguration(EnvironmentHelper.PropertiesToInputStream(props));
// Logger root = manager.getLogger("");
//// checkProperty(manager);
// assertEquals(Level.FINE, root.getLevel());
// assertEquals(2, root.getHandlers().length);
// but non-mock manager DO read it from the very beginning
Logger root = manager.getLogger("");
manager.readConfiguration(EnvironmentHelper.PropertiesToInputStream(props));
checkProperty(manager);
assertEquals(2, root.getHandlers().length);
assertEquals(Level.FINE, root.getLevel());
manager.reset();
checkPropertyNull(manager);
assertEquals(0, root.getHandlers().length);
assertEquals(Level.INFO, root.getLevel());
manager.readConfiguration(EnvironmentHelper.PropertiesToInputStream(props));
}
@Override
public void contextInitialized(ServletContextEvent sce) {
// Jersey uses java.util.logging - bridge to slf4
java.util.logging.Logger rootLogger = LogManager.getLogManager().getLogger("");
Handler[] handlers = rootLogger.getHandlers();
for (int i = 0; i < handlers.length; i++) {
rootLogger.removeHandler(handlers[i]);
}
SLF4JBridgeHandler.install();
LOGGER.info("jul-to-slf4j installed");
}