/*
* 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.felix.eventadmin.impl.adapter;
import java.util.Dictionary;
import java.util.Hashtable;
import org.apache.felix.eventadmin.impl.util.LogWrapper;
import org.osgi.framework.Bundle;
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.framework.ServiceReference;
import org.osgi.service.event.Event;
import org.osgi.service.event.EventAdmin;
import org.osgi.service.event.EventConstants;
/**
* This class registers itself as a listener for <tt>LogReaderService</tt> services
* with the framework and subsequently, a <tt>LogListener</tt> callback with any
* currently available <tt>LogReaderService</tt>. Any received log event is then
* posted via the EventAdmin as specified in 113.6.6 OSGi R4 compendium.
* Note that this class does not create a hard dependency on the org.osgi.service.log
* packages. The adaption only takes place if it is present or once it becomes
* available hence, combined with a DynamicImport-Package no hard dependency is
* needed.
*
* @author <a href="mailto:dev@felix.apache.org">Felix Project Team</a>
*/
public class LogEventAdapter extends AbstractAdapter implements ServiceListener
{
// The internal lock for this object used instead synchronized(this)
private final Object m_lock = new Object();
private BundleContext m_context;
// A singleton instance of the used log listener that is the adapter
private Object m_logListener;
/**
* The constructor of the adapter. This will register the adapter with the
* given context as a listener for <tt>LogReaderService</tt> services and
* subsequently, a <tt>LogListener</tt> callback with any currently available
* <tt>LogReaderService</tt>. Any received log event is then posted via the given
* EventAdmin.
*
* @param context The bundle context with which to register as a listener.
* @param admin The <tt>EventAdmin</tt> to use for posting events.
*/
public LogEventAdapter(final BundleContext context, final EventAdmin admin)
{
super(admin);
m_context = context;
try
{
m_context.addServiceListener(this, "(" + Constants.OBJECTCLASS
+ "=org.osgi.service.log.LogReaderService)");
final ServiceReference[] refs;
refs = m_context.getServiceReferences(
"org.osgi.service.log.LogReaderService", null);
if (null != refs)
{
for (int i = 0; i < refs.length; i++)
{
final org.osgi.service.log.LogReaderService logReader =
(org.osgi.service.log.LogReaderService) m_context
.getService(refs[i]);
if (null != logReader)
{
logReader.addLogListener((org.osgi.service.log.LogListener)
getLogListener());
}
}
}
} catch (InvalidSyntaxException e)
{
// This never happens
}
}
@Override
public void destroy(BundleContext context) {
context.removeServiceListener(this);
}
/**
* Once a <tt>LogReaderService</tt> register event is received this method
* registers a <tt>LogListener</tt> with the received service that assembles
* and posts any log event via the <tt>EventAdmin</tt> as specified in
* 113.6.6 OSGi R4 compendium.
*
* @param event The event to adapt.
*/
@Override
public void serviceChanged(final ServiceEvent event)
{
if (ServiceEvent.REGISTERED == event.getType())
{
final org.osgi.service.log.LogReaderService logReader =
(org.osgi.service.log.LogReaderService) m_context
.getService(event.getServiceReference());
if (null != logReader)
{
logReader.addLogListener((org.osgi.service.log.LogListener)
getLogListener());
}
}
}
/*
* Constructs a LogListener that assembles and posts any log event via the
* EventAdmin as specified in 113.6.6 OSGi R4 compendium. Note that great
* care is taken to not create a hard dependency on the org.osgi.service.log
* package.
*/
private Object getLogListener()
{
synchronized (m_lock)
{
if (null != m_logListener)
{
return m_logListener;
}
m_logListener = new org.osgi.service.log.LogListener()
{
@Override
public void logged(final org.osgi.service.log.LogEntry entry)
{
// This is where the assembly as specified in 133.6.6 OSGi R4
// compendium is taking place (i.e., the log entry is adapted to
// an event and posted via the EventAdmin)
final Dictionary<String, Object> properties = new Hashtable<String, Object>();
final Bundle bundle = entry.getBundle();
if (null != bundle)
{
properties.put("bundle.id", new Long(bundle
.getBundleId()));
final String symbolicName = bundle.getSymbolicName();
if (null != symbolicName)
{
properties.put(EventConstants.BUNDLE_SYMBOLICNAME,
symbolicName);
}
properties.put("bundle", bundle);
}
properties.put("log.level", new Integer(entry.getLevel()));
properties.put(EventConstants.MESSAGE,
(entry.getMessage()) != null ? entry.getMessage() : "" );
properties.put(EventConstants.TIMESTAMP, new Long(
entry.getTime()));
properties.put("log.entry", entry);
final Throwable exception = entry.getException();
if (null != exception)
{
properties.put(EventConstants.EXCEPTION_CLASS,
exception.getClass().getName());
final String message = exception.getMessage();
if (null != message)
{
properties.put(EventConstants.EXCEPTION_MESSAGE,
message);
}
properties.put(EventConstants.EXCEPTION, exception);
}
final ServiceReference service = entry
.getServiceReference();
if (null != service)
{
properties.put(EventConstants.SERVICE, service);
final Object id = service
.getProperty(EventConstants.SERVICE_ID);
if (null != id)
{
try
{
properties.put(EventConstants.SERVICE_ID,
new Long(id.toString()));
} catch (NumberFormatException ne)
{
// LOG and IGNORE
LogWrapper.getLogger().log(
entry.getServiceReference(),
LogWrapper.LOG_WARNING, "Exception parsing " +
EventConstants.SERVICE_ID + "=" + id, ne);
}
}
final Object pid = service.getProperty(
EventConstants.SERVICE_PID);
if (null != pid)
{
properties.put(EventConstants.SERVICE_PID,
pid.toString());
}
final Object objectClass = service.getProperty(
Constants.OBJECTCLASS);
if (null != objectClass)
{
if (objectClass instanceof String[])
{
properties.put(
EventConstants.SERVICE_OBJECTCLASS,
objectClass);
}
else
{
properties.put(
EventConstants.SERVICE_OBJECTCLASS,
new String[] { objectClass.toString() });
}
}
}
final StringBuffer topic = new StringBuffer(
org.osgi.service.log.LogEntry.class.getName().replace(
'.', '/')).append('/');
switch (entry.getLevel())
{
case org.osgi.service.log.LogService.LOG_ERROR:
topic.append("LOG_ERROR");
break;
case org.osgi.service.log.LogService.LOG_WARNING:
topic.append("LOG_WARNING");
break;
case org.osgi.service.log.LogService.LOG_INFO:
topic.append("LOG_INFO");
break;
case org.osgi.service.log.LogService.LOG_DEBUG:
topic.append("LOG_DEBUG");
break;
default:
topic.append("LOG_OTHER");
break;
}
try {
getEventAdmin().postEvent(new Event(topic.toString(), properties));
} catch(IllegalStateException e) {
// This is o.k. - indicates that we are stopped.
}
}
};
return m_logListener;
}
}
}