RELEASE_2_1_13/src/java/org/apache/cocoon/components/flow/ContinuationsManagerImpl.java - cocoon - Git at Google

 /*
  * 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.flow;

 import java.security.SecureRandom;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.SortedSet;
 import java.util.TreeSet;

 import javax.servlet.http.HttpSessionBindingEvent;
 import javax.servlet.http.HttpSessionBindingListener;

 import org.apache.avalon.framework.component.Component;
 import org.apache.avalon.framework.configuration.Configurable;
 import org.apache.avalon.framework.configuration.Configuration;
 import org.apache.avalon.framework.context.Context;
 import org.apache.avalon.framework.context.ContextException;
 import org.apache.avalon.framework.context.Contextualizable;
 import org.apache.avalon.framework.logger.AbstractLogEnabled;
 import org.apache.avalon.framework.service.ServiceException;
 import org.apache.avalon.framework.service.ServiceManager;
 import org.apache.avalon.framework.service.Serviceable;
 import org.apache.avalon.framework.thread.ThreadSafe;

 import org.apache.cocoon.components.ContextHelper;
 import org.apache.cocoon.components.thread.RunnableManager;
 import org.apache.cocoon.environment.ObjectModelHelper;
 import org.apache.cocoon.environment.Request;
 import org.apache.cocoon.environment.Session;
 import org.apache.cocoon.util.Deprecation;

 import org.apache.commons.collections.Predicate;
 import org.apache.commons.collections.iterators.FilterIterator;

 import org.apache.excalibur.instrument.CounterInstrument;
 import org.apache.excalibur.instrument.Instrument;
 import org.apache.excalibur.instrument.Instrumentable;
 import org.apache.excalibur.instrument.ValueInstrument;

 /**
  * The default implementation of {@link ContinuationsManager}. <br/>There are
  * two modes of work: <br/>
  * <ul>
  * <li><b>standard mode </b>- continuations are stored in single holder. No
  * security is applied to continuation lookup. Anyone can invoke a continuation
  * only knowing the ID. Set "session-bound-continuations" configuration option
  * to false to activate this mode.</li>
  * <li><b>secure mode </b>- each session has it's own continuations holder. A
  * continuation is only valid for the same session it was created for. Session
  * invalidation causes all bound continuations to be invalidated as well. Use
  * this setting for web applications. Set "session-bound-continuations"
  * configuration option to true to activate this mode.</li>
  * </ul>
  *
  * @author <a href="mailto:ovidiu@cup.hp.com">Ovidiu Predescu </a>
  * @author <a href="mailto:Michael.Melhem@managesoft.com">Michael Melhem </a>
  * @since March 19, 2002
  * @see ContinuationsManager
  * @version CVS $Id$
  */
 public class ContinuationsManagerImpl
         extends AbstractLogEnabled
         implements ContinuationsManager, Component, Configurable,
                    ThreadSafe, Instrumentable, Serviceable, Contextualizable {

     private static final int CONTINUATION_ID_LENGTH = 20;

     /**
      * Random number generator used to create continuation ID
      */
     protected SecureRandom random;
     protected final byte[] bytes = new byte[CONTINUATION_ID_LENGTH];

     /**
      * Sorted set of <code>WebContinuation</code> instances, based on
      * their expiration time. This is used by the background thread to
      * invalidate continuations.
      */
     protected final SortedSet expirations = Collections.synchronizedSortedSet(new TreeSet());

     protected ServiceManager serviceManager;
     protected Context context;

     /**
      * How long does a continuation exist in memory since the last
      * access? The time is in milliseconds, and the default is 1 hour.
      */
     protected int defaultTimeToLive;
     protected boolean isContinuationSharingBugCompatible;
     protected boolean bindContinuationsToSession;

     /**
      * Main continuations holder. Used unless continuations are stored in user
      * session.
      */
     protected WebContinuationsHolder continuationsHolder;

     // Instrumentation
     protected String instrumentableName;
     protected ValueInstrument continuationsCount;
     protected int continuationsCounter;
     protected ValueInstrument expirationsSize;
     protected CounterInstrument continuationsCreated;
     protected CounterInstrument continuationsInvalidated;

     public ContinuationsManagerImpl() throws Exception {
         try {
             random = SecureRandom.getInstance("SHA1PRNG");
         } catch(java.security.NoSuchAlgorithmException nsae) {
             // Maybe we are on IBM's SDK
             random = SecureRandom.getInstance("IBMSecureRandom");
         }
         random.setSeed(System.currentTimeMillis());

         continuationsCount = new ValueInstrument("count");
         continuationsCounter = 0;
         expirationsSize = new ValueInstrument("expirations-size");
         continuationsCreated = new CounterInstrument("creates");
         continuationsInvalidated = new CounterInstrument("invalidates");
     }

     public void contextualize(Context context) throws ContextException {
         this.context = context;
     }

     public void service(ServiceManager manager) throws ServiceException {
         this.serviceManager = manager;
     }

     public void configure(Configuration config) {
         this.defaultTimeToLive = config.getAttributeAsInteger("time-to-live", (3600 * 1000));
         this.isContinuationSharingBugCompatible = config.getAttributeAsBoolean("continuation-sharing-bug-compatible", false);
         this.bindContinuationsToSession = config.getAttributeAsBoolean( "session-bound-continuations", false );

         // create a global ContinuationsHolder if this the "session-bound-continuations" parameter is set to false
         if (!this.bindContinuationsToSession) {
             this.continuationsHolder = new WebContinuationsHolder();
         }

         // create a thread that invalidates the continuations
         final Configuration expireConf = config.getChild("expirations-check");
         final long initialDelay = expireConf.getChild("offset", true).getValueAsLong(180000);
         final long interval = expireConf.getChild("period", true).getValueAsLong(180000);
         try {
             final RunnableManager runnableManager = (RunnableManager)serviceManager.lookup(RunnableManager.ROLE);
             runnableManager.execute( new Runnable() {
                     public void run()
                     {
                         expireContinuations();
                     }
                 }, initialDelay, interval);
             serviceManager.release(runnableManager);
         } catch (Exception e) {
             getLogger().warn("Could not enqueue continuations expiration task. " +
                              "Continuations will not automatically expire.", e);
         }
     }

     public void setInstrumentableName(String instrumentableName) {
         this.instrumentableName = instrumentableName;
     }

     public String getInstrumentableName() {
         return instrumentableName;
     }

     public Instrument[] getInstruments() {
         return new Instrument[]{
             continuationsCount,
             continuationsCreated,
             continuationsInvalidated
         };
     }

     public Instrumentable[] getChildInstrumentables() {
         return Instrumentable.EMPTY_INSTRUMENTABLE_ARRAY;
     }

     public WebContinuation createWebContinuation(Object kont,
                                                  WebContinuation parent,
                                                  int timeToLive,
                                                  String interpreterId,
                                                  ContinuationsDisposer disposer) {
         int ttl = timeToLive == 0 ? defaultTimeToLive : timeToLive;

         WebContinuation wk = generateContinuation(kont, parent, ttl, interpreterId, disposer);

         synchronized (this.expirations) {
             if (parent != null) {
                 expirations.remove(parent);
             }
             expirations.add(wk);
             expirationsSize.setValue(expirations.size());
         }

         if (getLogger().isDebugEnabled()) {
             getLogger().debug("WK: Created continuation " + wk.getId());
         }

         return wk;
     }

     public WebContinuation lookupWebContinuation(String id, String interpreterId) {
         WebContinuationsHolder continuationsHolder = lookupWebContinuationsHolder(false);
         if (continuationsHolder == null) {
             return null;
         }

         WebContinuation kont = continuationsHolder.get(id);
         if (kont == null) {
             return null;
         }

         if (kont.hasExpired()) {
             removeContinuation(continuationsHolder, kont);
             return null;
         }

         if (!kont.interpreterMatches(interpreterId)) {
             if (getLogger().isWarnEnabled()) {
                 getLogger().warn("WK: Continuation (" + kont.getId()
                                  + ") lookup for wrong interpreter. Bound to: "
                                  + kont.getInterpreterId() + ", looked up for: "
                                  + interpreterId);
             }

             if (!isContinuationSharingBugCompatible) {
                 return null;
             }
         }

         // COCOON-2109: Sorting in the TreeSet happens on insert. So in order to re-sort the
         //              continuation has to be re-added.
         synchronized (this.expirations) {
             this.expirations.remove(kont);
             kont.updateLastAccessTime();
             this.expirations.add(kont);
         }

         return kont;
     }

     /**
      * Create <code>WebContinuation</code> and generate unique identifier
      * for it. The identifier is generated using a cryptographically strong
      * algorithm to prevent people to generate their own identifiers.
      *
      * @param kont an <code>Object</code> value representing continuation
      * @param parent value representing parent <code>WebContinuation</code>
      * @param ttl <code>WebContinuation</code> time to live
      * @param interpreterId id of interpreter invoking continuation creation
      * @param disposer <code>ContinuationsDisposer</code> instance to use for
      * cleanup of the continuation.
      * @return the generated <code>WebContinuation</code> with unique identifier
      */
     protected WebContinuation generateContinuation(Object kont,
                                                    WebContinuation parent,
                                                    int ttl,
                                                    String interpreterId,
                                                    ContinuationsDisposer disposer) {
         char[] result = new char[bytes.length * 2];
         WebContinuation wk;
         WebContinuationsHolder continuationsHolder = lookupWebContinuationsHolder(true);
         while (true) {
             random.nextBytes(bytes);

             for (int i = 0; i < CONTINUATION_ID_LENGTH; i++) {
                 byte ch = bytes[i];
                 result[2 * i] = Character.forDigit(Math.abs(ch >> 4), 16);
                 result[2 * i + 1] = Character.forDigit(Math.abs(ch & 0x0f), 16);
             }

             final String id = new String(result);
             synchronized (continuationsHolder.holder) {
                 if (!continuationsHolder.contains(id)) {
                     if (this.bindContinuationsToSession) {
                         wk = new HolderAwareWebContinuation(id, kont, parent,
                                                             ttl, interpreterId, disposer,
                                                             continuationsHolder);
                     } else {
                         wk = new WebContinuation(id, kont, parent, ttl,
                                                  interpreterId, disposer);
                     }
                     continuationsHolder.addContinuation(wk);
                     synchronized (continuationsCount) {
                         continuationsCounter++;
                         continuationsCount.setValue(continuationsCounter);
                     }
                     break;
                 }
             }
         }

         continuationsCreated.increment();
         return wk;
     }

     public void invalidateWebContinuation(WebContinuation wk) {
         WebContinuationsHolder continuationsHolder = lookupWebContinuationsHolder(false);
         if (!continuationsHolder.contains(wk)) {
             //TODO this looks like a security breach - should we throw?
             return;
         }
         _detach(wk);
         _invalidate(continuationsHolder, wk);
     }

     private void _invalidate(WebContinuationsHolder continuationsHolder, WebContinuation wk) {
         if (getLogger().isDebugEnabled()) {
             getLogger().debug("WK: Manual expire of continuation " + wk.getId());
         }
         disposeContinuation(continuationsHolder, wk);
         synchronized (this.expirations) {
             expirations.remove(wk);
             expirationsSize.setValue(expirations.size());
         }

         // Invalidate all the children continuations as well
         List children = wk.getChildren();
         int size = children.size();
         for (int i = 0; i < size; i++) {
             _invalidate(continuationsHolder, (WebContinuation) children.get(i));
         }
     }

     /**
      * Detach this continuation from parent. This method removes
      * continuation from parent's children collection, if it has parent.
      * @param wk Continuation to detach from parent.
      */
     private void _detach(WebContinuation wk) {
         WebContinuation parent = wk.getParentContinuation();
         if (parent != null) {
             wk.detachFromParent();
         }
     }

     /**
      * Makes the continuation inaccessible for lookup, and triggers possible needed
      * cleanup code through the ContinuationsDisposer interface.
      * @param continuationsHolder
      *
      * @param wk the continuation to dispose.
      */
     protected void disposeContinuation(WebContinuationsHolder continuationsHolder, WebContinuation wk) {
         continuationsHolder.removeContinuation(wk);
         synchronized( continuationsCount ) {
             continuationsCounter--;
             continuationsCount.setValue(continuationsCounter);
         }
         wk.dispose();
         continuationsInvalidated.increment();
     }

     /**
      * Removes an expired leaf <code>WebContinuation</code> node
      * from its continuation tree, and recursively removes its
      * parent(s) if it they have expired and have no (other) children.
      * @param continuationsHolder
      *
      * @param wk <code>WebContinuation</code> node
      */
     protected void removeContinuation(WebContinuationsHolder continuationsHolder, WebContinuation wk) {
         if (wk.getChildren().size() != 0) {
             return;
         }

         // remove access to this continuation
         disposeContinuation(continuationsHolder, wk);
         _detach(wk);

         if (getLogger().isDebugEnabled()) {
             getLogger().debug("WK: Deleted continuation: " + wk.getId());
         }

         // now check if parent needs to be removed.
         WebContinuation parent = wk.getParentContinuation();
         if (null != parent && parent.hasExpired()) {
             //parent must have the same continuations holder, lookup not needed
             removeContinuation(continuationsHolder, parent);
         }
     }

     /**
      * Remove all continuations which have already expired.
      */
     protected void expireContinuations() {
         long now = 0;
         if (getLogger().isDebugEnabled()) {
             now = System.currentTimeMillis();

             /* Continuations before clean up: */
             displayAllContinuations();
             displayExpireSet();
         }

         // Clean up expired continuations
         int count = 0;
         FilterIterator expirationIterator = new FilterIterator();
         Predicate expirationPredicate = new ExpirationPredicate();
         expirationIterator.setPredicate(expirationPredicate);
         synchronized (this.expirations) {
             expirationIterator.setIterator(this.expirations.iterator());
             while (expirationIterator.hasNext()) {
                 WebContinuation wk = (WebContinuation) expirationIterator.next();
                 expirationIterator.remove();
                 WebContinuationsHolder continuationsHolder;
                 if (wk instanceof HolderAwareWebContinuation) {
                     continuationsHolder = ((HolderAwareWebContinuation) wk).getContinuationsHolder();
                 } else {
                     continuationsHolder = this.continuationsHolder;
                 }
                 removeContinuation(continuationsHolder, wk);
                 count++;
             }
             expirationsSize.setValue(expirations.size());
         }

         if (getLogger().isDebugEnabled()) {
             getLogger().debug("WK Cleaned up " + count + " continuations in " +
                               (System.currentTimeMillis() - now) + " ms");
         }
     }

     /**
      * Method used by WebContinuationsHolder to notify the continuations manager
      * about session invalidation. Invalidates all continuations held by passed
      * continuationsHolder.
      */
     protected void invalidateContinuations(WebContinuationsHolder continuationsHolder) {
         // It's not possible to just iterate over continuationsHolder.holder since _invalidate(..)
         // calls remove(..) on the map leading to ConcurrentModification at the end.
         WebContinuation[] continuations;
         synchronized (continuationsHolder.holder) {
             continuations = new WebContinuation[continuationsHolder.holder.size()];
             continuations = (WebContinuation[]) continuationsHolder.holder.values().toArray(continuations);
         }
         for (int i = 0; i < continuations.length; i++) {
             _detach(continuations[i]);
             _invalidate(continuationsHolder, continuations[i]);
         }
     }

     /**
      * Lookup a proper web continuations holder.
      * @param createNew
      *            should the manager create a continuations holder in session
      *            when none found?
      */
     public WebContinuationsHolder lookupWebContinuationsHolder(boolean createNew) {
         //there is only one holder if continuations are not bound to session
         if (!this.bindContinuationsToSession)
             return this.continuationsHolder;

         //if continuations bound to session lookup a proper holder in the session
         Map objectModel = ContextHelper.getObjectModel(this.context);
         Request request = ObjectModelHelper.getRequest(objectModel);

         if (!createNew && request.getSession(false) == null)
             return null;

         Session session = request.getSession(true);
         WebContinuationsHolder holder =
             (WebContinuationsHolder) session.getAttribute(
                     WebContinuationsHolder.CONTINUATIONS_HOLDER);
         if (!createNew)
             return holder;

         if (holder != null)
             return holder;

         holder = new WebContinuationsHolder();
         session.setAttribute(WebContinuationsHolder.CONTINUATIONS_HOLDER, holder);
         return holder;
     }

     public Set getForest() {
         Set rootWebContinuations = new HashSet();
         // identify the root continuations, once done no more need to lock
         synchronized (this.expirations) {
             for (Iterator iter = this.expirations.iterator(); iter.hasNext();) {
                 WebContinuation webContinuation = (WebContinuation) iter.next();
                 while (webContinuation.getParentContinuation() != null) {
                     webContinuation = webContinuation.getParentContinuation();
                 }
                 rootWebContinuations.add(webContinuation);
             }
         }

         Set clonedRootWebContinuations = new HashSet();
         for (Iterator iter = rootWebContinuations.iterator(); iter.hasNext();) {
             WebContinuation rootContinuation = (WebContinuation) iter.next();
             clonedRootWebContinuations.add(rootContinuation.clone());
         }
         return clonedRootWebContinuations;
     }

     /**
      * Get a list of all web continuations (data only)
      *
      * @deprecated
      */
     public List getWebContinuationsDataBeanList() {
         if (Deprecation.logger.isWarnEnabled()) {
             Deprecation.logger.warn("ContinuationsManager.getWebContinuationsDataBeanList()"
                     + " is deprecated and should be replaced with getForest().");
         }
         List beanList = new ArrayList();
         for (Iterator it = getForest().iterator(); it.hasNext();) {
             beanList.add(new WebContinuationDataBean((WebContinuation) it.next()));
         }
         return beanList;
     }

     /**
      * Dump to Log file the current contents of
      * the expirations <code>SortedSet</code>
      */
     protected void displayExpireSet() {
         StringBuffer wkSet = new StringBuffer("\nWK; Expire set size: ");

         synchronized (this.expirations) {
             wkSet.append(this.expirations.size());
             for (Iterator i = this.expirations.iterator(); i.hasNext();) {
                 final WebContinuation wk = (WebContinuation) i.next();
                 wkSet.append("\nWK: ").append(wk.getId()).append(" ExpireTime [");
                 if (wk.hasExpired()) {
                     wkSet.append("Expired");
                 } else {
                     wkSet.append(wk.getLastAccessTime() + wk.getTimeToLive());
                 }
                 wkSet.append("]");
             }
         }
         getLogger().debug(wkSet.toString());
     }

     /**
      * Dump to Log file all <code>WebContinuation</code>s
      * in the system.
      *
      * This method will be changed to be an internal method solely for debugging
      * purposes just like {@link #displayExpireSet()}.
      */
     public void displayAllContinuations() {
         if (getLogger().isDebugEnabled()) {
             Set forest = getForest();
             getLogger().debug("WK: Forest size: " + forest.size());
             for (Iterator iter = forest.iterator(); iter.hasNext();) {
                 getLogger().debug(iter.next().toString());
             }
         }
     }

     /**
      * A holder for WebContinuations. When bound to session notifies the
      * continuations manager of session invalidation.
      *
      * For thread-safe access you have to synchronize on the Map {@link #holder}!
      */
     protected class WebContinuationsHolder implements HttpSessionBindingListener {

         private final static String CONTINUATIONS_HOLDER = "o.a.c.c.f.SCMI.WebContinuationsHolder";

         private Map holder = Collections.synchronizedMap(new HashMap());

         public WebContinuation get(Object id) {
             return (WebContinuation) this.holder.get(id);
         }

         public void addContinuation(WebContinuation wk) {
             this.holder.put(wk.getId(), wk);
         }

         public void removeContinuation(WebContinuation wk) {
             this.holder.remove(wk.getId());
         }

         public boolean contains(String continuationId) {
             return this.holder.containsKey(continuationId);
         }

         public boolean contains(WebContinuation wk) {
             return contains(wk.getId());
         }

         public void valueBound(HttpSessionBindingEvent event) {
         }

         public void valueUnbound(HttpSessionBindingEvent event) {
             invalidateContinuations(this);
         }

     }

     /**
      * WebContinuation extension that holds also the information about the
      * holder. This information is needed to cleanup a proper holder after
      * continuation's expiration time.
      */
     protected static class HolderAwareWebContinuation extends WebContinuation {

         private WebContinuationsHolder continuationsHolder;

         public HolderAwareWebContinuation(String id,
                                           Object continuation,
                                           WebContinuation parentContinuation,
                                           int timeToLive,
                                           String interpreterId,
                                           ContinuationsDisposer disposer,
                                           WebContinuationsHolder continuationsHolder) {
             super(id, continuation, parentContinuation, timeToLive, interpreterId, disposer);
             this.continuationsHolder = continuationsHolder;
         }

         public WebContinuationsHolder getContinuationsHolder() {
             return continuationsHolder;
         }

     }

     protected static class ExpirationPredicate implements Predicate {

         public boolean evaluate(final Object obj) {
             return ((WebContinuation)obj).hasExpired();
         }

     }

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

	import java.security.SecureRandom;
	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;
	import java.util.SortedSet;
	import java.util.TreeSet;

	import javax.servlet.http.HttpSessionBindingEvent;
	import javax.servlet.http.HttpSessionBindingListener;

	import org.apache.avalon.framework.component.Component;
	import org.apache.avalon.framework.configuration.Configurable;
	import org.apache.avalon.framework.configuration.Configuration;
	import org.apache.avalon.framework.context.Context;
	import org.apache.avalon.framework.context.ContextException;
	import org.apache.avalon.framework.context.Contextualizable;
	import org.apache.avalon.framework.logger.AbstractLogEnabled;
	import org.apache.avalon.framework.service.ServiceException;
	import org.apache.avalon.framework.service.ServiceManager;
	import org.apache.avalon.framework.service.Serviceable;
	import org.apache.avalon.framework.thread.ThreadSafe;

	import org.apache.cocoon.components.ContextHelper;
	import org.apache.cocoon.components.thread.RunnableManager;
	import org.apache.cocoon.environment.ObjectModelHelper;
	import org.apache.cocoon.environment.Request;
	import org.apache.cocoon.environment.Session;
	import org.apache.cocoon.util.Deprecation;

	import org.apache.commons.collections.Predicate;
	import org.apache.commons.collections.iterators.FilterIterator;

	import org.apache.excalibur.instrument.CounterInstrument;
	import org.apache.excalibur.instrument.Instrument;
	import org.apache.excalibur.instrument.Instrumentable;
	import org.apache.excalibur.instrument.ValueInstrument;

	/**
	* The default implementation of {@link ContinuationsManager}. <br/>There are
	* two modes of work: <br/>
	* <ul>
	* <li><b>standard mode </b>- continuations are stored in single holder. No
	* security is applied to continuation lookup. Anyone can invoke a continuation
	* only knowing the ID. Set "session-bound-continuations" configuration option
	* to false to activate this mode.</li>
	* <li><b>secure mode </b>- each session has it's own continuations holder. A
	* continuation is only valid for the same session it was created for. Session
	* invalidation causes all bound continuations to be invalidated as well. Use
	* this setting for web applications. Set "session-bound-continuations"
	* configuration option to true to activate this mode.</li>
	* </ul>
	*
	* @author <a href="mailto:ovidiu@cup.hp.com">Ovidiu Predescu </a>
	* @author <a href="mailto:Michael.Melhem@managesoft.com">Michael Melhem </a>
	* @since March 19, 2002
	* @see ContinuationsManager
	* @version CVS $Id$
	*/
	public class ContinuationsManagerImpl
	extends AbstractLogEnabled
	implements ContinuationsManager, Component, Configurable,
	ThreadSafe, Instrumentable, Serviceable, Contextualizable {

	private static final int CONTINUATION_ID_LENGTH = 20;

	/**
	* Random number generator used to create continuation ID
	*/
	protected SecureRandom random;
	protected final byte[] bytes = new byte[CONTINUATION_ID_LENGTH];

	/**
	* Sorted set of <code>WebContinuation</code> instances, based on
	* their expiration time. This is used by the background thread to
	* invalidate continuations.
	*/
	protected final SortedSet expirations = Collections.synchronizedSortedSet(new TreeSet());

	protected ServiceManager serviceManager;
	protected Context context;

	/**
	* How long does a continuation exist in memory since the last
	* access? The time is in milliseconds, and the default is 1 hour.
	*/
	protected int defaultTimeToLive;
	protected boolean isContinuationSharingBugCompatible;
	protected boolean bindContinuationsToSession;

	/**
	* Main continuations holder. Used unless continuations are stored in user
	* session.
	*/
	protected WebContinuationsHolder continuationsHolder;

	// Instrumentation
	protected String instrumentableName;
	protected ValueInstrument continuationsCount;
	protected int continuationsCounter;
	protected ValueInstrument expirationsSize;
	protected CounterInstrument continuationsCreated;
	protected CounterInstrument continuationsInvalidated;

	public ContinuationsManagerImpl() throws Exception {
	try {
	random = SecureRandom.getInstance("SHA1PRNG");
	} catch(java.security.NoSuchAlgorithmException nsae) {
	// Maybe we are on IBM's SDK
	random = SecureRandom.getInstance("IBMSecureRandom");
	}
	random.setSeed(System.currentTimeMillis());

	continuationsCount = new ValueInstrument("count");
	continuationsCounter = 0;
	expirationsSize = new ValueInstrument("expirations-size");
	continuationsCreated = new CounterInstrument("creates");
	continuationsInvalidated = new CounterInstrument("invalidates");
	}

	public void contextualize(Context context) throws ContextException {
	this.context = context;
	}

	public void service(ServiceManager manager) throws ServiceException {
	this.serviceManager = manager;
	}

	public void configure(Configuration config) {
	this.defaultTimeToLive = config.getAttributeAsInteger("time-to-live", (3600 * 1000));
	this.isContinuationSharingBugCompatible = config.getAttributeAsBoolean("continuation-sharing-bug-compatible", false);
	this.bindContinuationsToSession = config.getAttributeAsBoolean( "session-bound-continuations", false );

	// create a global ContinuationsHolder if this the "session-bound-continuations" parameter is set to false
	if (!this.bindContinuationsToSession) {
	this.continuationsHolder = new WebContinuationsHolder();
	}

	// create a thread that invalidates the continuations
	final Configuration expireConf = config.getChild("expirations-check");
	final long initialDelay = expireConf.getChild("offset", true).getValueAsLong(180000);
	final long interval = expireConf.getChild("period", true).getValueAsLong(180000);
	try {
	final RunnableManager runnableManager = (RunnableManager)serviceManager.lookup(RunnableManager.ROLE);
	runnableManager.execute( new Runnable() {
	public void run()
	{
	expireContinuations();
	}
	}, initialDelay, interval);
	serviceManager.release(runnableManager);
	} catch (Exception e) {
	getLogger().warn("Could not enqueue continuations expiration task. " +
	"Continuations will not automatically expire.", e);
	}
	}

	public void setInstrumentableName(String instrumentableName) {
	this.instrumentableName = instrumentableName;
	}

	public String getInstrumentableName() {
	return instrumentableName;
	}

	public Instrument[] getInstruments() {
	return new Instrument[]{
	continuationsCount,
	continuationsCreated,
	continuationsInvalidated
	};
	}

	public Instrumentable[] getChildInstrumentables() {
	return Instrumentable.EMPTY_INSTRUMENTABLE_ARRAY;
	}

	public WebContinuation createWebContinuation(Object kont,
	WebContinuation parent,
	int timeToLive,
	String interpreterId,
	ContinuationsDisposer disposer) {
	int ttl = timeToLive == 0 ? defaultTimeToLive : timeToLive;

	WebContinuation wk = generateContinuation(kont, parent, ttl, interpreterId, disposer);

	synchronized (this.expirations) {
	if (parent != null) {
	expirations.remove(parent);
	}
	expirations.add(wk);
	expirationsSize.setValue(expirations.size());
	}

	if (getLogger().isDebugEnabled()) {
	getLogger().debug("WK: Created continuation " + wk.getId());
	}

	return wk;
	}

	public WebContinuation lookupWebContinuation(String id, String interpreterId) {
	WebContinuationsHolder continuationsHolder = lookupWebContinuationsHolder(false);
	if (continuationsHolder == null) {
	return null;
	}

	WebContinuation kont = continuationsHolder.get(id);
	if (kont == null) {
	return null;
	}

	if (kont.hasExpired()) {
	removeContinuation(continuationsHolder, kont);
	return null;
	}

	if (!kont.interpreterMatches(interpreterId)) {
	if (getLogger().isWarnEnabled()) {
	getLogger().warn("WK: Continuation (" + kont.getId()
	+ ") lookup for wrong interpreter. Bound to: "
	+ kont.getInterpreterId() + ", looked up for: "
	+ interpreterId);
	}

	if (!isContinuationSharingBugCompatible) {
	return null;
	}
	}

	// COCOON-2109: Sorting in the TreeSet happens on insert. So in order to re-sort the
	// continuation has to be re-added.
	synchronized (this.expirations) {
	this.expirations.remove(kont);
	kont.updateLastAccessTime();
	this.expirations.add(kont);
	}

	return kont;
	}

	/**
	* Create <code>WebContinuation</code> and generate unique identifier
	* for it. The identifier is generated using a cryptographically strong
	* algorithm to prevent people to generate their own identifiers.
	*
	* @param kont an <code>Object</code> value representing continuation
	* @param parent value representing parent <code>WebContinuation</code>
	* @param ttl <code>WebContinuation</code> time to live
	* @param interpreterId id of interpreter invoking continuation creation
	* @param disposer <code>ContinuationsDisposer</code> instance to use for
	* cleanup of the continuation.
	* @return the generated <code>WebContinuation</code> with unique identifier
	*/
	protected WebContinuation generateContinuation(Object kont,
	WebContinuation parent,
	int ttl,
	String interpreterId,
	ContinuationsDisposer disposer) {
	char[] result = new char[bytes.length * 2];
	WebContinuation wk;
	WebContinuationsHolder continuationsHolder = lookupWebContinuationsHolder(true);
	while (true) {
	random.nextBytes(bytes);

	for (int i = 0; i < CONTINUATION_ID_LENGTH; i++) {
	byte ch = bytes[i];
	result[2 * i] = Character.forDigit(Math.abs(ch >> 4), 16);
	result[2 * i + 1] = Character.forDigit(Math.abs(ch & 0x0f), 16);
	}

	final String id = new String(result);
	synchronized (continuationsHolder.holder) {
	if (!continuationsHolder.contains(id)) {
	if (this.bindContinuationsToSession) {
	wk = new HolderAwareWebContinuation(id, kont, parent,
	ttl, interpreterId, disposer,
	continuationsHolder);
	} else {
	wk = new WebContinuation(id, kont, parent, ttl,
	interpreterId, disposer);
	}
	continuationsHolder.addContinuation(wk);
	synchronized (continuationsCount) {
	continuationsCounter++;
	continuationsCount.setValue(continuationsCounter);
	}
	break;
	}
	}
	}

	continuationsCreated.increment();
	return wk;
	}

	public void invalidateWebContinuation(WebContinuation wk) {
	WebContinuationsHolder continuationsHolder = lookupWebContinuationsHolder(false);
	if (!continuationsHolder.contains(wk)) {
	//TODO this looks like a security breach - should we throw?
	return;
	}
	_detach(wk);
	_invalidate(continuationsHolder, wk);
	}

	private void _invalidate(WebContinuationsHolder continuationsHolder, WebContinuation wk) {
	if (getLogger().isDebugEnabled()) {
	getLogger().debug("WK: Manual expire of continuation " + wk.getId());
	}
	disposeContinuation(continuationsHolder, wk);
	synchronized (this.expirations) {
	expirations.remove(wk);
	expirationsSize.setValue(expirations.size());
	}

	// Invalidate all the children continuations as well
	List children = wk.getChildren();
	int size = children.size();
	for (int i = 0; i < size; i++) {
	_invalidate(continuationsHolder, (WebContinuation) children.get(i));
	}
	}

	/**
	* Detach this continuation from parent. This method removes
	* continuation from parent's children collection, if it has parent.
	* @param wk Continuation to detach from parent.
	*/
	private void _detach(WebContinuation wk) {
	WebContinuation parent = wk.getParentContinuation();
	if (parent != null) {
	wk.detachFromParent();
	}
	}

	/**
	* Makes the continuation inaccessible for lookup, and triggers possible needed
	* cleanup code through the ContinuationsDisposer interface.
	* @param continuationsHolder
	*
	* @param wk the continuation to dispose.
	*/
	protected void disposeContinuation(WebContinuationsHolder continuationsHolder, WebContinuation wk) {
	continuationsHolder.removeContinuation(wk);
	synchronized( continuationsCount ) {
	continuationsCounter--;
	continuationsCount.setValue(continuationsCounter);
	}
	wk.dispose();
	continuationsInvalidated.increment();
	}

	/**
	* Removes an expired leaf <code>WebContinuation</code> node
	* from its continuation tree, and recursively removes its
	* parent(s) if it they have expired and have no (other) children.
	* @param continuationsHolder
	*
	* @param wk <code>WebContinuation</code> node
	*/
	protected void removeContinuation(WebContinuationsHolder continuationsHolder, WebContinuation wk) {
	if (wk.getChildren().size() != 0) {
	return;
	}

	// remove access to this continuation
	disposeContinuation(continuationsHolder, wk);
	_detach(wk);

	if (getLogger().isDebugEnabled()) {
	getLogger().debug("WK: Deleted continuation: " + wk.getId());
	}

	// now check if parent needs to be removed.
	WebContinuation parent = wk.getParentContinuation();
	if (null != parent && parent.hasExpired()) {
	//parent must have the same continuations holder, lookup not needed
	removeContinuation(continuationsHolder, parent);
	}
	}

	/**
	* Remove all continuations which have already expired.
	*/
	protected void expireContinuations() {
	long now = 0;
	if (getLogger().isDebugEnabled()) {
	now = System.currentTimeMillis();

	/* Continuations before clean up: */
	displayAllContinuations();
	displayExpireSet();
	}

	// Clean up expired continuations
	int count = 0;
	FilterIterator expirationIterator = new FilterIterator();
	Predicate expirationPredicate = new ExpirationPredicate();
	expirationIterator.setPredicate(expirationPredicate);
	synchronized (this.expirations) {
	expirationIterator.setIterator(this.expirations.iterator());
	while (expirationIterator.hasNext()) {
	WebContinuation wk = (WebContinuation) expirationIterator.next();
	expirationIterator.remove();
	WebContinuationsHolder continuationsHolder;
	if (wk instanceof HolderAwareWebContinuation) {
	continuationsHolder = ((HolderAwareWebContinuation) wk).getContinuationsHolder();
	} else {
	continuationsHolder = this.continuationsHolder;
	}
	removeContinuation(continuationsHolder, wk);
	count++;
	}
	expirationsSize.setValue(expirations.size());
	}

	if (getLogger().isDebugEnabled()) {
	getLogger().debug("WK Cleaned up " + count + " continuations in " +
	(System.currentTimeMillis() - now) + " ms");
	}
	}

	/**
	* Method used by WebContinuationsHolder to notify the continuations manager
	* about session invalidation. Invalidates all continuations held by passed
	* continuationsHolder.
	*/
	protected void invalidateContinuations(WebContinuationsHolder continuationsHolder) {
	// It's not possible to just iterate over continuationsHolder.holder since _invalidate(..)
	// calls remove(..) on the map leading to ConcurrentModification at the end.
	WebContinuation[] continuations;
	synchronized (continuationsHolder.holder) {
	continuations = new WebContinuation[continuationsHolder.holder.size()];
	continuations = (WebContinuation[]) continuationsHolder.holder.values().toArray(continuations);
	}
	for (int i = 0; i < continuations.length; i++) {
	_detach(continuations[i]);
	_invalidate(continuationsHolder, continuations[i]);
	}
	}

	/**
	* Lookup a proper web continuations holder.
	* @param createNew
	* should the manager create a continuations holder in session
	* when none found?
	*/
	public WebContinuationsHolder lookupWebContinuationsHolder(boolean createNew) {
	//there is only one holder if continuations are not bound to session
	if (!this.bindContinuationsToSession)
	return this.continuationsHolder;

	//if continuations bound to session lookup a proper holder in the session
	Map objectModel = ContextHelper.getObjectModel(this.context);
	Request request = ObjectModelHelper.getRequest(objectModel);

	if (!createNew && request.getSession(false) == null)
	return null;

	Session session = request.getSession(true);
	WebContinuationsHolder holder =
	(WebContinuationsHolder) session.getAttribute(
	WebContinuationsHolder.CONTINUATIONS_HOLDER);
	if (!createNew)
	return holder;

	if (holder != null)
	return holder;

	holder = new WebContinuationsHolder();
	session.setAttribute(WebContinuationsHolder.CONTINUATIONS_HOLDER, holder);
	return holder;
	}

	public Set getForest() {
	Set rootWebContinuations = new HashSet();
	// identify the root continuations, once done no more need to lock
	synchronized (this.expirations) {
	for (Iterator iter = this.expirations.iterator(); iter.hasNext();) {
	WebContinuation webContinuation = (WebContinuation) iter.next();
	while (webContinuation.getParentContinuation() != null) {
	webContinuation = webContinuation.getParentContinuation();
	}
	rootWebContinuations.add(webContinuation);
	}
	}

	Set clonedRootWebContinuations = new HashSet();
	for (Iterator iter = rootWebContinuations.iterator(); iter.hasNext();) {
	WebContinuation rootContinuation = (WebContinuation) iter.next();
	clonedRootWebContinuations.add(rootContinuation.clone());
	}
	return clonedRootWebContinuations;
	}

	/**
	* Get a list of all web continuations (data only)
	*
	* @deprecated
	*/
	public List getWebContinuationsDataBeanList() {
	if (Deprecation.logger.isWarnEnabled()) {
	Deprecation.logger.warn("ContinuationsManager.getWebContinuationsDataBeanList()"
	+ " is deprecated and should be replaced with getForest().");
	}
	List beanList = new ArrayList();
	for (Iterator it = getForest().iterator(); it.hasNext();) {
	beanList.add(new WebContinuationDataBean((WebContinuation) it.next()));
	}
	return beanList;
	}

	/**
	* Dump to Log file the current contents of
	* the expirations <code>SortedSet</code>
	*/
	protected void displayExpireSet() {
	StringBuffer wkSet = new StringBuffer("\nWK; Expire set size: ");

	synchronized (this.expirations) {
	wkSet.append(this.expirations.size());
	for (Iterator i = this.expirations.iterator(); i.hasNext();) {
	final WebContinuation wk = (WebContinuation) i.next();
	wkSet.append("\nWK: ").append(wk.getId()).append(" ExpireTime [");
	if (wk.hasExpired()) {
	wkSet.append("Expired");
	} else {
	wkSet.append(wk.getLastAccessTime() + wk.getTimeToLive());
	}
	wkSet.append("]");
	}
	}
	getLogger().debug(wkSet.toString());
	}

	/**
	* Dump to Log file all <code>WebContinuation</code>s
	* in the system.
	*
	* This method will be changed to be an internal method solely for debugging
	* purposes just like {@link #displayExpireSet()}.
	*/
	public void displayAllContinuations() {
	if (getLogger().isDebugEnabled()) {
	Set forest = getForest();
	getLogger().debug("WK: Forest size: " + forest.size());
	for (Iterator iter = forest.iterator(); iter.hasNext();) {
	getLogger().debug(iter.next().toString());
	}
	}
	}

	/**
	* A holder for WebContinuations. When bound to session notifies the
	* continuations manager of session invalidation.
	*
	* For thread-safe access you have to synchronize on the Map {@link #holder}!
	*/
	protected class WebContinuationsHolder implements HttpSessionBindingListener {

	private final static String CONTINUATIONS_HOLDER = "o.a.c.c.f.SCMI.WebContinuationsHolder";

	private Map holder = Collections.synchronizedMap(new HashMap());

	public WebContinuation get(Object id) {
	return (WebContinuation) this.holder.get(id);
	}

	public void addContinuation(WebContinuation wk) {
	this.holder.put(wk.getId(), wk);
	}

	public void removeContinuation(WebContinuation wk) {
	this.holder.remove(wk.getId());
	}

	public boolean contains(String continuationId) {
	return this.holder.containsKey(continuationId);
	}

	public boolean contains(WebContinuation wk) {
	return contains(wk.getId());
	}

	public void valueBound(HttpSessionBindingEvent event) {
	}

	public void valueUnbound(HttpSessionBindingEvent event) {
	invalidateContinuations(this);
	}

	}

	/**
	* WebContinuation extension that holds also the information about the
	* holder. This information is needed to cleanup a proper holder after
	* continuation's expiration time.
	*/
	protected static class HolderAwareWebContinuation extends WebContinuation {

	private WebContinuationsHolder continuationsHolder;

	public HolderAwareWebContinuation(String id,
	Object continuation,
	WebContinuation parentContinuation,
	int timeToLive,
	String interpreterId,
	ContinuationsDisposer disposer,
	WebContinuationsHolder continuationsHolder) {
	super(id, continuation, parentContinuation, timeToLive, interpreterId, disposer);
	this.continuationsHolder = continuationsHolder;
	}

	public WebContinuationsHolder getContinuationsHolder() {
	return continuationsHolder;
	}

	}

	protected static class ExpirationPredicate implements Predicate {

	public boolean evaluate(final Object obj) {
	return ((WebContinuation)obj).hasExpired();
	}

	}

	}