/*******************************************************************************

 * Copyright (c) 2005 IBM Corporation.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     IBM Corporation - initial API and implementation

 *******************************************************************************/

package org.eclipse.equinox.event.mapper;

import org.osgi.framework.ServiceReference;

import org.osgi.service.log.LogReaderService;

/**

 * @version $Revision: 1.1 $

 */

public interface LogReaderServiceListener {

	public void logReaderServiceAdding(ServiceReference reference,

			LogReaderService service);

	public void logReaderServiceRemoved(ServiceReference reference,

			LogReaderService service);

}

/*******************************************************************************

 * Copyright (c) 2005, 2007 IBM Corporation.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     IBM Corporation - initial API and implementation

 *******************************************************************************/

package org.eclipse.equinox.event.mapper;

import java.util.Hashtable;

import org.osgi.framework.Bundle;

import org.osgi.framework.FrameworkEvent;

import org.osgi.service.event.Event;

import org.osgi.service.event.EventAdmin;

/**

 * @version $Revision: 1.2 $

 */

public class FrameworkEventAdapter extends EventAdapter {

	// constants for Event topic substring

	public static final String HEADER = "org/osgi/framework/FrameworkEvent";

	public static final String STARTLEVEL_CHANGED = "STARTLEVEL_CHANGED";

	public static final String STARTED = "STARTED";

	public static final String PACKAGES_REFRESHED = "PACKAGES_REFRESHED";

	public static final String ERROR = "ERROR";

	protected FrameworkEvent event;

	public FrameworkEventAdapter(FrameworkEvent event, EventAdmin eventAdmin) {

		super(eventAdmin);

		this.event = event;

	}

	/**

	 * @see org.eclipse.equinox.event.mapper.EventAdapter#convert()

	 */

	public Event convert() {

		String typename = null;

		switch (event.getType()) {

			case FrameworkEvent.ERROR :

				typename = ERROR;

				break;

			case FrameworkEvent.PACKAGES_REFRESHED :

				typename = PACKAGES_REFRESHED;

				break;

			case FrameworkEvent.STARTED :

				typename = STARTED;

				break;

			case FrameworkEvent.STARTLEVEL_CHANGED :

				typename = STARTLEVEL_CHANGED;

				break;

			default :

				return null;

		}

		String topic = HEADER + Constants.TOPIC_SEPARATOR + typename;

		Hashtable properties = new Hashtable();

		Bundle bundle = event.getBundle();

		if (bundle != null) {

			putBundleProperties(properties, bundle);

		}

		Throwable t = event.getThrowable();

		if (t != null) {

			putExceptionProperties(properties, t);

		}

		properties.put(Constants.EVENT, event);

		Event converted = new Event(topic, properties);

		return converted;

	}

}

/*******************************************************************************

 * Copyright (c) 2005, 2007 IBM Corporation.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     IBM Corporation - initial API and implementation

 *******************************************************************************/

package org.eclipse.equinox.event.mapper;

import java.util.Hashtable;

import org.osgi.framework.ServiceReference;

import org.osgi.service.event.Event;

import org.osgi.service.event.EventAdmin;

import org.osgi.service.wireadmin.Wire;

import org.osgi.service.wireadmin.WireAdminEvent;

/**

 * @version $Revision: 1.2 $

 */

public class WireAdminEventAdapter extends EventAdapter {

	// constants for Event topic substring

	public static final String TOPIC = "org/osgi/service/wireadmin/WireAdminEvent";

	public static final String WIRE_CREATED = "WIRE_CREATED";

	public static final String WIRE_CONNECTED_T = "WIRE_CONNECTED";

	public static final String WIRE_UPDATED = "WIRE_UPDATED";

	public static final String WIRE_TRACE = "WIRE_TRACE";

	public static final String WIRE_DISCONNECTED = "WIRE_DISCONNECTED";

	public static final String WIRE_DELETED = "WIRE_DELETED";

	public static final String PRODUCER_EXCEPTION = "PRODUCER_EXCEPTION";

	public static final String CONSUMER_EXCEPTION = "CONSUMER_EXCEPTION";

	// constants for Event properties

	public static final String WIRE = "wire";

	public static final String WIRE_FLAVORS = "wire.flavors";

	public static final String WIRE_SCOPE = "wire.scope";

	public static final String WIRE_CONNECTED_P = "wire.connected";

	public static final String WIRE_VALID = "wire.valid";

	private WireAdminEvent event;

	public WireAdminEventAdapter(WireAdminEvent event, EventAdmin admin) {

		super(admin);

		this.event = event;

	}

	/**

	 * @see org.eclipse.equinox.event.mapper.EventAdapter#convert()

	 */

	public Event convert() {

		String typename = null;

		switch (event.getType()) {

			case WireAdminEvent.WIRE_CONNECTED :

				typename = WIRE_CONNECTED_T;

				break;

			case WireAdminEvent.WIRE_CREATED :

				typename = WIRE_CREATED;

				break;

			case WireAdminEvent.WIRE_UPDATED :

				typename = WIRE_UPDATED;

				break;

			case WireAdminEvent.WIRE_DELETED :

				typename = WIRE_DELETED;

				break;

			case WireAdminEvent.WIRE_DISCONNECTED :

				typename = WIRE_DISCONNECTED;

				break;

			case WireAdminEvent.WIRE_TRACE :

				typename = WIRE_TRACE;

				break;

			case WireAdminEvent.PRODUCER_EXCEPTION :

				typename = PRODUCER_EXCEPTION;

				break;

			case WireAdminEvent.CONSUMER_EXCEPTION :

				typename = CONSUMER_EXCEPTION;

				break;

			default :

				return null;

		}

		String topic = TOPIC + Constants.TOPIC_SEPARATOR + typename;

		Hashtable properties = new Hashtable();

		Throwable t = event.getThrowable();

		if (t != null) {

			putExceptionProperties(properties, t);

		}

		ServiceReference ref = event.getServiceReference();

		if (ref == null) {

			throw new RuntimeException("WireAdminEvent's getServiceReference() returns null.");

		}

		putServiceReferenceProperties(properties, ref);

		Wire wire = event.getWire();

		if (wire != null) {

			properties.put(WIRE, wire);

			if (wire.getFlavors() != null) {

				properties.put(WIRE_FLAVORS, classes2strings(wire.getFlavors()));

			}

			if (wire.getScope() != null) {

				properties.put(WIRE_SCOPE, wire.getScope());

			}

			properties.put(WIRE_CONNECTED_P, new Boolean(wire.isConnected()));

			properties.put(WIRE_VALID, new Boolean(wire.isValid()));

		}

		properties.put(Constants.EVENT, event);

		Event converted = new Event(topic, properties);

		return converted;

	}

}

/*******************************************************************************

 * Copyright (c) 2005, 2007 IBM Corporation.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     IBM Corporation - initial API and implementation

 *******************************************************************************/

package org.eclipse.equinox.event.mapper;

import java.util.Hashtable;

import org.osgi.framework.Bundle;

import org.osgi.framework.ServiceReference;

import org.osgi.service.event.Event;

