| /******************************************************************************* |
| * Copyright (c) 2010 Composent, Inc. 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: |
| * Composent, Inc. - initial API and implementation |
| ******************************************************************************/ |
| package org.eclipse.ecf.internal.osgi.services.distribution; |
| |
| import java.util.ArrayList; |
| import java.util.Dictionary; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Properties; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.ecf.core.util.LogHelper; |
| import org.eclipse.ecf.core.util.SystemLogService; |
| import org.osgi.framework.Bundle; |
| import org.osgi.framework.BundleActivator; |
| import org.osgi.framework.BundleContext; |
| import org.osgi.framework.Filter; |
| import org.osgi.framework.ServiceFactory; |
| import org.osgi.framework.ServiceReference; |
| import org.osgi.framework.ServiceRegistration; |
| import org.osgi.framework.hooks.service.EventListenerHook; |
| import org.osgi.service.log.LogService; |
| import org.osgi.service.remoteserviceadmin.EndpointDescription; |
| import org.osgi.service.remoteserviceadmin.EndpointEvent; |
| import org.osgi.service.remoteserviceadmin.EndpointEventListener; |
| import org.osgi.service.remoteserviceadmin.EndpointListener; |
| import org.osgi.service.remoteserviceadmin.RemoteServiceAdminListener; |
| import org.osgi.util.tracker.ServiceTracker; |
| |
| public class Activator implements BundleActivator { |
| |
| public static final String PLUGIN_ID = "org.eclipse.ecf.osgi.services.distribution"; //$NON-NLS-1$ |
| |
| public static final boolean autoCreateProxyContainer = new Boolean( |
| System.getProperty( |
| "org.eclipse.ecf.osgi.services.distribution.autoCreateProxyContainer", //$NON-NLS-1$ |
| "true")).booleanValue(); //$NON-NLS-1$ |
| |
| public static final boolean autoCreateHostContainer = new Boolean( |
| System.getProperty( |
| "org.eclipse.ecf.osgi.services.distribution.autoCreateHostContainer", //$NON-NLS-1$ |
| "true")).booleanValue(); //$NON-NLS-1$ |
| |
| public static final String defaultHostConfigType = System.getProperty( |
| "org.eclipse.ecf.osgi.services.distribution.defaultConfigType", //$NON-NLS-1$ |
| "ecf.generic.server"); //$NON-NLS-1$ |
| |
| private static final String PROP_USE_DS = "equinox.use.ds"; //$NON-NLS-1$ |
| |
| private static Activator plugin; |
| private BundleContext context; |
| |
| private ServiceTracker logServiceTracker = null; |
| private LogService logService = null; |
| |
| private BasicTopologyManagerImpl basicTopologyManagerImpl; |
| private ServiceRegistration endpointListenerReg; |
| private ServiceRegistration endpointEventListenerReg; |
| private Map<Bundle, List<EndpointEventHolder>> bundleEndpointEventListenerMap = new HashMap<Bundle, List<EndpointEventHolder>>(); |
| |
| private BasicTopologyManagerComponent basicTopologyManagerComp; |
| private ServiceRegistration eventListenerHookRegistration; |
| private ServiceRegistration eventAdminListenerRegistration; |
| |
| private static final boolean disableBasicTopologyManager = new Boolean( |
| System.getProperty( |
| "org.eclipse.ecf.osgi.services.distribution.disableBasicTopologyManager", //$NON-NLS-1$ |
| "false")).booleanValue(); //$NON-NLS-1$ |
| |
| private OSGiTopologyManagerImpl osgiTopologyManagerImpl; |
| |
| public static Activator getDefault() { |
| return plugin; |
| } |
| |
| public BundleContext getContext() { |
| return context; |
| } |
| |
| protected LogService getLogService() { |
| if (this.context == null) |
| return null; |
| if (logServiceTracker == null) { |
| logServiceTracker = new ServiceTracker(this.context, |
| LogService.class.getName(), null); |
| logServiceTracker.open(); |
| } |
| logService = (LogService) logServiceTracker.getService(); |
| if (logService == null) |
| logService = new SystemLogService(PLUGIN_ID); |
| return logService; |
| } |
| |
| public void log(IStatus status) { |
| if (logService == null) |
| logService = getLogService(); |
| if (logService != null) |
| logService.log(null, LogHelper.getLogCode(status), |
| LogHelper.getLogMessage(status), status.getException()); |
| } |
| |
| public void log(ServiceReference sr, IStatus status) { |
| log(sr, LogHelper.getLogCode(status), LogHelper.getLogMessage(status), |
| status.getException()); |
| } |
| |
| public void log(ServiceReference sr, int level, String message, Throwable t) { |
| if (logService == null) |
| logService = getLogService(); |
| if (logService != null) |
| logService.log(sr, level, message, t); |
| } |
| |
| class EndpointEventHolder { |
| private final EndpointDescription endpointDescription; |
| private final String filter; |
| |
| public EndpointEventHolder(EndpointDescription d, String f) { |
| this.endpointDescription = d; |
| this.filter = f; |
| } |
| |
| public EndpointDescription getEndpoint() { |
| return this.endpointDescription; |
| } |
| |
| public String getFilter() { |
| return this.filter; |
| } |
| } |
| |
| public class ProxyEndpointEventListener implements EndpointEventListener { |
| |
| private final Bundle bundle; |
| |
| public ProxyEndpointEventListener(Bundle b) { |
| this.bundle = b; |
| } |
| |
| public void endpointChanged(EndpointEvent event, String filter) { |
| int type = event.getType(); |
| if (type == EndpointEvent.ADDED) { |
| synchronized (bundleEndpointEventListenerMap) { |
| List<EndpointEventHolder> endpointEventHolders = bundleEndpointEventListenerMap |
| .get(this.bundle); |
| if (endpointEventHolders == null) |
| // create new one |
| endpointEventHolders = new ArrayList<EndpointEventHolder>(); |
| endpointEventHolders.add(new EndpointEventHolder(event |
| .getEndpoint(), filter)); |
| bundleEndpointEventListenerMap.put(this.bundle, |
| endpointEventHolders); |
| } |
| } else if (type == EndpointEvent.REMOVED) { |
| synchronized (bundleEndpointEventListenerMap) { |
| List<EndpointEventHolder> endpointEventHolders = bundleEndpointEventListenerMap |
| .get(this.bundle); |
| if (endpointEventHolders != null) { |
| for (Iterator<EndpointEventHolder> i = endpointEventHolders |
| .iterator(); i.hasNext();) { |
| EndpointEventHolder eh = i.next(); |
| EndpointDescription oldEd = eh.getEndpoint(); |
| EndpointDescription newEd = event.getEndpoint(); |
| if (oldEd.equals(newEd)) |
| i.remove(); |
| } |
| if (endpointEventHolders.size() == 0) |
| bundleEndpointEventListenerMap.remove(this.bundle); |
| } |
| |
| } |
| } |
| // Actually call underlying listener |
| deliverSafe(event, filter); |
| } |
| |
| public BasicTopologyManagerImpl getBasicTopologyManagerImpl() { |
| return Activator.this.basicTopologyManagerImpl; |
| } |
| |
| private void logError(String methodName, String message, Throwable e) { |
| getDefault().log( |
| new Status(IStatus.ERROR, Activator.PLUGIN_ID, |
| IStatus.ERROR, Activator.class.getName() + ":" //$NON-NLS-1$ |
| + ((methodName == null) ? "<unknown>" //$NON-NLS-1$ |
| : methodName) + ":" //$NON-NLS-1$ |
| + ((message == null) ? "<empty>" //$NON-NLS-1$ |
| : message), e)); |
| } |
| |
| private void deliverSafe(EndpointEvent endpointEvent, |
| String matchingFilter) { |
| EndpointEventListener listener = Activator.this.basicTopologyManagerImpl; |
| if (listener == null) |
| return; |
| try { |
| listener.endpointChanged(endpointEvent, matchingFilter); |
| } catch (Exception e) { |
| String message = "Exception in EndpointEventListener listener=" //$NON-NLS-1$ |
| + listener + " event=" //$NON-NLS-1$ |
| + endpointEvent + " matchingFilter=" //$NON-NLS-1$ |
| + matchingFilter; |
| logError("deliverSafe", message, e); //$NON-NLS-1$ |
| } catch (LinkageError e) { |
| String message = "LinkageError in EndpointEventListener listener=" //$NON-NLS-1$ |
| + listener + " event=" //$NON-NLS-1$ |
| + endpointEvent + " matchingFilter=" //$NON-NLS-1$ |
| + matchingFilter; |
| logError("deliverSafe", message, e); //$NON-NLS-1$ |
| } catch (AssertionError e) { |
| String message = "AssertionError in EndpointEventListener listener=" //$NON-NLS-1$ |
| + listener + " event=" //$NON-NLS-1$ |
| + endpointEvent + " matchingFilter=" //$NON-NLS-1$ |
| + matchingFilter; |
| logError("deliverSafe", message, e); //$NON-NLS-1$ |
| } |
| } |
| |
| public void deliverRemoveEventForBundle(EndpointEventHolder eventHolder) { |
| deliverSafe( |
| new EndpointEvent(EndpointEvent.REMOVED, |
| eventHolder.getEndpoint()), eventHolder.getFilter()); |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.osgi.framework.BundleActivator#start(org.osgi.framework.BundleContext |
| * ) |
| */ |
| public void start(final BundleContext ctxt) throws Exception { |
| // Always set plugin and context |
| plugin = this; |
| this.context = ctxt; |
| // If BasicTopologyManager has been disabled (default), then |
| // use OSGiTopologyManager |
| if (disableBasicTopologyManager) { |
| osgiTopologyManagerImpl = new OSGiTopologyManagerImpl(context); |
| |
| Properties props = new Properties(); |
| props.put( |
| org.osgi.service.remoteserviceadmin.EndpointEventListener.ENDPOINT_LISTENER_SCOPE, |
| osgiTopologyManagerImpl.getScope()); |
| |
| // Register as deprecated EndpointListener |
| endpointListenerReg = getContext().registerService( |
| EndpointListener.class.getName(), osgiTopologyManagerImpl, |
| (Dictionary) props); |
| |
| // Also register as EndpointEventListener |
| endpointEventListenerReg = getContext().registerService( |
| EndpointEventListener.class.getName(), |
| osgiTopologyManagerImpl, (Dictionary) props); |
| |
| // export any previously registered remote services by calling |
| // activate |
| osgiTopologyManagerImpl.activate(); |
| |
| } else { |
| // Create basicTopologyManagerImpl |
| basicTopologyManagerImpl = new BasicTopologyManagerImpl(context); |
| |
| // Register basicTopologyManagerImpl as EndpointListener always, so |
| // that |
| // gets notified when Endpoints are discovered |
| Properties props = new Properties(); |
| props.put( |
| org.osgi.service.remoteserviceadmin.EndpointEventListener.ENDPOINT_LISTENER_SCOPE, |
| basicTopologyManagerImpl.getScope()); |
| |
| // Register as deprecated EndpointListener |
| // endpointListenerReg = getContext().registerService( |
| // EndpointListener.class.getName(), basicTopologyManagerImpl, |
| // (Dictionary) props); |
| |
| // As per section 122.6.3/Tracking providers -Tracking providers |
| // An |
| // Endpoint Event |
| // Listener or Endpoint Listener must track the bundles that provide |
| // it |
| // with |
| // Endpoint Descriptions. If a bundle that provided Endpoint |
| // Descriptions is |
| // stopped, all Endpoint Descriptions that were provided by that |
| // bundle |
| // must |
| // be removed. This can be implemented straightforwardly with a |
| // Service |
| // Factory |
| endpointEventListenerReg = getContext().registerService( |
| EndpointEventListener.class.getName(), |
| new ServiceFactory() { |
| public Object getService(Bundle bundle, |
| ServiceRegistration registration) { |
| return new ProxyEndpointEventListener(bundle); |
| } |
| |
| public void ungetService(Bundle bundle, |
| ServiceRegistration registration, Object service) { |
| ProxyEndpointEventListener peel = (service instanceof ProxyEndpointEventListener) ? (ProxyEndpointEventListener) service |
| : null; |
| if (peel == null) |
| return; |
| synchronized (bundleEndpointEventListenerMap) { |
| List<EndpointEventHolder> endpointEventHolders = bundleEndpointEventListenerMap |
| .get(bundle); |
| if (endpointEventHolders != null) |
| for (EndpointEventHolder eh : endpointEventHolders) |
| peel.deliverRemoveEventForBundle(eh); |
| } |
| } |
| }, (Dictionary) props); |
| |
| // Like EventAdmin, if equinox ds is running, then we simply return |
| // (no |
| // more to do) |
| if (Boolean.valueOf(context.getProperty(PROP_USE_DS)) |
| .booleanValue()) |
| return; // If this property is set we assume DS is being used. |
| |
| // The following code is to make sure that we don't do any more if |
| // EventListenerHook has already been registered for us by DS |
| // Create serviceFilter for EventListenerHook classname |
| String serviceName = EventListenerHook.class.getName(); |
| Filter serviceFilter = context |
| .createFilter("(objectclass=" + serviceName + ")"); //$NON-NLS-1$ //$NON-NLS-2$ |
| // if this bundle has already registered EventListenerHook service |
| // via |
| // ds, then |
| // we're done |
| ServiceReference[] refs = context.getBundle() |
| .getRegisteredServices(); |
| if (refs != null) { |
| for (int i = 0; i < refs.length; i++) |
| if (serviceFilter.match(refs[i])) |
| return; // We found a service registered by this bundle |
| // already so we return |
| } |
| |
| // Otherwise (no DS), we create a basicTopologyManagerComponent |
| basicTopologyManagerComp = new BasicTopologyManagerComponent(); |
| // bind the topology manager to it |
| basicTopologyManagerComp |
| .bindEndpointEventListener(basicTopologyManagerImpl); |
| // Register RemoteServiceAdminListener |
| eventAdminListenerRegistration = this.context.registerService( |
| RemoteServiceAdminListener.class, basicTopologyManagerComp, |
| null); |
| // register the basic topology manager as EventListenerHook service |
| eventListenerHookRegistration = this.context.registerService( |
| EventListenerHook.class, basicTopologyManagerComp, null); |
| // export any previously registered remote services by calling |
| // activate |
| basicTopologyManagerComp.activate(); |
| |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.osgi.framework.BundleActivator#stop(org.osgi.framework.BundleContext) |
| */ |
| public void stop(BundleContext ctxt) throws Exception { |
| if (eventListenerHookRegistration != null) { |
| eventListenerHookRegistration.unregister(); |
| eventListenerHookRegistration = null; |
| } |
| if (basicTopologyManagerComp != null) { |
| basicTopologyManagerComp |
| .unbindEndpointEventListener(basicTopologyManagerImpl); |
| basicTopologyManagerComp = null; |
| } |
| if (endpointEventListenerReg != null) { |
| endpointEventListenerReg.unregister(); |
| endpointEventListenerReg = null; |
| } |
| if (endpointListenerReg != null) { |
| endpointListenerReg.unregister(); |
| endpointListenerReg = null; |
| } |
| if (eventAdminListenerRegistration != null) { |
| eventAdminListenerRegistration.unregister(); |
| eventAdminListenerRegistration = null; |
| } |
| synchronized (bundleEndpointEventListenerMap) { |
| bundleEndpointEventListenerMap.clear(); |
| } |
| if (basicTopologyManagerImpl != null) { |
| basicTopologyManagerImpl.close(); |
| basicTopologyManagerImpl = null; |
| } |
| if (logServiceTracker != null) { |
| logServiceTracker.close(); |
| logServiceTracker = null; |
| logService = null; |
| } |
| this.context = null; |
| plugin = null; |
| } |
| |
| } |
