Author: angelo.vandersijpt at luminis.eu
Date: Mon Oct 18 15:02:46 2010
New Revision: 185
Log:
AMDATU-103 Cleanup up the LogHandler, making classes responsible for one thing
only. Furthermore, cleaned up the way the ConsoleLogHandler uses its
configuration.
Modified:
trunk/platform-bundles/loghandler/src/main/java/org/amdatu/platform/loghandler/osgi/Activator.java
trunk/platform-bundles/loghandler/src/main/java/org/amdatu/platform/loghandler/service/ConsoleLogHandler.java
trunk/platform-bundles/loghandler/src/main/java/org/amdatu/platform/loghandler/service/JdkLogForwarder.java
Modified:
trunk/platform-bundles/loghandler/src/main/java/org/amdatu/platform/loghandler/osgi/Activator.java
==============================================================================
---
trunk/platform-bundles/loghandler/src/main/java/org/amdatu/platform/loghandler/osgi/Activator.java
(original)
+++
trunk/platform-bundles/loghandler/src/main/java/org/amdatu/platform/loghandler/osgi/Activator.java
Mon Oct 18 15:02:46 2010
@@ -16,111 +16,52 @@
*/
package org.amdatu.platform.loghandler.osgi;
-import java.util.Dictionary;
-import java.util.Hashtable;
-import java.util.Iterator;
-import java.util.LinkedList;
+import java.util.Properties;
import org.amdatu.platform.loghandler.service.ConsoleLogHandler;
import org.amdatu.platform.loghandler.service.JdkLogForwarder;
-import org.apache.felix.dm.Component;
import org.apache.felix.dm.DependencyActivatorBase;
import org.apache.felix.dm.DependencyManager;
import org.osgi.framework.BundleContext;
import org.osgi.framework.Constants;
-import org.osgi.framework.InvalidSyntaxException;
-import org.osgi.framework.ServiceEvent;
-import org.osgi.framework.ServiceListener;
-import org.osgi.service.cm.ConfigurationAdmin;
import org.osgi.service.cm.ManagedService;
import org.osgi.service.log.LogListener;
import org.osgi.service.log.LogReaderService;
-import org.osgi.util.tracker.ServiceTracker;
+import org.osgi.service.log.LogService;
/**
* This is the OSGi activator for this log handler bundle.
* @author ivol
*/
public class Activator extends DependencyActivatorBase {
- // The console log handler
- private LogListener m_console;
- // All log reader services
- private LinkedList<LogReaderService> m_readers = new
LinkedList<LogReaderService>();
-
- // The tracker to track log reader services
- private ServiceTracker m_logReaderTracker;
-
- // We use a ServiceListener to dynamically keep track of all the
LogReaderService service being
- // registered or unregistered
- private ServiceListener m_serviceListener = new ServiceListener() {
- public void serviceChanged(ServiceEvent event) {
- BundleContext bc =
event.getServiceReference().getBundle().getBundleContext();
- LogReaderService lrs = (LogReaderService)
bc.getService(event.getServiceReference());
- if (lrs != null) {
- if (event.getType() == ServiceEvent.REGISTERED) {
- m_readers.add(lrs);
- lrs.addLogListener(m_console);
- } else if (event.getType() == ServiceEvent.UNREGISTERING) {
- lrs.removeLogListener(m_console);
- m_readers.remove(lrs);
- }
- }
- }
- };
-
- /**
- * {@inheritDoc}
- */
@Override
public void init(BundleContext context, DependencyManager manager) throws
Exception {
System.out.println("Starting Log handler.");
- Component service = manager.createComponent();
- Dictionary<String, String> props = new Hashtable<String, String>();
- props.put(Constants.SERVICE_PID, ConsoleLogHandler.PID);
- manager.add(
- service
+ // Register our console log handler
+ Properties consoleLogHandlerProps = new Properties();
+ consoleLogHandlerProps.put(Constants.SERVICE_PID,
ConsoleLogHandler.PID);
+ manager.add(createComponent()
+ .setInterface(new String[]{LogListener.class.getName(),
ManagedService.class.getName()}, consoleLogHandlerProps)
.setImplementation(ConsoleLogHandler.class)
- .setInterface(new String[]{LogListener.class.getName(),
ManagedService.class.getName()}, props)
-
.add(manager.createServiceDependency().setService(ConfigurationAdmin.class).setRequired(true)));
- m_console = (LogListener) service.getService();
-
- // Get a list of all the registered LogReaderService, and add the
console listener
- m_logReaderTracker = new ServiceTracker(context,
LogReaderService.class.getName(), null);
- m_logReaderTracker.open();
- Object[] readers = m_logReaderTracker.getServices();
- if (readers != null) {
- for (int i = 0; i < readers.length; i++) {
- LogReaderService lrs = (LogReaderService) readers[i];
- m_readers.add(lrs);
- lrs.addLogListener(m_console);
- }
- }
-
- // Add the ServiceListener, but with a filter so that we only receive
events related to LogReaderService
- String filter = "(objectclass=" + LogReaderService.class.getName() +
")";
- try {
- context.addServiceListener(m_serviceListener, filter);
- } catch (InvalidSyntaxException e) {
- System.out.println(e.getMessage());
- e.printStackTrace();
- }
-
- // Other than the default handler we pass the package name of the
- // classes whose JDK loggers must forward logs to the OSGi Service.
- new JdkLogForwarder(context, new
String[]{"org.ops4j.pax.web.service.jetty.internal"});
+ .add(createServiceDependency()
+ .setService(LogReaderService.class)
+ .setRequired(false)
+ .setCallbacks("logReaderAdded", "logReaderRemoved")));
+
+
+ // Register the JDKLog bridge
+ manager.add(createComponent()
+ .setImplementation(new
JdkLogForwarder("org.ops4j.pax.web.service.jetty.internal"))
+ .add(createServiceDependency()
+ .setService(LogService.class)
+ .setRequired(true)));
+
+ // TODO Why do we filter? Don't we just want all stuff?
}
@Override
public void destroy(BundleContext context, DependencyManager manager)
throws Exception {
- System.out.println("Stopping Log handler.");
-
- for (Iterator<LogReaderService> i = m_readers.iterator();
i.hasNext();) {
- LogReaderService lrs = i.next();
- lrs.removeLogListener(m_console);
- i.remove();
- }
- m_logReaderTracker.close();
}
}
Modified:
trunk/platform-bundles/loghandler/src/main/java/org/amdatu/platform/loghandler/service/ConsoleLogHandler.java
==============================================================================
---
trunk/platform-bundles/loghandler/src/main/java/org/amdatu/platform/loghandler/service/ConsoleLogHandler.java
(original)
+++
trunk/platform-bundles/loghandler/src/main/java/org/amdatu/platform/loghandler/service/ConsoleLogHandler.java
Mon Oct 18 15:02:46 2010
@@ -16,38 +16,32 @@
*/
package org.amdatu.platform.loghandler.service;
-import java.io.IOException;
import java.util.Dictionary;
import java.util.HashMap;
import java.util.Map;
-import java.util.logging.Level;
-import java.util.logging.LogRecord;
-import org.osgi.framework.Bundle;
-import org.osgi.framework.ServiceReference;
-import org.osgi.service.cm.Configuration;
-import org.osgi.service.cm.ConfigurationAdmin;
import org.osgi.service.cm.ConfigurationException;
import org.osgi.service.cm.ManagedService;
import org.osgi.service.log.LogEntry;
import org.osgi.service.log.LogListener;
+import org.osgi.service.log.LogReaderService;
import org.osgi.service.log.LogService;
/**
* Handles log messages and prints them to the console.
* @author ivol
*/
-public class ConsoleLogHandler extends java.util.logging.Handler implements
LogListener, ManagedService {
- /**
- * Mapping of text for all possible loglevels.
- */
- private static final Map<Integer, String> LOGLEVEL;
+public class ConsoleLogHandler implements LogListener, ManagedService {
+ private static int DEFAULT_LOG_LEVEL = LogService.LOG_INFO;
+ private int m_minLogLevel = DEFAULT_LOG_LEVEL;
+
+ private static final Map<Integer, String> LOG_LEVELS;
static {
- LOGLEVEL = new HashMap<Integer, String>();
- LOGLEVEL.put(LogService.LOG_DEBUG, "DEBUG");
- LOGLEVEL.put(LogService.LOG_INFO, "INFO");
- LOGLEVEL.put(LogService.LOG_WARNING, "WARNING");
- LOGLEVEL.put(LogService.LOG_ERROR, "ERROR");
+ LOG_LEVELS = new HashMap<Integer, String>();
+ LOG_LEVELS.put(LogService.LOG_DEBUG, "DEBUG");
+ LOG_LEVELS.put(LogService.LOG_INFO, "INFO");
+ LOG_LEVELS.put(LogService.LOG_WARNING, "WARNING");
+ LOG_LEVELS.put(LogService.LOG_ERROR, "ERROR");
}
// Name of the configuration PID and property that determines the minimum
log level
@@ -55,26 +49,18 @@
public static final String PID = "org.amdatu.platform.loghandler";
private static final String MIN_LOGLEVEL_KEY = "console.mininum.loglevel";
- // Injected by the Felix dependency manager
- private volatile ConfigurationAdmin m_configurationAdmin;
+ public void logReaderAdded(LogReaderService reader) {
+ reader.addLogListener(this);
+ }
- // The minimum log level
- private int m_minLogLevel = LogService.LOG_INFO;
+ public void logReaderRemoved(LogReaderService reader) {
+ reader.removeLogListener(this);
+ }
- /**
- * Invoked by the Felix dependency manager.
- */
- public void init() {
- readMinLogLevel();
- }
-
- /**
- * {@inheritDoc}
- */
public void logged(LogEntry entry) {
if (entry.getLevel() <= m_minLogLevel) {
- String level = LOGLEVEL.get(entry.getLevel());
- System.out.println(level + ": " + entry.getMessage() + " [" +
entry.getBundle().getSymbolicName() + "]");
+ String levelName = LOG_LEVELS.get(entry.getLevel());
+ System.out.println(levelName + ": " + entry.getMessage() + " [" +
entry.getBundle().getSymbolicName() + "]");
if (entry.getException() != null) {
System.out.println(entry.getException().getMessage());
entry.getException().printStackTrace();
@@ -82,85 +68,27 @@
}
}
- private void readMinLogLevel() {
- Configuration config;
- try {
- config = m_configurationAdmin.getConfiguration(PID);
- if (config != null && config.getProperties() != null) {
- String minLogLevel =
config.getProperties().get(MIN_LOGLEVEL_KEY).toString();
- if ("DEBUG".equalsIgnoreCase(minLogLevel)) {
- m_minLogLevel = LogService.LOG_DEBUG;
- } else if ("INFO".equalsIgnoreCase(minLogLevel)) {
- m_minLogLevel = LogService.LOG_INFO;
- } else if ("WARNING".equalsIgnoreCase(minLogLevel)) {
- m_minLogLevel = LogService.LOG_WARNING;
- } else if ("ERROR".equalsIgnoreCase(minLogLevel)) {
- m_minLogLevel = LogService.LOG_ERROR;
- } else {
- m_minLogLevel = LogService.LOG_INFO;
- }
- }
- } catch (IOException e) {
- System.out.println("Could not initialize minimum log level for the
Console logger, using INFO");
- e.printStackTrace();
- }
- }
-
- @Override
- public void close() throws SecurityException {
- }
-
- @Override
- public void flush() {
+ public void updated(Dictionary properties) throws ConfigurationException {
+ m_minLogLevel = getLogLevelFromProperties(properties);
}
- @Override
- public void publish(final LogRecord record) {
- logged(new LogEntry() {
- public Bundle getBundle() {
- // Bundle is unkown in JDK logging
- return null;
- }
-
- public Throwable getException() {
- return record.getThrown();
- }
-
- public int getLevel() {
- Level level = record.getLevel();
- if (level == Level.FINE || level == Level.FINEST || level ==
Level.FINER) {
- return LogService.LOG_DEBUG;
- } else if (level == Level.INFO) {
- return LogService.LOG_INFO;
- } else if (level == Level.WARNING) {
- return LogService.LOG_WARNING;
- } else if (level == Level.SEVERE) {
- return LogService.LOG_ERROR;
- } else {
- return LogService.LOG_INFO;
- }
- }
-
- public String getMessage() {
- return record.getMessage();
- }
+ private int getLogLevelFromProperties(Dictionary dictionary) {
+ if (dictionary == null) {
+ return DEFAULT_LOG_LEVEL;
+ }
- public ServiceReference getServiceReference() {
- // Service reference is unknown in JDK logging
- return null;
- }
+ String minLogLevel = (String) dictionary.get(MIN_LOGLEVEL_KEY);
+ if (minLogLevel == null) {
+ return DEFAULT_LOG_LEVEL;
+ }
- public long getTime() {
- return record.getMillis();
+ for (Map.Entry<Integer, String> logLevelEntry : LOG_LEVELS.entrySet())
{
+ if (minLogLevel.equalsIgnoreCase(logLevelEntry.getValue())) {
+ return logLevelEntry.getKey();
}
- });
- }
+ }
- /**
- * {@inheritDoc}
- */
- public void updated(Dictionary properties) throws ConfigurationException {
- // When the configuration is changed, read the minimum log level
- readMinLogLevel();
+ // If we get here, there is no other way we can find the log level
+ return DEFAULT_LOG_LEVEL;
}
}
Modified:
trunk/platform-bundles/loghandler/src/main/java/org/amdatu/platform/loghandler/service/JdkLogForwarder.java
==============================================================================
---
trunk/platform-bundles/loghandler/src/main/java/org/amdatu/platform/loghandler/service/JdkLogForwarder.java
(original)
+++
trunk/platform-bundles/loghandler/src/main/java/org/amdatu/platform/loghandler/service/JdkLogForwarder.java
Mon Oct 18 15:02:46 2010
@@ -16,212 +16,79 @@
*/
package org.amdatu.platform.loghandler.service;
-import java.util.logging.*;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.logging.Handler;
+import java.util.logging.Level;
+import java.util.logging.LogRecord;
+import java.util.logging.Logger;
-import org.osgi.framework.*;
import org.osgi.service.log.LogService;
/**
* This class forwards JDK log messages to the OSGi log service.
* @author ivol
*/
-public class JdkLogForwarder {
- // Instance variables
- private final BundleContext m_bundleContext;
+public class JdkLogForwarder extends Handler {
+
+ private static final Map<Level, Integer> LOG_LEVEL_MAPPING = new
HashMap<Level, Integer>();
+ static {
+ LOG_LEVEL_MAPPING.put(Level.SEVERE, LogService.LOG_ERROR);
+ LOG_LEVEL_MAPPING.put(Level.WARNING, LogService.LOG_WARNING);
+ LOG_LEVEL_MAPPING.put(Level.INFO, LogService.LOG_INFO);
+ LOG_LEVEL_MAPPING.put(Level.CONFIG, LogService.LOG_INFO);
+ }
+
+ private volatile LogService m_log;
private final String[] m_loggerNames;
- private final Handler m_defaultHandler;
- private final ServiceListener m_logServiceServiceListener = new
LogServiceServiceListener();
- private ServiceReference m_lastUsedLogServiceRef;
- private Handler m_lastUsedHandler;
-
- /**
- * Constructor.
- * @param bundleContext
- * @param loggerNames
- */
- public JdkLogForwarder(BundleContext bundleContext, String[] loggerNames) {
- this(bundleContext, loggerNames, null);
- }
-
- /**
- * Constructor
- * @param bundleContext
- * @param loggerNames
- * @param defaultHandler
- */
- public JdkLogForwarder(BundleContext bundleContext, String[] loggerNames,
Handler defaultHandler) {
- m_bundleContext = bundleContext;
+
+ public JdkLogForwarder(String... loggerNames) {
m_loggerNames = loggerNames;
- m_defaultHandler = defaultHandler != null ? defaultHandler : new
DummyLogHandler();
}
- /**
- * Starts the JDK log forwarder
- */
public void start() {
- for (String loggerName : getLoggerNames()) {
+ for (String loggerName : m_loggerNames) {
Logger logger = Logger.getLogger(loggerName);
logger.setUseParentHandlers(false);
+ logger.addHandler(this);
}
-
- updateLogHandler();
- addLogServiceListener();
}
- /**
- * Stops the JDK log forwarder
- */
public void stop() {
-
getBundleContext().removeServiceListener(getLogServiceServiceListener());
-
- for (String loggerName : getLoggerNames()) {
- Logger.getLogger(loggerName).removeHandler(getLastUsedHandler());
- }
-
- if (getLastUsedLogServiceRef() != null) {
- getBundleContext().ungetService(getLastUsedLogServiceRef());
+ for (String loggerName : m_loggerNames) {
+ Logger.getLogger(loggerName).removeHandler(this);
}
}
- protected void updateLogHandler() {
- ServiceReference logServiceRef =
getBundleContext().getServiceReference(LogService.class.getName());
- Handler logHandler = null;
- if (logServiceRef != null && logServiceRef ==
getLastUsedLogServiceRef()) {
+ @Override
+ public void publish(LogRecord record) {
+ if (record.getLevel() == Level.OFF) {
return;
}
- if (logServiceRef != null) {
- logHandler = new OsgiLogDelegateHandler((LogService)
getBundleContext().getService(logServiceRef));
- } else {
- logHandler = getDefaultHandler();
- }
-
- Handler lastUsedHandler = getLastUsedHandler();
-
- for (String loggerName : getLoggerNames()) {
- Logger logger = Logger.getLogger(loggerName);
- logger.removeHandler(lastUsedHandler);
- logger.addHandler(logHandler);
- }
-
- if (getLastUsedLogServiceRef() != null) {
- getBundleContext().ungetService(getLastUsedLogServiceRef());
- }
- setLastUsedLogServiceRef(logServiceRef);
- setLastUsedHandler(logHandler);
- }
-
- protected void addLogServiceListener() {
- try {
-
getBundleContext().addServiceListener(getLogServiceServiceListener(),
- String.format("(%s=%s)", Constants.OBJECTCLASS,
LogService.class.getName()));
- } catch (InvalidSyntaxException ex) {
- // / This exception should not occur in the first place
- throw new RuntimeException(ex.getMessage());
+ if (record.getThrown() != null) {
+ m_log.log(getToOsgiLogLevel(record.getLevel()),
record.getMessage(), record.getThrown());
+ } else {
+ m_log.log(getToOsgiLogLevel(record.getLevel()),
record.getMessage());
}
}
- protected BundleContext getBundleContext() {
- return m_bundleContext;
+ @Override
+ public void close() throws SecurityException {
}
- protected String[] getLoggerNames() {
- return m_loggerNames;
+ @Override
+ public void flush() {
}
- protected Handler getDefaultHandler() {
- return m_defaultHandler;
- }
-
- protected ServiceListener getLogServiceServiceListener() {
- return m_logServiceServiceListener;
- }
-
- protected ServiceReference getLastUsedLogServiceRef() {
- return m_lastUsedLogServiceRef;
- }
-
- protected void setLastUsedLogServiceRef(ServiceReference
lastUsedLogServiceRef) {
- m_lastUsedLogServiceRef = lastUsedLogServiceRef;
- }
-
- protected Handler getLastUsedHandler() {
- return m_lastUsedHandler;
- }
-
- protected void setLastUsedHandler(Handler lastUsedHandler) {
- m_lastUsedHandler = lastUsedHandler;
- }
-
- protected class LogServiceServiceListener implements ServiceListener {
- // @Override
- public void serviceChanged(ServiceEvent serviceEvent) {
- try {
- updateLogHandler();
- } catch (Throwable ex) {
- System.out.println("Error: " + ex.getMessage());
- ex.printStackTrace();
- }
+ private int getToOsgiLogLevel(Level level) {
+ if (LOG_LEVEL_MAPPING.containsKey(level)) {
+ return LOG_LEVEL_MAPPING.get(level);
}
- }
-
- protected class OsgiLogDelegateHandler extends Handler {
- private final LogService m_logService;
-
- @Override
- public void publish(LogRecord record) {
- if (record.getLevel() == Level.OFF) {
- return;
- }
-
- if (record.getThrown() != null) {
- getLogService().log(getToOsgiLogLevel(record.getLevel()),
record.getMessage(), record.getThrown());
- } else {
- getLogService().log(getToOsgiLogLevel(record.getLevel()),
record.getMessage());
- }
- }
-
- @Override
- public void close() throws SecurityException {
- }
-
- @Override
- public void flush() {
- }
-
- protected int getToOsgiLogLevel(Level level) {
- if (level == Level.SEVERE) {
- return LogService.LOG_ERROR;
- } else if (level == Level.WARNING) {
- return LogService.LOG_WARNING;
- } else if (level == Level.INFO || level == Level.CONFIG) {
- return LogService.LOG_INFO;
- } else {
- return LogService.LOG_DEBUG;
- }
- }
-
- public OsgiLogDelegateHandler(LogService logService) {
- m_logService = logService;
- }
-
- protected LogService getLogService() {
- return m_logService;
+ else {
+ return LogService.LOG_DEBUG;
}
}
- protected class DummyLogHandler extends Handler {
- @Override
- public void publish(LogRecord record) {
- }
-
- @Override
- public void close() throws SecurityException {
- }
-
- @Override
- public void flush() {
- }
- }
}