import org.osgi.service.event.EventAdmin;

/**

 * @version $Revision: 1.2 $

 */

public abstract class EventAdapter {

	final EventAdmin eventAdmin;

	/**

	 * @param event

	 * @param eventAdmin

	 */

	public EventAdapter(EventAdmin eventAdmin) {

		this.eventAdmin = eventAdmin;

	}

	/**

	 * @return event

	 */

	public abstract Event convert();

	public void redeliver() {

		Event converted = convert();

		if (converted != null) {

			redeliverInternal(converted);

		}

	}

	/**

	 * subclasses should override this method if it wants to use sendEvent()

	 * instead.

	 */

	protected void redeliverInternal(Event converted) {

		eventAdmin.postEvent(converted);

	}

	public void putBundleProperties(Hashtable properties, Bundle bundle) {

		// assertion bundle != null

		properties.put(Constants.BUNDLE_ID, new Long(bundle.getBundleId()));

		String symbolicName = bundle.getSymbolicName();

		if (symbolicName != null) {

			properties.put(Constants.BUNDLE_SYMBOLICNAME, symbolicName);

		}

		properties.put(Constants.BUNDLE, bundle);

	}

	public void putExceptionProperties(Hashtable properties, Throwable t) {

		// assertion t != null

		properties.put(Constants.EXCEPTION, t);

		properties.put(Constants.EXCEPTION_CLASS, t.getClass().getName());

		String message = t.getMessage();

		if (message != null) {

			properties.put(Constants.EXCEPTION_MESSAGE, t.getMessage());

		}

	}

	public void putServiceReferenceProperties(Hashtable properties, ServiceReference ref) {

		// assertion ref != null

		properties.put(Constants.SERVICE, ref);

		properties.put(Constants.SERVICE_ID, ref.getProperty(org.osgi.framework.Constants.SERVICE_ID));

		Object o = ref.getProperty(org.osgi.framework.Constants.SERVICE_PID);

		if ((o != null) && (o instanceof String)) {

			properties.put(Constants.SERVICE_PID, (String) o);

		}

		Object o2 = ref.getProperty(org.osgi.framework.Constants.OBJECTCLASS);

		if ((o2 != null) && (o2 instanceof String[])) {

			properties.put(Constants.SERVICE_OBJECTCLASS, (String[]) o2);

		}

	}

	/*

	 * Utility function for converting classes into strings

	 */

	public String[] classes2strings(Class classes[]) {

		if ((classes == null) || (classes.length == 0))

			return null;

		String[] strings = new String[classes.length];

		for (int i = 0; i < classes.length; i++) {

			strings[i] = classes[i].getName();

		}

		return strings;

	}

}

/*******************************************************************************

 * Copyright (c) 2005, 2007 IBM Corporation.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     IBM Corporation - initial API and implementation

 *******************************************************************************/

package org.eclipse.equinox.event.mapper;

import java.util.Hashtable;

import org.osgi.framework.ServiceEvent;

import org.osgi.framework.ServiceReference;

import org.osgi.service.event.Event;

import org.osgi.service.event.EventAdmin;

/**

 * @version $Revision: 1.3 $

 */

public class ServiceEventAdapter extends EventAdapter {

	// constants for Event topic substring

	public static final String HEADER = "org/osgi/framework/ServiceEvent";

	public static final String UNREGISTERING = "UNREGISTERING";

	public static final String MODIFIED = "MODIFIED";

	public static final String REGISTERED = "REGISTERED";

	private ServiceEvent event;

	public ServiceEventAdapter(ServiceEvent event, EventAdmin eventAdmin) {

		super(eventAdmin);

		this.event = event;

	}

	/**

	 * @see org.eclipse.equinox.event.mapper.EventAdapter#convert()

	 */

	public Event convert() {

		String typename = null;

		switch (event.getType()) {

			case ServiceEvent.REGISTERED :

				typename = REGISTERED;

				break;

			case ServiceEvent.MODIFIED :

				typename = MODIFIED;

				break;

			case ServiceEvent.UNREGISTERING :

				typename = UNREGISTERING;

				break;

			default :

				return null;

		}

		String topic = HEADER + Constants.TOPIC_SEPARATOR + typename;

		Hashtable properties = new Hashtable();

		ServiceReference ref = event.getServiceReference();

		if (ref != null) {

			putServiceReferenceProperties(properties, ref);

		}

		properties.put(Constants.EVENT, event);

		Event converted = new Event(topic, properties);

		return converted;

	}

}

/*******************************************************************************

 * Copyright (c) 2005 IBM Corporation.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     IBM Corporation - initial API and implementation

 *******************************************************************************/

package org.eclipse.equinox.event.mapper;

/**

 * @version $Revision: 1.1 $

 */

public interface Constants {

	// constants for Event common properties; event specific properties are

	// defined in the corresponding event adapter.

	public static final String	BUNDLE				= "bundle";

	public static final String	BUNDLE_ID			= "bundle.id";

	public static final String	BUNDLE_SYMBOLICNAME	= "bundle.symbolicName";

	public static final String	EVENT				= "event";

	public static final String	EXCEPTION			= "exception";

	public static final String	EXCEPTION_CLASS		= "exception.class";

	public static final String	EXCEPTION_MESSAGE	= "exception.message";

	public static final String	MESSAGE				= "message";

	public static final String	SERVICE				= "service";

	public static final String	SERVICE_ID			= "service.id";

	public static final String	SERVICE_OBJECTCLASS	= "service.objectClass";

	public static final String	SERVICE_PID			= "service.pid";

	public static final String	TIMESTAMP			= "timestamp";

	public static final char	TOPIC_SEPARATOR		= '/';

}

/*******************************************************************************

 * Copyright (c) 2005, 2007 IBM Corporation.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     IBM Corporation - initial API and implementation

 *******************************************************************************/

package org.eclipse.equinox.event.mapper;

import java.util.Hashtable;

import org.osgi.framework.ServiceReference;

import org.osgi.service.event.Event;

import org.osgi.service.event.EventAdmin;

import org.osgi.service.useradmin.Role;

import org.osgi.service.useradmin.UserAdminEvent;

/**

 * @version $Revision: 1.2 $

 */

public class UserAdminEventAdapter extends EventAdapter {

	// constants for Event topic substring

	public static final String TOPIC = "org/osgi/service/useradmin/UserAdminEvent";

	public static final String ROLE_CREATED = "ROLE_CREATED";

	public static final String ROLE_CHANGED = "ROLE_CHANGED";

	public static final String ROLE_REMOVED = "ROLE_REMOVED";

	// constants for Event properties

	public static final String ROLE = "role";

	public static final String ROLE_NAME = "role.name";

	public static final String ROLE_TYPE = "role.type";

	private UserAdminEvent event;

	public UserAdminEventAdapter(UserAdminEvent event, EventAdmin eventAdmin) {

		super(eventAdmin);

		this.event = event;

	}

	/**

	 * @see org.eclipse.equinox.event.mapper.EventAdapter#convert()

	 */

