/*
* 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;
}
}
}