| /* |
| * 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.cocoon.components; |
| |
| import java.io.IOException; |
| import java.net.MalformedURLException; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.apache.avalon.excalibur.component.ExcaliburComponentManager; |
| import org.apache.avalon.framework.component.Component; |
| import org.apache.avalon.framework.component.ComponentException; |
| import org.apache.avalon.framework.component.ComponentManager; |
| import org.apache.avalon.framework.component.ComponentSelector; |
| import org.apache.avalon.framework.component.Recomposable; |
| import org.apache.avalon.framework.configuration.Configuration; |
| import org.apache.avalon.framework.configuration.ConfigurationException; |
| import org.apache.avalon.framework.logger.Logger; |
| import org.apache.cocoon.ProcessingException; |
| import org.apache.cocoon.Processor; |
| import org.apache.cocoon.environment.Environment; |
| import org.apache.cocoon.xml.XMLConsumer; |
| import org.apache.excalibur.instrument.InstrumentManager; |
| import org.apache.excalibur.source.Source; |
| import org.apache.excalibur.source.SourceException; |
| import org.apache.excalibur.source.SourceResolver; |
| |
| /** |
| * Cocoon Component Manager. |
| * This manager extends the {@link ExcaliburComponentManager} |
| * by a special lifecycle handling for a {@link RequestLifecycleComponent} |
| * and by handling the lookup of the {@link SourceResolver}. |
| * WARNING: This is a "private" Cocoon core class - do NOT use this class |
| * directly - and do not assume that a {@link ComponentManager} you get |
| * via the compose() method is an instance of CocoonComponentManager. |
| * |
| * @author <a href="mailto:bluetkemeier@s-und-n.de">Björn Lütkemeier</a> |
| * @author <a href="mailto:cziegeler@apache.org">Carsten Ziegeler</a> |
| * @version CVS $Id$ |
| */ |
| public final class CocoonComponentManager extends ExcaliburComponentManager |
| implements SourceResolver, Component { |
| |
| /** The key used to store the current process environment */ |
| private static final String PROCESS_KEY = CocoonComponentManager.class.getName(); |
| |
| /** The environment attribute used to keep track of the actual environment in which the pipeline was built. */ |
| private static final String PROCESSOR_ATTR = "CocoonComponentManager.processor"; |
| |
| /** The environment information */ |
| protected static final ThreadLocal environmentStack = new ThreadLocal(); |
| |
| /** The configured {@link SourceResolver} */ |
| private SourceResolver sourceResolver; |
| |
| /** The {@link SitemapConfigurationHolder}s */ |
| private Map sitemapConfigurationHolders = new HashMap(15); |
| |
| /** The parent component manager for implementing parent aware components */ |
| private ComponentManager parentManager; |
| |
| /** Temporary list of parent-aware components. Will be null for most of |
| * our lifecycle. */ |
| private ArrayList parentAwareComponents = new ArrayList(); |
| |
| /** has this been disposed? */ |
| private boolean wasDisposed; |
| |
| /** The instrument manager (if any). */ |
| private InstrumentManager instrumentManager; |
| |
| /** Create the ComponentManager */ |
| public CocoonComponentManager() { |
| super(null, Thread.currentThread().getContextClassLoader()); |
| } |
| |
| /** Create the ComponentManager with a Classloader */ |
| public CocoonComponentManager(final ClassLoader loader) { |
| super(null, loader); |
| } |
| |
| /** Create the ComponentManager with a Classloader and parent ComponentManager */ |
| public CocoonComponentManager(final ComponentManager manager, final ClassLoader loader) { |
| super(manager, loader); |
| this.setParentManager(manager); |
| } |
| |
| /** Create the ComponentManager with a parent ComponentManager */ |
| public CocoonComponentManager(final ComponentManager manager) { |
| super(manager); |
| this.setParentManager(manager); |
| } |
| |
| protected void setParentManager(final ComponentManager manager) { |
| this.parentManager = manager; |
| if ( manager instanceof CocoonComponentManager ) { |
| this.setInstrumentManager(((CocoonComponentManager)manager).instrumentManager); |
| } |
| } |
| |
| /** |
| * @see org.apache.avalon.excalibur.component.ExcaliburComponentManager#setInstrumentManager(org.apache.excalibur.instrument.InstrumentManager) |
| */ |
| public void setInstrumentManager(InstrumentManager iManager) { |
| this.instrumentManager = iManager; |
| super.setInstrumentManager(iManager); |
| } |
| |
| /** |
| * This hook must be called by the sitemap each time a sitemap is entered |
| * This method should never raise an exception, except when the |
| * parameters are not set! |
| */ |
| public static void enterEnvironment(Environment env, |
| ComponentManager manager, |
| Processor processor) { |
| if (null == env || null == manager || null == processor) { |
| throw new RuntimeException("CocoonComponentManager.enterEnvironment: " + |
| "All parameters must be set: " + env + " - " + manager + " - " + processor); |
| } |
| |
| EnvironmentStack stack = (EnvironmentStack)environmentStack.get(); |
| if (stack == null) { |
| stack = new EnvironmentStack(); |
| environmentStack.set(stack); |
| } |
| stack.push(new EnvironmentStack.Item(env, processor, manager, stack.getOffset())); |
| stack.setOffset(stack.size()-1); |
| |
| env.setAttribute(PROCESSOR_ATTR, processor); |
| } |
| |
| /** |
| * This hook must be called by the sitemap each time a sitemap is left. |
| * It's the counterpart to {@link #enterEnvironment(Environment, ComponentManager, Processor)}. |
| */ |
| public static void leaveEnvironment() { |
| // Calling with true will avoid any change on the active processor |
| leaveEnvironment(true); |
| } |
| |
| /** |
| * This hook must be called by the sitemap each time a sitemap is left. |
| * It's the counterpart to {@link #enterEnvironment(Environment, ComponentManager, Processor)}. |
| * |
| * @param success indicates if the request was successfully handled by the environment that's being left |
| */ |
| public static void leaveEnvironment(boolean success) { |
| final EnvironmentStack stack = (EnvironmentStack)environmentStack.get(); |
| final EnvironmentStack.Item objs = (EnvironmentStack.Item)stack.pop(); |
| stack.setOffset(objs.offset); |
| |
| if (stack.isEmpty()) { |
| final Environment env = objs.env; |
| final Map globalComponents = (Map)env.getAttribute(GlobalRequestLifecycleComponent.class.getName()); |
| if (globalComponents != null) { |
| |
| final Iterator iter = globalComponents.values().iterator(); |
| while (iter.hasNext()) { |
| final Object[] o = (Object[])iter.next(); |
| final Component c = (Component)o[0]; |
| ((CocoonComponentManager)o[1]).releaseRLComponent( c ); |
| } |
| } |
| env.removeAttribute(GlobalRequestLifecycleComponent.class.getName()); |
| |
| // Setting this ThreadLocal to null allows it to be garbage collected |
| CocoonComponentManager.environmentStack.set(null); |
| } else { |
| if (!success) { |
| // Restore the current processor as being the active one |
| getCurrentEnvironment().setAttribute(PROCESSOR_ATTR, getCurrentProcessor()); |
| } |
| } |
| } |
| |
| /** |
| * INTERNAL METHOD. Do not use, can be removed without warning or deprecation cycle. |
| */ |
| public static int markEnvironment() { |
| // TODO (CZ): This is only for testing - remove it later on. See also Cocoon.java. |
| final EnvironmentStack stack = (EnvironmentStack)environmentStack.get(); |
| if (stack != null) { |
| return stack.size(); |
| } |
| |
| return 0; |
| } |
| |
| /** |
| * INTERNAL METHOD. Do not use, can be removed without warning or deprecation cycle. |
| */ |
| public static void checkEnvironment(int depth, Logger logger) |
| throws Exception { |
| // TODO (CZ): This is only for testing - remove it later on. See also Cocoon.java. |
| final EnvironmentStack stack = (EnvironmentStack)environmentStack.get(); |
| int currentDepth = stack != null? stack.size() : 0; |
| if (currentDepth != depth) { |
| logger.error("ENVIRONMENT STACK HAS NOT BEEN CLEANED PROPERLY!"); |
| throw new ProcessingException("Environment stack has not been cleaned up properly. " + |
| "Please report this (and if possible, together with a test case) " + |
| "to the Cocoon developers."); |
| } |
| } |
| |
| /** |
| * Create an environment aware xml consumer for the cocoon |
| * protocol |
| */ |
| public static XMLConsumer createEnvironmentAwareConsumer(XMLConsumer consumer) { |
| final EnvironmentStack stack = (EnvironmentStack)environmentStack.get(); |
| final EnvironmentStack.Item objs = stack.getCurrent(); |
| return stack.getEnvironmentAwareConsumerWrapper(consumer, objs.offset); |
| } |
| |
| /** |
| * This hook has to be called before a request is processed. |
| * The hook is called by the Cocoon component and by the |
| * cocoon protocol implementation. |
| * This method should never raise an exception, except when |
| * the environment is not set. |
| * |
| * @return A unique key within this thread. |
| */ |
| public static Object startProcessing(Environment env) { |
| if (null == env) { |
| throw new RuntimeException("CocoonComponentManager.startProcessing: environment must be set."); |
| } |
| final EnvironmentDescription desc = new EnvironmentDescription(env); |
| env.getObjectModel().put(PROCESS_KEY, desc); |
| env.startingProcessing(); |
| return desc; |
| } |
| |
| /** |
| * This hook has to be called before a request is processed. |
| * The hook is called by the Cocoon component and by the |
| * cocoon protocol implementation. |
| * @param key A unique key within this thread return by |
| * {@link #startProcessing(Environment)}. |
| */ |
| public static void endProcessing(Environment env, Object key) { |
| env.finishingProcessing(); |
| final EnvironmentDescription desc = (EnvironmentDescription)key; |
| desc.release(); |
| env.getObjectModel().remove(PROCESS_KEY); |
| } |
| |
| /** |
| * Return the current environment (for the cocoon: protocol) |
| */ |
| public static Environment getCurrentEnvironment() { |
| final EnvironmentStack stack = (EnvironmentStack)environmentStack.get(); |
| if (null != stack && !stack.isEmpty()) { |
| return stack.getCurrent().env; |
| } |
| return null; |
| } |
| |
| /** |
| * Return the current processor (for the cocoon: protocol) |
| */ |
| public static Processor getCurrentProcessor() { |
| final EnvironmentStack stack = (EnvironmentStack)environmentStack.get(); |
| if (null != stack && !stack.isEmpty()) { |
| return stack.getCurrent().processor; |
| } |
| return null; |
| } |
| |
| /** |
| * Return the processor that has actually processed the request |
| */ |
| public static Processor getActiveProcessor(Environment env) { |
| return (Processor) env.getAttribute(PROCESSOR_ATTR); |
| } |
| |
| /** |
| * Get the current sitemap component manager. |
| * This method return the current sitemap component manager. This |
| * is the manager that holds all the components of the currently |
| * processed (sub)sitemap. |
| */ |
| static public ComponentManager getSitemapComponentManager() { |
| final EnvironmentStack stack = (EnvironmentStack)environmentStack.get(); |
| if (null != stack && !stack.isEmpty()) { |
| EnvironmentStack.Item o = (EnvironmentStack.Item) stack.peek(); |
| return o.manager; |
| } |
| |
| // If we don't have an environment yet, just return null |
| return null; |
| } |
| |
| /** |
| * Return an instance of a component based on a Role. The Role is usually the Interface's |
| * Fully Qualified Name(FQN)--unless there are multiple Components for the same Role. In that |
| * case, the Role's FQN is appended with "Selector", and we return a ComponentSelector. |
| */ |
| public Component lookup(final String role) |
| throws ComponentException { |
| if (null == role) { |
| final String message = |
| "ComponentLocator Attempted to retrieve component with null role."; |
| throw new ComponentException(role, message); |
| } |
| |
| if (role.equals(SourceResolver.ROLE)) { |
| if (null == this.sourceResolver) { |
| if(this.wasDisposed) { |
| // (BD) working on bug 27249: I think we could throw an Exception here, as |
| // the following call fails anyway, but I'm not sure enough ;-) |
| this.getLogger().warn("Trying to lookup SourceResolver on disposed CocoonComponentManager"); |
| } |
| this.sourceResolver = (SourceResolver) super.lookup( role ); |
| } |
| return this; |
| } |
| |
| final EnvironmentStack stack = (EnvironmentStack)environmentStack.get(); |
| if ( null != stack && !stack.isEmpty()) { |
| final EnvironmentStack.Item objects = stack.getCurrent(); |
| final Map objectModel = objects.env.getObjectModel(); |
| EnvironmentDescription desc = (EnvironmentDescription)objectModel.get(PROCESS_KEY); |
| if ( null != desc ) { |
| Component component = desc.getRequestLifecycleComponent(role); |
| if (null != component) { |
| return component; |
| } |
| component = desc.getGlobalRequestLifecycleComponent(role); |
| if (null != component) { |
| return component; |
| } |
| } |
| } |
| |
| final Component component = super.lookup(role); |
| |
| if (component != null && component instanceof RequestLifecycleComponent) { |
| if (stack == null || stack.isEmpty()) { |
| throw new ComponentException(role, "ComponentManager has no Environment Stack."); |
| } |
| |
| final EnvironmentStack.Item objects = stack.getCurrent(); |
| final Map objectModel = objects.env.getObjectModel(); |
| EnvironmentDescription desc = (EnvironmentDescription) objectModel.get(PROCESS_KEY); |
| if (null != desc) { |
| // first test if the parent CM has already initialized this component |
| if (!desc.containsRequestLifecycleComponent(role)) { |
| try { |
| if (component instanceof Recomposable) { |
| ((Recomposable) component).recompose(this); |
| } |
| ((RequestLifecycleComponent) component).setup(objects.env, objectModel); |
| } catch (Exception local) { |
| throw new ComponentException(role, "Exception during setup of RequestLifecycleComponent.", local); |
| } |
| desc.addRequestLifecycleComponent(role, component, this); |
| } |
| } |
| } |
| |
| if (component != null && component instanceof GlobalRequestLifecycleComponent) { |
| if (stack == null || stack.isEmpty()) { |
| throw new ComponentException(role, "ComponentManager has no Environment Stack."); |
| } |
| |
| final EnvironmentStack.Item objects = stack.getCurrent(); |
| final Map objectModel = objects.env.getObjectModel(); |
| EnvironmentDescription desc = (EnvironmentDescription) objectModel.get(PROCESS_KEY); |
| if (null != desc) { |
| // first test if the parent CM has already initialized this component |
| if ( !desc.containsGlobalRequestLifecycleComponent( role ) ) { |
| try { |
| if (component instanceof Recomposable) { |
| ((Recomposable) component).recompose(this); |
| } |
| ((GlobalRequestLifecycleComponent) component).setup(objects.env, objectModel); |
| } catch (Exception local) { |
| throw new ComponentException(role, "Exception during setup of RequestLifecycleComponent.", local); |
| } |
| desc.addGlobalRequestLifecycleComponent(role, component, this); |
| } |
| } |
| } |
| |
| if (component != null && component instanceof SitemapConfigurable) { |
| // FIXME: how can we prevent that this is called over and over again? |
| SitemapConfigurationHolder holder; |
| |
| holder = (SitemapConfigurationHolder) this.sitemapConfigurationHolders.get(role); |
| if (null == holder) { |
| // create new holder |
| holder = new DefaultSitemapConfigurationHolder(role); |
| this.sitemapConfigurationHolders.put(role, holder); |
| } |
| |
| try { |
| ((SitemapConfigurable)component).configure(holder); |
| } catch (ConfigurationException ce) { |
| throw new ComponentException(role, "Exception during setup of SitemapConfigurable.", ce); |
| } |
| } |
| |
| return component; |
| } |
| |
| /** |
| * Release a Component. This implementation makes sure it has a handle on the propper |
| * ComponentHandler, and let's the ComponentHandler take care of the actual work. |
| */ |
| public void release(final Component component) { |
| if (null == component) { |
| return; |
| } |
| |
| if (component instanceof RequestLifecycleComponent |
| || component instanceof GlobalRequestLifecycleComponent) { |
| return; |
| } |
| |
| if (component == this) { |
| return; |
| } |
| |
| super.release(component); |
| } |
| |
| /** |
| * Release a RequestLifecycleComponent |
| */ |
| protected void releaseRLComponent(final Component component) { |
| super.release(component); |
| } |
| |
| /** |
| * Add an automatically released component |
| */ |
| public static void addComponentForAutomaticRelease(final ComponentSelector selector, |
| final Component component, |
| final ComponentManager manager) |
| throws ProcessingException { |
| final EnvironmentStack stack = (EnvironmentStack)environmentStack.get(); |
| if ( null != stack && !stack.isEmpty()) { |
| final EnvironmentStack.Item objects = (EnvironmentStack.Item)stack.get(0); |
| final Map objectModel = objects.env.getObjectModel(); |
| EnvironmentDescription desc = (EnvironmentDescription)objectModel.get(PROCESS_KEY); |
| if ( null != desc ) { |
| desc.addToAutoRelease(selector, component, manager); |
| } |
| } else { |
| throw new ProcessingException("Unable to add component for automatic release: no environment available."); |
| } |
| } |
| |
| /** |
| * Add an automatically released component |
| */ |
| public static void addComponentForAutomaticRelease(final ComponentManager manager, |
| final Component component) |
| throws ProcessingException { |
| final EnvironmentStack stack = (EnvironmentStack)environmentStack.get(); |
| if ( null != stack && !stack.isEmpty()) { |
| final EnvironmentStack.Item objects = (EnvironmentStack.Item)stack.get(0); |
| final Map objectModel = objects.env.getObjectModel(); |
| EnvironmentDescription desc = (EnvironmentDescription)objectModel.get(PROCESS_KEY); |
| if ( null != desc ) { |
| desc.addToAutoRelease(manager, component); |
| } |
| } else { |
| throw new ProcessingException("Unable to add component for automatic release: no environment available."); |
| } |
| } |
| |
| /** |
| * Remove from automatically released components |
| */ |
| public static void removeFromAutomaticRelease(final Component component) |
| throws ProcessingException { |
| final EnvironmentStack stack = (EnvironmentStack)environmentStack.get(); |
| if ( null != stack && !stack.isEmpty()) { |
| final EnvironmentStack.Item objects = (EnvironmentStack.Item)stack.get(0); |
| final Map objectModel = objects.env.getObjectModel(); |
| EnvironmentDescription desc = (EnvironmentDescription)objectModel.get(PROCESS_KEY); |
| if ( null != desc ) { |
| desc.removeFromAutoRelease(component); |
| } |
| } else { |
| throw new ProcessingException("Unable to remove component from automatic release: no environment available."); |
| } |
| } |
| |
| /** |
| * Dispose |
| */ |
| public void dispose() { |
| if (this.getLogger().isDebugEnabled()) { |
| this.getLogger().debug("CocoonComponentManager.dispose() called"); |
| } |
| |
| if (null != this.sourceResolver) { |
| super.release((Component)this.sourceResolver); |
| // We cannot null out sourceResolver here yet as some other not |
| // disposed yet components might still have unreleased sources, |
| // and they will call {@link #release(Source)} during their |
| // dispose(). |
| } |
| |
| super.dispose(); |
| |
| // All components now are released so sourceResolver should be not |
| // needed anymore. |
| this.sourceResolver = null; |
| |
| // This is used to track bug 27249 |
| this.wasDisposed = true; |
| } |
| |
| /** |
| * Get a <code>Source</code> object. |
| */ |
| public Source resolveURI(final String location) |
| throws MalformedURLException, IOException, SourceException { |
| return this.resolveURI(location, null, null); |
| } |
| |
| /** |
| * Get a <code>Source</code> object. |
| */ |
| public Source resolveURI(final String location, |
| String baseURI, |
| final Map parameters) |
| throws MalformedURLException, IOException, SourceException { |
| if (baseURI == null) { |
| final EnvironmentStack stack = (EnvironmentStack)environmentStack.get(); |
| if ( null != stack && !stack.isEmpty()) { |
| final EnvironmentStack.Item objects = stack.getCurrent(); |
| baseURI = objects.env.getContext(); |
| } |
| } |
| return this.sourceResolver.resolveURI(location, baseURI, parameters); |
| } |
| |
| /** |
| * Releases a resolved resource |
| */ |
| public void release(final Source source) { |
| this.sourceResolver.release(source); |
| } |
| |
| |
| /* (non-Javadoc) |
| * @see org.apache.avalon.excalibur.component.ExcaliburComponentManager#addComponent(java.lang.String, java.lang.Class, org.apache.avalon.framework.configuration.Configuration) |
| */ |
| public void addComponent(String role, Class clazz, Configuration conf) |
| throws ComponentException { |
| super.addComponent(role, clazz, conf); |
| // Note that at this point, we're not initialized and cannot do |
| // lookups, so defer parental introductions to initialize(). |
| if (ParentAware.class.isAssignableFrom(clazz)) { |
| this.parentAwareComponents.add(role); |
| } |
| } |
| |
| public void initialize() throws Exception { |
| super.initialize(); |
| if (this.parentAwareComponents == null) { |
| throw new ComponentException(null, "CocoonComponentManager already initialized"); |
| } |
| // Set parents for parentAware components |
| Iterator iter = this.parentAwareComponents.iterator(); |
| while (iter.hasNext()) { |
| String role = (String)iter.next(); |
| this.getLogger().debug(".. "+role); |
| if ( this.parentManager != null && this.parentManager.hasComponent( role ) ) { |
| // lookup new component |
| Component component = null; |
| try { |
| component = this.lookup( role ); |
| ((ParentAware)component).setParentLocator( new ComponentLocatorImpl(this.parentManager, role )); |
| } catch (ComponentException ignore) { |
| // we don't set the parent then |
| } finally { |
| this.release( component ); |
| } |
| } |
| } |
| this.parentAwareComponents = null; // null to save memory, and catch logic bugs. |
| } |
| |
| /** |
| * A runnable wrapper that inherits the environment stack of the thread it is |
| * created in. |
| * <p> |
| * It's defined as an abstract class here to use some internals of EnvironmentHelper, and |
| * should only be used through its public counterpart, {@link org.apache.cocoon.environment.CocoonRunnable} |
| */ |
| public static abstract class AbstractCocoonRunnable implements Runnable { |
| private Object parentStack = null; |
| |
| public AbstractCocoonRunnable() { |
| // Clone the environment stack of the calling thread. |
| // We'll use it in run() below |
| Object stack = CocoonComponentManager.environmentStack.get(); |
| if (stack != null) { |
| this.parentStack = ((EnvironmentStack)stack).clone(); |
| } |
| } |
| |
| /** |
| * Calls {@link #doRun()} within the environment context of the creating thread. |
| */ |
| public final void run() { |
| // Install the stack from the parent thread and run the Runnable |
| Object oldStack = environmentStack.get(); |
| CocoonComponentManager.environmentStack.set(this.parentStack); |
| try { |
| this.doRun(); |
| } finally { |
| // Restore the previous stack |
| CocoonComponentManager.environmentStack.set(oldStack); |
| } |
| // FIXME: Check the lifetime of this run compared to the parent thread. |
| // A CocoonThread is meant to start and die within the execution period of the parent request, |
| // and it is an error if it lives longer as the parent environment is no more valid. |
| } |
| |
| abstract protected void doRun(); |
| } |
| } |
| |
| final class EnvironmentDescription { |
| |
| Environment environment; |
| Map objectModel; |
| Map requestLifecycleComponents; |
| List autoreleaseComponents = new ArrayList(4); |
| |
| /** |
| * Constructor |
| */ |
| EnvironmentDescription(Environment env) { |
| this.environment = env; |
| this.objectModel = env.getObjectModel(); |
| } |
| |
| Map getGlobalRequestLifcecycleComponents() { |
| Map m = (Map)this.environment.getAttribute(GlobalRequestLifecycleComponent.class.getName()); |
| if ( m == null ) { |
| m = new HashMap(); |
| this.environment.setAttribute(GlobalRequestLifecycleComponent.class.getName(), m); |
| } |
| return m; |
| } |
| |
| /** |
| * Release all components of this environment |
| * All RequestLifecycleComponents and autoreleaseComponents are |
| * released. |
| */ |
| synchronized void release() { |
| if ( this.requestLifecycleComponents != null ) { |
| final Iterator iter = this.requestLifecycleComponents.values().iterator(); |
| while (iter.hasNext()) { |
| final Object[] o = (Object[])iter.next(); |
| final Component component = (Component)o[0]; |
| ((CocoonComponentManager)o[1]).releaseRLComponent( component ); |
| } |
| this.requestLifecycleComponents.clear(); |
| } |
| |
| for (int i = 0; i < this.autoreleaseComponents.size(); i++) { |
| final Object[] o = (Object[])this.autoreleaseComponents.get(i); |
| final Component component = (Component)o[0]; |
| if (o[1] instanceof ComponentManager) { |
| ((ComponentManager)o[1]).release( component ); |
| } else { |
| ((ComponentSelector) o[1]).release(component); |
| if (o[2] != null) { |
| ((ComponentManager) o[2]).release((Component) o[1]); |
| } |
| } |
| } |
| this.autoreleaseComponents.clear(); |
| this.environment = null; |
| this.objectModel = null; |
| } |
| |
| /** |
| * Add a RequestLifecycleComponent to the environment |
| */ |
| void addRequestLifecycleComponent(final String role, |
| final Component co, |
| final ComponentManager manager) { |
| if ( this.requestLifecycleComponents == null ) { |
| this.requestLifecycleComponents = new HashMap(); |
| } |
| this.requestLifecycleComponents.put(role, new Object[] {co, manager}); |
| } |
| |
| /** |
| * Add a GlobalRequestLifecycleComponent to the environment |
| */ |
| void addGlobalRequestLifecycleComponent(final String role, |
| final Component co, |
| final ComponentManager manager) { |
| this.getGlobalRequestLifcecycleComponents().put(role, new Object[] {co, manager}); |
| } |
| |
| /** |
| * Do we already have a request lifecycle component |
| */ |
| boolean containsRequestLifecycleComponent(final String role) { |
| if ( this.requestLifecycleComponents == null ) { |
| return false; |
| } |
| return this.requestLifecycleComponents.containsKey( role ); |
| } |
| |
| /** |
| * Do we already have a global request lifecycle component |
| */ |
| boolean containsGlobalRequestLifecycleComponent(final String role) { |
| return this.getGlobalRequestLifcecycleComponents().containsKey( role ); |
| } |
| |
| /** |
| * Search a RequestLifecycleComponent |
| */ |
| Component getRequestLifecycleComponent(final String role) { |
| if ( this.requestLifecycleComponents == null ) { |
| return null; |
| } |
| final Object[] o = (Object[])this.requestLifecycleComponents.get(role); |
| if ( null != o ) { |
| return (Component)o[0]; |
| } |
| return null; |
| } |
| |
| /** |
| * Search a GlobalRequestLifecycleComponent |
| */ |
| Component getGlobalRequestLifecycleComponent(final String role) { |
| final Object[] o = (Object[])this.getGlobalRequestLifcecycleComponents().get(role); |
| if ( null != o ) { |
| return (Component)o[0]; |
| } |
| return null; |
| } |
| |
| /** |
| * Add an automatically released component |
| */ |
| synchronized void addToAutoRelease(final ComponentSelector selector, |
| final Component component, |
| final ComponentManager manager) { |
| this.autoreleaseComponents.add(new Object[] {component, selector, manager}); |
| } |
| |
| /** |
| * Add an automatically released component |
| */ |
| synchronized void addToAutoRelease(final ComponentManager manager, |
| final Component component) { |
| this.autoreleaseComponents.add(new Object[] {component, manager}); |
| } |
| |
| /** |
| * Remove from automatically released components |
| */ |
| synchronized void removeFromAutoRelease(final Component component) |
| throws ProcessingException { |
| int i = 0; |
| boolean found = false; |
| while (i < this.autoreleaseComponents.size() && !found) { |
| final Object[] o = (Object[])this.autoreleaseComponents.get(i); |
| if (o[0] == component) { |
| found = true; |
| if (o[1] instanceof ComponentManager) { |
| ((ComponentManager)o[1]).release( component ); |
| } else { |
| ((ComponentSelector)o[1]).release( component ); |
| if (o[2] != null) { |
| ((ComponentManager)o[2]).release( (Component)o[1] ); |
| } |
| } |
| this.autoreleaseComponents.remove(i); |
| } else { |
| i++; |
| } |
| } |
| if (!found) { |
| throw new ProcessingException("Unable to remove component from automatic release: component not found."); |
| } |
| } |
| } |