	public Event convert() {

		String typename = null;

		switch (event.getType()) {

			case UserAdminEvent.ROLE_CREATED :

				typename = ROLE_CREATED;

				break;

			case UserAdminEvent.ROLE_CHANGED :

				typename = ROLE_CHANGED;

				break;

			case UserAdminEvent.ROLE_REMOVED :

				typename = ROLE_REMOVED;

				break;

			default :

				return null;

		}

		String topic = TOPIC + Constants.TOPIC_SEPARATOR + typename;

		Hashtable properties = new Hashtable();

		ServiceReference ref = event.getServiceReference();

		if (ref == null) {

			throw new RuntimeException("UserAdminEvent's getServiceReference() returns null.");

		}

		putServiceReferenceProperties(properties, ref);

		Role role = event.getRole();

		if (role == null) {

			throw new RuntimeException("UserAdminEvent's getRole() returns null.");

		}

		if (role != null) {

			properties.put(ROLE, role);

			properties.put(ROLE_NAME, role.getName());

			properties.put(ROLE_TYPE, new Integer(role.getType()));

		}

		properties.put(Constants.EVENT, event);

		Event converted = new Event(topic, properties);

		return converted;

	}

}

/*******************************************************************************

 * Copyright (c) 2005 IBM Corporation.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     IBM Corporation - initial API and implementation

 *******************************************************************************/

package org.eclipse.equinox.event.mapper;

import org.osgi.framework.BundleContext;

import org.osgi.framework.ServiceReference;

import org.osgi.service.log.LogReaderService;

import org.osgi.util.tracker.ServiceTracker;

/**

 * @version $Revision: 1.1 $

 */

public class LogReaderServiceTracker extends ServiceTracker {

	private final LogReaderServiceListener	listener;

	private ServiceReference				reference;

	public LogReaderServiceTracker(BundleContext context,

			LogReaderServiceListener listener) {

		super(context, LogReaderService.class.getName(), null);

		this.listener = listener;

	}

	public Object addingService(ServiceReference reference) {

		Object object = super.addingService(reference);

		if ((object != null) && (this.reference == null)

				&& (object instanceof LogReaderService)) {

			this.reference = reference;

			listener.logReaderServiceAdding(reference,

					(LogReaderService) object);

		}

		return object;

	}

	public void removedService(ServiceReference reference, Object service) {

		if ((service != null) && (this.reference.equals(reference))

				&& (service instanceof LogReaderService)) {

			listener.logReaderServiceRemoved(reference,

					(LogReaderService) service);

			this.reference = null;

		}

		super.removedService(reference, service);

		//this method calls ungetService()

	}

}

/*******************************************************************************

 * Copyright (c) 2005 IBM Corporation.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     IBM Corporation - initial API and implementation

 *******************************************************************************/

package org.eclipse.equinox.event.mapper;

import java.util.Dictionary;

import java.util.Hashtable;

import org.osgi.framework.*;

import org.osgi.service.cm.ConfigurationEvent;

import org.osgi.service.cm.ConfigurationListener;

import org.osgi.service.event.EventAdmin;

import org.osgi.service.log.LogEntry;

import org.osgi.service.log.LogListener;

import org.osgi.service.log.LogReaderService;

import org.osgi.service.upnp.UPnPDevice;

import org.osgi.service.upnp.UPnPEventListener;

import org.osgi.service.upnp.UPnPService;

import org.osgi.service.useradmin.UserAdminEvent;

import org.osgi.service.useradmin.UserAdminListener;

import org.osgi.service.wireadmin.WireAdminEvent;

import org.osgi.service.wireadmin.WireAdminListener;

import org.osgi.service.wireadmin.WireConstants;

import org.osgi.util.tracker.ServiceTracker;

/**

 * Main class for redeliver special events like FrameworkEvents via EventAdmin.

 * 

 * 

 * @version $Revision: 1.1 $

 */

