* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

*

* Copyright (c) 1997-2012 Oracle and/or its affiliates. All rights reserved.

*

* The contents of this file are subject to the terms of either the GNU

* General Public License Version 2 only ("GPL") or the Common Development

* and Distribution License("CDDL") (collectively, the "License").  You

* may not use this file except in compliance with the License.  You can

* obtain a copy of the License at

* https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html

* or packager/legal/LICENSE.txt.  See the License for the specific

* language governing permissions and limitations under the License.

*

* When distributing the software, include this License Header Notice in each

* file and include the License file at packager/legal/LICENSE.txt.

*

* GPL Classpath Exception:

* Oracle designates this particular file as subject to the "Classpath"

* exception as provided by Oracle in the GPL Version 2 section of the License

* file that accompanied this code.

*

* Modifications:

* If applicable, add the following below the License Header, with the fields

* enclosed by brackets [] replaced by your own identifying information:

* "Portions Copyright [year] [name of copyright owner]"

*

* Contributor(s):

* If you wish your version of this file to be governed by only the CDDL or

* only the GPL Version 2, indicate your decision by adding "[Contributor]

* elects to include this software in this distribution under the [CDDL or GPL

* Version 2] license."  If you don't indicate a single choice of license, a

* recipient has the option to distribute your version of this file under

* either the CDDL, the GPL Version 2 or to extend the choice of license to

* its licensees as provided above.  However, if you add GPL Version 2 code

* and therefore, elected the GPL Version 2 license, then the option applies

* only if the new code is made subject to such option by the copyright

* holder.

*/

* This class provides container functionality specific to stateful

* SessionBeans.

* At deployment time, one instance of the StatefulSessionContainer is created

* for each stateful SessionBean type (i.e. deployment descriptor) in a JAR.

* <p/>

* The 5 states of a Stateful EJB (an EJB can be in only 1 state at a time):

* 1. PASSIVE : has been passivated

* 2. READY : ready for invocations, no transaction in progress

* 3. INVOKING : processing an invocation

* 4. INCOMPLETE_TX : ready for invocations, transaction in progress

* 5. DESTROYED : does not exist

*

* @author Mahesh Kannan

