| /******************************************************************************* |
| * Copyright (c) 2007 Versant Corp. |
| * 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: |
| * Markus Kuppe (mkuppe <at> versant <dot> com) - initial API and implementation |
| ******************************************************************************/ |
| package org.eclipse.ecf.discovery; |
| |
| import java.util.*; |
| import org.eclipse.core.runtime.Assert; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.ecf.core.AbstractContainer; |
| import org.eclipse.ecf.core.identity.*; |
| import org.eclipse.ecf.core.util.Trace; |
| import org.eclipse.ecf.discovery.identity.IServiceID; |
| import org.eclipse.ecf.discovery.identity.IServiceTypeID; |
| import org.eclipse.ecf.internal.discovery.*; |
| import org.eclipse.equinox.concurrent.future.*; |
| |
| public abstract class AbstractDiscoveryContainerAdapter extends |
| AbstractContainer implements IDiscoveryLocator, IDiscoveryAdvertiser { |
| |
| /** |
| * Collection of service listeners i.e. Collection<IServiceListener>. NOTE: |
| * Access to this collection is synchronized, so subclasses should take this |
| * into account. |
| */ |
| protected final Set allServiceListeners; |
| |
| private DiscoveryContainerConfig config; |
| |
| /** |
| * Map of service type to collection of service listeners i.e. |
| * <String,Collection<IServiceListener>>. NOTE: Access to this map is |
| * synchronized, so subclasses should take this into account. |
| */ |
| protected final Map serviceListeners; |
| protected final String servicesNamespaceName; |
| /** |
| * Collection of service type listeners i.e. |
| * Collection<IServiceTypeListener>. NOTE: Access to this collection is |
| * synchronized, so subclasses should take this into account. |
| */ |
| protected final Collection serviceTypeListeners; |
| |
| private DiscoveryServiceListener discoveryServiceListener; |
| private DiscoveryServiceListener discoveryServiceTypeListener; |
| private ServiceTypeComparator discoveryServiceListenerComparator; |
| |
| private final IServiceInfoServiceListener iServiceInfoServiceListener; |
| |
| /** |
| * @param aNamespaceName |
| * @param aConfig |
| */ |
| public AbstractDiscoveryContainerAdapter(String aNamespaceName, |
| DiscoveryContainerConfig aConfig) { |
| servicesNamespaceName = aNamespaceName; |
| Assert.isNotNull(servicesNamespaceName); |
| config = aConfig; |
| Assert.isNotNull(config); |
| serviceTypeListeners = Collections.synchronizedSet(new HashSet()); |
| serviceListeners = Collections.synchronizedMap(new HashMap()); |
| allServiceListeners = Collections.synchronizedSet(new HashSet()); |
| |
| discoveryServiceListener = new DiscoveryServiceListener(this, |
| IServiceListener.class); |
| discoveryServiceTypeListener = new DiscoveryServiceListener(this, |
| IServiceTypeListener.class); |
| |
| discoveryServiceListenerComparator = new ServiceTypeComparator(); |
| |
| iServiceInfoServiceListener = new IServiceInfoServiceListener(this); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#addServiceListener |
| * (org.eclipse.ecf.discovery.IServiceListener) |
| */ |
| public void addServiceListener(final IServiceListener aListener) { |
| Assert.isNotNull(aListener); |
| |
| if (aListener.triggerDiscovery()) { |
| final IExecutor executor = new ThreadsExecutor(); |
| executor.execute(new IProgressRunnable() { |
| public Object run(final IProgressMonitor arg0) throws Exception { |
| final IServiceInfo[] services = getServices(); |
| |
| for (int i = 0; i < services.length; i++) { |
| final IServiceInfo iServiceInfo = services[i]; |
| aListener.serviceDiscovered(getServiceEvent( |
| iServiceInfo, getConfig().getID())); |
| } |
| allServiceListeners.add(aListener); |
| return null; |
| } |
| }, null); |
| } else { |
| allServiceListeners.add(aListener); |
| } |
| } |
| |
| /** |
| * @since 5.0 |
| */ |
| protected IServiceEvent getServiceEvent(IServiceInfo iServiceInfo, ID id) { |
| return new ServiceContainerEvent(iServiceInfo, id); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#addServiceListener |
| * (org.eclipse.ecf.discovery.identity.IServiceTypeID, |
| * org.eclipse.ecf.discovery.IServiceListener) |
| */ |
| public void addServiceListener(final IServiceTypeID aType, |
| final IServiceListener aListener) { |
| Assert.isNotNull(aListener); |
| Assert.isNotNull(aType); |
| |
| if (aListener.triggerDiscovery()) { |
| final IExecutor executor = new ThreadsExecutor(); |
| executor.execute(new IProgressRunnable() { |
| public Object run(final IProgressMonitor arg0) throws Exception { |
| final IServiceInfo[] services = getServices(aType); |
| |
| for (int i = 0; i < services.length; i++) { |
| final IServiceInfo iServiceInfo = services[i]; |
| aListener.serviceDiscovered(getServiceEvent( |
| iServiceInfo, getConfig().getID())); |
| } |
| // Add the listener _after_ explicitly discovering services |
| // to _reduce_ the chance of notifying the listener more |
| // than once. This happens, if the background discovery job |
| // runs interleaved with explicit discovery here. However, |
| // ECF discovery -at the API level- does not guarantee that |
| // it won't send out notifications for the same logical |
| // discovery event at-most once/exactly once. It provides |
| // at-least-once instead/best-effort. |
| addServiceListener0(aType, aListener); |
| return null; |
| } |
| }, null); |
| } else { |
| addServiceListener0(aType, aListener); |
| } |
| } |
| |
| private void addServiceListener0(final IServiceTypeID aType, |
| final IServiceListener aListener) { |
| synchronized (serviceListeners) { // put-if-absent idiom race |
| // condition |
| Collection v = (Collection) serviceListeners.get(aType); |
| if (v == null) { |
| v = Collections.synchronizedSet(new HashSet()); |
| serviceListeners.put(aType, v); |
| } |
| v.add(aListener); |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#addServiceTypeListener |
| * (org.eclipse.ecf.discovery.IServiceTypeListener) |
| */ |
| public void addServiceTypeListener(IServiceTypeListener aListener) { |
| Assert.isNotNull(aListener); |
| serviceTypeListeners.add(aListener); |
| } |
| |
| protected void clearListeners() { |
| serviceListeners.clear(); |
| serviceTypeListeners.clear(); |
| allServiceListeners.clear(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ecf.core.AbstractContainer#dispose() |
| */ |
| public void dispose() { |
| disconnect(); |
| clearListeners(); |
| config = null; |
| discoveryServiceListener.dispose(); |
| discoveryServiceTypeListener.dispose(); |
| iServiceInfoServiceListener.dispose(); |
| super.dispose(); |
| } |
| |
| /** |
| * Calls {@link IServiceListener#serviceDiscovered(IServiceEvent)} for all |
| * registered {@link IServiceListener} |
| * |
| * @param aServiceEvent |
| * The {@link IServiceEvent} to send along the call |
| */ |
| protected void fireServiceDiscovered(IServiceEvent aServiceEvent) { |
| Assert.isNotNull(aServiceEvent); |
| final Collection listeners = getListeners(aServiceEvent |
| .getServiceInfo().getServiceID().getServiceTypeID()); |
| if (listeners != null) { |
| for (final Iterator i = listeners.iterator(); i.hasNext();) { |
| final IServiceListener l = (IServiceListener) i.next(); |
| l.serviceDiscovered(aServiceEvent); |
| Trace.trace(DiscoveryPlugin.PLUGIN_ID, |
| DiscoveryDebugOption.METHODS_TRACING, this.getClass(), |
| "fireServiceDiscovered", aServiceEvent.toString()); //$NON-NLS-1$ |
| } |
| } |
| } |
| |
| /** |
| * Calls |
| * {@link IServiceTypeListener#serviceTypeDiscovered(IServiceTypeEvent)} for |
| * all registered {@link IServiceTypeListener} |
| * |
| * @param aServiceTypeEvent |
| * The {@link IServiceTypeEvent} to send along the call |
| */ |
| protected void fireServiceTypeDiscovered(IServiceTypeEvent aServiceTypeEvent) { |
| Assert.isNotNull(aServiceTypeEvent); |
| List notify = null; |
| synchronized (serviceTypeListeners) { |
| notify = new ArrayList(serviceTypeListeners); |
| } |
| for (final Iterator i = notify.iterator(); i.hasNext();) { |
| final IServiceTypeListener l = (IServiceTypeListener) i.next(); |
| l.serviceTypeDiscovered(aServiceTypeEvent); |
| Trace.trace(DiscoveryPlugin.PLUGIN_ID, |
| DiscoveryDebugOption.METHODS_TRACING, this.getClass(), |
| "fireServiceTypeDiscovered", aServiceTypeEvent.toString()); //$NON-NLS-1$ |
| } |
| } |
| |
| /** |
| * Calls {@link IServiceListener#serviceUndiscovered(IServiceEvent)} for all |
| * registered {@link IServiceListener} |
| * |
| * @param aServiceEvent |
| * The {@link IServiceEvent} to send along the call |
| */ |
| protected void fireServiceUndiscovered(IServiceEvent aServiceEvent) { |
| Assert.isNotNull(aServiceEvent); |
| final Collection listeners = getListeners(aServiceEvent |
| .getServiceInfo().getServiceID().getServiceTypeID()); |
| if (listeners != null) { |
| for (final Iterator i = listeners.iterator(); i.hasNext();) { |
| final IServiceListener l = (IServiceListener) i.next(); |
| l.serviceUndiscovered(aServiceEvent); |
| Trace.trace(DiscoveryPlugin.PLUGIN_ID, |
| DiscoveryDebugOption.METHODS_TRACING, this.getClass(), |
| "fireServiceUndiscovered", aServiceEvent.toString()); //$NON-NLS-1$ |
| } |
| } |
| } |
| |
| /** |
| * @return The {@link DiscoveryContainerConfig} of this |
| * {@link IDiscoveryContainerAdapter} |
| */ |
| protected DiscoveryContainerConfig getConfig() { |
| return config; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ecf.core.IContainer#getConnectNamespace() |
| */ |
| public Namespace getConnectNamespace() { |
| return IDFactory.getDefault().getNamespaceByName(servicesNamespaceName); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ecf.core.identity.IIdentifiable#getID() |
| */ |
| public ID getID() { |
| if (config != null) { |
| return config.getID(); |
| } |
| return null; |
| } |
| |
| /** |
| * @return The name of this discovery container |
| * @since 4.0 |
| */ |
| public abstract String getContainerName(); |
| |
| // merges the allServiceListener with the serviceListeners for the given |
| // type |
| |
| /** |
| * Joins the {@link Collection} of {@link IServiceListener}s interested in |
| * any {@link IServiceTypeID} with the {@link Collection} of the |
| * {@link IServiceListener} registered for the given {@link IServiceTypeID} |
| * |
| * @param aServiceType |
| * The {@link IServiceTypeID} for which the |
| * {@link IServiceListener}s are returned |
| * @return All {@link IServiceListener}s interested in the given |
| * {@link IServiceTypeID} |
| */ |
| protected Collection getListeners(IServiceTypeID aServiceType) { |
| Assert.isNotNull(aServiceType); |
| Collection listeners = new HashSet(); |
| synchronized (serviceListeners) { |
| for (Iterator itr = serviceListeners.keySet().iterator(); itr |
| .hasNext();) { |
| final IServiceTypeID typeID = (IServiceTypeID) itr.next(); |
| int compare = discoveryServiceListenerComparator.compare( |
| aServiceType, typeID); |
| if (compare == 0) { |
| Collection collection = (Collection) serviceListeners |
| .get(typeID); |
| if (collection != null) { |
| listeners.addAll(collection); |
| } |
| } |
| } |
| } |
| synchronized (allServiceListeners) { |
| listeners.addAll(allServiceListeners); |
| } |
| return Collections.unmodifiableCollection(listeners); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#getServicesNamespace |
| * () |
| */ |
| public Namespace getServicesNamespace() { |
| return IDFactory.getDefault().getNamespaceByName(servicesNamespaceName); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#removeServiceListener |
| * (org.eclipse.ecf.discovery.IServiceListener) |
| */ |
| public void removeServiceListener(IServiceListener aListener) { |
| Assert.isNotNull(aListener); |
| allServiceListeners.remove(aListener); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ecf.discovery.IDiscoveryContainerAdapter#removeServiceListener |
| * (org.eclipse.ecf.discovery.identity.IServiceTypeID, |
| * org.eclipse.ecf.discovery.IServiceListener) |
| */ |
| public void removeServiceListener(IServiceTypeID aType, |
| IServiceListener aListener) { |
| Assert.isNotNull(aListener); |
| Assert.isNotNull(aType); |
| synchronized (serviceListeners) { |
| final Collection v = (Collection) serviceListeners.get(aType); |
| if (v != null) { |
| v.remove(aListener); |
| } |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ecf.discovery.IDiscoveryContainerAdapter# |
| * removeServiceTypeListener(org.eclipse.ecf.discovery.IServiceTypeListener) |
| */ |
| public void removeServiceTypeListener(IServiceTypeListener aListener) { |
| Assert.isNotNull(aListener); |
| serviceTypeListeners.remove(aListener); |
| } |
| |
| /** |
| * @see org.eclipse.ecf.discovery.IDiscoveryAdvertiser#unregisterAllServices() |
| * @since 3.0 |
| */ |
| public void unregisterAllServices() { |
| throw new UnsupportedOperationException("Not yet implemeted"); //$NON-NLS-1$ |
| } |
| |
| /** |
| * @see org.eclipse.ecf.discovery.IDiscoveryLocator#purgeCache() |
| * @since 3.0 |
| */ |
| public IServiceInfo[] purgeCache() { |
| return new IServiceInfo[] {}; |
| } |
| |
| /** |
| * @see org.eclipse.ecf.discovery.IDiscoveryLocator#getAsyncServiceInfo(org.eclipse.ecf.discovery.identity.IServiceID) |
| * @since 3.0 |
| */ |
| public IFuture getAsyncServiceInfo(final IServiceID service) { |
| IExecutor executor = new ThreadsExecutor(); |
| return executor.execute(new IProgressRunnable() { |
| public Object run(IProgressMonitor monitor) throws Exception { |
| return getServiceInfo(service); |
| } |
| }, null); |
| } |
| |
| /** |
| * @see org.eclipse.ecf.discovery.IDiscoveryLocator#getAsyncServiceTypes() |
| * @since 3.0 |
| */ |
| public IFuture getAsyncServiceTypes() { |
| IExecutor executor = new ThreadsExecutor(); |
| return executor.execute(new IProgressRunnable() { |
| public Object run(IProgressMonitor monitor) throws Exception { |
| return getServiceTypes(); |
| } |
| }, null); |
| } |
| |
| /** |
| * @see org.eclipse.ecf.discovery.IDiscoveryLocator#getAsyncServices() |
| * @since 3.0 |
| */ |
| public IFuture getAsyncServices() { |
| IExecutor executor = new ThreadsExecutor(); |
| return executor.execute(new IProgressRunnable() { |
| public Object run(IProgressMonitor monitor) throws Exception { |
| return getServices(); |
| } |
| }, null); |
| } |
| |
| /** |
| * @see org.eclipse.ecf.discovery.IDiscoveryLocator#getAsyncServices(org.eclipse.ecf.discovery.identity.IServiceTypeID) |
| * @since 3.0 |
| */ |
| public IFuture getAsyncServices(final IServiceTypeID type) { |
| IExecutor executor = new ThreadsExecutor(); |
| return executor.execute(new IProgressRunnable() { |
| public Object run(IProgressMonitor monitor) throws Exception { |
| return getServices(type); |
| } |
| }, null); |
| } |
| } |