public class EventRedeliverer implements FrameworkListener, BundleListener,

		ServiceListener, LogListener, LogReaderServiceListener,

		ConfigurationListener, WireAdminListener, UPnPEventListener,

		UserAdminListener {

	private ServiceTracker			eventAdminTracker;

	private LogReaderServiceTracker	logTracker;

	private LogReaderService		reader;

	private final static boolean	DEBUG	= false;

	private BundleContext			bc;

	private ServiceRegistration		configurationListenerReg;

	private ServiceRegistration		wireAdminListenerReg;

	private ServiceRegistration		upnpEventListenerReg;

	private ServiceRegistration		userAdminListenerReg;

	public EventRedeliverer(BundleContext bc) {

		this.bc = bc;

	}

	public void close() {

		if (logTracker != null) {

			logTracker.close();

			logTracker = null;

		}

		if (eventAdminTracker != null) {

			eventAdminTracker.close();

			eventAdminTracker = null;

		}

		if (reader != null) {

			reader.removeLogListener(this);

		}

		reader = null;

		bc.removeFrameworkListener(this);

		bc.removeBundleListener(this);

		bc.removeServiceListener(this);

		if (configurationListenerReg != null) {

			configurationListenerReg.unregister();

			configurationListenerReg = null;

		}

		if (wireAdminListenerReg != null) {

			wireAdminListenerReg.unregister();

			wireAdminListenerReg = null;

		}

		if (upnpEventListenerReg != null) {

			upnpEventListenerReg.unregister();

			upnpEventListenerReg = null;

		}

		if (userAdminListenerReg != null) {

			userAdminListenerReg.unregister();

			userAdminListenerReg = null;

		}

	}

	/**

	 * prepare any service trackers and register event listeners which are

	 * necessary to obtain events to be mapped

	 */

	public void open() {

		// open ServiceTracker for EventAdmin

		eventAdminTracker = new ServiceTracker(bc, EventAdmin.class.getName(),

				null);

		eventAdminTracker.open();

		// open ServiceTracker for LogReaderService

		logTracker = new LogReaderServiceTracker(bc, this);

		logTracker.open();

		// add legacy event listener for framework level event

		bc.addFrameworkListener(this);

		bc.addBundleListener(this);

		bc.addServiceListener(this);

		// register configurationListener

		configurationListenerReg = bc.registerService(

				ConfigurationListener.class.getName(), this, null);

		// register WireAdminListener

		Hashtable ht = new Hashtable();

		// create an event mask to receive all the types of WireAdminEvent

		Integer mask = new Integer(WireAdminEvent.WIRE_CONNECTED

				| WireAdminEvent.WIRE_CREATED | WireAdminEvent.WIRE_DELETED

				| WireAdminEvent.WIRE_DISCONNECTED | WireAdminEvent.WIRE_TRACE

				| WireAdminEvent.WIRE_UPDATED

				| WireAdminEvent.CONSUMER_EXCEPTION

				| WireAdminEvent.PRODUCER_EXCEPTION);

		ht.put(WireConstants.WIREADMIN_EVENTS, mask);

		wireAdminListenerReg = bc.registerService(WireAdminListener.class

				.getName(), this, ht);

		// register UPnPEventListener

		// create a Filter object to receive all the UPnP events

		Hashtable ht2 = new Hashtable();

		Filter filter = null;

		try {

			filter = bc.createFilter("(|(|(" + UPnPDevice.TYPE + "=*)("

					+ UPnPDevice.ID + "=*))(|(" + UPnPService.TYPE + "=*)("

					+ UPnPService.ID + "=*)))");

		}

		catch (InvalidSyntaxException e) {

			System.out

					.println("Exception thrown while trying to create Filter. "

							+ e);

			e.printStackTrace(System.out);

		}

		if (filter != null) {

			ht2.put(UPnPEventListener.UPNP_FILTER, filter);

			upnpEventListenerReg = bc.registerService(UPnPEventListener.class

					.getName(), this, ht2);

		}

		// register usrAdminListener

		userAdminListenerReg = bc.registerService(UserAdminListener.class

				.getName(), this, null);

	}

	private EventAdmin getEventAdmin() {

		if (eventAdminTracker == null)

			return null;

		return (EventAdmin) eventAdminTracker.getService();

	}

	/**

	 * @param event

	 * @see org.osgi.framework.FrameworkListener#frameworkEvent(org.osgi.framework.FrameworkEvent)

	 */

	public void frameworkEvent(FrameworkEvent event) {

		EventAdmin eventAdmin = getEventAdmin();

		if (eventAdmin != null) {

			(new FrameworkEventAdapter(event, eventAdmin)).redeliver();

		}

		else {

			printNoEventAdminError();

		}

	}

	private void printNoEventAdminError() {

		if (DEBUG) {

			System.out.println(this.getClass().getName()

					+ ": Cannot find the EventAdmin.");

		}

	}

	/**

	 * @param event

	 * @see org.osgi.framework.BundleListener#bundleChanged(org.osgi.framework.BundleEvent)

	 */

	public void bundleChanged(BundleEvent event) {

		EventAdmin eventAdmin = getEventAdmin();

		if (eventAdmin != null) {

			(new BundleEventAdapter(event, eventAdmin)).redeliver();

		}

		else {

			printNoEventAdminError();

		}

	}

	/**

	 * @param event

	 * @see org.osgi.framework.ServiceListener#serviceChanged(org.osgi.framework.ServiceEvent)

	 */

	public void serviceChanged(ServiceEvent event) {

		EventAdmin eventAdmin = getEventAdmin();

		if (eventAdmin != null) {

			(new ServiceEventAdapter(event, eventAdmin)).redeliver();

		}

		else {

			printNoEventAdminError();

		}

	}

	/**

	 * @param entry

	 * @see org.osgi.service.log.LogListener#logged(org.osgi.service.log.LogEntry)

	 */

	public void logged(LogEntry entry) {

		EventAdmin eventAdmin = getEventAdmin();

		if (eventAdmin != null) {

			(new LogEntryAdapter(entry, eventAdmin)).redeliver();

		}

		else {

			printNoEventAdminError();

		}

	}

	/**

	 * @param reference

	 * @param service

	 * @see org.eclipse.equinox.event.mapper.LogReaderServiceListener#logReaderServiceAdding(org.osgi.framework.ServiceReference,

	 *      org.osgi.service.log.LogReaderService)

	 */

	public void logReaderServiceAdding(ServiceReference reference,

			LogReaderService service) {

		if (reader != null) {

			return;

		}

		reader = service;

		reader.addLogListener(this);

	}

	/**

	 * @param reference

	 * @param service

	 * @see org.eclipse.equinox.event.mapper.LogReaderServiceListener#logReaderServiceRemoved(org.osgi.framework.ServiceReference,

	 *      org.osgi.service.log.LogReaderService)

	 */

	public void logReaderServiceRemoved(ServiceReference reference,

			LogReaderService service) {

		if ((reader != null) && reader.equals(service)) {

			reader.removeLogListener(this);

			reader = null;

		}

		// ungetService() will be called after returning to

		// LogReaderServiceTracker's removedService() method.

	}

	/**

	 * @param event

	 * @see org.osgi.service.cm.ConfigurationListener#configurationEvent(org.osgi.service.cm.ConfigurationEvent)

	 */

	public void configurationEvent(ConfigurationEvent event) {

		EventAdmin eventAdmin = getEventAdmin();

		if (eventAdmin != null) {

			(new ConfigurationEventAdapter(event, eventAdmin)).redeliver();

		}

		else {

			printNoEventAdminError();

		}

	}

	/**

	 * @param event

	 * @see org.osgi.service.wireadmin.WireAdminListener#wireAdminEvent(org.osgi.service.wireadmin.WireAdminEvent)

	 */

	public void wireAdminEvent(WireAdminEvent event) {

		EventAdmin eventAdmin = getEventAdmin();

		if (eventAdmin != null) {

			(new WireAdminEventAdapter(event, eventAdmin)).redeliver();

		}

		else {

			printNoEventAdminError();

		}

	}

	/**

	 * @param deviceId

	 * @param serviceId

	 * @param events

	 * @see org.osgi.service.upnp.UPnPEventListener#notifyUPnPEvent(java.lang.String,

	 *      java.lang.String, java.util.Dictionary)

	 */

	public void notifyUPnPEvent(String deviceId, String serviceId,

			Dictionary events) {

		EventAdmin eventAdmin = getEventAdmin();

		if (eventAdmin != null) {

			(new UPnPEventAdapter(deviceId, serviceId, events, eventAdmin))

					.redeliver();

		}

		else {

			printNoEventAdminError();

		}

	}

	/**

	 * @param event

	 * @see org.osgi.service.useradmin.UserAdminListener#roleChanged(org.osgi.service.useradmin.UserAdminEvent)

	 */

	public void roleChanged(UserAdminEvent event) {

		EventAdmin eventAdmin = getEventAdmin();

		if (eventAdmin != null) {

			(new UserAdminEventAdapter(event, eventAdmin)).redeliver();

		}

		else {

			printNoEventAdminError();

		}

	}

}

/*******************************************************************************

 * Copyright (c) 2005, 2007 IBM Corporation.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     IBM Corporation - initial API and implementation

 *******************************************************************************/

package org.eclipse.equinox.event.mapper;

import java.util.Dictionary;

import java.util.Hashtable;

import org.osgi.service.event.Event;

import org.osgi.service.event.EventAdmin;

/**

 * @version $Revision: 1.2 $

 */

public class UPnPEventAdapter extends EventAdapter {

	// constants for Event topic substring

	public static final String TOPIC = "org/osgi/service/upnp/UPnPEvent";

	// constants for Event properties

	public static final String UPNP_DEVICEID = "upnp.deviceId";

	public static final String UPNP_SERVICEID = "upnp.serviceId";

	public static final String UPNP_EVENTS = "upnp.events";

	private String deviceId;

	private String serviceId;

	private Dictionary events;

	public UPnPEventAdapter(String deviceId, String serviceId, Dictionary events, EventAdmin eventAdmin) {

		super(eventAdmin);

		this.deviceId = deviceId;

		this.serviceId = serviceId;

		this.events = events;

	}

	/**

	 * @see org.eclipse.equinox.event.mapper.EventAdapter#convert()

	 */

