| /* | |
| * 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.ipojo.util; | |
| import org.apache.felix.ipojo.ComponentInstance; | |
| import org.apache.felix.ipojo.IPOJOServiceFactory; | |
| import org.apache.felix.ipojo.dependency.impl.ServiceReferenceManager; | |
| import org.osgi.framework.BundleContext; | |
| import org.osgi.framework.Filter; | |
| import org.osgi.framework.InvalidSyntaxException; | |
| import org.osgi.framework.ServiceReference; | |
| import java.util.*; | |
| import java.util.concurrent.locks.ReentrantReadWriteLock; | |
| /** | |
| * Abstract dependency model. | |
| * This class is the parent class of every service dependency. It manages the most | |
| * part of dependency management. This class creates an interface between the service | |
| * tracker and the concrete dependency. | |
| * | |
| * @author <a href="mailto:dev@felix.apache.org">Felix Project Team</a> | |
| */ | |
| public abstract class DependencyModel { | |
| /** | |
| * Dependency state : BROKEN. | |
| * A broken dependency cannot be fulfilled anymore. The dependency becomes | |
| * broken when a used service disappears in the static binding policy. | |
| */ | |
| public static final int BROKEN = -1; | |
| /** | |
| * Dependency state : UNRESOLVED. | |
| * A dependency is unresolved if the dependency is not valid and no service | |
| * providers are available. | |
| */ | |
| public static final int UNRESOLVED = 0; | |
| /** | |
| * Dependency state : RESOLVED. | |
| * A dependency is resolved if the dependency is optional or at least one | |
| * provider is available. | |
| */ | |
| public static final int RESOLVED = 1; | |
| /** | |
| * Binding policy : Dynamic. | |
| * In this policy, services can appears and departs without special treatment. | |
| */ | |
| public static final int DYNAMIC_BINDING_POLICY = 0; | |
| /** | |
| * Binding policy : Static. | |
| * Once a service is used, if this service disappears the dependency becomes | |
| * {@link DependencyModel#BROKEN}. The instance needs to be recreated. | |
| */ | |
| public static final int STATIC_BINDING_POLICY = 1; | |
| /** | |
| * Binding policy : Dynamic-Priority. | |
| * In this policy, services can appears and departs. However, once a service | |
| * with a highest ranking (according to the used comparator) appears, this | |
| * new service is re-injected. | |
| */ | |
| public static final int DYNAMIC_PRIORITY_BINDING_POLICY = 2; | |
| /** | |
| * The service reference manager. | |
| */ | |
| protected final ServiceReferenceManager m_serviceReferenceManager; | |
| /** | |
| * The manager handling context sources. | |
| */ | |
| private final ContextSourceManager m_contextSourceManager; | |
| /** | |
| * Listener object on which invoking the {@link DependencyStateListener#validate(DependencyModel)} | |
| * and {@link DependencyStateListener#invalidate(DependencyModel)} methods. | |
| */ | |
| private final DependencyStateListener m_listener; | |
| /** | |
| * The instance requiring the service. | |
| */ | |
| private final ComponentInstance m_instance; | |
| /** | |
| * Does the dependency bind several providers ? | |
| */ | |
| private boolean m_aggregate; | |
| /** | |
| * Is the dependency optional ? | |
| */ | |
| private boolean m_optional; | |
| /** | |
| * The required specification. | |
| * Cannot change once set. | |
| */ | |
| private Class m_specification; | |
| /** | |
| * Bundle context used by the dependency. | |
| * (may be a {@link org.apache.felix.ipojo.ServiceContext}). | |
| */ | |
| private BundleContext m_context; | |
| /** | |
| * The actual state of the dependency. | |
| * {@link DependencyModel#UNRESOLVED} at the beginning. | |
| */ | |
| private int m_state; | |
| /** | |
| * The Binding policy of the dependency. | |
| */ | |
| private int m_policy = DYNAMIC_BINDING_POLICY; | |
| /** | |
| * The tracker used by this dependency to track providers. | |
| */ | |
| private Tracker m_tracker; | |
| /** | |
| * Map {@link ServiceReference} -> Service Object. | |
| * This map stores service object, and so is able to handle | |
| * iPOJO custom policies. | |
| */ | |
| private Map<ServiceReference, ServiceBindingHolder> m_serviceObjects = new HashMap<ServiceReference, ServiceBindingHolder>(); | |
| /** | |
| * The current list of bound services. | |
| */ | |
| private List<ServiceReference> m_boundServices = new ArrayList<ServiceReference>(); | |
| /** | |
| * The lock ensuring state consistency of the dependency. | |
| * This lock can be acquired from all collaborators. | |
| */ | |
| private ReentrantReadWriteLock m_lock = new ReentrantReadWriteLock(); | |
| /** | |
| * The listeners of the dependency model. | |
| */ | |
| private final List<DependencyModelListener> m_listeners = new ArrayList<DependencyModelListener>(); | |
| /** | |
| * Creates a DependencyModel. | |
| * If the dependency has no comparator and follows the | |
| * {@link DependencyModel#DYNAMIC_PRIORITY_BINDING_POLICY} policy | |
| * the OSGi Service Reference Comparator is used. | |
| * | |
| * @param specification the required specification | |
| * @param aggregate is the dependency aggregate ? | |
| * @param optional is the dependency optional ? | |
| * @param filter the LDAP filter | |
| * @param comparator the comparator object to sort references | |
| * @param policy the binding policy | |
| * @param context the bundle context (or service context) | |
| * @param listener the dependency lifecycle listener to notify from dependency | |
| * @param ci instance managing the dependency | |
| * state changes. | |
| */ | |
| public DependencyModel(Class specification, boolean aggregate, boolean optional, Filter filter, | |
| Comparator<ServiceReference> comparator, int policy, | |
| BundleContext context, DependencyStateListener listener, ComponentInstance ci) { | |
| m_specification = specification; | |
| m_aggregate = aggregate; | |
| m_optional = optional; | |
| m_instance = ci; | |
| m_policy = policy; | |
| // If the dynamic priority policy is chosen, and we have no comparator, fix it to OSGi standard service reference comparator. | |
| if (m_policy == DYNAMIC_PRIORITY_BINDING_POLICY && comparator == null) { | |
| comparator = new ServiceReferenceRankingComparator(); | |
| } | |
| if (context != null) { | |
| m_context = context; | |
| // If the context is null, it gonna be set later using the setBundleContext method. | |
| } | |
| m_serviceReferenceManager = new ServiceReferenceManager(this, filter, comparator); | |
| if (filter != null) { | |
| try { | |
| m_contextSourceManager = new ContextSourceManager(this); | |
| } catch (InvalidSyntaxException e) { | |
| throw new IllegalArgumentException(e); | |
| } | |
| } else { | |
| m_contextSourceManager = null; | |
| } | |
| m_state = UNRESOLVED; | |
| m_listener = listener; | |
| } | |
| /** | |
| * Opens the tracking. | |
| * This method computes the dependency state. | |
| * <p/> | |
| * As the dependency is starting, locking is not required here. | |
| * | |
| * @see DependencyModel#computeAndSetDependencyState() | |
| */ | |
| public void start() { | |
| m_state = UNRESOLVED; | |
| m_tracker = new Tracker(m_context, m_specification.getName(), m_serviceReferenceManager); | |
| m_serviceReferenceManager.open(); | |
| m_tracker.open(); | |
| if (m_contextSourceManager != null) { | |
| m_contextSourceManager.start(); | |
| } | |
| computeAndSetDependencyState(); | |
| } | |
| /** | |
| * Gets the bundle context used by the dependency. | |
| * @return the bundle context | |
| */ | |
| public BundleContext getBundleContext() { | |
| // Immutable member, no lock required. | |
| return m_context; | |
| } | |
| /** | |
| * This callback is called by ranking interceptor to notify the dependency that the selected service set has | |
| * changed and must be recomputed. | |
| */ | |
| public void invalidateSelectedServices() { | |
| m_serviceReferenceManager.invalidateSelectedServices(); | |
| } | |
| public void invalidateMatchingServices() { | |
| m_serviceReferenceManager.invalidateMatchingServices(); | |
| } | |
| /** | |
| * Closes the tracking. | |
| * The dependency becomes {@link DependencyModel#UNRESOLVED} | |
| * at the end of this method. | |
| */ | |
| public void stop() { | |
| // We're stopping, we must take the exclusive lock | |
| try { | |
| acquireWriteLockIfNotHeld(); | |
| if (m_tracker != null) { | |
| m_tracker.close(); | |
| m_tracker = null; | |
| } | |
| m_boundServices.clear(); | |
| m_serviceReferenceManager.close(); | |
| ungetAllServices(); | |
| m_state = UNRESOLVED; | |
| if (m_contextSourceManager != null) { | |
| m_contextSourceManager.stop(); | |
| } | |
| } finally { | |
| releaseWriteLockIfHeld(); | |
| } | |
| } | |
| /** | |
| * Ungets all 'get' service references. | |
| * This also clears the service object map. | |
| * The method is called while holding the exclusive lock. | |
| */ | |
| private void ungetAllServices() { | |
| for (Map.Entry<ServiceReference, ServiceBindingHolder> entry : m_serviceObjects.entrySet()) { | |
| ServiceReference ref = entry.getKey(); | |
| ServiceBindingHolder sbh = entry.getValue(); | |
| if (m_tracker != null) { | |
| m_tracker.ungetService(ref); | |
| } | |
| if (sbh.factory != null) { | |
| sbh.factory.ungetService(m_instance, sbh.service); | |
| } | |
| m_serviceReferenceManager.unweavingServiceBinding(sbh); | |
| } | |
| m_serviceObjects.clear(); | |
| } | |
| /** | |
| * Is the reference set frozen (cannot change anymore)? | |
| * This method must be override by concrete dependency to support | |
| * the static binding policy. In fact, this method allows optimizing | |
| * the static dependencies to become frozen only when needed. | |
| * This method returns <code>false</code> by default. | |
| * The method must always return <code>false</code> for non-static dependencies. | |
| * | |
| * @return <code>true</code> if the reference set is frozen. | |
| */ | |
| public boolean isFrozen() { | |
| return false; | |
| } | |
| /** | |
| * Unfreezes the dependency. | |
| * This method must be override by concrete dependency to support | |
| * the static binding policy. This method is called after tracking restarting. | |
| */ | |
| public void unfreeze() { | |
| // nothing to do | |
| } | |
| /** | |
| * Does the service reference match ? This method must be overridden by | |
| * concrete dependencies if they need advanced testing on service reference | |
| * (that cannot be expressed in the LDAP filter). By default this method | |
| * returns <code>true</code>. | |
| * | |
| * @param ref the tested reference. | |
| * @return <code>true</code> if the service reference matches. | |
| */ | |
| public boolean match(ServiceReference ref) { | |
| return true; | |
| } | |
| /** | |
| * Computes the actual dependency state. | |
| * This methods invokes the {@link DependencyStateListener}. | |
| * If this method is called without the write lock, it takes it. Anyway, the lock will be released before called | |
| * the | |
| * callbacks. | |
| */ | |
| private void computeAndSetDependencyState() { | |
| try { | |
| boolean mustCallValidate = false; | |
| boolean mustCallInvalidate = false; | |
| acquireWriteLockIfNotHeld(); | |
| // The dependency is broken, nothing else can be done | |
| if (m_state == BROKEN) { | |
| return; | |
| } | |
| if (m_optional || !m_serviceReferenceManager.isEmpty()) { | |
| // The dependency is valid | |
| if (m_state == UNRESOLVED) { | |
| m_state = RESOLVED; | |
| mustCallValidate = true; | |
| } | |
| } else { | |
| // The dependency is invalid | |
| if (m_state == RESOLVED) { | |
| m_state = UNRESOLVED; | |
| mustCallInvalidate = true; | |
| } | |
| } | |
| // Invoke callback in a non-synchronized region | |
| // First unlock the lock | |
| releaseWriteLockIfHeld(); | |
| // Now we can call the callbacks | |
| if (mustCallInvalidate) { | |
| invalidate(); | |
| } else if (mustCallValidate) { | |
| validate(); | |
| } | |
| } finally { | |
| // If we are still holding the exclusive lock, unlock it. | |
| releaseWriteLockIfHeld(); | |
| } | |
| } | |
| /** | |
| * Gets the first bound service reference. | |
| * | |
| * @return <code>null</code> if no more provider is available, | |
| * else returns the first reference from the matching set. | |
| */ | |
| public ServiceReference getServiceReference() { | |
| // Read lock required | |
| try { | |
| acquireReadLockIfNotHeld(); | |
| if (m_boundServices.isEmpty()) { | |
| return null; | |
| } else { | |
| return m_boundServices.get(0); | |
| } | |
| } finally { | |
| releaseReadLockIfHeld(); | |
| } | |
| } | |
| /** | |
| * Gets bound service references. | |
| * | |
| * @return the sorted (if a comparator is used) array of matching service | |
| * references, <code>null</code> if no references are available. | |
| */ | |
| public ServiceReference[] getServiceReferences() { | |
| // Read lock required | |
| try { | |
| acquireReadLockIfNotHeld(); | |
| if (m_boundServices.isEmpty()) { | |
| return null; | |
| } | |
| return m_boundServices.toArray(new ServiceReference[m_boundServices.size()]); | |
| } finally { | |
| releaseReadLockIfHeld(); | |
| } | |
| } | |
| /** | |
| * Gets the list of currently used service references. | |
| * If no service references, returns <code>null</code> | |
| * | |
| * @return the list of used reference (according to the service tracker). | |
| */ | |
| public List<ServiceReference> getUsedServiceReferences() { | |
| // Read lock required | |
| try { | |
| acquireReadLockIfNotHeld(); | |
| // The list must confront actual matching services with already get services from the tracker. | |
| int size = m_boundServices.size(); | |
| List<ServiceReference> usedByTracker = null; | |
| if (m_tracker != null) { | |
| usedByTracker = m_tracker.getUsedServiceReferences(); | |
| } | |
| if (size == 0 || usedByTracker == null) { | |
| return null; | |
| } | |
| List<ServiceReference> list = new ArrayList<ServiceReference>(1); | |
| for (ServiceReference ref : m_boundServices) { | |
| if (usedByTracker.contains(ref)) { | |
| list.add(ref); // Add the service in the list. | |
| if (!isAggregate()) { // IF we are not multiple, return the list when the first element is found. | |
| return list; | |
| } | |
| } | |
| } | |
| return list; | |
| } finally { | |
| releaseReadLockIfHeld(); | |
| } | |
| } | |
| /** | |
| * @return the component instance on which this dependency is plugged. | |
| */ | |
| public ComponentInstance getComponentInstance() { | |
| // No lock required as m_instance is final | |
| return m_instance; | |
| } | |
| /** | |
| * Gets the number of actual matching references. | |
| * | |
| * @return the number of matching references | |
| */ | |
| public int getSize() { | |
| try { | |
| acquireReadLockIfNotHeld(); | |
| return m_boundServices.size(); | |
| } finally { | |
| releaseReadLockIfHeld(); | |
| } | |
| } | |
| /** | |
| * Concrete dependency callback. | |
| * This method is called when a new service needs to be | |
| * re-injected in the underlying concrete dependency. | |
| * | |
| * @param ref the service reference to inject. | |
| */ | |
| public abstract void onServiceArrival(ServiceReference ref); | |
| /** | |
| * Concrete dependency callback. | |
| * This method is called when a used service (already injected) is leaving. | |
| * | |
| * @param ref the leaving service reference. | |
| */ | |
| public abstract void onServiceDeparture(ServiceReference ref); | |
| /** | |
| * Concrete dependency callback. | |
| * This method is called when a used service (already injected) is modified. | |
| * | |
| * @param ref the modified service reference. | |
| */ | |
| public abstract void onServiceModification(ServiceReference ref); | |
| /** | |
| * Concrete dependency callback. | |
| * This method is called when the dependency is reconfigured and when this | |
| * reconfiguration implies changes on the matching service set ( and by the | |
| * way on the injected service). | |
| * | |
| * @param departs the service leaving the matching set. | |
| * @param arrivals the service arriving in the matching set. | |
| */ | |
| public abstract void onDependencyReconfiguration(ServiceReference[] departs, ServiceReference[] arrivals); | |
| /** | |
| * Calls the listener callback to notify the new state of the current | |
| * dependency. | |
| * No lock hold when calling this callback. | |
| */ | |
| private void invalidate() { | |
| m_listener.invalidate(this); | |
| // Notify dependency invalidation to listeners | |
| notifyListeners(DependencyEventType.INVALIDATE, null, null); | |
| } | |
| /** | |
| * Calls the listener callback to notify the new state of the current | |
| * dependency. | |
| * No lock hold when calling this callback. | |
| */ | |
| private void validate() { | |
| m_listener.validate(this); | |
| // Notify dependency validation to listeners | |
| notifyListeners(DependencyEventType.VALIDATE, null, null); | |
| } | |
| /** | |
| * Gets the actual state of the dependency. | |
| * @return the state of the dependency. | |
| */ | |
| public int getState() { | |
| try { | |
| acquireReadLockIfNotHeld(); | |
| return m_state; | |
| } finally { | |
| releaseReadLockIfHeld(); | |
| } | |
| } | |
| /** | |
| * Gets the tracked specification. | |
| * | |
| * @return the Class object tracked by the dependency. | |
| */ | |
| public Class getSpecification() { | |
| return m_specification; | |
| } | |
| /** | |
| * Sets the required specification of this service dependency. | |
| * This operation is not supported if the dependency tracking has already begun. | |
| * So, we don't have to hold a lock. | |
| * | |
| * @param specification the required specification. | |
| */ | |
| public void setSpecification(Class specification) { | |
| if (m_tracker == null) { | |
| m_specification = specification; | |
| } else { | |
| throw new UnsupportedOperationException("Dynamic specification change is not yet supported"); | |
| } | |
| } | |
| /** | |
| * Acquires the write lock only and only if the write lock is not already held by the current thread. | |
| * @return {@literal true} if the lock was acquired within the method, {@literal false} otherwise. | |
| */ | |
| public boolean acquireWriteLockIfNotHeld() { | |
| if (! m_lock.isWriteLockedByCurrentThread()) { | |
| m_lock.writeLock().lock(); | |
| return true; | |
| } | |
| return false; | |
| } | |
| /** | |
| * Releases the write lock only and only if the write lock is held by the current thread. | |
| * @return {@literal true} if the lock has no more holders, {@literal false} otherwise. | |
| */ | |
| public boolean releaseWriteLockIfHeld() { | |
| if (m_lock.isWriteLockedByCurrentThread()) { | |
| m_lock.writeLock().unlock(); | |
| } | |
| return m_lock.getWriteHoldCount() == 0; | |
| } | |
| /** | |
| * Acquires the read lock only and only if no read lock is already held by the current thread. | |
| * | |
| * As the introspection methods provided by this method are java 6+, we just take a read lock. | |
| * @return {@literal true} if the lock was acquired within the method, {@literal false} otherwise. | |
| */ | |
| public boolean acquireReadLockIfNotHeld() { | |
| m_lock.readLock().lock(); | |
| return true; | |
| } | |
| /** | |
| * Releases the read lock only and only if the read lock is held by the current thread. | |
| * * As the introspection methods provided by this method are java 6+, we just unlock the read lock. | |
| * @return {@literal true} if the lock has no more holders, {@literal false} otherwise. | |
| */ | |
| public boolean releaseReadLockIfHeld() { | |
| try { | |
| m_lock.readLock().unlock(); | |
| } catch (IllegalMonitorStateException e) { | |
| // Oupsy we were not holding the lock... | |
| } | |
| return true; | |
| } | |
| /** | |
| * Returns the dependency filter (String form). | |
| * | |
| * @return the String form of the LDAP filter used by this dependency, | |
| * <code>null</code> if not set. | |
| */ | |
| public String getFilter() { | |
| Filter filter; | |
| try { | |
| acquireReadLockIfNotHeld(); | |
| filter = m_serviceReferenceManager.getFilter(); | |
| } finally { | |
| releaseReadLockIfHeld(); | |
| } | |
| if (filter == null) { | |
| return null; | |
| } else { | |
| return filter.toString(); | |
| } | |
| } | |
| /** | |
| * Sets the filter of the dependency. This method recomputes the | |
| * matching set and call the onDependencyReconfiguration callback. | |
| * | |
| * @param filter the new LDAP filter. | |
| */ | |
| public void setFilter(Filter filter) { | |
| try { | |
| acquireWriteLockIfNotHeld(); | |
| ServiceReferenceManager.ChangeSet changeSet = m_serviceReferenceManager.setFilter(filter, m_tracker); | |
| // We call this method when holding the lock, but the method may decide to release the lock to invoke | |
| // callbacks, so we must defensively unlock the lock in the finally block. | |
| applyReconfiguration(changeSet); | |
| } finally { | |
| releaseWriteLockIfHeld(); | |
| } | |
| } | |
| /** | |
| * Applies the given reconfiguration. | |
| * This method check if the current thread is holding the write lock, if not, acquire it. | |
| * The lock will be released before calling callbacks. As a consequence, the caller has to check if the lock is | |
| * still hold when this method returns. | |
| * @param changeSet the reconfiguration changes | |
| */ | |
| public void applyReconfiguration(ServiceReferenceManager.ChangeSet changeSet) { | |
| List<ServiceReference> arr = new ArrayList<ServiceReference>(); | |
| List<ServiceReference> dep = new ArrayList<ServiceReference>(); | |
| try { | |
| acquireWriteLockIfNotHeld(); | |
| if (m_tracker == null) { | |
| // Nothing else to do. | |
| return; | |
| } else { | |
| // Update bindings | |
| m_boundServices.clear(); | |
| if (m_aggregate) { | |
| m_boundServices = new ArrayList<ServiceReference>(changeSet.selected); | |
| arr = changeSet.arrivals; | |
| dep = changeSet.departures; | |
| } else { | |
| ServiceReference used = null; | |
| if (!m_boundServices.isEmpty()) { | |
| used = m_boundServices.get(0); | |
| } | |
| if (!changeSet.selected.isEmpty()) { | |
| final ServiceReference best = changeSet.newFirstReference; | |
| // We didn't a provider | |
| if (used == null) { | |
| // We are not bound with anyone yet, so take the first of the selected set | |
| m_boundServices.add(best); | |
| arr.add(best); | |
| } else { | |
| // A provider was already bound, did we changed ? | |
| if (changeSet.selected.contains(used)) { | |
| // We are still valid - but in dynamic priority, we may have to change | |
| if (getBindingPolicy() == DYNAMIC_PRIORITY_BINDING_POLICY && used != best) { | |
| m_boundServices.add(best); | |
| dep.add(used); | |
| arr.add(best); | |
| } else { | |
| // We restore the old binding. | |
| m_boundServices.add(used); | |
| } | |
| } else { | |
| // The used service has left. | |
| m_boundServices.add(best); | |
| dep.add(used); | |
| arr.add(best); | |
| } | |
| } | |
| } else { | |
| // We don't have any service anymore | |
| if (used != null) { | |
| arr.add(used); | |
| } | |
| } | |
| } | |
| } | |
| } finally { | |
| releaseWriteLockIfHeld(); | |
| } | |
| // This method releases the exclusive lock. | |
| computeAndSetDependencyState(); | |
| // As the previous method has released the lock, we can call the callback safely. | |
| onDependencyReconfiguration( | |
| dep.toArray(new ServiceReference[dep.size()]), | |
| arr.toArray(new ServiceReference[arr.size()])); | |
| // Notify dependency reconfiguration to listeners | |
| notifyListeners(DependencyEventType.RECONFIGURED, null, null); | |
| } | |
| public boolean isAggregate() { | |
| try { | |
| acquireReadLockIfNotHeld(); | |
| return m_aggregate; | |
| } finally { | |
| releaseReadLockIfHeld(); | |
| } | |
| } | |
| /** | |
| * Sets the aggregate attribute of the current dependency. | |
| * If the tracking is opened, it will call arrival and departure callbacks. | |
| * | |
| * @param isAggregate the new aggregate attribute value. | |
| */ | |
| public void setAggregate(boolean isAggregate) { | |
| // Acquire the write lock here. | |
| acquireWriteLockIfNotHeld(); | |
| List<ServiceReference> arrivals = new ArrayList<ServiceReference>(); | |
| List<ServiceReference> departures = new ArrayList<ServiceReference>(); | |
| try { | |
| if (m_tracker == null) { // Not started ... | |
| m_aggregate = isAggregate; | |
| } else { | |
| // We become aggregate. | |
| if (!m_aggregate && isAggregate) { | |
| m_aggregate = true; | |
| // Call the callback on all non already injected service. | |
| if (m_state == RESOLVED) { | |
| for (ServiceReference ref : m_serviceReferenceManager.getSelectedServices()) { | |
| if (!m_boundServices.contains(ref)) { | |
| m_boundServices.add(ref); | |
| arrivals.add(ref); | |
| } | |
| } | |
| } | |
| } else if (m_aggregate && !isAggregate) { | |
| m_aggregate = false; | |
| // We become non-aggregate. | |
| if (m_state == RESOLVED) { | |
| List<ServiceReference> list = new ArrayList<ServiceReference>(m_boundServices); | |
| for (int i = 1; i < list.size(); i++) { // The loop begin at 1, as the 0 stays injected. | |
| m_boundServices.remove(list.get(i)); | |
| departures.add(list.get(i)); | |
| } | |
| } | |
| } | |
| // Else, do nothing. | |
| } | |
| } finally { | |
| releaseWriteLockIfHeld(); | |
| } | |
| // TODO shouldn't we call onDependencyReconfiguration here???? | |
| // Now call callbacks, the lock is not held anymore | |
| // Only one of the list is not empty.. | |
| try { | |
| acquireReadLockIfNotHeld(); | |
| for (ServiceReference ref : arrivals) { | |
| onServiceArrival(ref); | |
| // Notify service binding to listeners | |
| notifyListeners(DependencyEventType.BINDING, ref, m_serviceObjects.get(ref).service); | |
| } | |
| for (ServiceReference ref : departures) { | |
| onServiceDeparture(ref); | |
| // Notify service unbinding to listeners | |
| notifyListeners(DependencyEventType.UNBINDING, ref, m_serviceObjects.get(ref).service); | |
| } | |
| } finally { | |
| releaseReadLockIfHeld(); | |
| } | |
| } | |
| /** | |
| * Sets the optionality attribute of the current dependency. | |
| * | |
| * @param isOptional the new optional attribute value. | |
| */ | |
| public void setOptionality(boolean isOptional) { | |
| try { | |
| acquireWriteLockIfNotHeld(); | |
| m_optional = isOptional; | |
| computeAndSetDependencyState(); | |
| } finally { | |
| releaseWriteLockIfHeld(); | |
| } | |
| } | |
| public boolean isOptional() { | |
| try { | |
| acquireReadLockIfNotHeld(); | |
| return m_optional; | |
| } finally { | |
| releaseReadLockIfHeld(); | |
| } | |
| } | |
| /** | |
| * Gets the used binding policy. | |
| * | |
| * @return the current binding policy. | |
| */ | |
| public int getBindingPolicy() { | |
| try { | |
| acquireReadLockIfNotHeld(); | |
| return m_policy; | |
| } finally { | |
| releaseReadLockIfHeld(); | |
| } | |
| } | |
| /** | |
| * Gets the used comparator name. | |
| * <code>null</code> if no comparator (i.e. the OSGi one is used). | |
| * | |
| * @return the comparator class name or <code>null</code> if the dependency doesn't use a comparator. | |
| */ | |
| public String getComparator() { | |
| final Comparator<ServiceReference> comparator; | |
| try { | |
| acquireReadLockIfNotHeld(); | |
| comparator = m_serviceReferenceManager.getComparator(); | |
| } finally { | |
| releaseReadLockIfHeld(); | |
| } | |
| if (comparator != null) { | |
| return comparator.getClass().getName(); | |
| } else { | |
| return null; | |
| } | |
| } | |
| public void setComparator(Comparator<ServiceReference> cmp) { | |
| try { | |
| acquireWriteLockIfNotHeld(); | |
| m_serviceReferenceManager.setComparator(cmp); | |
| } finally { | |
| releaseWriteLockIfHeld(); | |
| } | |
| } | |
| /** | |
| * Sets the bundle context used by this dependency. | |
| * This operation is not supported if the tracker is already opened, and as a consequence does not require locking. | |
| * | |
| * @param context the bundle context or service context to use | |
| */ | |
| public void setBundleContext(BundleContext context) { | |
| if (m_tracker == null) { // Not started ... | |
| m_context = context; | |
| } else { | |
| throw new UnsupportedOperationException("Dynamic bundle (i.e. service) context change is not supported"); | |
| } | |
| } | |
| /** | |
| * Gets a service object for the given reference. | |
| * The service object is stored to handle custom policies. | |
| * | |
| * @param ref the wanted service reference | |
| * @return the service object attached to the given reference | |
| */ | |
| public Object getService(ServiceReference ref) { | |
| return getService(ref, true); | |
| } | |
| /** | |
| * Gets a service object for the given reference. | |
| * | |
| * @param ref the wanted service reference | |
| * @param store enables / disables the storing of the reference. | |
| * @return the service object attached to the given reference | |
| */ | |
| public Object getService(ServiceReference ref, boolean store) { | |
| if (m_tracker == null) { | |
| // The tracker is already closed, we can't access the service anymore. | |
| return null; | |
| } | |
| // If we already have the service object, just return it. | |
| if (m_serviceObjects.containsKey(ref)) { | |
| return m_serviceObjects.get(ref).service; | |
| } | |
| ServiceBindingHolder holder = null; | |
| Object svc = m_tracker.getService(ref); | |
| IPOJOServiceFactory factory = null; | |
| if (svc instanceof IPOJOServiceFactory) { | |
| factory = (IPOJOServiceFactory) svc; | |
| svc = factory.getService(m_instance); | |
| } | |
| holder = new ServiceBindingHolder(ref, factory, svc); | |
| svc = m_serviceReferenceManager.weavingServiceBinding(holder); | |
| if (store) { | |
| try { | |
| acquireWriteLockIfNotHeld(); | |
| // The service object may have been modified by the interceptor, update the holder | |
| if (svc != holder.service) { | |
| m_serviceObjects.put(ref, new ServiceBindingHolder(ref, factory, svc)); | |
| } else { | |
| m_serviceObjects.put(ref, holder); | |
| } | |
| } finally { | |
| releaseWriteLockIfHeld(); | |
| } | |
| } | |
| return svc; | |
| } | |
| /** | |
| * Ungets a used service reference. | |
| * | |
| * @param ref the reference to unget. | |
| */ | |
| public void ungetService(ServiceReference ref) { | |
| m_tracker.ungetService(ref); | |
| ServiceBindingHolder sbh; | |
| try { | |
| acquireWriteLockIfNotHeld(); | |
| sbh = m_serviceObjects.remove(ref); | |
| } finally { | |
| releaseWriteLockIfHeld(); | |
| } | |
| // Call the callback outside the lock. | |
| if (sbh != null && sbh.factory != null) { | |
| sbh.factory.ungetService(m_instance, sbh.service); | |
| } | |
| m_serviceReferenceManager.unweavingServiceBinding(sbh); | |
| } | |
| public ContextSourceManager getContextSourceManager() { | |
| // Final member, no lock required. | |
| return m_contextSourceManager; | |
| } | |
| /** | |
| * Gets the dependency id. | |
| * | |
| * @return the dependency id. Specification name by default. | |
| */ | |
| public String getId() { | |
| // Immutable, no lock required. | |
| return getSpecification().getName(); | |
| } | |
| /** | |
| * Callbacks call by the ServiceReferenceManager when the selected service set has changed. | |
| * @param set the change set. | |
| */ | |
| public void onChange(ServiceReferenceManager.ChangeSet set) { | |
| try { | |
| acquireWriteLockIfNotHeld(); | |
| // First handle the static case with a frozen state | |
| if (isFrozen() && getState() != BROKEN) { | |
| for (ServiceReference ref : set.departures) { | |
| // Check if any of the service that have left was in used. | |
| if (m_boundServices.contains(ref)) { | |
| // Static dependency broken. | |
| m_state = BROKEN; | |
| // We are going to call callbacks, releasing the lock. | |
| ServiceBindingHolder sbh = m_serviceObjects.get(ref); | |
| releaseWriteLockIfHeld(); | |
| // Notify listeners | |
| notifyListeners(DependencyEventType.UNBINDING, ref, sbh.service); | |
| notifyListeners(DependencyEventType.DEPARTURE, ref, null); | |
| invalidate(); // This will invalidate the instance. | |
| m_instance.stop(); // Stop the instance | |
| unfreeze(); | |
| m_instance.start(); | |
| return; | |
| } | |
| } | |
| } | |
| List<ServiceReference> arrivals = new ArrayList<ServiceReference>(); | |
| List<ServiceReference> departures = new ArrayList<ServiceReference>(); | |
| // Manage departures | |
| // We unbind all bound services that are leaving. | |
| for (ServiceReference ref : set.departures) { | |
| if (m_boundServices.contains(ref)) { | |
| // We were using the reference | |
| m_boundServices.remove(ref); | |
| departures.add(ref); | |
| } | |
| } | |
| // Manage arrivals | |
| // For aggregate dependencies, call onServiceArrival for all services not-yet-bound and in the order of the | |
| // selection. | |
| if (m_aggregate) { | |
| // If the dependency is not already in used, | |
| // the bindings must be sorted as in set.selected | |
| if (m_serviceObjects.isEmpty() || DYNAMIC_PRIORITY_BINDING_POLICY == getBindingPolicy()) { | |
| m_boundServices.clear(); | |
| m_boundServices.addAll(set.selected); | |
| } | |
| // Now we notify from the arrival. | |
| // If we didn't add the reference yet, we add it. | |
| for (ServiceReference ref : set.arrivals) { | |
| // We bind all not-already bound services, so it's an arrival | |
| if (!m_boundServices.contains(ref)) { | |
| m_boundServices.add(ref); | |
| } | |
| arrivals.add(ref); | |
| } | |
| } else { | |
| if (!set.selected.isEmpty()) { | |
| final ServiceReference best = set.selected.get(0); | |
| // We have a provider | |
| if (m_boundServices.isEmpty()) { | |
| // We are not bound with anyone yet, so take the first of the selected set | |
| m_boundServices.add(best); | |
| arrivals.add(best); | |
| } else { | |
| final ServiceReference current = m_boundServices.get(0); | |
| // We are already bound, to the rebinding decision depends on the binding strategy | |
| if (getBindingPolicy() == DYNAMIC_PRIORITY_BINDING_POLICY) { | |
| // Rebinding in the DP binding policy if the bound one if not the new best one. | |
| if (current != best) { | |
| m_boundServices.remove(current); | |
| m_boundServices.add(best); | |
| departures.add(current); | |
| arrivals.add(best); | |
| } | |
| } else { | |
| // In static and dynamic binding policy, if the service is not yet used and the new best is not | |
| // the currently selected one, we should switch. | |
| boolean isUsed = m_serviceObjects.containsKey(current); | |
| if (!isUsed && current != best) { | |
| m_boundServices.remove(current); | |
| m_boundServices.add(best); | |
| departures.add(current); | |
| arrivals.add(best); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| // Before leaving the protected region, copy used services. | |
| Map<ServiceReference, ServiceBindingHolder> services = new HashMap<ServiceReference, ServiceBindingHolder>(m_serviceObjects); | |
| // Leaving the locked region to invoke callbacks | |
| releaseWriteLockIfHeld(); | |
| for (ServiceReference ref : departures) { | |
| onServiceDeparture(ref); | |
| // Notify service unbinding to listeners | |
| final ServiceBindingHolder sbh = services.get(ref); | |
| if (sbh != null) { | |
| notifyListeners(DependencyEventType.UNBINDING, ref, sbh.service); | |
| } else { | |
| notifyListeners(DependencyEventType.UNBINDING, ref, null); | |
| } | |
| // Unget the service reference. | |
| ungetService(ref); | |
| } | |
| for (ServiceReference ref : arrivals) { | |
| onServiceArrival(ref); | |
| // Notify service binding to listeners | |
| final ServiceBindingHolder sbh = services.get(ref); | |
| if (sbh != null) { | |
| notifyListeners(DependencyEventType.BINDING, ref, sbh.service); | |
| } else { | |
| notifyListeners(DependencyEventType.BINDING, ref, null); | |
| } | |
| } | |
| // Do we have a modified service ? | |
| if (set.modified != null && m_boundServices.contains(set.modified)) { | |
| onServiceModification(set.modified); | |
| // TODO call boundServiceModified on listeners??? | |
| } | |
| // Did our state changed ? | |
| // this method will manage its own synchronization. | |
| computeAndSetDependencyState(); | |
| } finally { | |
| releaseWriteLockIfHeld(); | |
| } | |
| } | |
| public ServiceReferenceManager getServiceReferenceManager() { | |
| return m_serviceReferenceManager; | |
| } | |
| public Tracker getTracker() { | |
| return m_tracker; | |
| } | |
| public enum DependencyEventType { | |
| VALIDATE, | |
| INVALIDATE, | |
| ARRIVAL, | |
| MODIFIED, | |
| DEPARTURE, | |
| BINDING, | |
| UNBINDING, | |
| RECONFIGURED | |
| } | |
| /** | |
| * Add the given listener to the dependency model's list of listeners. | |
| * | |
| * @param listener the {@code DependencyModelListener} object to be added | |
| * @throws NullPointerException if {@code listener} is {@code null} | |
| */ | |
| public void addListener(DependencyModelListener listener) { | |
| if (listener == null) { | |
| throw new NullPointerException("null listener"); | |
| } | |
| synchronized (m_listeners) { | |
| m_listeners.add(listener); | |
| } | |
| } | |
| /** | |
| * Remove the given listener from the dependency model's list of listeners. | |
| * | |
| * @param listener the {@code DependencyModelListener} object to be removed | |
| * @throws NullPointerException if {@code listener} is {@code null} | |
| * @throws NoSuchElementException if {@code listener} wasn't present in the dependency model's list of listeners | |
| */ | |
| public void removeListener(DependencyModelListener listener) { | |
| if (listener == null) { | |
| throw new NullPointerException("null listener"); | |
| } | |
| synchronized (m_listeners) { | |
| // We definitely cannot rely on listener's equals method... | |
| // ...so we need to manually search for the listener, using ==. | |
| int i = -1; | |
| for(int j = m_listeners.size() -1; j>=0 ; j--) { | |
| if (m_listeners.get(j) == listener) { | |
| // Found! | |
| i = j; | |
| break; | |
| } | |
| } | |
| if (i != -1) { | |
| m_listeners.remove(i); | |
| } else { | |
| throw new NoSuchElementException("no such listener"); | |
| } | |
| } | |
| } | |
| /** | |
| * Notify all listeners that a change has occurred in this dependency model. | |
| * | |
| * @param type the type of event | |
| * @param service the reference of the concerned service (may be null) | |
| * @param object the concerned service object (may be null) | |
| */ | |
| public void notifyListeners(DependencyEventType type, ServiceReference<?> service, Object object) { | |
| // Get a snapshot of the listeners | |
| List<DependencyModelListener> tmp; | |
| synchronized (m_listeners) { | |
| tmp = new ArrayList<DependencyModelListener>(m_listeners); | |
| } | |
| // Do notify, outside the m_listeners lock | |
| for (DependencyModelListener l : tmp) { | |
| try { | |
| switch (type) { | |
| case VALIDATE: | |
| l.validate(this); | |
| break; | |
| case INVALIDATE: | |
| l.invalidate(this); | |
| break; | |
| case ARRIVAL: | |
| l.matchingServiceArrived(this, service); | |
| break; | |
| case MODIFIED: | |
| l.matchingServiceModified(this, service); | |
| break; | |
| case DEPARTURE: | |
| l.matchingServiceDeparted(this, service); | |
| break; | |
| case BINDING: | |
| l.serviceBound(this, service, object); | |
| break; | |
| case UNBINDING: | |
| l.serviceUnbound(this, service, object); | |
| break; | |
| case RECONFIGURED: | |
| l.reconfigured(this); | |
| break; | |
| } | |
| } catch (Throwable e) { | |
| // Put a warning on the logger, and continue | |
| getComponentInstance().getFactory().getLogger().log(Log.WARNING, | |
| String.format( | |
| "[%s] A DependencyModelListener has failed: %s", | |
| getComponentInstance().getInstanceName(), | |
| e.getMessage()) | |
| , e); | |
| } | |
| } | |
| } | |
| /** | |
| * Removes all the listeners from this dependency before it gets disposed. | |
| */ | |
| public void cleanup() { | |
| synchronized (m_listeners) { | |
| m_listeners.clear(); | |
| } | |
| } | |
| /** | |
| * Service binding structure. | |
| */ | |
| public class ServiceBindingHolder { | |
| public final Object service; | |
| public final IPOJOServiceFactory factory; | |
| public final ServiceReference reference; | |
| private ServiceBindingHolder(ServiceReference reference, IPOJOServiceFactory factory, Object service) { | |
| this.service = service; | |
| this.factory = factory; | |
| this.reference = reference; | |
| } | |
| private ServiceBindingHolder(ServiceReference reference, Object service) { | |
| this.service = service; | |
| this.factory = null; | |
| this.reference = reference; | |
| } | |
| } | |
| } |