*/

        extends BaseContainer

        implements CacheListener, SFSBContainerCallback,

        SFSBContainerInitialization {

        //StatefulSessionBeanStatsProvider, SFSBContainerInitialization {

    private static final Logger _logger =

            LogDomains.getLogger(StatefulSessionContainer.class, LogDomains.EJB_LOGGER);

    // We do not want too many ORB task for passivation

    public static final int MIN_PASSIVATION_BATCH_COUNT = 8;

    private final static long CONCURRENCY_NOT_ALLOWED = 0;

    private final static long BLOCK_INDEFINITELY = -1;

    private long instanceCount = 1;

    private ArrayList passivationCandidates = new ArrayList();

    private Object asyncTaskSemaphore = new Object();

    private int asyncTaskCount = 0;

    private int asyncCummTaskCount = 0;

    private int passivationBatchCount

            = MIN_PASSIVATION_BATCH_COUNT;

    private int containerTrimCount = 0;

    private LruSessionCache sessionBeanCache;

    private BackingStore<Serializable, SimpleMetadata> backingStore;

    private SFSBUUIDUtil uuidGenerator;

    private ArrayList scheduledTimerTasks = new ArrayList();

    private int statMethodReadyCount = 0;

    private Level TRACE_LEVEL = Level.FINE;

    private String ejbName;

    private CheckpointPolicy checkpointPolicy;

    private int removalGracePeriodInSeconds;

    private InvocationInfo postConstructInvInfo;

    private InvocationInfo preDestroyInvInfo;

    private InvocationInfo postActivateInvInfo;

    private InvocationInfo prePassivateInvInfo;

    private StatefulSessionStoreMonitor sfsbStoreMonitor;

    private final String traceInfoPrefix;

    private SFSBVersionManager sfsbVersionManager;

    private Method afterBeginMethod;

    private Method beforeCompletionMethod;

    private Method afterCompletionMethod;

    /*

     * Cache for keeping ref count for shared extended entity manager.

     * The key in this map is the physical entity manager

     */

    private static Map<EntityManager, EEMRefInfo> extendedEMReferenceCountMap

            = new HashMap<EntityManager, EEMRefInfo>();

    private static Map<EEMRefInfoKey, EntityManager> eemKey2EEMMap

            = new HashMap<EEMRefInfoKey, EntityManager>();

    /**

     * This constructor is called from the JarManager when a Jar is deployed.

     *

     * @throws Exception on error

     */

    public StatefulSessionContainer(EjbDescriptor desc,

                                    ClassLoader loader)

            throws Exception {

        this(ContainerType.STATEFUL, desc, loader);

    }

    public StatefulSessionContainer(ContainerType conType, EjbDescriptor desc,

                                    ClassLoader loader)

            throws Exception {

        super(conType, desc, loader);

        super.createCallFlowAgent(ComponentType.SFSB);

        this.ejbName = desc.getName();

        this.traceInfoPrefix = "sfsb-" + ejbName + ": ";

        postConstructInvInfo = getLifecycleCallbackInvInfo(ejbDescriptor.getPostConstructDescriptors());

        preDestroyInvInfo = getLifecycleCallbackInvInfo(ejbDescriptor.getPreDestroyDescriptors());

        EjbSessionDescriptor sfulDesc = (EjbSessionDescriptor) ejbDescriptor;

        postActivateInvInfo = getLifecycleCallbackInvInfo(sfulDesc.getPostActivateDescriptors());

        prePassivateInvInfo = getLifecycleCallbackInvInfo(sfulDesc.getPrePassivateDescriptors());

    }

    private InvocationInfo getLifecycleCallbackInvInfo(

            Set<LifecycleCallbackDescriptor> lifecycleCallbackDescriptors) throws Exception {

        InvocationInfo inv = new InvocationInfo();

        inv.ejbName = ejbDescriptor.getName();

        inv.methodIntf = MethodDescriptor.EJB_BEAN;

        inv.txAttr = getTxAttrForLifecycleCallback(lifecycleCallbackDescriptors,

                -1, Container.TX_NOT_SUPPORTED, Container.TX_REQUIRES_NEW);

        return inv;

    }

    protected void initializeHome()

            throws Exception {

        super.initializeHome();

      initSessionSyncMethods();

        loadCheckpointInfo();

        registerMonitorableComponents();

    }

    private void initSessionSyncMethods() throws Exception {

      if( SessionSynchronization.class.isAssignableFrom(ejbClass) ) {

          try {

            afterBeginMethod = ejbClass.getMethod("afterBegin", null);

            beforeCompletionMethod = ejbClass.getMethod("beforeCompletion", null);

            afterCompletionMethod = ejbClass.getMethod("afterCompletion", Boolean.TYPE);

          } catch(Exception e) {

            _logger.log(Level.WARNING, "[SFSBContainer] Exception while "

                    + " initializing SessionSynchronization methods ", e);

          }

      } else {

            EjbSessionDescriptor sessionDesc = (EjbSessionDescriptor) ejbDescriptor;

          MethodDescriptor afterBeginMethodDesc = sessionDesc.getAfterBeginMethod();

            if( afterBeginMethodDesc != null ) {

                afterBeginMethod = afterBeginMethodDesc.getDeclaredMethod(sessionDesc);

                processSessionSynchMethod(afterBeginMethod);

            }

          MethodDescriptor beforeCompletionMethodDesc = sessionDesc.getBeforeCompletionMethod();

            if( beforeCompletionMethodDesc != null ) {

                beforeCompletionMethod = beforeCompletionMethodDesc.getDeclaredMethod(sessionDesc);

                processSessionSynchMethod(beforeCompletionMethod);

            }

           

          MethodDescriptor afterCompletionMethodDesc = sessionDesc.getAfterCompletionMethod();

            if( afterCompletionMethodDesc != null ) {

                afterCompletionMethod = afterCompletionMethodDesc.getDeclaredMethod(sessionDesc);

                if( afterCompletionMethod == null ) {

                    afterCompletionMethod =

                        afterCompletionMethodDesc.getDeclaredMethod(sessionDesc, new Class[] { Boolean.TYPE });

                }

                processSessionSynchMethod(afterCompletionMethod);

            }

      }

    }

    private void processSessionSynchMethod(Method sessionSynchMethod)

        throws Exception {

        final Method methodAccessible = sessionSynchMethod;

        // SessionSynch method defined through annotation or ejb-jar.xml

        // can have any access modifier so make sure we have permission

        // to invoke it.

        java.security.AccessController.doPrivileged(

            new java.security.PrivilegedExceptionAction() {

                public java.lang.Object run() throws Exception {

                    if( !methodAccessible.isAccessible() ) {

                        methodAccessible.setAccessible(true);

                    }

                    return null;

                }

         });

     

    }

    // Called before invoking a bean with no Tx or with a new Tx.

    // Check if the bean is associated with an unfinished tx.

    protected void checkUnfinishedTx(Transaction prevTx, EjbInvocation inv) {

        try {

            if ( inv.invocationInfo.isBusinessMethod && prevTx != null &&