	public Event convert() {

		Hashtable properties = new Hashtable();

		if (deviceId != null) {

			properties.put(UPNP_DEVICEID, deviceId);

		}

		if (serviceId != null) {

			properties.put(UPNP_SERVICEID, serviceId);

		}

		if (events != null) {

			properties.put(UPNP_EVENTS, events);

		}

		Event converted = new Event(TOPIC, properties);

		return converted;

	}

}

/*******************************************************************************

 * Copyright (c) 2005, 2007 IBM Corporation.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     IBM Corporation - initial API and implementation

 *******************************************************************************/

package org.eclipse.equinox.event.mapper;

import java.util.Hashtable;

import org.osgi.framework.ServiceReference;

import org.osgi.service.cm.ConfigurationEvent;

import org.osgi.service.event.Event;

import org.osgi.service.event.EventAdmin;

/**

 * @version $Revision: 1.2 $

 */

public class ConfigurationEventAdapter extends EventAdapter {

	// constants for Event topic substring

	public static final String HEADER = "org/osgi/service/cm/ConfigurationEvent";

	public static final String CM_UPDATED = "CM_UPDATED";

	public static final String CM_DELETED = "CM_DELETED";

	// constants for Event properties

	public static final String CM_FACTORY_PID = "cm.factoryPid";

	public static final String CM_PID = "cm.pid";

	private ConfigurationEvent event;

	public ConfigurationEventAdapter(ConfigurationEvent event, EventAdmin eventAdmin) {

		super(eventAdmin);

		this.event = event;

	}

	/**

	 * @see org.eclipse.equinox.event.mapper.EventAdapter#convert()

	 */

	public Event convert() {

		String typename = null;

		switch (event.getType()) {

			case ConfigurationEvent.CM_UPDATED :

				typename = CM_UPDATED;

				break;

			case ConfigurationEvent.CM_DELETED :

				typename = CM_DELETED;

				break;

			default :

				return null;

		}

		String topic = HEADER + Constants.TOPIC_SEPARATOR + typename;

		Hashtable properties = new Hashtable();

		ServiceReference ref = event.getReference();

		if (ref == null) {

			throw new RuntimeException("ServiceEvent.getServiceReference() is null");

		}

		properties.put(CM_PID, event.getPid());

		if (event.getFactoryPid() != null) {

			properties.put(CM_FACTORY_PID, event.getFactoryPid());

		}

		putServiceReferenceProperties(properties, ref);

		// assert objectClass includes

		// "org.osgi.service.cm.ConfigurationAdmin"

		Event converted = new Event(topic, properties);

		return converted;

	}

}

/*******************************************************************************

 * Copyright (c) 2005, 2007 IBM Corporation.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     IBM Corporation - initial API and implementation

 *******************************************************************************/

package org.eclipse.equinox.event.mapper;

import java.util.Hashtable;

import org.osgi.framework.Bundle;

import org.osgi.framework.ServiceReference;

import org.osgi.service.event.Event;

import org.osgi.service.event.EventAdmin;

import org.osgi.service.log.LogEntry;

import org.osgi.service.log.LogService;

/**

 * @version $Revision: 1.2 $

 */

public class LogEntryAdapter extends EventAdapter {

	// constants for Event topic substring

	public static final String TOPIC = "org/osgi/service/log/LogEntry";

	// constants for Event properties

	public static final String TIMESTAMP = "timestamp";

	public static final String MESSAGE = "message";

	public static final String LOG_LEVEL = "log.level";

	public static final String LOG_ENTRY = "log.entry";

	private LogEntry entry;

	public LogEntryAdapter(LogEntry entry, EventAdmin eventAdmin) {

		super(eventAdmin);

		this.entry = entry;

	}

	/**

	 * @see org.eclipse.equinox.event.mapper.EventAdapter#convert()

	 */

	public Event convert() {

		String topic = TOPIC;

		int level = entry.getLevel();

		switch (level) {

			case LogService.LOG_ERROR :

			case LogService.LOG_WARNING :

			case LogService.LOG_INFO :

			case LogService.LOG_DEBUG :

				break;

			default :

				// other log levels are represented by their decimal value

				topic += Constants.TOPIC_SEPARATOR + level;

		}

		Hashtable properties = new Hashtable();

		Bundle bundle = entry.getBundle();

		if (bundle == null) {

			throw new RuntimeException("LogEntry.getBundle() returns null");

		}

		putBundleProperties(properties, bundle);

		Throwable t = entry.getException();

		if (t != null) {

			putExceptionProperties(properties, t);

		}

		ServiceReference ref = entry.getServiceReference();

		if (ref != null) {

			putServiceReferenceProperties(properties, ref);

		}

		properties.put(LOG_ENTRY, entry);

		properties.put(LOG_LEVEL, new Integer(entry.getLevel()));

		if (entry.getMessage() != null)

			properties.put(MESSAGE, entry.getMessage());

		properties.put(TIMESTAMP, new Long(entry.getTime()));

		Event converted = new Event(topic, properties);

		return converted;

	}

}

/*******************************************************************************

 * Copyright (c) 2005, 2007 IBM Corporation.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     IBM Corporation - initial API and implementation

 *******************************************************************************/

package org.eclipse.equinox.event.mapper;

import java.util.Hashtable;

import org.osgi.framework.Bundle;

import org.osgi.framework.BundleEvent;

import org.osgi.service.event.Event;

import org.osgi.service.event.EventAdmin;

/**

 * @version $Revision: 1.2 $

 */

public class BundleEventAdapter extends EventAdapter {

	// constants for Event topic substring

	public static final String HEADER = "org/osgi/framework/BundleEvent";

	public static final String INSTALLED = "INSTALLED";

	public static final String STOPPED = "STOPPED";

	public static final String STARTED = "STARTED";

	public static final String UPDATED = "UPDATED";

	public static final String UNINSTALLED = "UNINSTALLED";

	public static final String RESOLVED = "RESOLVED";

	public static final String UNRESOLVED = "UNRESOLVED";

	private BundleEvent event;

	public BundleEventAdapter(BundleEvent event, EventAdmin eventAdmin) {

		super(eventAdmin);

		this.event = event;

	}

	/**

	 * @return event

	 * @see org.eclipse.equinox.event.mapper.EventAdapter#convert()

	 */

	public Event convert() {

		String typename = null;

		switch (event.getType()) {

			case BundleEvent.INSTALLED :

				typename = INSTALLED;

				break;

			case BundleEvent.STOPPED :

				typename = STOPPED;

				break;

			case BundleEvent.STARTED :

				typename = STARTED;

				break;

			case BundleEvent.UPDATED :

				typename = UPDATED;

				break;

			case BundleEvent.UNINSTALLED :

				typename = UNINSTALLED;

				break;

			case BundleEvent.RESOLVED :

				typename = RESOLVED;

				break;

			case BundleEvent.UNRESOLVED :

				typename = UNRESOLVED;

				break;

			default :

				// unknown events must be send as their decimal value

				typename = "" + event.getType();

		}

		String topic = HEADER + Constants.TOPIC_SEPARATOR + typename;

		Hashtable properties = new Hashtable();

		Bundle bundle = event.getBundle();

		if (bundle == null) {

			throw new RuntimeException("BundleEvent.getBundle() returns null");

		} else {

			putBundleProperties(properties, bundle);

		}

		properties.put(Constants.EVENT, event);

		Event converted = new Event(topic, properties);

		return converted;

	}

}

