| /* |
| * 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.dm.impl; |
| |
| import static org.apache.felix.dm.ComponentState.INACTIVE; |
| import static org.apache.felix.dm.ComponentState.INSTANTIATED_AND_WAITING_FOR_REQUIRED; |
| import static org.apache.felix.dm.ComponentState.STARTED; |
| import static org.apache.felix.dm.ComponentState.STARTING; |
| import static org.apache.felix.dm.ComponentState.STOPPED; |
| import static org.apache.felix.dm.ComponentState.STOPPING; |
| import static org.apache.felix.dm.ComponentState.TRACKING_OPTIONAL; |
| import static org.apache.felix.dm.ComponentState.WAITING_FOR_REQUIRED; |
| |
| import java.lang.reflect.InvocationTargetException; |
| import java.lang.reflect.Method; |
| import java.lang.reflect.Proxy; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Dictionary; |
| import java.util.Enumeration; |
| import java.util.HashMap; |
| import java.util.Hashtable; |
| import java.util.IdentityHashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.concurrent.ConcurrentHashMap; |
| import java.util.concurrent.ConcurrentSkipListSet; |
| import java.util.concurrent.CopyOnWriteArrayList; |
| import java.util.concurrent.Executor; |
| import java.util.concurrent.atomic.AtomicBoolean; |
| import java.util.concurrent.atomic.AtomicLong; |
| import java.util.function.Predicate; |
| import java.util.function.Supplier; |
| import java.util.stream.Stream; |
| |
| import org.apache.felix.dm.Component; |
| import org.apache.felix.dm.ComponentDeclaration; |
| import org.apache.felix.dm.ComponentDependencyDeclaration; |
| import org.apache.felix.dm.ComponentExecutorFactory; |
| import org.apache.felix.dm.ComponentState; |
| import org.apache.felix.dm.ComponentStateListener; |
| import org.apache.felix.dm.Dependency; |
| import org.apache.felix.dm.DependencyManager; |
| import org.apache.felix.dm.Logger; |
| import org.apache.felix.dm.context.ComponentContext; |
| import org.apache.felix.dm.context.DependencyContext; |
| import org.apache.felix.dm.context.Event; |
| import org.apache.felix.dm.context.EventType; |
| import org.osgi.framework.Bundle; |
| import org.osgi.framework.BundleContext; |
| import org.osgi.framework.PrototypeServiceFactory; |
| import org.osgi.framework.ServiceFactory; |
| import org.osgi.framework.ServiceRegistration; |
| import org.osgi.service.log.LogService; |
| |
| /** |
| * Dependency Manager Component implementation. |
| * |
| * @author <a href="mailto:dev@felix.apache.org">Felix Project Team</a> |
| */ |
| public class ComponentImpl implements Component, ComponentContext, ComponentDeclaration { |
| /** |
| * NullObject ServiceRegistration that is injected in components that don't provide any services. |
| */ |
| private static final ServiceRegistration<?> NULL_REGISTRATION = (ServiceRegistration<?>) Proxy |
| .newProxyInstance(ComponentImpl.class.getClassLoader(), |
| new Class[] { ServiceRegistration.class }, |
| new DefaultNullObject()); |
| |
| /** |
| * Constant Used to get empty constructor by reflection. |
| */ |
| private static final CallbackTypeDef VOID = new CallbackTypeDef(new Class[][] {{}}, new Object[][] {{}}); |
| |
| /** |
| * Default Component Executor, which is by default single threaded. The first thread which schedules a task |
| * is the master thread and will execute all tasks that are scheduled by other threads at the time the master |
| * thread is executing. Internal tasks scheduled by the master thread are executed immediately (inline execution). |
| * |
| * If a ComponentExecutorFactory is provided in the OSGI registry, then this executor will be replaced by the |
| * executor returned by the ComponentExecutorFactory (however, the same semantic of the default executor is used: |
| * all tasks are serially executed). |
| * |
| * @see @link {@link ComponentExecutorFactory} |
| */ |
| private volatile Executor m_executor; |
| |
| /** |
| * The current state of the component state machine. |
| */ |
| private ComponentState m_state = ComponentState.INACTIVE; |
| |
| /** |
| * Indicates that the handleChange method is currently being executed. |
| */ |
| private boolean m_handlingChange; |
| |
| /** |
| * List of dependencies. We use a COW list in order to avoid ConcurrentModificationException while iterating on the |
| * list and while a component synchronously add more dependencies from one of its callback method. |
| */ |
| private final CopyOnWriteArrayList<DependencyContext> m_dependencies = new CopyOnWriteArrayList<>(); |
| |
| /** |
| * List of Component state listeners. We use a COW list in order to avoid ConcurrentModificationException while iterating on the |
| * list and while a component synchronously adds more listeners from one of its callback method. |
| */ |
| private final List<ComponentStateListener> m_listeners = new CopyOnWriteArrayList<>(); |
| |
| /** |
| * Is the component active ? |
| */ |
| private boolean m_isStarted; |
| |
| /** |
| * The Component logger. |
| */ |
| private final Logger m_logger; |
| |
| /** |
| * The Component bundle context. |
| */ |
| private final BundleContext m_context; |
| |
| /** |
| * The DependencyManager object that has created this component. |
| */ |
| private final DependencyManager m_manager; |
| |
| /** |
| * The object used to create the component. Can be a class name, or the component implementation instance. |
| */ |
| private volatile Object m_componentDefinition; |
| |
| /** |
| * The component instance. |
| */ |
| private Object m_componentInstance; |
| |
| /** |
| * The service(s) provided by this component. Can be a String, or a String array. |
| */ |
| private volatile Object m_serviceName; |
| |
| /** |
| * The service properties, if this component is providing a service. |
| */ |
| private volatile Dictionary<Object, Object> m_serviceProperties; |
| |
| /** |
| * The component service registration. Can be a NullObject in case the component does not provide a service. |
| */ |
| private volatile ServiceRegistration<?> m_registration; |
| |
| /** |
| * The component name as it must be returned by getName. |
| */ |
| private volatile String m_componentName; |
| |
| /** |
| * Map of auto configured fields (BundleContext, ServiceRegistration, DependencyManager, or Component). |
| * By default, all fields mentioned above are auto configured (injected in class fields having the same type). |
| */ |
| private final Map<Class<?>, Boolean> m_autoConfig = new ConcurrentHashMap<>(); |
| |
| /** |
| * Map of auto configured instance fields that will be used when injected auto configured fields. |
| * @see #m_autoConfig |
| */ |
| private final Map<Class<?>, String> m_autoConfigInstance = new ConcurrentHashMap<>(); |
| |
| /** |
| * Data structure used to record the elapsed time used by component lifecycle callbacks. |
| * Key = callback name ("init", "start", "stop", "destroy"). |
| * Value = elapsed time in nanos. |
| */ |
| private final Map<String, Long> m_stopwatch = new ConcurrentHashMap<>(); |
| |
| /** |
| * Unique component id. |
| */ |
| private final long m_id; |
| |
| /** |
| * Unique ID generator. |
| */ |
| private final static AtomicLong m_idGenerator = new AtomicLong(); |
| |
| /** |
| * Holds all the services of a given dependency context. Caution: the last entry in the skiplist is the highest |
| * ranked service. |
| */ |
| private final Map<DependencyContext, ConcurrentSkipListSet<Event>> m_dependencyEvents = new HashMap<>(); |
| |
| /** |
| * Flag used to check if this component has been added in a DependencyManager object. |
| */ |
| private final AtomicBoolean m_active = new AtomicBoolean(false); |
| |
| /** |
| * Init lifecycle callback. From that method, component are expected to add more extra dependencies. |
| * When this callback is invoked, all required dependencies have been injected. |
| */ |
| private volatile String m_callbackInit; |
| |
| /** |
| * Start lifecycle callback. When this method is called, all required + all extra required dependencies defined in the |
| * init callback have been injected. The component may then perform its initialization. |
| */ |
| private volatile String m_callbackStart; |
| |
| /** |
| * Stop callback. When this method is called, the component has been unregistered (if it provides any services), |
| * and all optional dependencies have been unbound. |
| */ |
| private volatile String m_callbackStop; |
| |
| /** |
| * Destroy callback. When this method is called, all required dependencies defined in the init method have been unbound. |
| * After this method is called, then all required dependencies defined in the Activator will be unbound. |
| */ |
| private volatile String m_callbackDestroy; |
| |
| /** |
| * By default, the init/start/stop/destroy callbacks are invoked on the component instance(s). |
| * But you can specify a separate callback instance. |
| */ |
| private volatile Object m_callbackInstance; |
| |
| /** |
| * Component Factory instance object, that can be used to instantiate the component instance. |
| */ |
| private volatile Object m_instanceFactory; |
| |
| /** |
| * Name of the Factory method to call. |
| */ |
| private volatile String m_instanceFactoryCreateMethod; |
| |
| /** |
| * Composition Manager that can be used to create a graph of objects that are used to implement the component. |
| */ |
| private volatile Object m_compositionManager; |
| |
| /** |
| * Name of the method used to invoke in order to get the list of component instance objects. |
| */ |
| private volatile String m_compositionManagerGetMethod; |
| |
| /** |
| * The composition manager instance object, if specified. |
| */ |
| private volatile Object m_compositionManagerInstance; |
| |
| /** |
| * The Component bundle. |
| */ |
| private final Bundle m_bundle; |
| |
| /** |
| * Cache of callback invocation used to avoid calling the same callback twice. |
| * This situation may sometimes happen when the state machine triggers a lifecycle callback ("bind" call), and |
| * when the bind method registers a service which is tracked by another optional component dependency. |
| * |
| * @see org.apache.felix.dm.itest.api.FELIX4913_OptionalCallbackInvokedTwiceTest which reproduces the use case. |
| */ |
| private final Map<Event, Event> m_invokeCallbackCache = new IdentityHashMap<>(); |
| |
| /** |
| * Flag used to check if the start callback has been invoked. |
| * We use this flag to ensure that we only inject optional dependencies after the start callback has been called. |
| */ |
| private boolean m_startCalled; |
| |
| /** |
| * Used to track the last state we delivered to any state listeners. |
| */ |
| private ComponentState m_lastStateDeliveredToListeners = ComponentState.INACTIVE; |
| |
| /** |
| * Component service scope. |
| */ |
| private volatile ServiceScope m_scope = Component.ServiceScope.SINGLETON; |
| |
| /** |
| * Indicates if injection of methods or class fields is disabled for this component. |
| */ |
| private volatile boolean m_injectionDisabled; |
| |
| /** |
| * Prototype instance used when a component scope is not a singleton when when no init callback is defined. |
| */ |
| private final static Object PROTOTYPE_INSTANCE = new Object(); |
| |
| /** |
| * Default component declaration implementation. |
| */ |
| static class SCDImpl implements ComponentDependencyDeclaration { |
| private final String m_name; |
| private final int m_state; |
| private final String m_type; |
| |
| public SCDImpl(String name, int state, String type) { |
| m_name = name; |
| m_state = state; |
| m_type = type; |
| } |
| |
| public String getName() { |
| return m_name; |
| } |
| |
| public String getSimpleName() { |
| return m_name; |
| } |
| |
| public String getFilter() { |
| return null; |
| } |
| |
| public int getState() { |
| return m_state; |
| } |
| |
| public String getType() { |
| return m_type; |
| } |
| } |
| |
| class FactoryBase { |
| final Map<Object, ComponentImpl> m_clones = new ConcurrentHashMap<>(); |
| |
| public Object getService(Bundle bundle, ServiceRegistration<Object> registration) { |
| // create a clone of the prototype for the consumer |
| ComponentImpl clone = (ComponentImpl) m_manager.createComponent() |
| .setImplementation(m_componentDefinition) |
| .setFactory(m_instanceFactory, m_instanceFactoryCreateMethod) // if not set, no effect |
| .setComposition(m_compositionManager, m_compositionManagerGetMethod) // if not set, no effect |
| .setCallbacks(m_callbackInstance, m_callbackInit, m_callbackStart, m_callbackStop, m_callbackDestroy); // if not set, no effect |
| clone.setThreadPool(m_executor); |
| clone.setAutoConfig(ServiceRegistration.class, false); // don't inject the ServiceRegistration for the moment |
| configureAutoConfigState(clone, ComponentImpl.this); |
| // copy prototype dependencies, except instance bound dependencies |
| getDependencies().stream().filter(dc -> ! dc.isInstanceBound()).map(dc -> dc.createCopy()).forEach(clone::add); |
| clone.setCallbacks(m_callbackInit, m_callbackStart, m_callbackStop, m_callbackDestroy); |
| m_listeners.forEach(clone::add); |
| int ctorIndex = clone.instantiateComponent(createScopedComponentConstructorArgs(bundle, registration)); |
| // ctorIndex == -1 means we have used a factory to create the component |
| // if ctorIndex == 0 means we have used the first constructor (the one used to inject service registration and bundles |
| if (ctorIndex != 0) { |
| // we don't have injected the bundle and service registration in the constructor, so inject them in the class fields |
| autoConfigField(clone, ServiceRegistration.class, registration); |
| autoConfigField(clone, Bundle.class, bundle); |
| } |
| |
| clone.start(); |
| Object instance = clone.getInstance(); |
| if (instance == null) { |
| // Race condition: the prototype is probably deactivating. |
| throw new IllegalStateException("Can't create prototype instance"); |
| } |
| m_clones.put(instance, clone); |
| return instance; |
| } |
| |
| public void ungetService(Bundle bundle, ServiceRegistration<Object> registration, Object service) { |
| ComponentImpl clone = m_clones.remove(service); |
| if (clone != null) { |
| clone.stop(); |
| } |
| } |
| |
| private void autoConfigField(ComponentImpl clone, Class<?> type, Object autoConfig) { |
| Boolean doAutoConfig = m_autoConfig.get(type); |
| clone.setAutoConfig(type, doAutoConfig == null ? true : doAutoConfig); |
| clone.autoConfigureImplementation(type, autoConfig); |
| } |
| } |
| |
| class ComponentServiceFactory extends FactoryBase implements ServiceFactory<Object> { |
| } |
| |
| class ComponentPrototypeServiceFactory extends FactoryBase implements PrototypeServiceFactory<Object> { |
| } |
| |
| /** |
| * Constructor. Only used for tests. |
| */ |
| public ComponentImpl() { |
| this(null, null, new Logger(null)); |
| } |
| |
| /** |
| * Constructor |
| * @param context the component bundle context |
| * @param manager the manager used to create the component |
| * @param logger the logger to use |
| */ |
| public ComponentImpl(BundleContext context, DependencyManager manager, Logger logger) { |
| m_context = context; |
| m_bundle = context != null ? context.getBundle() : null; |
| m_manager = manager; |
| m_logger = logger; |
| m_executor = new SerialExecutor(m_logger); |
| m_autoConfig.put(BundleContext.class, Boolean.TRUE); |
| m_autoConfig.put(ServiceRegistration.class, Boolean.TRUE); |
| m_autoConfig.put(DependencyManager.class, Boolean.TRUE); |
| m_autoConfig.put(Component.class, Boolean.TRUE); |
| m_autoConfig.put(Bundle.class, Boolean.TRUE); |
| m_callbackInit = "init"; |
| m_callbackStart = "start"; |
| m_callbackStop = "stop"; |
| m_callbackDestroy = "destroy"; |
| m_id = m_idGenerator.getAndIncrement(); |
| } |
| |
| @Override |
| public <T> T createConfigurationType(Class<T> type, Dictionary<?, ?> config) { |
| Dictionary<String, Object> declaredServiceProperties = getDeclaredServiceProperties(); |
| return Configurable.create(type, config, declaredServiceProperties); |
| } |
| |
| @Override |
| public Executor getExecutor() { |
| return m_executor; |
| } |
| |
| @Override |
| public ComponentImpl setDebug(String debugKey) { |
| // Force debug level in our logger |
| m_logger.setEnabledLevel(LogService.LOG_DEBUG); |
| m_logger.setDebugKey(debugKey); |
| return this; |
| } |
| |
| @Override |
| public ComponentImpl add(final Dependency ... dependencies) { |
| getExecutor().execute(() -> { |
| List<DependencyContext> instanceBoundDeps = new ArrayList<>(); |
| for (Dependency d : dependencies) { |
| DependencyContext dc = (DependencyContext) d; |
| if (dc.getComponentContext() != null) { |
| m_logger.err("%s can't be added to %s (dependency already added to component %s).", dc, ComponentImpl.this, dc.getComponentContext()); |
| continue; |
| } |
| m_dependencyEvents.put(dc, new ConcurrentSkipListSet<Event>()); |
| m_dependencies.add(dc); |
| generateNameBasedOnServiceAndProperties(); |
| dc.setComponentContext(ComponentImpl.this); |
| if (!(m_state == ComponentState.INACTIVE)) { |
| dc.setInstanceBound(true); |
| instanceBoundDeps.add(dc); |
| } |
| } |
| startDependencies(instanceBoundDeps); |
| handleChange(); |
| }); |
| return this; |
| } |
| |
| @Override |
| public ComponentImpl remove(final Dependency d) { |
| getExecutor().execute(() -> { |
| DependencyContext dc = (DependencyContext) d; |
| // First remove this dependency from the dependency list |
| m_dependencies.remove(d); |
| generateNameBasedOnServiceAndProperties(); |
| // Now we can stop the dependency (our component won't be deactivated, it will only be unbound with |
| // the removed dependency). |
| if (!(m_state == ComponentState.INACTIVE)) { |
| dc.stop(); |
| } |
| // Finally, cleanup the dependency events. |
| m_dependencyEvents.remove(d); |
| handleChange(); |
| }); |
| return this; |
| } |
| |
| @Override |
| public void start() { |
| checkParamsConsistency(); |
| if (m_active.compareAndSet(false, true)) { |
| getExecutor().execute(() -> { |
| m_isStarted = true; |
| handleChange(); |
| }); |
| } |
| } |
| |
| @Override |
| public void stop() { |
| if (m_active.compareAndSet(true, false)) { |
| // try to be synchronous, even if a threadpool is used (best effort). |
| schedule(true /* bypass threadpool if possible */, () -> { |
| m_isStarted = false; |
| handleChange(); |
| }); |
| } |
| } |
| |
| @SuppressWarnings("unchecked") |
| @Override |
| public ComponentImpl setInterface(String serviceName, Dictionary<?, ?> properties) { |
| ensureNotActive(); |
| m_serviceName = serviceName; |
| m_serviceProperties = (Dictionary<Object, Object>) properties; |
| generateNameBasedOnServiceAndProperties(); |
| return this; |
| } |
| |
| @SuppressWarnings("unchecked") |
| @Override |
| public ComponentImpl setInterface(String[] serviceName, Dictionary<?, ?> properties) { |
| ensureNotActive(); |
| m_serviceName = serviceName; |
| m_serviceProperties = (Dictionary<Object, Object>) properties; |
| generateNameBasedOnServiceAndProperties(); |
| return this; |
| } |
| |
| @Override |
| public ComponentImpl setInterface(Class<?> serviceName, Dictionary<?, ?> properties) { |
| return setInterface(serviceName.getName(), properties); |
| } |
| |
| @Override |
| public ComponentImpl setInterface(Class<?>[] serviceName, Dictionary<?, ?> properties) { |
| String[] serviceNameStr = Stream.of(serviceName).map(clazz -> clazz.getName()).toArray(String[]::new); |
| return setInterface(serviceNameStr, properties); |
| } |
| |
| @Override |
| public void handleEvent(final DependencyContext dc, final EventType type, final Event... event) { |
| // since this method can be invoked by anyone from any thread, we need to |
| // pass on the event to a runnable that we execute using the component's |
| // executor. There is one corner case: if this is a REMOVE event, and if we are using a threadpool, |
| // then make a best effort to try invoking the component unbind callback synchronously (to make |
| // sure the unbound service is not stopped at the time we call unbind on our component |
| // which depends on the removing service). |
| // This is just a best effort, and the removed event will be handled asynchronosly if our |
| // queue is currently being run by another thread, or by the threadpool. |
| |
| boolean bypassThreadPoolIfPossible = (type == EventType.REMOVED); |
| schedule(bypassThreadPoolIfPossible, () -> { |
| try { |
| switch (type) { |
| case ADDED: |
| handleAdded(dc, event[0]); |
| break; |
| case CHANGED: |
| handleChanged(dc, event[0]); |
| break; |
| case REMOVED: |
| handleRemoved(dc, event[0]); |
| break; |
| case SWAPPED: |
| handleSwapped(dc, event[0], event[1]); |
| break; |
| } |
| } finally { |
| // Clear cache of component callbacks invocation, except if we are currently called from handleChange(). |
| // (See FELIX-4913). |
| clearInvokeCallbackCache(); |
| } |
| }); |
| } |
| |
| @Override |
| public Event getDependencyEvent(DependencyContext dc) { |
| ConcurrentSkipListSet<Event> events = m_dependencyEvents.get(dc); |
| return events.size() > 0 ? events.last() : null; |
| } |
| |
| @Override |
| public Set<Event> getDependencyEvents(DependencyContext dc) { |
| return m_dependencyEvents.get(dc); |
| } |
| |
| @Override |
| public ComponentImpl setAutoConfig(Class<?> clazz, boolean autoConfig) { |
| m_autoConfig.put(clazz, Boolean.valueOf(autoConfig)); |
| return this; |
| } |
| |
| @Override |
| public ComponentImpl setAutoConfig(Class<?> clazz, String instanceName) { |
| m_autoConfig.put(clazz, Boolean.valueOf(instanceName != null)); |
| m_autoConfigInstance.put(clazz, instanceName); |
| return this; |
| } |
| |
| @Override |
| public boolean getAutoConfig(Class<?> clazz) { |
| Boolean result = (Boolean) m_autoConfig.get(clazz); |
| return (result != null && result.booleanValue()); |
| } |
| |
| @Override |
| public String getAutoConfigInstance(Class<?> clazz) { |
| return (String) m_autoConfigInstance.get(clazz); |
| } |
| |
| @SuppressWarnings("unchecked") |
| public <T> T getInstance() { |
| Object[] instances = getCompositionInstances(); |
| return instances.length == 0 ? null : (T) instances[0]; |
| } |
| |
| public Object[] getInstances() { |
| return getCompositionInstances(); |
| } |
| |
| public void invokeCallbackMethod(Object[] instances, String methodName, Class<?>[][] signatures, Object[][] parameters) { |
| invokeCallbackMethod(instances, methodName, signatures, parameters, true); |
| } |
| |
| public void invokeCallbackMethod(Object[] instances, String methodName, Class<?>[][] signatures, Object[][] parameters, boolean logIfNotFound) { |
| boolean callbackFound = false; |
| for (int i = 0; i < instances.length; i++) { |
| try { |
| InvocationUtil.invokeCallbackMethod(instances[i], methodName, signatures, parameters); |
| callbackFound |= true; |
| } |
| catch (NoSuchMethodException e) { |
| // if the method does not exist, ignore it |
| } |
| catch (InvocationTargetException e) { |
| // the method itself threw an exception, log that |
| m_logger.log(Logger.LOG_ERROR, "Invocation of '" + methodName + "' failed.", e.getCause()); |
| callbackFound |= true; |
| } |
| catch (Throwable e) { // IllegalArgumentException (wrong params passed to the method), or IllegalAccessException (method can't be accessed) |
| m_logger.log(Logger.LOG_ERROR, "Could not invoke '" + methodName + "'.", e); |
| } |
| } |
| |
| // If the callback is not found, we don't log if the method is on an AbstractDecorator. |
| // (Aspect or Adapter are not interested in user dependency callbacks) |
| if (logIfNotFound && ! callbackFound && ! (getInstance() instanceof AbstractDecorator)) { |
| m_logger.log(LogService.LOG_ERROR, "\"" + methodName + "\" callback not found on component instances " + Arrays.toString(instances)); |
| } |
| } |
| |
| public void invokeCallback(Object[] instances, String methodName, Class<?>[][] signatures, Supplier<?>[][] parameters, boolean logIfNotFound) { |
| boolean callbackFound = false; |
| for (int i = 0; i < instances.length; i++) { |
| try { |
| InvocationUtil.invokeCallbackMethod(instances[i], methodName, signatures, parameters); |
| callbackFound |= true; |
| } |
| catch (NoSuchMethodException e) { |
| // if the method does not exist, ignore it |
| } |
| catch (InvocationTargetException e) { |
| // the method itself threw an exception, log that |
| m_logger.log(Logger.LOG_ERROR, "Invocation of '" + methodName + "' failed.", e.getCause()); |
| callbackFound |= true; |
| } |
| catch (Throwable e) { |
| m_logger.log(Logger.LOG_ERROR, "Could not invoke '" + methodName + "'.", e); |
| } |
| } |
| |
| // If the callback is not found, we don't log if the method is on an AbstractDecorator. |
| // (Aspect or Adapter are not interested in user dependency callbacks) |
| if (logIfNotFound && ! callbackFound && ! (getInstance() instanceof AbstractDecorator)) { |
| m_logger.log(LogService.LOG_ERROR, "\"" + methodName + "\" callback not found on component instances " + Arrays.toString(instances)); |
| } |
| } |
| |
| @Override |
| public boolean isAvailable() { |
| return m_state == TRACKING_OPTIONAL; |
| } |
| |
| @Override |
| public boolean isActive() { |
| return m_active.get(); |
| } |
| |
| @Override |
| public ComponentImpl add(ComponentStateListener listener) { |
| getExecutor().execute(() -> { |
| m_listeners.add(listener); |
| switch (m_lastStateDeliveredToListeners) { |
| case STARTING: |
| // this new listener missed the starting cb |
| listener.changed(ComponentImpl.this, STARTING); |
| break; |
| case TRACKING_OPTIONAL: |
| // this new listener missed the starting/started cb |
| listener.changed(ComponentImpl.this, STARTING); |
| listener.changed(ComponentImpl.this, TRACKING_OPTIONAL); |
| break; |
| case STOPPING: |
| // this new listener missed the starting/started/stopping cb |
| listener.changed(ComponentImpl.this, STARTING); |
| listener.changed(ComponentImpl.this, TRACKING_OPTIONAL); |
| listener.changed(ComponentImpl.this, STOPPING); |
| break; |
| case STOPPED: |
| // no need to call missed listener callbacks |
| break; |
| default: |
| break; |
| } |
| }); |
| return this; |
| } |
| |
| @Override |
| public ComponentImpl remove(ComponentStateListener listener) { |
| m_listeners.remove(listener); |
| return this; |
| } |
| |
| @SuppressWarnings("unchecked") |
| @Override |
| public List<DependencyContext> getDependencies() { |
| return (List<DependencyContext>) m_dependencies.clone(); |
| } |
| |
| @Override |
| public ComponentImpl setImplementation(Object implementation) { |
| m_componentDefinition = implementation; |
| return this; |
| } |
| |
| @SuppressWarnings("rawtypes") |
| @Override |
| public ServiceRegistration getServiceRegistration() { |
| return m_registration; |
| } |
| |
| @SuppressWarnings("unchecked") |
| @Override |
| public <K,V> Dictionary<K, V> getServiceProperties() { |
| return (Dictionary<K, V>) calculateServiceProperties(); |
| } |
| |
| public <K,V> Dictionary<K, V> getDeclaredServiceProperties() { |
| return (m_serviceProperties != null) ? ServiceUtil.toR6Dictionary(m_serviceProperties) : ServiceUtil.toR6Dictionary(ServiceUtil.EMPTY_PROPERTIES); |
| |
| // if (m_serviceProperties != null) { |
| // // Applied patch from FELIX-4304 |
| // Hashtable<String, Object> serviceProperties = new Hashtable<>(); |
| // addTo(serviceProperties, m_serviceProperties); |
| // return (Dictionary<K, V>) serviceProperties; |
| // } |
| // return (Dictionary<K, V>) ServiceUtil.EMPTY_PROPERTIES; |
| } |
| |
| @Override |
| @SuppressWarnings("unchecked") |
| public ComponentImpl setServiceProperties(final Dictionary<?, ?> serviceProperties) { |
| getExecutor().execute(() -> { |
| Dictionary<String, Object> properties = null; |
| m_serviceProperties = (Dictionary<Object, Object>) serviceProperties; |
| generateNameBasedOnServiceAndProperties(); |
| if ((m_registration != null) && (m_serviceName != null)) { |
| properties = calculateServiceProperties(); |
| m_registration.setProperties(properties); |
| } |
| }); |
| return this; |
| } |
| |
| public ComponentImpl setCallbacks(String init, String start, String stop, String destroy) { |
| ensureNotActive(); |
| m_callbackInit = init; |
| m_callbackStart = start; |
| m_callbackStop = stop; |
| m_callbackDestroy = destroy; |
| return this; |
| } |
| |
| public ComponentImpl setCallbacks(Object instance, String init, String start, String stop, String destroy) { |
| ensureNotActive(); |
| m_callbackInstance = instance; |
| m_callbackInit = init; |
| m_callbackStart = start; |
| m_callbackStop = stop; |
| m_callbackDestroy = destroy; |
| return this; |
| } |
| |
| @Override |
| public ComponentImpl setFactory(Object factory, String createMethod) { |
| ensureNotActive(); |
| m_instanceFactory = factory; |
| m_instanceFactoryCreateMethod = createMethod; |
| return this; |
| } |
| |
| @Override |
| public ComponentImpl setFactory(String createMethod) { |
| return setFactory(null, createMethod); |
| } |
| |
| @Override |
| public ComponentImpl setComposition(Object instance, String getMethod) { |
| ensureNotActive(); |
| m_compositionManager = instance; |
| m_compositionManagerGetMethod = getMethod; |
| return this; |
| } |
| |
| @Override |
| public ComponentImpl setComposition(String getMethod) { |
| return setComposition(null, getMethod); |
| } |
| |
| @Override |
| public DependencyManager getDependencyManager() { |
| return m_manager; |
| } |
| |
| @Override |
| public boolean injectionDisabled() { |
| return m_injectionDisabled; |
| } |
| |
| public ComponentDependencyDeclaration[] getComponentDependencies() { |
| List<DependencyContext> deps = getDependencies(); |
| if (deps != null) { |
| ComponentDependencyDeclaration[] result = new ComponentDependencyDeclaration[deps.size()]; |
| for (int i = 0; i < result.length; i++) { |
| DependencyContext dep = (DependencyContext) deps.get(i); |
| if (dep instanceof ComponentDependencyDeclaration) { |
| result[i] = (ComponentDependencyDeclaration) dep; |
| } |
| else { |
| result[i] = new SCDImpl(dep.toString(), (dep.isAvailable() ? 1 : 0) + (dep.isRequired() ? 2 : 0), dep.getClass().getName()); |
| } |
| } |
| return result; |
| } |
| return null; |
| } |
| |
| public String getName() { |
| StringBuilder sb = new StringBuilder(); |
| Object serviceName = m_serviceName; |
| |
| if( (!(serviceName instanceof String[])) && (!(serviceName instanceof String))) { |
| // The component does not provide a service, use the component definition as the name. |
| Object componentDefinition = m_componentDefinition; |
| if (componentDefinition != null) { |
| sb.append(toString(componentDefinition)); |
| } else { |
| // No component definition means we are using a factory. If the component instance is available use it as the component name, |
| // alse use teh factory object as the component name. |
| Object componentInstance = m_componentInstance; |
| if (componentInstance != null) { |
| sb.append(componentInstance.getClass().getName()); |
| } else { |
| // Check if a factory is set. |
| Object instanceFactory = m_instanceFactory; |
| if (instanceFactory != null) { |
| sb.append(toString(instanceFactory)); |
| } else { |
| sb.append(super.toString()); |
| } |
| } |
| } |
| m_componentName = sb.toString(); |
| } |
| return m_componentName; |
| } |
| |
| @Override |
| public ComponentImpl setScope(ServiceScope scope) { |
| m_scope = scope; |
| return this; |
| } |
| |
| ServiceScope getScope() { |
| return m_scope; |
| } |
| |
| private void checkParamsConsistency() { |
| switch (m_scope) { |
| case PROTOTYPE: |
| case BUNDLE: |
| if (m_serviceName == null) { |
| throw new IllegalStateException("No service interface specified for scoped service"); |
| } |
| |
| if ((!(m_componentDefinition instanceof Class)) && m_instanceFactoryCreateMethod == null) { |
| throw new IllegalStateException( |
| "The component instance must be created using either a class or a factory object when scope is not singleton."); |
| } |
| |
| } |
| |
| } |
| |
| private void generateNameBasedOnServiceAndProperties() { |
| StringBuilder sb = new StringBuilder(); |
| Object serviceName = m_serviceName; |
| |
| // If the component provides service(s), return the services as the component name. |
| if (serviceName instanceof String[]) { |
| String[] names = (String[]) serviceName; |
| for (int i = 0; i < names.length; i++) { |
| if (i > 0) { |
| sb.append(", "); |
| } |
| sb.append(names[i]); |
| } |
| ServiceUtil.appendProperties(sb, calculateServiceProperties()); |
| } else if(serviceName instanceof String) { |
| sb.append(serviceName.toString()); |
| ServiceUtil.appendProperties(sb, calculateServiceProperties()); |
| } |
| m_componentName = sb.toString(); |
| } |
| |
| @Override |
| public BundleContext getBundleContext() { |
| return m_context; |
| } |
| |
| @Override |
| public Bundle getBundle() { |
| return m_bundle; |
| } |
| |
| public long getId() { |
| return m_id; |
| } |
| |
| public String getClassName() { |
| Object serviceInstance = m_componentInstance; |
| if (serviceInstance != null) { |
| return serviceInstance.getClass().getName(); |
| } |
| |
| Object implementation = m_componentDefinition; |
| if (implementation != null) { |
| if (implementation instanceof Class) { |
| return ((Class<?>) implementation).getName(); |
| } |
| return implementation.getClass().getName(); |
| } |
| |
| Object instanceFactory = m_instanceFactory; |
| if (instanceFactory != null) { |
| return toString(instanceFactory); |
| } else { |
| // unexpected. |
| return ComponentImpl.class.getName(); |
| } |
| } |
| |
| public String[] getServices() { |
| if (m_serviceName instanceof String[]) { |
| return (String[]) m_serviceName; |
| } else if (m_serviceName instanceof String) { |
| return new String[] { (String) m_serviceName }; |
| } else { |
| return null; |
| } |
| } |
| |
| public int getState() { |
| return (isAvailable() ? ComponentDeclaration.STATE_REGISTERED : ComponentDeclaration.STATE_UNREGISTERED); |
| } |
| |
| public void ensureNotActive() { |
| if (m_active.get()) { |
| throw new IllegalStateException("Can't modify an already started component."); |
| } |
| } |
| |
| public ComponentDeclaration getComponentDeclaration() { |
| return this; |
| } |
| |
| @Override |
| public String toString() { |
| if (m_logger.getDebugKey() != null) { |
| return m_logger.getDebugKey(); |
| } |
| return getClassName(); |
| } |
| |
| @Override |
| public void setThreadPool(Executor threadPool) { |
| ensureNotActive(); |
| m_executor = new DispatchExecutor(threadPool, m_logger); |
| } |
| |
| @Override |
| public Logger getLogger() { |
| return m_logger; |
| } |
| |
| @Override |
| public Map<String, Long> getCallbacksTime() { |
| return m_stopwatch; |
| } |
| |
| @Override |
| public ComponentContext instantiateComponent() { |
| CallbackTypeDef ctorArgs = null; |
| |
| switch (m_scope) { |
| case SINGLETON: |
| // When a component scope is singleton, we'll use the following constructor or factory "create" method signatures: |
| ctorArgs = VOID; |
| break; |
| |
| case PROTOTYPE: |
| case BUNDLE: |
| if (m_injectionDisabled) { |
| m_componentInstance = PROTOTYPE_INSTANCE; |
| return this; |
| } else { |
| ctorArgs = createScopedComponentConstructorArgs(null, null); |
| } |
| break; |
| |
| default: |
| throw new IllegalStateException("Invalid scope: " + m_scope); |
| } |
| |
| // Create the factory "create" method signatures types |
| instantiateComponent(ctorArgs); |
| return this; |
| } |
| |
| // ---------------------- Package/Private methods --------------------------- |
| |
| /** |
| * Creates a constructor argument descritor for a scoped component (having scope=BUNDLE|PROTOTYPE) |
| */ |
| private CallbackTypeDef createScopedComponentConstructorArgs(Bundle b, ServiceRegistration sr) { |
| return new CallbackTypeDef( |
| new Class[][] {{Bundle.class, ServiceRegistration.class}, {Bundle.class, ServiceRegistration.class, BundleContext.class}, {}}, |
| new Object[][] {{b,sr}, {b,sr, m_context}, {}}); |
| } |
| |
| /** |
| * Creates the component instance. |
| * @param ctorArgs the constructor argument signatures |
| * @return the index of the constructor argument signatures that was used when creating the component. -1 means the component has been created using a factory "create" method. |
| */ |
| private int instantiateComponent(CallbackTypeDef ctorArgs) { |
| m_logger.debug("instantiating component."); |
| int ctorArgsUsed = -1; |
| |
| if (m_componentInstance == null) { |
| if (m_componentDefinition instanceof Class) { |
| try { |
| InvocationUtil.ComponentInstance ci = InvocationUtil.createInstance((Class<?>) m_componentDefinition, ctorArgs); |
| m_componentInstance = ci.m_instance; |
| ctorArgsUsed = ci.m_ctorIndex; |
| } catch (Exception e) { |
| m_logger.log(Logger.LOG_ERROR, "Could not instantiate class " + m_componentDefinition, e); |
| } |
| } else { |
| if (m_instanceFactoryCreateMethod != null) { |
| Object factory = null; |
| if (m_instanceFactory != null) { |
| if (m_instanceFactory instanceof Class) { |
| try { |
| InvocationUtil.ComponentInstance ci = InvocationUtil.createInstance((Class<?>) m_instanceFactory, VOID); |
| factory = ci.m_instance; |
| } catch (Exception e) { |
| m_logger.log(Logger.LOG_ERROR, |
| "Could not create factory instance of class " + m_instanceFactory + ".", e); |
| } |
| } else { |
| factory = m_instanceFactory; |
| } |
| } else { |
| // TODO review if we want to try to default to something if not specified |
| // for now the JavaDoc of setFactory(method) reflects the fact that we need |
| // to review it |
| } |
| if (factory == null) { |
| m_logger.log(Logger.LOG_ERROR, "Factory cannot be null."); |
| } else { |
| try { |
| CallbackTypeDef factoryArgs = new CallbackTypeDef( |
| new Class[][] {{}, {Component.class}}, |
| new Object[][] {{}, {this}}); |
| m_componentInstance = InvocationUtil.invokeMethod(factory, factory.getClass(), |
| m_instanceFactoryCreateMethod, factoryArgs.m_sigs, factoryArgs.m_args, false); |
| } catch (Exception e) { |
| m_logger.log(Logger.LOG_ERROR, "Could not create service instance using factory " + factory |
| + " method " + m_instanceFactoryCreateMethod + ".", e); |
| } |
| } |
| } |
| } |
| |
| if (m_componentInstance == null) { |
| m_componentInstance = m_componentDefinition; |
| } |
| |
| // configure the bundle context |
| autoConfigureImplementation(BundleContext.class, m_context); |
| autoConfigureImplementation(ServiceRegistration.class, NULL_REGISTRATION); |
| autoConfigureImplementation(DependencyManager.class, m_manager); |
| autoConfigureImplementation(Component.class, this); |
| } |
| return ctorArgsUsed; |
| } |
| |
| private String toString(Object implementation) { |
| if (implementation instanceof Class) { |
| return (((Class<?>) implementation).getName()); |
| } else { |
| // If the implementation instance does not override "toString", just display |
| // the class name, else display the component using its toString method |
| try { |
| Method m = implementation.getClass().getMethod("toString", new Class[0]); |
| if (m.getDeclaringClass().equals(Object.class)) { |
| return implementation.getClass().getName(); |
| } else { |
| return implementation.toString(); |
| } |
| } catch (java.lang.NoSuchMethodException e) { |
| // Just display the class name |
| return implementation.getClass().getName(); |
| } |
| } |
| } |
| |
| /** |
| * Runs the state machine, to see if a change event has to trigger some component state transition. |
| */ |
| private void handleChange() { |
| if (isHandlingChange()) { |
| return; |
| } |
| m_logger.debug("handleChanged"); |
| handlingChange(true); |
| try { |
| ComponentState oldState; |
| ComponentState newState; |
| do { |
| oldState = m_state; |
| newState = calculateNewState(oldState); |
| m_logger.debug("%s -> %s", oldState, newState); |
| m_state = newState; |
| } while (performTransition(oldState, newState)); |
| } finally { |
| handlingChange(false); |
| clearInvokeCallbackCache(); |
| m_logger.debug("end handling change."); |
| } |
| } |
| |
| /** |
| * Based on the current state, calculate the new state. |
| */ |
| private ComponentState calculateNewState(ComponentState currentState) { |
| if (currentState == INACTIVE) { |
| if (m_isStarted) { |
| return WAITING_FOR_REQUIRED; |
| } |
| } |
| if (currentState == WAITING_FOR_REQUIRED) { |
| if (!m_isStarted) { |
| return INACTIVE; |
| } |
| if (allRequiredAvailable()) { |
| return INSTANTIATED_AND_WAITING_FOR_REQUIRED; |
| } |
| } |
| if (currentState == INSTANTIATED_AND_WAITING_FOR_REQUIRED) { |
| if (m_isStarted && allRequiredAvailable()) { |
| if (allInstanceBoundAvailable()) { |
| return TRACKING_OPTIONAL; |
| } |
| return currentState; |
| } |
| return WAITING_FOR_REQUIRED; |
| } |
| if (currentState == TRACKING_OPTIONAL) { |
| if (m_isStarted && allRequiredAvailable() && allInstanceBoundAvailable()) { |
| return currentState; |
| } |
| return INSTANTIATED_AND_WAITING_FOR_REQUIRED; |
| } |
| return currentState; |
| } |
| |
| /** |
| * Perform all the actions associated with state transitions. |
| * @returns true if a transition was performed. |
| **/ |
| private boolean performTransition(ComponentState oldState, ComponentState newState) { |
| if (oldState == ComponentState.INACTIVE && newState == ComponentState.WAITING_FOR_REQUIRED) { |
| initPrototype(); |
| startDependencies(m_dependencies); |
| notifyListeners(newState); |
| return true; |
| } |
| if (oldState == WAITING_FOR_REQUIRED && newState == INSTANTIATED_AND_WAITING_FOR_REQUIRED) { |
| instantiateComponent(); |
| invokeAutoConfigDependencies(); |
| invokeAddRequiredDependencies(); |
| invoke(m_callbackInit); |
| notifyListeners(newState); |
| return true; |
| } |
| if (oldState == INSTANTIATED_AND_WAITING_FOR_REQUIRED && newState == TRACKING_OPTIONAL) { |
| invokeAutoConfigInstanceBoundDependencies(); |
| invokeAddRequiredInstanceBoundDependencies(); |
| notifyListeners(STARTING); |
| invokeStart(); |
| notifyListeners(STARTED); |
| invokeAddOptionalDependencies(); |
| registerService(); |
| notifyListeners(newState); |
| return true; |
| } |
| if (oldState == TRACKING_OPTIONAL && newState == INSTANTIATED_AND_WAITING_FOR_REQUIRED) { |
| notifyListeners(STOPPING); |
| unregisterService(); |
| invokeRemoveOptionalDependencies(); |
| invokeStop(); |
| invokeRemoveRequiredInstanceBoundDependencies(); |
| notifyListeners(newState); |
| notifyListeners(STOPPED); |
| return true; |
| } |
| if (oldState == INSTANTIATED_AND_WAITING_FOR_REQUIRED && newState == WAITING_FOR_REQUIRED) { |
| invoke(m_callbackDestroy); |
| removeInstanceBoundDependencies(); |
| invokeRemoveRequiredDependencies(); |
| notifyListeners(newState); |
| if (! someDependenciesNeedInstance()) { |
| destroyComponent(); |
| } |
| return true; |
| } |
| if (oldState == WAITING_FOR_REQUIRED && newState == INACTIVE) { |
| stopDependencies(); |
| destroyComponent(); |
| notifyListeners(newState); |
| cleanup(); |
| return true; |
| } |
| return false; |
| } |
| |
| private void cleanup() { |
| m_dependencyEvents.values().forEach(eventList -> { |
| eventList.forEach(event -> event.close()); |
| eventList.clear(); |
| }); |
| } |
| |
| private void invokeStart() { |
| // Only invoke start callback for singleton components. |
| // We don't invoke start callbacks for components with scope=prototype or bundle because |
| // prototypes (bundle/prototype) components are only used to register ServiceFactory (or PrototypeServiceFactory) services. |
| if (m_scope == ServiceScope.SINGLETON) { |
| invoke(m_callbackStart); |
| m_startCalled = true; |
| } |
| } |
| |
| private void invokeStop() { |
| // Only invoke stop callback for singleton components. |
| // We don't invoke stop callbacks for components with scope=prototype or bundle because |
| // prototypes (bundle/prototype) components are only used to register ServiceFactory (or PrototypeServiceFactory) services. |
| if (m_scope == ServiceScope.SINGLETON) { |
| invoke(m_callbackStop); |
| m_startCalled = false; |
| } |
| } |
| |
| /** |
| * Sets the m_handlingChange flag that indicates if the state machine is currently running the handleChange method. |
| */ |
| private void handlingChange(boolean transiting) { |
| m_handlingChange = transiting; |
| } |
| |
| /** |
| * Are we currently running the handleChange method ? |
| */ |
| private boolean isHandlingChange() { |
| return m_handlingChange; |
| } |
| |
| /** |
| * Then handleEvent calls this method when a dependency service is being added. |
| */ |
| private void handleAdded(DependencyContext dc, Event e) { |
| if (! m_isStarted) { |
| return; |
| } |
| m_logger.debug("handleAdded %s", e); |
| |
| Set<Event> dependencyEvents = m_dependencyEvents.get(dc); |
| dependencyEvents.add(e); |
| dc.setAvailable(true); |
| |
| // In the following switch block, we sometimes only recalculate state changes |
| // if the dependency is fully started. If the dependency is not started, |
| // it means it is actually starting (the service tracker is executing the open method). |
| // And in this case, depending on the state, we don't recalculate state changes now. |
| // |
| // All this is done for two reasons: |
| // 1- optimization: it is preferable to recalculate state changes once we know about all currently |
| // available dependency services (after the tracker has returned from its open method). |
| // 2- This also allows to determine the list of currently available dependency services before calling |
| // the component start() callback. |
| |
| switch (m_state) { |
| case WAITING_FOR_REQUIRED: |
| if (dc.isStarted() && dc.isRequired()) { |
| handleChange(); |
| } |
| break; |
| case INSTANTIATED_AND_WAITING_FOR_REQUIRED: |
| if (!dc.isInstanceBound()) { |
| invokeCallback(dc, EventType.ADDED, e); |
| updateInstance(dc, e, false, true); |
| } else { |
| if (dc.isStarted() && dc.isRequired()) { |
| handleChange(); |
| } |
| } |
| break; |
| case TRACKING_OPTIONAL: |
| invokeCallback(dc, EventType.ADDED, e); |
| updateInstance(dc, e, false, true); |
| break; |
| default: |
| } |
| } |
| |
| /** |
| * Then handleEvent calls this method when a dependency service is being changed. |
| */ |
| private void handleChanged(final DependencyContext dc, final Event e) { |
| if (! m_isStarted) { |
| return; |
| } |
| Set<Event> dependencyEvents = m_dependencyEvents.get(dc); |
| dependencyEvents.remove(e); |
| dependencyEvents.add(e); |
| |
| switch (m_state) { |
| case TRACKING_OPTIONAL: |
| invokeCallback(dc, EventType.CHANGED, e); |
| updateInstance(dc, e, true, false); |
| break; |
| |
| case INSTANTIATED_AND_WAITING_FOR_REQUIRED: |
| if (!dc.isInstanceBound()) { |
| invokeCallback(dc, EventType.CHANGED, e); |
| updateInstance(dc, e, true, false); |
| } |
| break; |
| default: |
| // noop |
| } |
| } |
| |
| /** |
| * Then handleEvent calls this method when a dependency service is being removed. |
| */ |
| private void handleRemoved(DependencyContext dc, Event e) { |
| try { |
| if (! m_isStarted) { |
| return; |
| } |
| // Check if the dependency is still available. |
| Set<Event> dependencyEvents = m_dependencyEvents.get(dc); |
| int size = dependencyEvents.size(); |
| if (dependencyEvents.contains(e)) { |
| size--; // the dependency is currently registered and is about to be removed. |
| } |
| dc.setAvailable(size > 0); |
| |
| // If the dependency is now unavailable, we have to recalculate state change. This will result in invoking the |
| // "removed" callback with the removed dependency (which we have not yet removed from our dependency events list.). |
| // But we don't recalculate the state if the dependency is not started (if not started, it means that it is currently starting, |
| // and the tracker is detecting a removed service). |
| if (size == 0 && dc.isStarted()) { |
| handleChange(); |
| } |
| |
| // Now, really remove the dependency event. |
| dependencyEvents.remove(e); |
| |
| // Depending on the state, we possible have to invoke the callbacks and update the component instance. |
| switch (m_state) { |
| case INSTANTIATED_AND_WAITING_FOR_REQUIRED: |
| if (!dc.isInstanceBound()) { |
| invokeCallback(dc, EventType.REMOVED, e); |
| updateInstance(dc, e, false, false); |
| } |
| break; |
| case TRACKING_OPTIONAL: |
| invokeCallback(dc, EventType.REMOVED, e); |
| updateInstance(dc, e, false, false); |
| break; |
| default: |
| } |
| } finally { |
| e.close(); |
| } |
| } |
| |
| private void handleSwapped(DependencyContext dc, Event oldEvent, Event newEvent) { |
| try { |
| if (! m_isStarted) { |
| return; |
| } |
| Set<Event> dependencyEvents = m_dependencyEvents.get(dc); |
| dependencyEvents.remove(oldEvent); |
| dependencyEvents.add(newEvent); |
| |
| // Depending on the state, we possible have to invoke the callbacks and update the component instance. |
| switch (m_state) { |
| case WAITING_FOR_REQUIRED: |
| // No need to swap, we don't have yet injected anything |
| break; |
| case INSTANTIATED_AND_WAITING_FOR_REQUIRED: |
| // Only swap *non* instance-bound dependencies |
| if (!dc.isInstanceBound()) { |
| invokeSwapCallback(dc, oldEvent, newEvent); |
| } |
| break; |
| case TRACKING_OPTIONAL: |
| invokeSwapCallback(dc, oldEvent, newEvent); |
| break; |
| default: |
| } |
| } finally { |
| oldEvent.close(); |
| } |
| } |
| |
| private boolean allRequiredAvailable() { |
| boolean available = true; |
| for (DependencyContext d : m_dependencies) { |
| if (d.isRequired() && !d.isInstanceBound()) { |
| if (!d.isAvailable()) { |
| available = false; |
| break; |
| } |
| } |
| } |
| return available; |
| } |
| |
| private boolean allInstanceBoundAvailable() { |
| boolean available = true; |
| for (DependencyContext d : m_dependencies) { |
| if (d.isRequired() && d.isInstanceBound()) { |
| if (!d.isAvailable()) { |
| available = false; |
| break; |
| } |
| } |
| } |
| return available; |
| } |
| |
| private boolean someDependenciesNeedInstance() { |
| for (DependencyContext d : m_dependencies) { |
| if (d.needsInstance()) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Updates the component instance(s). |
| * @param dc the dependency context for the updating dependency service |
| * @param event the event holding the updating service (service + properties) |
| * @param update true if dependency service properties are updating, false if not. If false, it means |
| * that a dependency service is being added or removed. (see the "add" flag). |
| * @param add true if the dependency service has been added, false if it has been removed. This flag is |
| * ignored if the "update" flag is true (because the dependency properties are just being updated). |
| */ |
| private void updateInstance(DependencyContext dc, Event event, boolean update, boolean add) { |
| if (dc.isAutoConfig()) { |
| updateImplementation(dc.getAutoConfigType(), dc, dc.getAutoConfigName(), event, update, add); |
| } |
| if (dc.isPropagated() && m_registration != null) { |
| m_registration.setProperties(calculateServiceProperties()); |
| } |
| } |
| |
| private void startDependencies(List<DependencyContext> dependencies) { |
| // Start first optional dependencies first. |
| m_logger.debug("startDependencies."); |
| List<DependencyContext> requiredDeps = new ArrayList<>(); |
| for (DependencyContext d : dependencies) { |
| if (d.isRequired()) { |
| requiredDeps.add(d); |
| continue; |
| } |
| if (d.needsInstance()) { |
| instantiateComponent(); |
| } |
| d.start(); |
| } |
| // now, start required dependencies. |
| for (DependencyContext d : requiredDeps) { |
| if (d.needsInstance()) { |
| instantiateComponent(); |
| } |
| d.start(); |
| } |
| } |
| |
| private void stopDependencies() { |
| for (DependencyContext d : m_dependencies) { |
| d.stop(); |
| } |
| } |
| |
| private void registerService() { |
| if (m_context != null && m_serviceName != null) { |
| ServiceRegistrationImpl wrapper = new ServiceRegistrationImpl(); |
| m_registration = wrapper; |
| autoConfigureImplementation(ServiceRegistration.class, m_registration); |
| |
| // service name can either be a string or an array of strings |
| ServiceRegistration<?> registration; |
| |
| // determine service properties |
| Dictionary<String, Object> properties = calculateServiceProperties(); |
| |
| // register the service |
| try { |
| Object componentInstance = null; |
| switch (m_scope) { |
| case SINGLETON: componentInstance = m_componentInstance; break; |
| case BUNDLE: componentInstance = new ComponentServiceFactory(); break; |
| case PROTOTYPE: componentInstance = new ComponentPrototypeServiceFactory(); break; |
| } |
| |
| if (m_serviceName instanceof String) { |
| registration = m_context.registerService((String) m_serviceName, componentInstance, properties); |
| } |
| else { |
| registration = m_context.registerService((String[]) m_serviceName, componentInstance, properties); |
| } |
| wrapper.setServiceRegistration(registration); |
| } |
| catch (IllegalArgumentException iae) { |
| m_logger.log(Logger.LOG_ERROR, "Could not register service " + m_componentInstance, iae); |
| // set the registration to an illegal state object, which will make all invocations on this |
| // wrapper fail with an ISE (which also occurs when the SR becomes invalid) |
| wrapper.setIllegalState(); |
| } |
| } |
| } |
| |
| private void unregisterService() { |
| if (m_serviceName != null && m_registration != null) { |
| try { |
| if (m_bundle != null && (m_bundle.getState() == Bundle.STARTING || m_bundle.getState() == Bundle.ACTIVE || m_bundle.getState() == Bundle.STOPPING)) { |
| m_registration.unregister(); |
| } |
| } catch (IllegalStateException e) { /* Should we really log this ? */} |
| autoConfigureImplementation(ServiceRegistration.class, NULL_REGISTRATION); |
| m_registration = null; |
| } |
| } |
| |
| private Dictionary<String, Object> calculateServiceProperties() { |
| Dictionary<String, Object> properties = new Hashtable<>(); |
| // First add propagated dependency service properties which don't override our component service properties |
| Predicate<DependencyContext> dependencyPropagated = (dc) -> dc.isPropagated() && dc.isAvailable(); |
| |
| m_dependencies.stream() |
| .filter(dc -> dependencyPropagated.test(dc) && ! dc.overrideServiceProperties()) |
| .forEach(dc -> addTo(properties, dc.getProperties())); |
| |
| // Now add our component service properties, which override previously added propagated dependency service properties |
| addTo(properties, m_serviceProperties); |
| |
| // Finally, add dependency service properties which override our component service properties |
| m_dependencies.stream() |
| .filter(dc -> dependencyPropagated.test(dc) && dc.overrideServiceProperties()) |
| .forEach(dc -> addTo(properties, dc.getProperties())); |
| |
| return properties; // FELIX-5683: now we never return null |
| } |
| |
| private void addTo(Dictionary<String, Object> properties, Dictionary<?, Object> additional) { |
| if (properties == null) { |
| throw new IllegalArgumentException("Dictionary to add to cannot be null."); |
| } |
| if (additional != null) { |
| Enumeration<?> e = additional.keys(); |
| while (e.hasMoreElements()) { |
| Object key = e.nextElement(); |
| properties.put(key.toString(), additional.get(key)); |
| } |
| } |
| } |
| |
| private void destroyComponent() { |
| m_componentInstance = null; |
| } |
| |
| private void invokeAddRequiredDependencies() { |
| for (DependencyContext d : m_dependencies) { |
| if (d.isRequired() && !d.isInstanceBound()) { |
| for (Event e : m_dependencyEvents.get(d)) { |
| invokeCallback(d, EventType.ADDED, e); |
| } |
| } |
| } |
| } |
| |
| private void invokeAutoConfigDependencies() { |
| for (DependencyContext d : m_dependencies) { |
| if (d.isAutoConfig() && !d.isInstanceBound()) { |
| configureImplementation(d.getAutoConfigType(), d, d.getAutoConfigName()); |
| } |
| } |
| } |
| |
| private void invokeAutoConfigInstanceBoundDependencies() { |
| for (DependencyContext d : m_dependencies) { |
| if (d.isAutoConfig() && d.isInstanceBound()) { |
| configureImplementation(d.getAutoConfigType(), d, d.getAutoConfigName()); |
| } |
| } |
| } |
| |
| private void invokeAddRequiredInstanceBoundDependencies() { |
| for (DependencyContext d : m_dependencies) { |
| if (d.isRequired() && d.isInstanceBound()) { |
| for (Event e : m_dependencyEvents.get(d)) { |
| invokeCallback(d, EventType.ADDED, e); |
| } |
| } |
| } |
| } |
| |
| private void invokeAddOptionalDependencies() { |
| for (DependencyContext d : m_dependencies) { |
| if (! d.isRequired()) { |
| for (Event e : m_dependencyEvents.get(d)) { |
| invokeCallback(d, EventType.ADDED, e); |
| } |
| } |
| } |
| } |
| |
| private void invokeRemoveRequiredDependencies() { |
| for (DependencyContext d : m_dependencies) { |
| if (!d.isInstanceBound() && d.isRequired()) { |
| for (Event e : m_dependencyEvents.get(d)) { |
| invokeCallback(d, EventType.REMOVED, e); |
| } |
| } |
| } |
| } |
| |
| private void invokeRemoveOptionalDependencies() { |
| for (DependencyContext d : m_dependencies) { |
| if (! d.isRequired()) { |
| for (Event e : m_dependencyEvents.get(d)) { |
| invokeCallback(d, EventType.REMOVED, e); |
| } |
| } |
| } |
| } |
| |
| private void invokeRemoveRequiredInstanceBoundDependencies() { |
| for (DependencyContext d : m_dependencies) { |
| if (d.isInstanceBound() && d.isRequired()) { |
| for (Event e : m_dependencyEvents.get(d)) { |
| invokeCallback(d, EventType.REMOVED, e); |
| } |
| } |
| } |
| } |
| |
| /** |
| * This method ensures that a dependency callback is invoked only one time; |
| * It also ensures that if the dependency callback is optional, then we only |
| * invoke the bind method if the component start callback has already been called. |
| */ |
| private void invokeCallback(DependencyContext dc, EventType type, Event event) { |
| // don't inject anything if the component instance is a hidden prototype instance |
| if (m_injectionDisabled) { |
| return; |
| } |
| |
| if (! dc.isRequired() && ! m_startCalled) { |
| return; |
| } |
| |
| // First, check if the callback has not already been called (see FELIX-4913) |
| if (m_invokeCallbackCache.put(event, event) == null) { |
| // FELIX-5155: we must not invoke callbacks on our special internal components (adapters/aspects) if the dependency is not the first one, or |
| // if the internal component is a Factory Pid Adapter. |
| // For aspects/adapters, the first dependency only need to be injected, not the other extra dependencies added by user. |
| // (in fact, we do this because extra dependencies (added by user) may contain a callback instance, and we really don't want to invoke the callbacks twice ! |
| Object mainComponentImpl = getInstance(); |
| if (mainComponentImpl instanceof AbstractDecorator) { |
| if (mainComponentImpl instanceof FactoryConfigurationAdapterImpl.AdapterImpl || dc != m_dependencies.get(0)) { |
| return; |
| } |
| } |
| dc.invokeCallback(type, event); |
| } |
| } |
| |
| /** |
| * Invokes a swap callback, except if the dependency is optional and the component is |
| * not started (optional dependencies are always injected while the component is started). |
| */ |
| private void invokeSwapCallback(DependencyContext dc, Event oldEvent, Event newEvent) { |
| if (! dc.isRequired() && ! m_startCalled) { |
| return; |
| } |
| dc.invokeCallback(EventType.SWAPPED, oldEvent, newEvent); |
| } |
| |
| /** |
| * Removes and closes all instance bound dependencies. |
| * This method is called when a component is destroyed. |
| */ |
| private void removeInstanceBoundDependencies() { |
| for (DependencyContext dep : m_dependencies) { |
| if (dep.isInstanceBound()) { |
| m_dependencies.remove(dep); |
| generateNameBasedOnServiceAndProperties(); |
| dep.stop(); |
| } |
| } |
| } |
| |
| /** |
| * Clears the cache of invoked components callbacks. |
| * We only clear the cache when the state machine is not running. |
| * The cache is used to avoid calling the same bind callback twice. |
| * See FELIX-4913. |
| */ |
| private void clearInvokeCallbackCache() { |
| if (! isHandlingChange()) { |
| m_invokeCallbackCache.clear(); |
| } |
| } |
| |
| private void invoke(String name) { |
| if (name != null) { |
| // if a callback instance was specified, look for the method there, if not, |
| // ask the service for its composition instances |
| Object[] instances = m_callbackInstance != null ? new Object[] { m_callbackInstance } : getCompositionInstances(); |
| |
| long t1 = System.nanoTime(); |
| try { |
| invokeCallbackMethod(instances, name, |
| new Class[][] {{ Component.class }, {}}, |
| new Object[][] {{ this }, {}}, |
| false); |
| } finally { |
| long t2 = System.nanoTime(); |
| m_stopwatch.put(name, t2 - t1); |
| } |
| } |
| } |
| |
| private void notifyListeners(ComponentState state) { |
| if (m_scope == ServiceScope.SINGLETON) { |
| m_lastStateDeliveredToListeners = state; |
| for (ComponentStateListener l : m_listeners) { |
| try { |
| l.changed(this, state); |
| } catch (Exception e) { |
| m_logger.log(Logger.LOG_ERROR, "Exception caught while invoking component state listener", e); |
| } |
| } |
| } |
| } |
| |
| void autoConfigureImplementation(Class<?> clazz, Object instance) { |
| if (((Boolean) m_autoConfig.get(clazz)).booleanValue()) { |
| configureImplementation(clazz, instance, (String) m_autoConfigInstance.get(clazz)); |
| } |
| } |
| |
| /** |
| * Configure a field in the service implementation. The service implementation |
| * is searched for fields that have the same type as the class that was specified |
| * and for each of these fields, the specified instance is filled in. |
| * |
| * @param clazz the class to search for |
| * @param instance the object to fill in the implementation class(es) field |
| * @param instanceName the name of the instance to fill in, or <code>null</code> if not used |
| */ |
| void configureImplementation(Class<?> clazz, Object instance, String fieldName) { |
| // don't inject anything if the component instance is a hidden prototype instance |
| if (m_injectionDisabled) { |
| return; |
| } |
| |
| Object[] targets = getInstances(); |
| if (! FieldUtil.injectField(targets, fieldName, clazz, instance, m_logger) && fieldName != null) { |
| // If the target is an abstract decorator (i.e: an adapter, or an aspect), we must not log warnings |
| // if field has not been injected. |
| if (! (getInstance() instanceof AbstractDecorator)) { |
| m_logger.log(Logger.LOG_ERROR, "Could not inject " + instance + " to field \"" + fieldName |
| + "\" at any of the following component instances: " + Arrays.toString(targets)); |
| } |
| } |
| } |
| |
| private void configureImplementation(Class<?> clazz, DependencyContext dc, String fieldName) { |
| // don't inject anything if the component instance is a hidden prototype instance |
| if (m_injectionDisabled) { |
| return; |
| } |
| |
| Object[] targets = getInstances(); |
| if (! FieldUtil.injectDependencyField(targets, fieldName, clazz, dc, m_logger) && fieldName != null) { |
| // If the target is an abstract decorator (i.e: an adapter, or an aspect), we must not log warnings |
| // if field has not been injected. |
| if (! (getInstance() instanceof AbstractDecorator)) { |
| m_logger.log(Logger.LOG_ERROR, "Could not inject dependency " + clazz.getName() + " to field \"" |
| + fieldName + "\" at any of the following component instances: " + Arrays.toString(targets)); |
| } |
| } |
| } |
| |
| /** |
| * Update the component instances. |
| * |
| * @param clazz the class of the dependency service to inject in the component instances |
| * @param dc the dependency context for the updating dependency service |
| * @param fieldName the component instances fieldname to fill in with the updated dependency service |
| * @param event the event holding the updating service (service + properties) |
| * @param update true if dependency service properties are updating, false if not. If false, it means |
| * that a dependency service is being added or removed. (see the "add" flag). |
| * @param add true if the dependency service has been added, false if it has been removed. This flag is |
| * ignored if the "update" flag is true (because the dependency properties are just being updated). |
| */ |
| private void updateImplementation(Class<?> clazz, DependencyContext dc, String fieldName, Event event, boolean update, boolean add) { |
| if (! m_injectionDisabled) { |
| Object[] targets = getInstances(); |
| FieldUtil.updateDependencyField(targets, fieldName, update, add, clazz, event, dc, m_logger); |
| } |
| } |
| |
| private Object[] getCompositionInstances() { |
| Object[] instances = null; |
| if (m_compositionManagerGetMethod != null) { |
| if (m_compositionManager != null) { |
| m_compositionManagerInstance = m_compositionManager; |
| } |
| else { |
| m_compositionManagerInstance = m_componentInstance; |
| } |
| if (m_compositionManagerInstance != null) { |
| try { |
| instances = (Object[]) InvocationUtil.invokeMethod(m_compositionManagerInstance, m_compositionManagerInstance.getClass(), m_compositionManagerGetMethod, new Class[][] {{}}, new Object[][] {{}}, false); |
| } |
| catch (Exception e) { |
| m_logger.log(Logger.LOG_ERROR, "Could not obtain instances from the composition manager.", e); |
| instances = m_componentInstance == null ? new Object[] {} : new Object[] { m_componentInstance }; |
| } |
| } else { |
| return new Object[0]; |
| } |
| } |
| else { |
| instances = m_componentInstance == null ? new Object[] {} : new Object[] { m_componentInstance }; |
| } |
| return instances; |
| } |
| |
| /** |
| * Executes a task using our component queue. The queue associated to this component is by default a "SerialExecutor", or |
| * a "DispatchExecutor" if a threadpool is used (that is: if a ComponentExecutorFactory has returned an executor this our |
| * component). |
| * |
| * A SerialExecutor always try to execute the task synchronously, except if another master thread is currently |
| * running the SerialExecutor queue. |
| * A DispatchExecutor always schedule the task asynchronously in a threadpool, but can optionally try to execute the task synchronously |
| * (the threadpool is bypassed only if the queue is not currently being run by the threadpool). |
| * |
| * The "bypassThreadPoolIfPossible" argument is only used in case there is a threadpool configured. If no threadpool is used, |
| * this argument is ignored and the task is run synchronously if the serial queue is not concurrently run from another |
| * master threads. |
| * |
| * @param bypassThreadPoolIfPossible This argument is only used if a threadpool is configured for this component. if true, |
| * it means that if a threadpool is configured, then we attempt to run the task synchronously and not using the threadpool, |
| * but if the queue is currently run from the threadpool, then the task is scheduled in it. |
| * false means we always use the threadpool and the task is executed asynchronously. |
| * @param task the task to execute. |
| */ |
| private void schedule(boolean bypassThreadPoolIfPossible, Runnable task) { |
| Executor exec = getExecutor(); |
| if (exec instanceof DispatchExecutor) { |
| // We are using a threadpool. If byPassThreadPoolIsPossible is true, it means we can try to run the task synchronously from the current |
| // thread. But if our queue is currently run from the threadpool, then the task will be run from it (asynchronously). |
| ((DispatchExecutor) exec).execute(task, ! bypassThreadPoolIfPossible); |
| } else { |
| // The queue is a serial queue: the task will be run synchronously, except if another master thread is currently running the queue. |
| exec.execute(task); |
| } |
| } |
| |
| private void configureAutoConfigState(Component target, ComponentContext source) { |
| configureAutoConfigState(target, source, BundleContext.class); |
| configureAutoConfigState(target, source, ServiceRegistration.class); |
| configureAutoConfigState(target, source, DependencyManager.class); |
| configureAutoConfigState(target, source, Component.class); |
| } |
| |
| private void configureAutoConfigState(Component target, ComponentContext source, Class<?> clazz) { |
| String name = source.getAutoConfigInstance(clazz); |
| if (name != null) { |
| target.setAutoConfig(clazz, name); |
| } |
| else { |
| target.setAutoConfig(clazz, source.getAutoConfig(clazz)); |
| } |
| } |
| |
| private final static Class[][] INIT_SIGNATUTES = new Class[][] { { Component.class }, {} }; |
| private final static Class[][] FACTORY_CREATE_SIGNATURES = new Class[][] { {}, { Component.class } }; |
| |
| private boolean hasInitMethodWhenNotSingleton() { |
| if (m_callbackInit == null) { |
| return false; |
| } |
| if (m_componentDefinition instanceof Class) { |
| if (null != InvocationUtil.getCallbackMethod((Class<?>) m_componentDefinition, m_callbackInit, INIT_SIGNATUTES)) { |
| return true; |
| } |
| } else if (m_instanceFactoryCreateMethod != null) { |
| if (m_instanceFactory != null) { |
| Class<?> factoryClass = null; |
| |
| if (m_instanceFactory instanceof Class) { |
| factoryClass = (Class<?>) m_instanceFactory; |
| } else if (m_instanceFactory != null) { |
| factoryClass = m_instanceFactory.getClass(); |
| } |
| Method create = InvocationUtil.getCallbackMethod(factoryClass, m_instanceFactoryCreateMethod, FACTORY_CREATE_SIGNATURES); |
| Class<?> componentType = create.getReturnType(); |
| if (componentType != null && InvocationUtil.getCallbackMethod(componentType, m_callbackInit, INIT_SIGNATUTES) != null) { |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| private void initPrototype() { |
| switch (m_scope) { |
| case PROTOTYPE: |
| case BUNDLE: |
| if (m_callbackInit == null || ! hasInitMethodWhenNotSingleton()) { |
| // when no init callback is defined, or if the component implementation does not actually has an init method, we disable injection for the component prototype instance. |
| m_injectionDisabled = true; |
| } |
| break; |
| } |
| } |
| } |
