/*
* Copyright (C) 2003-2010 eXo Platform SAS.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Affero General Public License
* as published by the Free Software Foundation; either version 3
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see<http://www.gnu.org/licenses/>.
*/
package org.exoplatform.container;
import org.exoplatform.container.security.ContainerPermissions;
import org.picocontainer.ComponentAdapter;
import org.picocontainer.MutablePicoContainer;
import org.picocontainer.Parameter;
import org.picocontainer.PicoContainer;
import org.picocontainer.PicoException;
import org.picocontainer.PicoRegistrationException;
import org.picocontainer.PicoVerificationException;
import org.picocontainer.PicoVisitor;
import org.picocontainer.alternatives.ImmutablePicoContainer;
import org.picocontainer.defaults.AbstractPicoVisitor;
import org.picocontainer.defaults.AmbiguousComponentResolutionException;
import org.picocontainer.defaults.CachingComponentAdapter;
import org.picocontainer.defaults.CachingComponentAdapterFactory;
import org.picocontainer.defaults.ComponentAdapterFactory;
import org.picocontainer.defaults.DefaultComponentAdapterFactory;
import org.picocontainer.defaults.DefaultPicoContainer;
import org.picocontainer.defaults.DuplicateComponentKeyRegistrationException;
import org.picocontainer.defaults.InstanceComponentAdapter;
import org.picocontainer.defaults.VerifyingVisitor;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CopyOnWriteArraySet;
import java.util.concurrent.atomic.AtomicBoolean;
/**
* This class is aimed to be the ThreadSafe counterpart of {@link DefaultPicoContainer} based on
* java.util.concurrent collections.
*
* Created by The eXo Platform SAS
* Author : Nicolas Filotto
* nicolas.filotto@exoplatform.com
* 6 mai 2010
* @version $Revision$
*/
@SuppressWarnings("unchecked")
public class ConcurrentPicoContainer implements MutablePicoContainer, Serializable
{
/**
* The serial version UID
*/
private static final long serialVersionUID = -2275793454555604533L;
private final ConcurrentMap<Object, ComponentAdapter> componentKeyToAdapterCache =
new ConcurrentHashMap<Object, ComponentAdapter>();
private final ComponentAdapterFactory componentAdapterFactory;
private final PicoContainer parent;
private final Set<ComponentAdapter> componentAdapters = new CopyOnWriteArraySet<ComponentAdapter>();
// Keeps track of instantiation order.
private final CopyOnWriteArrayList<ComponentAdapter> orderedComponentAdapters = new CopyOnWriteArrayList<ComponentAdapter>();
private final AtomicBoolean started = new AtomicBoolean();
private final AtomicBoolean disposed = new AtomicBoolean();
private final Set<PicoContainer> children = new CopyOnWriteArraySet<PicoContainer>();
/**
* Context used to keep in memory the components that are currently being created.
* This context is used to prevent cyclic resolution due to component plugins.
*/
private final ThreadLocal<Map<Object, Object>> depResolutionCtx = new ThreadLocal<Map<Object, Object>>();
/**
* Creates a new container with a custom ComponentAdapterFactory and a parent container.
* <p/>
* <em>
* Important note about caching: If you intend the components to be cached, you should pass
* in a factory that creates {@link CachingComponentAdapter} instances, such as for example
* {@link CachingComponentAdapterFactory}. CachingComponentAdapterFactory can delegate to
* other ComponentAdapterFactories.
* </em>
*
* @param componentAdapterFactory the factory to use for creation of ComponentAdapters.
* @param parent the parent container (used for component dependency lookups).
*/
public ConcurrentPicoContainer(ComponentAdapterFactory componentAdapterFactory, PicoContainer parent)
{
if (componentAdapterFactory == null)
throw new NullPointerException("componentAdapterFactory");
this.componentAdapterFactory = componentAdapterFactory;
this.parent = parent == null ? null : new ImmutablePicoContainer(parent);
}
/**
* Creates a new container with a (caching) {@link DefaultComponentAdapterFactory}
* and a parent container.
*/
public ConcurrentPicoContainer(PicoContainer parent)
{
this(new DefaultComponentAdapterFactory(), parent);
}
/**
* Creates a new container with a custom ComponentAdapterFactory and no parent container.
*
* @param componentAdapterFactory the ComponentAdapterFactory to use.
*/
public ConcurrentPicoContainer(ComponentAdapterFactory componentAdapterFactory)
{
this(componentAdapterFactory, null);
}
/**
* Creates a new container with a (caching) {@link DefaultComponentAdapterFactory} and no parent container.
*/
public ConcurrentPicoContainer()
{
this(new DefaultComponentAdapterFactory(), null);
}
public Collection getComponentAdapters()
{
return Collections.unmodifiableSet(componentAdapters);
}
public final ComponentAdapter getComponentAdapter(Object componentKey) throws AmbiguousComponentResolutionException
{
ComponentAdapter adapter = componentKeyToAdapterCache.get(componentKey);
if (adapter == null && parent != null)
{
adapter = parent.getComponentAdapter(componentKey);
}
return adapter;
}
public ComponentAdapter getComponentAdapterOfType(Class componentType)
{
// See http://jira.codehaus.org/secure/ViewIssue.jspa?key=PICO-115
ComponentAdapter adapterByKey = getComponentAdapter(componentType);
if (adapterByKey != null)
{
return adapterByKey;
}
List found = getComponentAdaptersOfType(componentType);
if (found.size() == 1)
{
return ((ComponentAdapter)found.get(0));
}
else if (found.size() == 0)
{
if (parent != null)
{
return parent.getComponentAdapterOfType(componentType);
}
else
{
return null;
}
}
else
{
Class[] foundClasses = new Class[found.size()];
for (int i = 0; i < foundClasses.length; i++)
{
ComponentAdapter componentAdapter = (ComponentAdapter)found.get(i);
foundClasses[i] = componentAdapter.getComponentImplementation();
}
throw new AmbiguousComponentResolutionException(componentType, foundClasses);
}
}
public List getComponentAdaptersOfType(Class componentType)
{
if (componentType == null)
{
return Collections.EMPTY_LIST;
}
List<ComponentAdapter> found = new ArrayList<ComponentAdapter>();
for (Iterator<ComponentAdapter> iterator = componentAdapters.iterator(); iterator.hasNext();)
{
ComponentAdapter componentAdapter = iterator.next();
if (componentType.isAssignableFrom(componentAdapter.getComponentImplementation()))
{
found.add(componentAdapter);
}
}
return found;
}
/**
* {@inheritDoc}
* This method can be used to override the ComponentAdapter created by the {@link ComponentAdapterFactory}
* passed to the constructor of this container.
*/
public ComponentAdapter registerComponent(ComponentAdapter componentAdapter)
throws DuplicateComponentKeyRegistrationException
{
SecurityManager security = System.getSecurityManager();
if (security != null)
security.checkPermission(ContainerPermissions.MANAGE_COMPONENT_PERMISSION);
Object componentKey = componentAdapter.getComponentKey();
if (componentKeyToAdapterCache.putIfAbsent(componentKey, componentAdapter) != null)
{
throw new DuplicateComponentKeyRegistrationException(componentKey);
}
componentAdapters.add(componentAdapter);
return componentAdapter;
}
public ComponentAdapter unregisterComponent(Object componentKey)
{
SecurityManager security = System.getSecurityManager();
if (security != null)
security.checkPermission(ContainerPermissions.MANAGE_COMPONENT_PERMISSION);
ComponentAdapter adapter = componentKeyToAdapterCache.remove(componentKey);
componentAdapters.remove(adapter);
orderedComponentAdapters.remove(adapter);
return adapter;
}
/**
* {@inheritDoc}
* The returned ComponentAdapter will be an {@link InstanceComponentAdapter}.
*/
public ComponentAdapter registerComponentInstance(Object component) throws PicoRegistrationException
{
return registerComponentInstance(component.getClass(), component);
}
/**
* {@inheritDoc}
* The returned ComponentAdapter will be an {@link InstanceComponentAdapter}.
*/
public ComponentAdapter registerComponentInstance(Object componentKey, Object componentInstance)
throws PicoRegistrationException
{
if (componentInstance instanceof MutablePicoContainer)
{
MutablePicoContainer pc = (MutablePicoContainer)componentInstance;
Object contrivedKey = new Object();
String contrivedComp = "";
pc.registerComponentInstance(contrivedKey, contrivedComp);
try
{
if (this.getComponentInstance(contrivedKey) != null)
{
throw new PicoRegistrationException(
"Cannot register a container to itself. The container is already implicitly registered.");
}
}
finally
{
pc.unregisterComponent(contrivedKey);
}
}
ComponentAdapter componentAdapter = new InstanceComponentAdapter(componentKey, componentInstance);
registerComponent(componentAdapter);
return componentAdapter;
}
/**
* {@inheritDoc}
* The returned ComponentAdapter will be instantiated by the {@link ComponentAdapterFactory}
* passed to the container's constructor.
*/
public ComponentAdapter registerComponentImplementation(Class componentImplementation)
throws PicoRegistrationException
{
return registerComponentImplementation(componentImplementation, componentImplementation);
}
/**
* {@inheritDoc}
* The returned ComponentAdapter will be instantiated by the {@link ComponentAdapterFactory}
* passed to the container's constructor.
*/
public ComponentAdapter registerComponentImplementation(Object componentKey, Class componentImplementation)
throws PicoRegistrationException
{
return registerComponentImplementation(componentKey, componentImplementation, (Parameter[])null);
}
/**
* {@inheritDoc}
* The returned ComponentAdapter will be instantiated by the {@link ComponentAdapterFactory}
* passed to the container's constructor.
*/
public ComponentAdapter registerComponentImplementation(Object componentKey, Class componentImplementation,
Parameter[] parameters) throws PicoRegistrationException
{
ComponentAdapter componentAdapter =
componentAdapterFactory.createComponentAdapter(componentKey, componentImplementation, parameters);
registerComponent(componentAdapter);
return componentAdapter;
}
/**
* Same as {@link #registerComponentImplementation(java.lang.Object, java.lang.Class, org.picocontainer.Parameter[])}
* but with parameters as a {@link List}. Makes it possible to use with Groovy arrays (which are actually Lists).
*/
public ComponentAdapter registerComponentImplementation(Object componentKey, Class componentImplementation,
List parameters) throws PicoRegistrationException
{
Parameter[] parametersAsArray = (Parameter[])parameters.toArray(new Parameter[parameters.size()]);
return registerComponentImplementation(componentKey, componentImplementation, parametersAsArray);
}
private void addOrderedComponentAdapter(ComponentAdapter componentAdapter)
{
orderedComponentAdapters.addIfAbsent(componentAdapter);
}
public List getComponentInstances() throws PicoException
{
return getComponentInstancesOfType(Object.class);
}
public List getComponentInstancesOfType(Class componentType) throws PicoException
{
if (componentType == null)
{
return Collections.EMPTY_LIST;
}
Map<ComponentAdapter, Object> adapterToInstanceMap = new HashMap<ComponentAdapter, Object>();
for (Iterator<ComponentAdapter> iterator = componentAdapters.iterator(); iterator.hasNext();)
{
ComponentAdapter componentAdapter = iterator.next();
if (componentType.isAssignableFrom(componentAdapter.getComponentImplementation()))
{
Object componentInstance = getInstance(componentAdapter);
adapterToInstanceMap.put(componentAdapter, componentInstance);
// This is to ensure all are added. (Indirect dependencies will be added
// from InstantiatingComponentAdapter).
addOrderedComponentAdapter(componentAdapter);
}
}
List<Object> result = new ArrayList<Object>();
for (Iterator<ComponentAdapter> iterator = orderedComponentAdapters.iterator(); iterator.hasNext();)
{
Object componentAdapter = iterator.next();
final Object componentInstance = adapterToInstanceMap.get(componentAdapter);
if (componentInstance != null)
{
// may be null in the case of the "implicit" adapter
// representing "this".
result.add(componentInstance);
}
}
return result;
}
public Object getComponentInstance(Object componentKey) throws PicoException
{
ComponentAdapter componentAdapter = getComponentAdapter(componentKey);
if (componentAdapter != null)
{
return getInstance(componentAdapter);
}
else
{
return null;
}
}
/**
* If no {@link ComponentAdapter} can be found it returns <tt>null</tt> otherwise
* it first try to get it from the dependency resolution context if it still cannot
* be found we get the instance from the {@link ComponentAdapter}.
* @see org.picocontainer.PicoContainer#getComponentInstanceOfType(java.lang.Class)
*/
public Object getComponentInstanceOfType(Class componentType)
{
final ComponentAdapter componentAdapter = getComponentAdapterOfType(componentType);
if (componentAdapter == null)
return null;
Map<Object, Object> map = depResolutionCtx.get();
if (map != null)
{
Object result = map.get(componentType);
if (result != null)
{
return result;
}
}
return getInstance(componentAdapter);
}
/**
* Add the component corresponding to the given key, to the dependency resolution
* context
* @param key The key of the component to add to the context
* @param component The instance of the component to add to the context
*/
public void addComponentToCtx(Object key, Object component)
{
Map<Object, Object> map = depResolutionCtx.get();
if (map == null)
{
map = new HashMap<Object, Object>();
depResolutionCtx.set(map);
}
map.put(key, component);
}
/**
* Remove the component corresponding to the given key, from the dependency resolution
* context
* @param key The key of the component to remove from the context
*/
public void removeComponentFromCtx(Object key)
{
Map<Object, Object> map = depResolutionCtx.get();
if (map != null)
{
map.remove(key);
if (map.isEmpty())
{
depResolutionCtx.set(null);
}
}
}
private Object getInstance(ComponentAdapter componentAdapter)
{
// check wether this is our adapter
// we need to check this to ensure up-down dependencies cannot be followed
final boolean isLocal = componentAdapters.contains(componentAdapter);
if (isLocal)
{
Object instance = componentAdapter.getComponentInstance(this);
addOrderedComponentAdapter(componentAdapter);
return instance;
}
else if (parent != null)
{
return parent.getComponentInstance(componentAdapter.getComponentKey());
}
return null;
}
public PicoContainer getParent()
{
return parent;
}
public ComponentAdapter unregisterComponentByInstance(Object componentInstance)
{
for (Iterator<ComponentAdapter> iterator = componentAdapters.iterator(); iterator.hasNext();)
{
ComponentAdapter componentAdapter = iterator.next();
Object o;
try
{
o = getInstance(componentAdapter);
}
catch (Exception e)
{
// Ignore me,
// may be caused by lazy initialization mechanism
continue;
}
if (componentInstance.equals(o))
{
return unregisterComponent(componentAdapter.getComponentKey());
}
}
return null;
}
/**
* @deprecated since 1.1 - Use new VerifyingVisitor().traverse(this)
*/
public void verify() throws PicoVerificationException
{
new VerifyingVisitor().traverse(this);
}
/**
* Indicates whether or not the container can be started
*/
protected boolean canBeStarted()
{
return !disposed.get() && !started.get();
}
/**
* Indicates whether or not the container can be stopped
*/
protected boolean canBeStopped()
{
return !disposed.get() && started.get();
}
/**
* Indicates whether or not the container can be disposed
*/
protected boolean canBeDisposed()
{
return !disposed.get();
}
/**
* Start the components of this PicoContainer and all its logical child containers.
* Any component implementing the lifecycle interface {@link org.picocontainer.Startable} will be started.
* @see #makeChildContainer()
* @see #addChildContainer(PicoContainer)
* @see #removeChildContainer(PicoContainer)
*/
public void start()
{
if (!canBeStarted())
return;
LifecycleVisitor.start(this);
started.set(true);
}
/**
* Stop the components of this PicoContainer and all its logical child containers.
* Any component implementing the lifecycle interface {@link org.picocontainer.Startable} will be stopped.
* @see #makeChildContainer()
* @see #addChildContainer(PicoContainer)
* @see #removeChildContainer(PicoContainer)
*/
public void stop()
{
if (!canBeStopped())
return;
LifecycleVisitor.stop(this);
started.set(false);
}
/**
* Dispose the components of this PicoContainer and all its logical child containers.
* Any component implementing the lifecycle interface {@link org.picocontainer.Disposable} will be disposed.
* @see #makeChildContainer()
* @see #addChildContainer(PicoContainer)
* @see #removeChildContainer(PicoContainer)
*/
public void dispose()
{
if (!canBeDisposed())
return;
LifecycleVisitor.dispose(this);
disposed.set(true);
}
public MutablePicoContainer makeChildContainer()
{
DefaultPicoContainer pc = new DefaultPicoContainer(componentAdapterFactory, this);
addChildContainer(pc);
return pc;
}
public boolean addChildContainer(PicoContainer child)
{
SecurityManager security = System.getSecurityManager();
if (security != null)
security.checkPermission(ContainerPermissions.MANAGE_CONTAINER_PERMISSION);
return children.add(child);
}
public boolean removeChildContainer(PicoContainer child)
{
SecurityManager security = System.getSecurityManager();
if (security != null)
security.checkPermission(ContainerPermissions.MANAGE_CONTAINER_PERMISSION);
return children.remove(child);
}
public void accept(PicoVisitor visitor)
{
visitor.visitContainer(this);
for (Iterator<ComponentAdapter> iterator = componentAdapters.iterator(); iterator.hasNext();)
{
ComponentAdapter componentAdapter = iterator.next();
componentAdapter.accept(visitor);
}
for (Iterator<PicoContainer> iterator = children.iterator(); iterator.hasNext();)
{
PicoContainer child = iterator.next();
child.accept(visitor);
}
}
/**
* Accepts a visitor that should visit the child containers only.
*/
protected void accept(ContainerVisitor visitor)
{
visitor.visitContainer(this);
for (Iterator<PicoContainer> iterator = children.iterator(); iterator.hasNext();)
{
PicoContainer child = iterator.next();
child.accept(visitor);
}
}
/**
* Cans be used to indicate that we only want to visit Containers
*/
protected static abstract class ContainerVisitor extends AbstractPicoVisitor
{
public final void visitComponentAdapter(ComponentAdapter componentAdapter)
{
}
public final void visitParameter(Parameter parameter)
{
}
}
}