/*******************************************************************************

 * Copyright (c) 2005, 2007 IBM Corporation.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     IBM Corporation - initial API and implementation

 *******************************************************************************/

package org.eclipse.equinox.event;

import java.security.Permission;

import java.util.Iterator;

import java.util.Set;

import org.eclipse.osgi.framework.eventmgr.*;

import org.eclipse.osgi.util.NLS;

import org.osgi.framework.BundleContext;

import org.osgi.service.event.*;

import org.osgi.service.log.LogService;

/**

 * Implementation of org.osgi.service.event.EventAdmin. EventAdminImpl uses

 * org.eclipse.osgi.framework.eventmgr.EventManager. It is assumeed

 * org.eclipse.osgi.framework.eventmgr package is exported by some other bundle.

 */

public class EventAdminImpl implements EventAdmin {

	private final LogTracker log;

	private final EventHandlerTracker handlers;

	private volatile EventManager		eventManager;

	/**

	 * Constructor for EventAdminImpl.

	 * 

	 * @param context BundleContext

	 */

	EventAdminImpl(BundleContext context) {

		super();

		log = new LogTracker(context, System.out);

		handlers = new EventHandlerTracker(context, log);

	}

	/**

	 * This method should be called before registering EventAdmin service

	 */

	void start() {

		log.open();

		ThreadGroup eventGroup = new ThreadGroup("Equinox Event Admin"); //$NON-NLS-1$

		eventGroup.setDaemon(true);

		eventManager = new EventManager(EventAdminMsg.EVENT_ASYNC_THREAD_NAME, eventGroup);

		handlers.open();

	}

	/**

	 * This method should be called after unregistering EventAdmin service

	 */

	void stop() {

		handlers.close();

		eventManager.close();

		eventManager = null;	// signify we have stopped

		log.close();

	}

	/**

	 * @param event

	 * @see org.osgi.service.event.EventAdmin#postEvent(org.osgi.service.event.Event)

	 */

	public void postEvent(Event event) {

		dispatchEvent(event, true);

	}

	/**

	 * @param event

	 * @see org.osgi.service.event.EventAdmin#sendEvent(org.osgi.service.event.Event)

	 */

	public void sendEvent(Event event) {

		dispatchEvent(event, false);

	}

	/**

	 * Internal main method for sendEvent() and postEvent(). Dispatching an

	 * event to EventHandler. All exceptions are logged except when dealing with

	 * LogEntry.

	 * 

	 * @param event to be delivered

	 * @param isAsync must be set to true for syncronous event delivery, false

	 *        for asyncronous delivery.

	 */

	private void dispatchEvent(Event event, boolean isAsync) {

		// keep a local copy in case we are stopped in the middle of dispatching

		EventManager currentManager = eventManager;

		if (currentManager == null) {

			// EventAdmin is stopped

			return;

		}

		if (event == null) {

			log.log(LogService.LOG_ERROR, EventAdminMsg.EVENT_NULL_EVENT);

			// continue from here will result in an NPE below; the spec for EventAdmin does not allow for null here

		}

		String topic = event.getTopic();

		try {

			checkTopicPermissionPublish(topic);

		} catch (SecurityException e) {

			String msg = NLS.bind(EventAdminMsg.EVENT_NO_TOPICPERMISSION_PUBLISH, event.getTopic());

			log.log(LogService.LOG_ERROR, msg);

			// must throw a security exception here according to the EventAdmin spec

			throw e;

		}

		Set eventHandlers = handlers.getHandlers(topic);

		// If there are no handlers, then we are done

		if (eventHandlers.size() == 0) {

			return;

		}

		SecurityManager sm = System.getSecurityManager();

		Permission perm = (sm == null) ? null : new TopicPermission(topic, TopicPermission.SUBSCRIBE);

		EventListeners listeners = new EventListeners();

		Iterator iter = eventHandlers.iterator();

		while (iter.hasNext()) {

			EventHandlerWrapper wrapper = (EventHandlerWrapper) iter.next();

			listeners.addListener(wrapper, perm);

		}

		// Create the listener queue for this event delivery

		ListenerQueue listenerQueue = new ListenerQueue(currentManager);

		// Add the listeners to the queue and associate them with the event

		// dispatcher

		listenerQueue.queueListeners(listeners, handlers);

		// Deliver the event to the listeners.

		if (isAsync) {

			listenerQueue.dispatchEventAsynchronous(0, event);

		}

		else {

			listenerQueue.dispatchEventSynchronous(0, event);

		}

	}

	/**

	 * Checks if the caller bundle has right PUBLISH TopicPermision.

	 * 

	 * @param topic

	 * @throws SecurityException if the caller does not have the right to PUBLISH TopicPermission

	 */

	private void checkTopicPermissionPublish(String topic) throws SecurityException{

		SecurityManager sm = System.getSecurityManager();

		if (sm == null)

			return;

		sm.checkPermission(new TopicPermission(topic, TopicPermission.PUBLISH));

	}

}

/*******************************************************************************

 * Copyright (c) 2007 IBM Corporation and others.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     IBM Corporation - initial API and implementation

 *******************************************************************************/

package org.eclipse.equinox.event;

import java.security.Permission;

import java.util.*;

import org.eclipse.osgi.framework.eventmgr.EventDispatcher;

import org.osgi.framework.BundleContext;

import org.osgi.framework.ServiceReference;

import org.osgi.service.event.Event;

import org.osgi.service.event.EventHandler;

import org.osgi.service.log.LogService;

import org.osgi.util.tracker.ServiceTracker;

public class EventHandlerTracker extends ServiceTracker implements EventDispatcher {

	private final LogService log;

	//* List<EventHandlerWrapper> of all handlers with topic of "*"

	private final List globalWildcard;

	// Map<String,List<EventHandlerWrapper>> key is topic prefix of partial wildcard

	private final Map partialWildcard;

	// Map<String,List<EventHandlerWrapper>> key is topic name

	private final Map topicName;

	public EventHandlerTracker(BundleContext context, LogService log) {

		super(context, EventHandler.class.getName(), null);

		this.log = log;

		globalWildcard = new ArrayList();

		partialWildcard = new HashMap();

		topicName = new HashMap();

	}

	public Object addingService(ServiceReference reference) {

		EventHandlerWrapper wrapper = new EventHandlerWrapper(reference, context, log);

		synchronized (this) {

			if (wrapper.init()) {

				bucket(wrapper);

			}

		}

		return wrapper;

	}

	public void modifiedService(ServiceReference reference, Object service) {

		EventHandlerWrapper wrapper = (EventHandlerWrapper) service;

		synchronized (this) {

			unbucket(wrapper);

			if (wrapper.init()) {

				bucket(wrapper);

				return;

			}

		}

		wrapper.flush(); // needs to be called outside sync region

	}

	public void removedService(ServiceReference reference, Object service) {

		EventHandlerWrapper wrapper = (EventHandlerWrapper) service;

		synchronized (this) {

			unbucket(wrapper);

		}

		wrapper.flush(); // needs to be called outside sync region

	}

	/**

	 * Place the wrapper into the appropriate buckets.

	 * This is a performance optimization for event delivery.

	 * 

	 * @param wrapper The wrapper to place in buckets.

	 * @GuardedBy this

	 */

	private void bucket(EventHandlerWrapper wrapper) {

		final String[] topics = wrapper.getTopics();

		final int length = (topics == null) ? 0 : topics.length;

		for (int i = 0; i < length; i++) {

			String topic = topics[i];

			// global wildcard

			if (topic.equals("*")) { //$NON-NLS-1$

				globalWildcard.add(wrapper);

			}

			// partial wildcard

			else if (topic.endsWith("/*")) { //$NON-NLS-1$

				String key = topic.substring(0, topic.length() - 2); // Strip off "/*" from the end

				List wrappers = (List) partialWildcard.get(key);

				if (wrappers == null) {

					wrappers = new ArrayList();

					partialWildcard.put(key, wrappers);

				}

				wrappers.add(wrapper);

			}

			// simple topic name

			else {

				List wrappers = (List) topicName.get(topic);

				if (wrappers == null) {

					wrappers = new ArrayList();

					topicName.put(topic, wrappers);

				}

				wrappers.add(wrapper);

			}

		}

	}

	/**

	 * Remove the wrapper from the buckets.

	 * 

	 * @param wrapper The wrapper to remove from the buckets.

	 * @GuardedBy this

	 */

	private void unbucket(EventHandlerWrapper wrapper) {

		final String[] topics = wrapper.getTopics();

		final int length = (topics == null) ? 0 : topics.length;

		for (int i = 0; i < length; i++) {

			String topic = topics[i];

			// global wilcard

			if (topic.equals("*")) { //$NON-NLS-1$

				globalWildcard.remove(wrapper);

			}

			// partial wildcard

			else if (topic.endsWith("/*")) { //$NON-NLS-1$

				String key = topic.substring(0, topic.length() - 2); // Strip off "/*" from the end

				List wrappers = (List) partialWildcard.get(key);

				if (wrappers != null) {

					wrappers.remove(wrapper);

					if (wrappers.size() == 0) {

						partialWildcard.remove(key);

					}

				}

			}

			// simple topic name

			else {

				List wrappers = (List) topicName.get(topic);

				if (wrappers != null) {

					wrappers.remove(wrapper);

					if (wrappers.size() == 0) {

						topicName.remove(topic);

					}

				}

			}

		}

	}

	/**

	 * Return the set of handlers which subscribe to the event topic.

	 * A set is used to ensure a handler is not called for an event more than once.

	 * 

	 * @param topic

	 * @return a set of handlers

	 */

	public synchronized Set getHandlers(final String topic) {

		// Use a set to remove duplicates

		Set handlers = new HashSet();

		// Add the "*" handlers

		handlers.addAll(globalWildcard);

		// Add the handlers with partial matches

		if (partialWildcard.size() > 0) {

			int index = topic.length();

			while (index >= 0) {

				String subTopic = topic.substring(0, index); // First subtopic is the complete topic.

				List wrappers = (List) partialWildcard.get(subTopic);

				if (wrappers != null) {

					handlers.addAll(wrappers);

				}

				// Strip the last level from the topic. For example, org/osgi/framework becomes org/osgi.

				// Wildcard topics are inserted into the map with the "/*" stripped off.

				index = subTopic.lastIndexOf('/');

			}

		}

		// Add the handlers for matching topic names

		List wrappers = (List) topicName.get(topic);

		if (wrappers != null) {

			handlers.addAll(wrappers);

		}

		return handlers;

	}

	/**

	 * Dispatches Event to EventHandlers

	 * 

	 * @param eventListener

	 * @param listenerObject

	 * @param eventAction

	 * @param eventObject

	 * @see org.eclipse.osgi.framework.eventmgr.EventDispatcher#dispatchEvent(java.lang.Object,

	 *      java.lang.Object, int, java.lang.Object)

	 */

	public void dispatchEvent(Object eventListener, Object listenerObject, int eventAction, Object eventObject) {

		((EventHandlerWrapper) eventListener).handleEvent((Event) eventObject, (Permission) listenerObject);

	}

}

/*******************************************************************************

 * Copyright (c) 2007 IBM Corporation and others.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     IBM Corporation - initial API and implementation

 *******************************************************************************/

package org.eclipse.equinox.event;

import java.security.Permission;

import org.eclipse.osgi.util.NLS;

import org.osgi.framework.*;

import org.osgi.service.event.*;

import org.osgi.service.log.LogService;

/**

 * A wrapper for EventHandlers. This class caches property values and 

 * performs final checks before calling the wrapped handler.

 *

 */

public class EventHandlerWrapper {

	private final ServiceReference reference;

	private final LogService log;

	private final BundleContext context;

	private EventHandler handler;

	private String[] topics;

	private Filter filter;

	/**

	 * Create an EventHandlerWrapper. 

	 * @param reference Reference to the EventHandler

	 * @param context Bundle Context of the Event Admin bundle

	 * @param log LogService object for logging

	 */

	public EventHandlerWrapper(ServiceReference reference, BundleContext context, LogService log) {

		this.reference = reference;

		this.context = context;

		this.log = log;

	}

	/**

	 * Cache values from service properties

	 * 

	 * @return true if the handler should be called; false if the handler should not be called

	 */

	public synchronized boolean init() {

		topics = null;

		filter = null;

		// Get topic names

		Object o = reference.getProperty(EventConstants.EVENT_TOPIC);

		if (o instanceof String) {

			topics = new String[] {(String)o};

		}

		else if (o instanceof String[]) {

			topics = (String[]) o;

		}

		if (topics == null) {

			return false;

		}

		// get filter

		o = reference.getProperty(EventConstants.EVENT_FILTER);

		if (o instanceof String) {

			try {

				filter = context.createFilter((String)o);

			}

			catch (InvalidSyntaxException e) {

				log.log(LogService.LOG_ERROR,NLS.bind(EventAdminMsg.EVENT_INVALID_HANDLER_FILTER, o), e);

				return false;

			}

		}

		return true;

	}

	/**

	 * Flush the handler service if it has been obtained.

	 */

	public void flush() {

		synchronized (this) {

			if (handler == null) {

				return;

			}

			handler = null;

		}

		context.ungetService(reference);

	}

	/**

	 * Get the event topics for the wrapped handler.

	 * 

	 * @return The wrapped handler's event topics

	 */

	public synchronized String[] getTopics()  {

		return topics;

	}

	/**

	 * Return the wrapped handler. 

	 * @return The wrapped handler.

	 */

	private EventHandler getHandler() {

		synchronized (this) {

			// if we already have a handler, return it

			if (handler != null) {

				return handler;

			}

		}

		// we don't have the handler, so lets get it outside the sync region

		EventHandler tempHandler = (EventHandler)context.getService(reference);

		synchronized (this) {

			// do we still need the handler we just got?

			if (handler == null) {

				handler = tempHandler;

				return handler;

			}

			// get the current handler

			tempHandler = handler;

		}

		// unget the handler we just got since we don't need it

		context.ungetService(reference);

		// return the current handler (copied into the local var)

		return tempHandler;

	}

	/**

	 * Get the filter object

	 * 

	 * @return The handler's filter

	 */

	private synchronized Filter getFilter() {

		return filter;

	}

	/**

	 * Dispatch event to handler. Perform final tests before actually calling the handler.

	 * 

	 * @param event The event to dispatch

	 * @param perm The permission to be checked

	 */

	public void handleEvent(Event event, Permission perm) {

		Bundle bundle = reference.getBundle();

		// is service unregistered?

		if (bundle == null) {

			return;

		}

		// filter match

		Filter eventFilter = getFilter();

		if ((eventFilter != null) && !event.matches(eventFilter)) {

			return;

		}

		// permission check

		if ((perm != null) && (!bundle.hasPermission(perm))) {

			return;

		}

		// get handler service

		EventHandler handlerService = getHandler();

		if (handlerService == null) {

			return;

		}

		try {

			handlerService.handleEvent(event);

		}

		catch (Throwable t) {

			// log/handle any Throwable thrown by the listener

			log.log(LogService.LOG_ERROR, NLS.bind(EventAdminMsg.EVENT_DISPATCH_HANDLER_EXCEPTION, event, handlerService), t);

		}

	}

}

###############################################################################

# Copyright (c) 2005, 2006 IBM Corporation and others.

# All rights reserved. This program and the accompanying materials

# are made available under the terms of the Eclipse Public License v1.0

# which accompanies this distribution, and is available at

# http://www.eclipse.org/legal/epl-v10.html

#

# Contributors:

#     IBM Corporation - initial API and implementation

###############################################################################

# NLS_MESSAGEFORMAT_ALL 

Unknown_Log_level=Unknown Log Level

Info=Log Info

Warning=Log Warning

Error=Log Error

Debug=Log Debug

/*******************************************************************************

 * Copyright (c) 1999, 2007 IBM Corporation and others.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     IBM Corporation - initial API and implementation

 *******************************************************************************/

package org.eclipse.equinox.event;

import org.eclipse.osgi.util.NLS;

public class EventAdminMsg extends NLS {

	private static final String BUNDLE_NAME = "org.eclipse.equinox.event.ExternalMessages"; //$NON-NLS-1$

	public static String EVENT_ASYNC_THREAD_NAME;

	public static String EVENT_NULL_EVENT;

	public static String EVENT_NO_TOPICPERMISSION_PUBLISH;

	public static String EVENT_DISPATCH_HANDLER_EXCEPTION;

	public static String EVENT_INVALID_HANDLER_FILTER;

	static {

		// initialize resource bundles

		NLS.initializeMessages(BUNDLE_NAME, EventAdminMsg.class);

	}

}

/*******************************************************************************

 * Copyright (c) 2005, 2007 IBM Corporation and others.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     IBM Corporation - initial API and implementation

 *******************************************************************************/

package org.eclipse.equinox.event;

import org.eclipse.equinox.event.mapper.EventRedeliverer;

import org.osgi.framework.*;

public class Activator implements BundleActivator {

	private EventRedeliverer    eventRedeliverer;

	private ServiceRegistration eventAdminService;

	private EventAdminImpl eventAdmin;

	public void start(BundleContext bundleContext) {

		eventAdmin = new EventAdminImpl(bundleContext);

		eventAdmin.start();

		eventAdminService = bundleContext.registerService("org.osgi.service.event.EventAdmin", //$NON-NLS-1$

				eventAdmin,null);

		eventRedeliverer  = new EventRedeliverer(bundleContext);

		eventRedeliverer.open();

	}

	public void stop(BundleContext bundleContext) {

		eventRedeliverer.close();

		eventAdminService.unregister();

		eventAdmin.stop();

	}

}

/*******************************************************************************

 * Copyright (c) 1998, 2007 IBM Corporation and others.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     IBM Corporation - initial API and implementation

 *******************************************************************************/

package org.eclipse.equinox.event;

import java.io.PrintStream;

import java.util.Calendar;

import java.util.Date;

import org.osgi.framework.BundleContext;

import org.osgi.framework.ServiceReference;

import org.osgi.service.log.LogService;

import org.osgi.util.tracker.ServiceTracker;

/**

 * LogTracker class. This class encapsulates the LogService

 * and handles all issues such as the service coming and going.

 */

public class LogTracker extends ServiceTracker implements LogService {

	/** LogService interface class name */

	protected final static String clazz = "org.osgi.service.log.LogService"; //$NON-NLS-1$

	/** PrintStream to use if LogService is unavailable */

	private final PrintStream out;

	/**

	 * Create new LogTracker.

	 *

	 * @param context BundleContext of parent bundle.

	 * @param out Default PrintStream to use if LogService is unavailable.

	 */

	public LogTracker(BundleContext context, PrintStream out) {

		super(context, clazz, null);

		this.out = out;

	}

	/*

	 * ----------------------------------------------------------------------

	 *      LogService Interface implementation

	 * ----------------------------------------------------------------------

	 */

	public void log(int level, String message) {

		log(null, level, message, null);

	}

	public void log(int level, String message, Throwable exception) {

		log(null, level, message, exception);

	}

	public void log(ServiceReference reference, int level, String message) {

		log(reference, level, message, null);

	}

	public synchronized void log(ServiceReference reference, int level, String message, Throwable exception) {

		ServiceReference[] references = getServiceReferences();

		if (references != null) {

			int size = references.length;

			for (int i = 0; i < size; i++) {

				LogService service = (LogService) getService(references[i]);

				if (service != null) {

					try {

						service.log(reference, level, message, exception);

					} catch (Exception e) {

						// TODO: consider printing to System Error

					}

				}

			}

			return;

		}

		noLogService(level, message, exception, reference);

	}

	/**

	 * The LogService is not available so we write the message to a PrintStream.

	 *

	 * @param level Logging level

	 * @param message Log message.

	 * @param throwable Log exception or null if none.

	 * @param reference ServiceReference associated with message or null if none.

	 */

	protected void noLogService(int level, String message, Throwable throwable, ServiceReference reference) {

		if (out != null) {

			synchronized (out) {

				// Bug #113286.  If no log service present and messages are being

				// printed to stdout, prepend message with a timestamp.

				String timestamp = getDate(new Date());

				out.print(timestamp + " "); //$NON-NLS-1$

				switch (level) {

					case LOG_DEBUG : {

						out.print(LogTrackerMsg.Debug);

						break;

					}

					case LOG_INFO : {

						out.print(LogTrackerMsg.Info); 

						break;

					}

					case LOG_WARNING : {

						out.print(LogTrackerMsg.Warning);