StatefulSessionContainer.java

/*
 * Copyright (c) 2021, 2023 Contributors to the Eclipse Foundation
 * Copyright (c) 1997, 2020 Oracle and/or its affiliates. All rights reserved.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0, which is available at
 * http://www.eclipse.org/legal/epl-2.0.
 *
 * This Source Code may also be made available under the following Secondary
 * Licenses when the conditions for such availability set forth in the
 * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
 * version 2 with the GNU Classpath Exception, which is available at
 * https://www.gnu.org/software/classpath/license.html.
 *
 * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 */

package com.sun.ejb.containers;

import com.sun.appserv.util.cache.CacheListener;
import com.sun.ejb.ComponentContext;
import com.sun.ejb.Container;
import com.sun.ejb.EJBUtils;
import com.sun.ejb.EjbInvocation;
import com.sun.ejb.InvocationInfo;
import com.sun.ejb.MethodLockInfo;
import com.sun.ejb.base.stats.HAStatefulSessionStoreMonitor;
import com.sun.ejb.base.stats.StatefulSessionStoreMonitor;
import com.sun.ejb.containers.EJBContextImpl.BeanState;
import com.sun.ejb.containers.util.cache.LruSessionCache;
import com.sun.ejb.monitoring.probes.EjbCacheProbeProvider;
import com.sun.ejb.monitoring.stats.EjbCacheStatsProvider;
import com.sun.ejb.monitoring.stats.EjbMonitoringStatsProvider;
import com.sun.ejb.monitoring.stats.EjbMonitoringUtils;
import com.sun.ejb.monitoring.stats.StatefulSessionBeanStatsProvider;
import com.sun.ejb.spi.container.SFSBContainerCallback;
import com.sun.ejb.spi.container.StatefulEJBContext;
import com.sun.ejb.spi.sfsb.util.SFSBUUIDUtil;
import com.sun.ejb.spi.sfsb.util.SFSBVersionManager;
import com.sun.enterprise.admin.monitor.callflow.ComponentType;
import com.sun.enterprise.container.common.impl.EntityManagerFactoryWrapper;
import com.sun.enterprise.container.common.impl.EntityManagerWrapper;
import com.sun.enterprise.container.common.impl.PhysicalEntityManagerWrapper;
import com.sun.enterprise.container.common.spi.util.IndirectlySerializable;
import com.sun.enterprise.container.common.spi.util.SerializableObjectFactory;
import com.sun.enterprise.deployment.EntityManagerReferenceDescriptor;
import com.sun.enterprise.deployment.LifecycleCallbackDescriptor;
import com.sun.enterprise.deployment.LifecycleCallbackDescriptor.CallbackType;
import com.sun.enterprise.deployment.MethodDescriptor;
import com.sun.enterprise.security.SecurityManager;
import com.sun.enterprise.transaction.api.JavaEETransaction;
import com.sun.enterprise.util.Utility;
import com.sun.enterprise.util.io.FileUtils;

import jakarta.ejb.ConcurrentAccessException;
import jakarta.ejb.ConcurrentAccessTimeoutException;
import jakarta.ejb.CreateException;
import jakarta.ejb.EJBException;
import jakarta.ejb.EJBHome;
import jakarta.ejb.EJBLocalHome;
import jakarta.ejb.EJBObject;
import jakarta.ejb.IllegalLoopbackException;
import jakarta.ejb.NoSuchObjectLocalException;
import jakarta.ejb.RemoveException;
import jakarta.ejb.SessionBean;
import jakarta.ejb.SessionSynchronization;
import jakarta.persistence.EntityManager;
import jakarta.persistence.EntityManagerFactory;
import jakarta.persistence.PersistenceContextType;
import jakarta.persistence.SynchronizationType;
import jakarta.transaction.Status;
import jakarta.transaction.SystemException;
import jakarta.transaction.Transaction;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.NotSerializableException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.lang.reflect.InaccessibleObjectException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.security.PrivilegedExceptionAction;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.Timer;
import java.util.TimerTask;
import java.util.logging.Level;
import java.util.logging.Logger;

import org.glassfish.api.invocation.ComponentInvocation;
import org.glassfish.api.invocation.ComponentInvocation.ComponentInvocationType;
import org.glassfish.ejb.LogFacade;
import org.glassfish.ejb.deployment.descriptor.EjbDescriptor;
import org.glassfish.ejb.deployment.descriptor.EjbRemovalInfo;
import org.glassfish.ejb.deployment.descriptor.EjbSessionDescriptor;
import org.glassfish.ejb.deployment.descriptor.runtime.CheckpointAtEndOfMethodDescriptor;
import org.glassfish.ejb.deployment.descriptor.runtime.IASEjbExtraDescriptors;
import org.glassfish.flashlight.provider.ProbeProviderFactory;
import org.glassfish.ha.store.api.BackingStore;
import org.glassfish.ha.store.api.BackingStoreException;
import org.glassfish.ha.store.util.SimpleMetadata;
import org.glassfish.logging.annotation.LogMessageInfo;

import static com.sun.ejb.codegen.AsmSerializableBeanGenerator.getGeneratedSerializableClassName;
import static jakarta.persistence.SynchronizationType.SYNCHRONIZED;

/**
 * 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
 */
public final class StatefulSessionContainer
        extends BaseContainer
        implements CacheListener, SFSBContainerCallback {

    private static final Logger _logger  = LogFacade.getLogger();

    @LogMessageInfo(
        message = "[SFSBContainer] Exception while  initializing SessionSynchronization methods",
        level = "WARNING")
    private static final String EXCEPTION_WHILE_INITIALIZING_SESSION_SYNCHRONIZATION = "AS-EJB-00012";

    @LogMessageInfo(
        message = "[SFSBContainer] Exception while  loading checkpoint info",
        level = "WARNING")
    private static final String EXCEPTION_WHILE_LOADING_CHECKPOINT = "AS-EJB-00013";

    @LogMessageInfo(
        message = "Exception creating ejb object : [{0}]",
        level = "WARNING")
    private static final String CREATE_EJBOBJECT_EXCEPTION = "AS-EJB-00014";

    @LogMessageInfo(
        message = "Exception creating ejb local object [{0}]",
        level = "WARNING")
    private static final String CREATE_EJBLOCALOBJECT_EXCEPTION = "AS-EJB-00015";

    @LogMessageInfo(
        message = "Couldn't update timestamp for: [{0}]; Exception: [{1}]",
        level = "WARNING")
    private static final String COULDNT_UPDATE_TIMESTAMP_FOR_EXCEPTION = "AS-EJB-00016";

    @LogMessageInfo(
        message = "Cannot register bean for checkpointing",
        level = "WARNING")
    private static final String CANNOT_REGISTER_BEAN_FOR_CHECKPOINTING = "AS-EJB-00017";

    @LogMessageInfo(
        message = "Error  during checkpoint ([{0}]. Key: [{1}]) [{2}]",
        level = "WARNING")
    private static final String ERROR_DURING_CHECKPOINT_3PARAMs = "AS-EJB-00018";

    @LogMessageInfo(
        message = "sfsb checkpoint error. Name: [{0}]",
        level = "WARNING")
    private static final String SFSB_CHECKPOINT_ERROR_NAME = "AS-EJB-00019";

    @LogMessageInfo(
        message = "sfsb checkpoint error. Key: [{0}]",
        level = "WARNING")
    private static final String SFSB_CHECKPOINT_ERROR_KEY = "AS-EJB-00020";

    @LogMessageInfo(
        message = "Exception in afterCompletion : [{0}]",
        level = "INFO")
    private static final String AFTER_COMPLETION_EXCEPTION = "AS-EJB-00021";

    @LogMessageInfo(
        message = "1. passivateEJB() returning because containerState: [{0}]",
        level = "WARNING")
    private static final String PASSIVATE_EJB_RETURNING_BECAUSE_CONTAINER_STATE = "AS-EJB-00022";

    @LogMessageInfo(
        message = "Extended EM not serializable. Exception: [{0}]",
        level = "WARNING")
    private static final String EXTENDED_EM_NOT_SERIALIZABLE = "AS-EJB-00023";

    @LogMessageInfo(
        message = "Error during passivation: [{0}]; [{1}]",
        level = "WARNING")
    private static final String ERROR_DURING_PASSIVATION = "AS-EJB-00024";

    @LogMessageInfo(
        message = "Error during passivation of [{0}]",
        level = "WARNING")
    private static final String PASSIVATION_ERROR_1PARAM = "AS-EJB-00025";

    @LogMessageInfo(
        message = "sfsb passivation error. Key: [{0}]",
        level = "WARNING")
    private static final String SFSB_PASSIVATION_ERROR_1PARAM = "AS-EJB-00026";

    @LogMessageInfo(
        message = "Error during Stateful Session Bean activation for key [{0}]",
        level = "SEVERE",
        cause = "A problem occurred while the container was activating a stateful session bean.  " +
                "One possible cause is that the bean code threw a system exception from its ejbActivate method.",
        action = "Check the stack trace to see whether the exception was thrown from the ejbActivate method " +
                "and if so double-check the application code to determine what caused the exception.")
    private static final String SFSB_ACTIVATION_ERROR = "AS-EJB-00028";

    @LogMessageInfo(
        message = "[{0}]: Error during backingStore.shutdown()",
        level = "WARNING")
    private static final String ERROR_DURING_BACKING_STORE_SHUTDOWN = "AS-EJB-00029";

    @LogMessageInfo(
        message = "[{0}]: Error during  onShutdown()",
        level = "WARNING")
    private static final String ERROR_DURING_ON_SHUTDOWN = "AS-EJB-00030";

    @LogMessageInfo(
        message = "[{0}]: Error while  undeploying ctx. Key: [{1}]",
        level = "WARNING")
    private static final String ERROR_WHILE_UNDEPLOYING_CTX_KEY = "AS-EJB-00031";

    @LogMessageInfo(
        message = "Cannot add idle bean cleanup task",
        level = "WARNING")
    private static final String ADD_CLEANUP_TASK_ERROR = "AS-EJB-00032";

    @LogMessageInfo(
        message = "Got exception during removeExpiredSessions (but the reaper thread is still alive)",
        level = "WARNING")
    private static final String GOT_EXCEPTION_DURING_REMOVE_EXPIRED_SESSIONS = "AS-EJB-00033";

    @LogMessageInfo(
        message = "Error during checkpoint(, but session not destroyed)",
        level = "WARNING")
    private static final String ERROR_DURING_CHECKPOINT_SESSION_ALIVE = "AS-EJB-00034";

    @LogMessageInfo(
        message = "Error during checkpoint",
        level = "WARNING")
    private static final String ERROR_DURING_CHECKPOINT = "AS-EJB-00035";

    @LogMessageInfo(
        message = "Cache is shutting down, {0} stateful session beans will not be restored after restarting " +
                "since passivation is disabled",
        level = "INFO")
    private static final String SFSB_NOT_RESTORED_AFTER_RESTART = "AS-EJB-00050";

    @LogMessageInfo(
        message = "Exception in backingStore.size()",
        level   = "WARNING")
    private static final String ERROR_WHILE_BACKSTORE_SIZE_ACCESS = "AS-EJB-00063";

    // 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 final ArrayList passivationCandidates = new ArrayList();
    private final 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<Object> uuidGenerator;
    private final ArrayList scheduledTimerTasks = new ArrayList();

    private int statMethodReadyCount = 0;

    private final String ejbName;

    private boolean isHAEnabled;
    private int removalGracePeriodInSeconds;

    private final InvocationInfo postConstructInvInfo;
    private final InvocationInfo preDestroyInvInfo;
    private final InvocationInfo postActivateInvInfo;
    private final InvocationInfo prePassivateInvInfo;

    private StatefulSessionStoreMonitor sfsbStoreMonitor;

    private final String traceInfoPrefix;

    private SFSBVersionManager sfsbVersionManager;

    private Method afterBeginMethod;
    private Method beforeCompletionMethod;
    private Method afterCompletionMethod;
    private final boolean isPassivationCapable;

    /**
     * Cache for keeping ref count for shared extended entity manager.
     * The key in this map is the physical entity manager
     */
    private static final Map<EntityManager, EEMRefInfo> extendedEMReferenceCountMap = new HashMap<>();

    private static final Map<EEMRefInfoKey, EntityManager> eemKey2EEMMap = new HashMap<>();

    /**
     * This constructor is called from the JarManager when a Jar is deployed.
     *
     * @throws Exception on error
     */
    public StatefulSessionContainer(EjbDescriptor desc, ClassLoader loader, SecurityManager sm) throws Exception {
        this(ContainerType.STATEFUL, desc, loader, sm);
    }


    public StatefulSessionContainer(ContainerType conType, EjbDescriptor desc, ClassLoader loader, SecurityManager sm)
        throws Exception {
        super(conType, desc, loader, sm);
        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());

        isPassivationCapable = sfulDesc.isPassivationCapable();
    }


    @Override
    public boolean isPassivationCapable() {
        return isPassivationCapable;
    }


    private InvocationInfo getLifecycleCallbackInvInfo(Set<LifecycleCallbackDescriptor> lifecycleCallbackDescriptors)
        throws Exception {
        InvocationInfo inv = new InvocationInfo();
        inv.ejbName = ejbDescriptor.getName();
        inv.methodIntf = MethodDescriptor.LIFECYCLE_CALLBACK;
        inv.txAttr = getTxAttrForLifecycleCallback(lifecycleCallbackDescriptors, -1, TX_NOT_SUPPORTED, TX_REQUIRES_NEW);
        return inv;
    }


    @Override
    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");
                beforeCompletionMethod = ejbClass.getMethod("beforeCompletion");
                afterCompletionMethod = ejbClass.getMethod("afterCompletion", Boolean.TYPE);
            } catch (Exception e) {
                _logger.log(Level.WARNING, EXCEPTION_WHILE_INITIALIZING_SESSION_SYNCHRONIZATION, 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.
        PrivilegedExceptionAction<Void> action = () -> {
            if (!methodAccessible.trySetAccessible()) {
                throw new InaccessibleObjectException("Unable to make accessible: " + methodAccessible);
            }
            return null;
        };
        AccessController.doPrivileged(action);
    }


    // Called before invoking a bean with no Tx or with a new Tx.
    // Check if the bean is associated with an unfinished tx.
    @Override
    protected void checkUnfinishedTx(Transaction prevTx, EjbInvocation inv) {
        try {
            if (inv.invocationInfo.isBusinessMethod && prevTx != null
                && prevTx.getStatus() != Status.STATUS_NO_TRANSACTION) {
                // An unfinished tx exists for the bean.
                // so we cannot invoke the bean with no Tx or a new Tx.
                throw new IllegalStateException("Bean is associated with a different unfinished transaction");
            }
        } catch (SystemException ex) {
            _logger.log(Level.FINE, "Exception in checkUnfinishedTx", ex);
            throw new EJBException(ex);
        }
    }


    protected void loadCheckpointInfo() {
        try {
            if (isHAEnabled) {
                Iterator<InvocationInfo> iter = invocationInfoMap.values().iterator();
                while (iter.hasNext()) {
                    InvocationInfo info = iter.next();
                    info.checkpointEnabled = false;
                    MethodDescriptor md = new MethodDescriptor(info.method, info.methodIntf);
                    IASEjbExtraDescriptors extraDesc = ejbDescriptor.getIASEjbExtraDescriptors();
                    if (extraDesc != null) {
                        CheckpointAtEndOfMethodDescriptor cpDesc = extraDesc.getCheckpointAtEndOfMethodDescriptor();
                        if (cpDesc != null) {
                            info.checkpointEnabled = cpDesc.isCheckpointEnabledFor(md);
                        }
                    }

                    if (info.checkpointEnabled) {
                        _logger.log(Level.FINE, "[SFSBContainer] {0} MARKED for end-of-method-checkpoint", info.method);
                    }
                }
            }
        } catch (Exception ex) {
            _logger.log(Level.WARNING, EXCEPTION_WHILE_LOADING_CHECKPOINT, ex);
        }
    }


    @Override
    protected void registerMonitorableComponents() {
        registerEjbCacheProbeProvider();
        super.registerMonitorableComponents();
        cacheProbeListener = new EjbCacheStatsProvider(sessionBeanCache, getContainerId(), containerInfo.appName,
            containerInfo.modName, containerInfo.ejbName);
        cacheProbeListener.register();

        if (isHAEnabled) {
            sfsbStoreMonitor = new HAStatefulSessionStoreMonitor();
        } else {
            sfsbStoreMonitor = new StatefulSessionStoreMonitor();
        }
        sessionBeanCache.setStatefulSessionStoreMonitor(sfsbStoreMonitor);
        _logger.log(Level.FINE, "[SFSBContainer] registered monitorable");
    }


    private void registerEjbCacheProbeProvider() {
        try {
            final String applicationName = ejbDescriptor.getApplication().isVirtual() ? null
                : ejbDescriptor.getApplication().getRegistrationName();
            final String moduleName;
            if (applicationName == null) {
                moduleName = ejbDescriptor.getApplication().getRegistrationName();
            } else {
                final String archiveuri = ejbDescriptor.getEjbBundleDescriptor().getModuleDescriptor().getArchiveUri();
                moduleName = FileUtils.makeFriendlyFilename(archiveuri);
            }
            final String ejbNameFromDescriptor = ejbDescriptor.getName();
            final ProbeProviderFactory probeFactory = ejbContainerUtilImpl.getProbeProviderFactory();
            final String invokerId = EjbMonitoringUtils.getInvokerId(applicationName, moduleName, ejbNameFromDescriptor);
            cacheProbeNotifier = probeFactory.getProbeProvider(EjbCacheProbeProvider.class, invokerId);
            _logger.log(Level.FINE, "Got ProbeProvider: {0}", cacheProbeNotifier.getClass().getName());
        } catch (Exception ex) {
            cacheProbeNotifier = new EjbCacheProbeProvider();
            _logger.log(Level.FINE, "Error getting the EjbCacheProbeProvider");
        }
    }


    public String getMonitorAttributeValues() {
        StringBuilder sbuf = new StringBuilder();
        sbuf.append(" { asyncTaskCount=").append(asyncTaskCount)
            .append("; asyncCummTaskCount=").append(asyncCummTaskCount)
            .append("; passivationBatchCount=").append(passivationBatchCount)
            .append("; passivationQSz=").append(passivationCandidates.size())
            .append("; trimEventCount=").append(containerTrimCount)
            .append(" }");
        return sbuf.toString();
    }


    @Override
    protected EjbMonitoringStatsProvider getMonitoringStatsProvider(String appName, String modName, String ejbName) {
        StatefulSessionBeanStatsProvider statsProvider = new StatefulSessionBeanStatsProvider(this, getContainerId(),
            appName, modName, ejbName);
        try {
            statsProvider.setPassiveCount(backingStore.size());
        } catch (BackingStoreException e) {
            _logger.log(Level.WARNING, ERROR_WHILE_BACKSTORE_SIZE_ACCESS, e);
        }
        return statsProvider;
    }


    private static String convertCtxStateToString(SessionContextImpl sc) {
        switch (sc.getState()) {
            case PASSIVATED:
                return "PASSIVE";
            case READY:
                return "READY";
            case INVOKING:
                return "INVOKING";
            case INCOMPLETE_TX:
                return "INCOMPLETE_TX";
            case DESTROYED:
                return "DESTROYED";
            default:
                return "UNKNOWN-STATE";
        }
    }


    @Override
    protected boolean isIdentical(EJBObjectImpl ejbo, EJBObject other) throws RemoteException {
        if (other == ejbo.getStub()) {
            return true;
        }
        try {
            // other may be a stub for a remote object.
            return getProtocolManager().isIdentical(ejbo.getStub(), other);
        } catch (Exception ex) {
            _logger.log(Level.FINE, "Exception while getting stub for ejb", ex);
            throw new RemoteException("Error during isIdentical.", ex);
        }
    }


    /**
     * This is called from the generated "HelloEJBHomeImpl" create method
     * via EJBHomeImpl.createEJBObject.
     * <p>
     * Note: for stateful beans, the HelloEJBHomeImpl.create calls
     * ejbCreate on the new bean after createEJBObject() returns.
     * Return the EJBObject for the bean.
     */
    @Override
    protected EJBObjectImpl createEJBObjectImpl() throws CreateException, RemoteException {
        try {
            SessionContextImpl context = createBeanInstance();
            EJBObjectImpl ejbObjImpl = createEJBObjectImpl(context);
            afterInstanceCreation(context);
            return ejbObjImpl;
        } catch (Exception ex) {
            _logger.log(Level.WARNING, CREATE_EJBOBJECT_EXCEPTION, new Object[] {ejbDescriptor.getName(), ex});
            if (ex instanceof EJBException) {
                throw (EJBException) ex;
            }
            CreateException ce = new CreateException("ERROR creating stateful SessionBean");
            ce.initCause(ex);
            throw ce;
        }
    }


    @Override
    protected EJBObjectImpl createRemoteBusinessObjectImpl() throws CreateException, RemoteException {
        try {
            SessionContextImpl context = createBeanInstance();
            EJBObjectImpl ejbBusinessObjImpl = createRemoteBusinessObjectImpl(context);
            afterInstanceCreation(context);
            return ejbBusinessObjImpl;
        } catch (Exception ex) {
            _logger.log(Level.WARNING, CREATE_EJBOBJECT_EXCEPTION, new Object[] {ejbDescriptor.getName(), ex});
            if (ex instanceof EJBException) {
                throw (EJBException) ex;
            }
            CreateException ce = new CreateException("ERROR creating stateful SessionBean");
            ce.initCause(ex);
            throw ce;
        }
    }


    /**
     * This is called from the generated "HelloEJBLocalHomeImpl" create method
     * via EJBLocalHomeImpl.createEJBObject.
     * <p>
     * Note: for stateful beans, the HelloEJBLocalHomeImpl.create calls
     * ejbCreate on the new bean after createEJBLocalObjectImpl() returns.
     * Return the EJBLocalObject for the bean.
     */
    @Override
    protected EJBLocalObjectImpl createEJBLocalObjectImpl() throws CreateException {
        try {
            SessionContextImpl context = createBeanInstance();
            EJBLocalObjectImpl localObjImpl = createEJBLocalObjectImpl(context);
            afterInstanceCreation(context);
            return localObjImpl;
        } catch (Exception ex) {
            _logger.log(Level.WARNING, CREATE_EJBLOCALOBJECT_EXCEPTION, new Object[] {ejbDescriptor.getName(), ex});
            if (ex instanceof EJBException) {
                throw (EJBException) ex;
            }
            CreateException ce = new CreateException("ERROR creating stateful SessionBean");
            ce.initCause(ex);
            throw ce;
        }
    }


    /**
     * Internal creation event for Local Business view of SFSB
     */
    @Override
    EJBLocalObjectImpl createEJBLocalBusinessObjectImpl(boolean localBeanView) throws CreateException {
        try {
            SessionContextImpl context = createBeanInstance();
            EJBLocalObjectImpl localBusinessObjImpl = localBeanView ? createOptionalEJBLocalBusinessObjectImpl(context)
                : createEJBLocalBusinessObjectImpl(context);
            afterInstanceCreation(context);
            return localBusinessObjImpl;
        } catch (Exception ex) {
            _logger.log(Level.WARNING, CREATE_EJBLOCALOBJECT_EXCEPTION, new Object[] {ejbDescriptor.getName(), ex});
            if (ex instanceof EJBException) {
                throw (EJBException) ex;
            }
            CreateException ce = new CreateException("ERROR creating stateful SessionBean");
            ce.initCause(ex);
            throw ce;
        }
    }


    @Override
    protected EJBContextImpl _constructEJBContextImpl(Object instance) {
        return new SessionContextImpl(instance, this);
    }


    @Override
    protected Object _constructEJBInstance() throws Exception {
        if (sfsbSerializedClass == null) {
            return ejbClass.getDeclaredConstructor().newInstance();
        }
        return sfsbSerializedClass.getDeclaredConstructor().newInstance();
    }


    @Override
    protected boolean suspendTransaction(EjbInvocation inv) throws Exception {
        SessionContextImpl sc = (SessionContextImpl) inv.context;
        return !inv.invocationInfo.isBusinessMethod && !sc.getInLifeCycleCallback();
    }


    @Override
    protected boolean resumeTransaction(EjbInvocation inv) throws Exception {
        SessionContextImpl sc = (SessionContextImpl) inv.context;
        return !inv.invocationInfo.isBusinessMethod && !sc.getInLifeCycleCallback();
    }


    /**
     * Create a new Session Bean and set Session Context.
     */
    private SessionContextImpl createBeanInstance() throws Exception {
        EjbInvocation ejbInv = null;
        try {
            SessionContextImpl context = (SessionContextImpl) createEjbInstanceAndContext();
            Object ejb = context.getEJB();
            Object sessionKey = uuidGenerator.createSessionKey();
            createExtendedEMs(context, sessionKey);

            // Need to do preInvoke because setSessionContext can access JNDI
            ejbInv = super.createEjbInvocation(ejb, context);
            invocationManager.preInvoke(ejbInv);

            // setSessionContext will be called without a Tx as required
            // by the spec, because the EJBHome.create would have been called
            // after the container suspended any client Tx.
            // setSessionContext is also called before createEJBObject because
            // the bean is not allowed to do EJBContext.getEJBObject here
            if (ejb instanceof SessionBean) {
                ((SessionBean) ejb).setSessionContext(context);
            }

            // Perform injection right after where setSessionContext
            // would be called.  This is important since injection methods
            // have the same "operations allowed" permissions as
            // setSessionContext.
            injectEjbInstance(context);

            // Set the timestamp before inserting into bean store, else
            // Recycler might go crazy and remove this bean!
            context.touch();

            // Add the EJB into the session store
            // and get the instanceKey for this EJB instance.
            // XXX The store operation could be avoided for local-only beans.

            sessionBeanCache.put(sessionKey, context);
            context.setInstanceKey(sessionKey);

            _logger.log(Level.FINE, "[SFSBContainer] Created session: {0}", sessionKey);

            return context;
        } catch (Exception ex) {
            throw ex;
        } catch (Throwable t) {
            EJBException ejbEx = new EJBException();
            ejbEx.initCause(t);
            throw ejbEx;
        } finally {
            if (ejbInv != null) {
                invocationManager.postInvoke(ejbInv);
            }
        }
    }


    private void createExtendedEMs(SessionContextImpl ctx, Object sessionKey) {
        Set<EntityManagerReferenceDescriptor> emRefs = ejbDescriptor.getEntityManagerReferenceDescriptors();
        Iterator<EntityManagerReferenceDescriptor> iter = emRefs.iterator();
        Set<EEMRefInfo> eemRefInfos = new HashSet<>();
        while (iter.hasNext()) {
            EntityManagerReferenceDescriptor refDesc = iter.next();
            if (refDesc.getPersistenceContextType() == PersistenceContextType.EXTENDED) {
                String unitName = refDesc.getUnitName();
                EntityManagerFactory emf = EntityManagerFactoryWrapper.lookupEntityManagerFactory(
                    ComponentInvocation.ComponentInvocationType.EJB_INVOCATION, unitName, ejbDescriptor);
                if (emf != null) {
                    PhysicalEntityManagerWrapper physicalEntityManagerWrapper = findExtendedEMFromInvList(emf);
                    if (physicalEntityManagerWrapper == null) {
                        // We did not find an extended EM that we can inherit from. Create one
                        try {
                            EntityManager em = emf.createEntityManager(refDesc.getSynchronizationType(),
                                refDesc.getProperties());
                            physicalEntityManagerWrapper = new PhysicalEntityManagerWrapper(em,
                                refDesc.getSynchronizationType());
                        } catch (Throwable th) {
                            EJBException ejbEx = new EJBException("Couldn't create EntityManager for" + " refName: "
                                + refDesc.getName() + "; unitname: " + unitName);
                            ejbEx.initCause(th);
                            throw ejbEx;
                        }
                    } else {
                        // We found an extended EM we can inherit from. Validate that sync type matches
                        if (physicalEntityManagerWrapper.getSynchronizationType() != refDesc.getSynchronizationType()) {
                            throw new EJBException(
                                "The current invocation inherits a persistence context of synchronization type '"
                                    + physicalEntityManagerWrapper.getSynchronizationType()
                                    + "' where as it references a persistence context of synchronization type '"
                                    + refDesc.getSynchronizationType() + "' refName: " + refDesc.getName()
                                    + " unitName: " + unitName);
                        }
                    }
                    String emRefName = refDesc.getName();
                    long containerID = this.getContainerId();
                    EEMRefInfo refInfo = null;
                    synchronized (extendedEMReferenceCountMap) {
                        refInfo = extendedEMReferenceCountMap.get(physicalEntityManagerWrapper.getEM());
                        if (refInfo != null) {
                            refInfo.refCount++;
                        } else {
                            refInfo = new EEMRefInfo(emRefName, refDesc.getUnitName(), refDesc.getSynchronizationType(),
                                containerID, sessionKey, physicalEntityManagerWrapper.getEM(), emf);
                            refInfo.refCount = 1;
                            extendedEMReferenceCountMap.put(physicalEntityManagerWrapper.getEM(), refInfo);
                            eemKey2EEMMap.put(refInfo.getKey(), refInfo.getEntityManager());
                        }
                    }
                    ctx.addExtendedEntityManagerMapping(emf, refInfo);
                    eemRefInfos.add(refInfo);
                } else {
                    throw new EJBException("EMF is null. Couldn't get extended EntityManager for"
                            + " refName: " + refDesc.getName()
                            + "; unitname: " + unitName);
                }
            }
        }

        if (!eemRefInfos.isEmpty()) {
            ctx.setEEMRefInfos(eemRefInfos);
        }
    }


    private PhysicalEntityManagerWrapper findExtendedEMFromInvList(EntityManagerFactory emf) {
        ComponentInvocation compInv = invocationManager.getCurrentInvocation();
        if (compInv != null) {
            if (compInv.getInvocationType() == ComponentInvocation.ComponentInvocationType.EJB_INVOCATION) {
                EjbInvocation ejbInv = (EjbInvocation) compInv;
                if (ejbInv.context instanceof SessionContextImpl) {
                    SessionContextImpl ctxImpl = (SessionContextImpl) ejbInv.context;
                    if (ctxImpl.container instanceof StatefulSessionContainer) {
                        return ctxImpl.getExtendedEntityManager(emf);
                    }
                }
            }
        }
        return null;
    }


    @Override
    public EntityManager lookupExtendedEntityManager(EntityManagerFactory emf) {
        PhysicalEntityManagerWrapper physicalEntityManagerWrapper = findExtendedEMFromInvList(emf);
        return physicalEntityManagerWrapper == null ? null : physicalEntityManagerWrapper.getEM();
    }


    private void afterInstanceCreation(SessionContextImpl context) throws Exception {
        context.setState(BeanState.READY);
        EjbInvocation ejbInv = null;
        boolean inTx = false;
        try {
            // Need to do preInvoke because setSessionContext can access JNDI
            ejbInv = super.createEjbInvocation(context.getEJB(), context);
            invocationManager.preInvoke(ejbInv);

            // PostConstruct must be called after state set to something other than CREATED
            inTx = callLifecycleCallbackInTxIfUsed(ejbInv, context, postConstructInvInfo, CallbackType.POST_CONSTRUCT);
        } catch (Throwable t) {
            EJBException ejbEx = new EJBException();
            ejbEx.initCause(t);
            throw ejbEx;
        } finally {
            if (ejbInv != null) {
                try {
                    invocationManager.postInvoke(ejbInv);
                    if (inTx) {
                        // Call directly to report exception
                        postInvokeTx(ejbInv);
                    }
                } catch (Exception pie) {
                    if (ejbInv.exception != null) {
                        _logger.log(Level.FINE, "Exception during SFSB startup postInvoke ", pie);
                    } else {
                        ejbInv.exception = pie;
                        CreateException creEx = new CreateException(
                            "Initialization failed for Stateful Session Bean " + ejbDescriptor.getName());
                        creEx.initCause(pie);
                        throw creEx;
                    }
                } finally {
                    context.setInLifeCycleCallback(false);
                }
            }
        }

        ejbProbeNotifier.ejbBeanCreatedEvent(getContainerId(),
                containerInfo.appName, containerInfo.modName,
                containerInfo.ejbName);
        incrementMethodReadyStat();
    }


    // called from createEJBObject and activateEJB and createEJBLocalObjectImpl
    private EJBLocalObjectImpl createEJBLocalObjectImpl(SessionContextImpl context) throws Exception {
        if (context.getEJBLocalObjectImpl() != null) {
            return context.getEJBLocalObjectImpl();
        }

        // create EJBLocalObject
        EJBLocalObjectImpl localObjImpl = instantiateEJBLocalObjectImpl(context.getInstanceKey());

        // introduce context and EJBLocalObject to each other
        context.setEJBLocalObjectImpl(localObjImpl);
        localObjImpl.setContext(context);

        if (hasLocalBusinessView) {
            createEJBLocalBusinessObjectImpl(context);
        }
        if (hasOptionalLocalBusinessView) {
            createOptionalEJBLocalBusinessObjectImpl(context);
        }
        if (hasRemoteHomeView) {
            // enable remote invocations too
            createEJBObjectImpl(context);
        }
        if (hasRemoteBusinessView) {
            createRemoteBusinessObjectImpl(context);
        }
        return localObjImpl;
    }


    private EJBLocalObjectImpl createEJBLocalBusinessObjectImpl(SessionContextImpl context) throws Exception {
        if (context.getEJBLocalBusinessObjectImpl() != null) {
            return context.getEJBLocalBusinessObjectImpl();
        }

        EJBLocalObjectImpl localBusinessObjImpl = instantiateEJBLocalBusinessObjectImpl();

        context.setEJBLocalBusinessObjectImpl(localBusinessObjImpl);
        localBusinessObjImpl.setContext(context);
        localBusinessObjImpl.setKey(context.getInstanceKey());

        if (hasOptionalLocalBusinessView) {
            createOptionalEJBLocalBusinessObjectImpl(context);
        }
        if (hasLocalHomeView) {
            createEJBLocalObjectImpl(context);
        }
        if (hasRemoteHomeView) {
            // enable remote invocations too
            createEJBObjectImpl(context);
        }
        if (hasRemoteBusinessView) {
            createRemoteBusinessObjectImpl(context);
        }
        return localBusinessObjImpl;
    }


    private EJBLocalObjectImpl createOptionalEJBLocalBusinessObjectImpl(SessionContextImpl context) throws Exception {
        if (context.getOptionalEJBLocalBusinessObjectImpl() != null) {
            return context.getOptionalEJBLocalBusinessObjectImpl();
        }

        EJBLocalObjectImpl optionalLocalBusinessObjImpl = instantiateOptionalEJBLocalBusinessObjectImpl();

        context.setOptionalEJBLocalBusinessObjectImpl(optionalLocalBusinessObjImpl);
        optionalLocalBusinessObjImpl.setContext(context);
        optionalLocalBusinessObjImpl.setKey(context.getInstanceKey());

        if (hasLocalBusinessView) {
            createEJBLocalBusinessObjectImpl(context);
        }
        if (hasLocalHomeView) {
            createEJBLocalObjectImpl(context);
        }
        if (hasRemoteHomeView) {
            // enable remote invocations too
            createEJBObjectImpl(context);
        }
        if (hasRemoteBusinessView) {
            createRemoteBusinessObjectImpl(context);
        }
        return optionalLocalBusinessObjImpl;
    }


    // called from createEJBObject and activateEJB and createEJBLocalObjectImpl
    private EJBObjectImpl createEJBObjectImpl(SessionContextImpl context) throws Exception {
        if (context.getEJBObjectImpl() != null) {
            return context.getEJBObjectImpl();
        }

        // create EJBObject and associate it with the key
        Object sessionKey = context.getInstanceKey();
        EJBObjectImpl ejbObjImpl = instantiateEJBObjectImpl(null, sessionKey);

        // introduce context and EJBObject to each other
        context.setEJBObjectImpl(ejbObjImpl);
        ejbObjImpl.setContext(context);

        // connect the EJBObject to the ProtocolManager
        // (creates the client-side stub too)
        byte[] sessionOID = uuidGenerator.keyToByteArray(sessionKey);
        EJBObject ejbStub = (EJBObject) remoteHomeRefFactory.createRemoteReference(sessionOID);

        context.setEJBStub(ejbStub);
        ejbObjImpl.setStub(ejbStub);

        if (hasRemoteBusinessView) {
            createRemoteBusinessObjectImpl(context);
        }

        if (isLocal) {
            if (hasLocalHomeView) {
                // enable local home invocations too
                createEJBLocalObjectImpl(context);
            }
            if (hasLocalBusinessView) {
                // enable local business invocations too
                createEJBLocalBusinessObjectImpl(context);
            }
            if (hasOptionalLocalBusinessView) {
                createOptionalEJBLocalBusinessObjectImpl(context);
            }
        }
        return ejbObjImpl;
    }


    private EJBObjectImpl createRemoteBusinessObjectImpl(SessionContextImpl context) throws Exception {
        if (context.getEJBRemoteBusinessObjectImpl() != null) {
            return context.getEJBRemoteBusinessObjectImpl();
        }

        // create EJBObject
        EJBObjectImpl ejbBusinessObjImpl = instantiateRemoteBusinessObjectImpl();

        context.setEJBRemoteBusinessObjectImpl(ejbBusinessObjImpl);
        ejbBusinessObjImpl.setContext(context);
        Object sessionKey = context.getInstanceKey();
        ejbBusinessObjImpl.setKey(sessionKey);

        // connect the Remote object to the ProtocolManager
        // (creates the client-side stub too)
        byte[] sessionOID = uuidGenerator.keyToByteArray(sessionKey);
        for (RemoteBusinessIntfInfo next : remoteBusinessIntfInfo.values()) {
            Remote stub = next.referenceFactory.createRemoteReference(sessionOID);
            ejbBusinessObjImpl.setStub(next.generatedRemoteIntf.getName(), stub);
        }

        if (hasRemoteHomeView) {
            createEJBObjectImpl(context);
        }

        if (isLocal) {
            if (hasLocalHomeView) {
                // enable local home invocations too
                createEJBLocalObjectImpl(context);
            }
            if (hasLocalBusinessView) {
                // enable local business invocations too
                createEJBLocalBusinessObjectImpl(context);
            }
            if (hasOptionalLocalBusinessView) {
                createOptionalEJBLocalBusinessObjectImpl(context);
            }
        }

        return ejbBusinessObjImpl;
    }


    // Called from EJBObjectImpl.remove, EJBLocalObjectImpl.remove,
    // EJBHomeImpl.remove(Handle).
    @Override
    protected void removeBean(EJBLocalRemoteObject ejbo, Method removeMethod, boolean local)
        throws RemoveException, EJBException {
        EjbInvocation ejbInv = super.createEjbInvocation();
        ejbInv.ejbObject = ejbo;
        ejbInv.isLocal = local;
        ejbInv.isRemote = !local;
        ejbInv.method = removeMethod;

        // Method must be a remove method defined on one of :
        // jakarta.ejb.EJBHome, jakarta.ejb.EJBObject, jakarta.ejb.EJBLocalHome,
        // jakarta.ejb.EJBLocalObject
        Class<?> declaringClass = removeMethod.getDeclaringClass();
        ejbInv.isHome = (declaringClass == EJBHome.class || declaringClass == EJBLocalHome.class);

        try {
            preInvoke(ejbInv);
            removeBean(ejbInv);
        } catch (Exception e) {
            _logger.log(Level.FINE, "Exception while running pre-invoke : ejbName = [{0}]", e);
            ejbInv.exception = e;
        } finally {
            postInvoke(ejbInv);
        }

        if (ejbInv.exception != null) {
            if (ejbInv.exception instanceof RemoveException) {
                throw (RemoveException) ejbInv.exception;
            } else if (ejbInv.exception instanceof RuntimeException) {
                throw (RuntimeException) ejbInv.exception;
            } else if (ejbInv.exception instanceof Exception) {
                throw new EJBException((Exception) ejbInv.exception);
            } else {
                EJBException ejbEx = new EJBException();
                ejbEx.initCause(ejbInv.exception);
                throw ejbEx;
            }
        }
    }


    /**
     * Called from EJBObjectImpl.remove().
     * Note: preInvoke and postInvoke are called for remove().
     */
    private void removeBean(EjbInvocation inv) throws RemoveException {
        // At this point the EJB's state is always INVOKING
        // because EJBObjectImpl.remove() called preInvoke().
        try {
            ejbProbeNotifier.ejbBeanDestroyedEvent(getContainerId(), containerInfo.appName, containerInfo.modName,
                containerInfo.ejbName);
            SessionContextImpl sc = (SessionContextImpl) inv.context;
            Transaction tc = sc.getTransaction();
            if (tc != null && tc.getStatus() != Status.STATUS_NO_TRANSACTION) {
                // EJB2.0 section 7.6.4: remove must always be called without a transaction.
                throw new RemoveException("Cannot remove EJB: transaction in progress");
            }

            // call ejbRemove on the EJB
            _logger.log(Level.FINE, "[SFSBContainer] Removing session: {0}", sc.getInstanceKey());

            sc.setInEjbRemove(true);
            try {
                destroyBean(inv, sc);
            } catch (Throwable t) {
                _logger.log(Level.FINE, "exception thrown from SFSB PRE_DESTROY", t);
            } finally {
                sc.setInEjbRemove(false);
            }
            forceDestroyBean(sc);
        } catch (EJBException ex) {
            _logger.log(Level.FINE, "EJBException in removing bean", ex);
            throw ex;
        } catch (RemoveException ex) {
            _logger.log(Level.FINE, "Remove exception while removing bean", ex);
            throw ex;
        } catch (Exception ex) {
            _logger.log(Level.FINE, "Some exception while removing bean", ex);
            throw new EJBException(ex);
        }
    }


    /**
     * Force destroy the EJB and rollback any Tx it was associated with
     * Called from removeBean, timeoutBean and BaseContainer.postInvokeTx.
     * Note: EJB2.0 section 18.3.1 says that discarding an EJB
     * means that no methods other than finalize() should be invoked on it.
     */
    @Override
    protected void forceDestroyBean(EJBContextImpl ctx) {
        SessionContextImpl sc = (SessionContextImpl) ctx;

        synchronized (sc) {
            if (sc.getState() == EJBContextImpl.BeanState.DESTROYED) {
                return;
            }

            // mark context as destroyed so no more invocations happen on it
            sc.setState(BeanState.DESTROYED);
            cleanupInstance(ctx);

            _logger.log(Level.FINE, "[SFSBContainer] (Force)Destroying session: {0}", sc.getInstanceKey());

            Transaction prevTx = sc.getTransaction();
            try {
                if (prevTx != null && prevTx.getStatus() != Status.STATUS_NO_TRANSACTION) {
                    prevTx.setRollbackOnly();
                }
            } catch (SystemException ex) {
                throw new EJBException(ex);
            } catch (IllegalStateException ex) {
                throw new EJBException(ex);
            }

            // remove the bean from the session store
            Object sessionKey = sc.getInstanceKey();
            sessionBeanCache.remove(sessionKey, sc.existsInStore());

            if (isRemote) {
                if (hasRemoteHomeView) {
                    // disconnect the EJBObject from the context and vice versa
                    EJBObjectImpl ejbObjImpl = sc.getEJBObjectImpl();
                    ejbObjImpl.clearContext();
                    ejbObjImpl.setRemoved(true);
                    sc.setEJBObjectImpl(null);

                    // disconnect the EJBObject from the ProtocolManager
                    // so that no remote invocations can reach the EJBObject
                    remoteHomeRefFactory.destroyReference(ejbObjImpl.getStub(), ejbObjImpl.getEJBObject());
                }

                if (hasRemoteBusinessView) {
                    EJBObjectImpl ejbBusinessObjImpl = sc.getEJBRemoteBusinessObjectImpl();
                    ejbBusinessObjImpl.clearContext();
                    ejbBusinessObjImpl.setRemoved(true);
                    sc.setEJBRemoteBusinessObjectImpl(null);

                    for (RemoteBusinessIntfInfo next : remoteBusinessIntfInfo.values()) {
                        // disconnect from the ProtocolManager
                        // so that no remote invocations can get through
                        next.referenceFactory.destroyReference(
                            ejbBusinessObjImpl.getStub(next.generatedRemoteIntf.getName()),
                            ejbBusinessObjImpl.getEJBObject(next.generatedRemoteIntf.getName()));
                    }
                }
            }

            if (isLocal) {
                if (hasLocalHomeView) {
                    // disconnect the EJBLocalObject from the context and vice versa
                    EJBLocalObjectImpl localObjImpl = sc.getEJBLocalObjectImpl();
                    localObjImpl.clearContext();
                    localObjImpl.setRemoved(true);
                    sc.setEJBLocalObjectImpl(null);
                }
                if (hasLocalBusinessView) {
                    // disconnect the EJBLocalObject from the context and vice versa
                    EJBLocalObjectImpl localBusinessObjImpl = sc.getEJBLocalBusinessObjectImpl();
                    localBusinessObjImpl.clearContext();
                    localBusinessObjImpl.setRemoved(true);
                    sc.setEJBLocalBusinessObjectImpl(null);
                }
                if (hasOptionalLocalBusinessView) {
                    EJBLocalObjectImpl optionalLocalBusinessObjImpl = sc.getOptionalEJBLocalBusinessObjectImpl();
                    optionalLocalBusinessObjImpl.clearContext();
                    optionalLocalBusinessObjImpl.setRemoved(true);
                    sc.setOptionalEJBLocalBusinessObjectImpl(null);
                }
            }

            destroyExtendedEMsForContext(sc);

            // tell the TM to release resources held by the bean
            transactionManager.componentDestroyed(sc);
        }
    }


    private void destroyExtendedEMsForContext(SessionContextImpl sc) {
        for (PhysicalEntityManagerWrapper emWrapper : sc.getExtendedEntityManagers()) {
            synchronized (extendedEMReferenceCountMap) {
                EntityManager em = emWrapper.getEM();
                if (extendedEMReferenceCountMap.containsKey(em)) {
                    EEMRefInfo refInfo = extendedEMReferenceCountMap.get(em);
                    if (refInfo.refCount > 1) {
                        refInfo.refCount--;
                        _logger.log(Level.FINE, "Decremented RefCount ExtendedEM em: {0}", em);
                    } else {
                        _logger.log(Level.FINE, "DESTROYED ExtendedEM em: {0}", em);
                        refInfo = extendedEMReferenceCountMap.remove(em);
                        eemKey2EEMMap.remove(refInfo.getKey());
                        try {
                            em.close();
                        } catch (Throwable th) {
                            _logger.log(Level.FINE, "Exception during em.close()", th);
                        }
                    }
                }
            }
        }
    }


    @Override
    public boolean userTransactionMethodsAllowed(ComponentInvocation inv) {
        boolean utMethodsAllowed = false;
        if (isBeanManagedTran) {
            if (inv instanceof EjbInvocation) {
                SessionContextImpl sc = (SessionContextImpl) ((EjbInvocation) inv).context;
                // This will prevent setSessionContext access to
                // UserTransaction methods.
                utMethodsAllowed = (sc.getInstanceKey() != null);
            } else {
                utMethodsAllowed = true;
            }
        }
        return utMethodsAllowed;
    }


    public void removeTimedoutBean(EJBContextImpl ctx) {
        // check if there is an invocation in progress for
        // this instance.
        synchronized (ctx) {
            if (ctx.getState() != BeanState.INVOKING) {
                try {
                    // call ejbRemove on the bean
                    ctx.setInEjbRemove(true);
                    destroyBean(null, ctx);
                } catch (Throwable t) {
                    _logger.log(Level.FINE, "ejbRemove exception", t);
                } finally {
                    ctx.setInEjbRemove(false);
                }

                if (_logger.isLoggable(Level.FINE)) {
                    SessionContextImpl sc = (SessionContextImpl) ctx;
                    _logger.log(Level.FINE, "[SFSBContainer] Removing TIMEDOUT session: {0}", sc.getInstanceKey());
                }

                forceDestroyBean(ctx);
            }
        }
    }


    /**
     * Called when a remote invocation arrives for an EJB.
     *
     * @throws NoSuchObjectLocalException if the target object does not exist
     */
    private SessionContextImpl _getContextForInstance(byte[] instanceKey) {
        Serializable sessionKey = (Serializable) uuidGenerator.byteArrayToKey(instanceKey, 0, -1);
        _logger.log(Level.FINE, "[SFSBContainer] Got request for: {0}", sessionKey);
        while (true) {
            SessionContextImpl sc = (SessionContextImpl) sessionBeanCache.lookupEJB(sessionKey, this, null);
            if (sc == null) {
                // EJB2.0 section 7.6
                // Note: the NoSuchObjectLocalException gets converted to a
                // remote exception by the protocol manager.
                throw new NoSuchObjectLocalException("Invalid Session Key ( " + sessionKey + ")");
            }
            synchronized (sc) {
                switch (sc.getState()) {
                    case PASSIVATED: // Next cache.lookup() == different_ctx
                    case DESTROYED: // Next cache.lookup() == null
                        break;
                    default:
                        return sc;
                }
            }
        }
    }


    @Override
    protected EJBObjectImpl getEJBObjectImpl(byte[] instanceKey) {
        SessionContextImpl sc = _getContextForInstance(instanceKey);
        return sc.getEJBObjectImpl();
    }


    @Override
    EJBObjectImpl getEJBRemoteBusinessObjectImpl(byte[] instanceKey) {
        SessionContextImpl sc = _getContextForInstance(instanceKey);
        return sc.getEJBRemoteBusinessObjectImpl();
    }


    /**
     * Called from EJBLocalObjectImpl.getLocalObject() while deserializing
     * a local object reference.
     */
    @Override
    protected EJBLocalObjectImpl getEJBLocalObjectImpl(Object sessionKey) {

        // Create an EJBLocalObject reference which
        // is *not* associated with a SessionContext.  That way, the
        // session bean context lookup will be done lazily whenever
        // the reference is actually accessed.  This avoids I/O in the
        // case that the reference points to a passivated session bean.
        // It's also consistent with the deserialization approach used
        // throughout the container.  e.g. a timer reference is deserialized
        // from its handle without checking it against the timer database.

        EJBLocalObjectImpl localObjImpl;
        try {
            localObjImpl = instantiateEJBLocalObjectImpl(sessionKey);
        } catch (Exception ex) {
            EJBException ejbEx = new EJBException();
            ejbEx.initCause(ex);
            throw ejbEx;
        }
        return localObjImpl;
    }


    @Override
    EJBLocalObjectImpl getEJBLocalBusinessObjectImpl(Object sessionKey) {
        // Create an EJBLocalObject reference which
        // is *not* associated with a SessionContext.  That way, the
        // session bean context lookup will be done lazily whenever
        // the reference is actually accessed.  This avoids I/O in the
        // case that the reference points to a passivated session bean.
        // It's also consistent with the deserialization approach used
        // throughout the container.  e.g. a timer reference is deserialized
        // from its handle without checking it against the timer database.
        EJBLocalObjectImpl localBusinessObjImpl;
        try {
            localBusinessObjImpl = instantiateEJBLocalBusinessObjectImpl();
            localBusinessObjImpl.setKey(sessionKey);
        } catch (Exception ex) {
            EJBException ejbEx = new EJBException();
            ejbEx.initCause(ex);
            throw ejbEx;
        }
        return localBusinessObjImpl;
    }


    @Override
    EJBLocalObjectImpl getOptionalEJBLocalBusinessObjectImpl(Object sessionKey) {
        // Create an EJBLocalObject reference which
        // is *not* associated with a SessionContext.  That way, the
        // session bean context lookup will be done lazily whenever
        // the reference is actually accessed.  This avoids I/O in the
        // case that the reference points to a passivated session bean.
        // It's also consistent with the deserialization approach used
        // throughout the container.  e.g. a timer reference is deserialized
        // from its handle without checking it against the timer database.
        EJBLocalObjectImpl localBusinessObjImpl;
        try {
            localBusinessObjImpl = instantiateOptionalEJBLocalBusinessObjectImpl();
            localBusinessObjImpl.setKey(sessionKey);
        } catch (Exception ex) {
            EJBException ejbEx = new EJBException();
            ejbEx.initCause(ex);
            throw ejbEx;
        }
        return localBusinessObjImpl;
    }


    /**
     * Check if the given EJBObject/LocalObject has been removed.
     *
     * @throws NoSuchObjectLocalException if the object has been removed.
     */
    @Override
    protected void checkExists(EJBLocalRemoteObject ejbObj) {
        if (ejbObj.isRemoved()) {
            throw new NoSuchObjectLocalException("Bean has been removed");
        }
    }


    private void logTraceInfo(EjbInvocation inv, Object key, String message) {
        _logger.log(Level.FINE, traceInfoPrefix + message + " for " + inv.method.getName() + "; key: " + key);
    }


    private void logTraceInfo(SessionContextImpl sc, String message) {
        _logger.log(Level.FINE,
            traceInfoPrefix + message + " for key: " + sc.getInstanceKey() + "; " + System.identityHashCode(sc));
    }


    /**
     * Called from preInvoke which is called from the EJBObject
     * for local and remote invocations.
     */
    @Override
    public ComponentContext _getContext(EjbInvocation inv) {
        EJBLocalRemoteObject ejbo = inv.ejbObject;
        SessionContextImpl sc = ejbo.getContext();
        Serializable sessionKey = (Serializable) ejbo.getKey();

        if (_logger.isLoggable(Level.FINE)) {
            logTraceInfo(inv, sessionKey, "Trying to get context");
        }

        if (sc == null) {
            // This is possible if the EJB was destroyed or passivated.
            // Try to activate it again.
            sc = (SessionContextImpl) sessionBeanCache.lookupEJB(sessionKey, this, ejbo);
        }

        if (sc == null || sc.getState() == BeanState.DESTROYED) {
            if (_logger.isLoggable(Level.FINE)) {
                logTraceInfo(inv, sessionKey, "Context already destroyed");
            }
            // EJB2.0 section 7.6
            throw new NoSuchObjectLocalException("The EJB does not exist. session-key: " + sessionKey);
        }

        MethodLockInfo lockInfo = inv.invocationInfo.methodLockInfo;
        boolean allowSerializedAccess = lockInfo == null || lockInfo.getTimeout() != CONCURRENCY_NOT_ALLOWED;

        if (allowSerializedAccess) {
            boolean blockWithTimeout = lockInfo != null && lockInfo.getTimeout() != BLOCK_INDEFINITELY;
            if (blockWithTimeout) {
                try {
                    boolean acquired = sc.getStatefulWriteLock().tryLock(lockInfo.getTimeout(), lockInfo.getTimeUnit());
                    if (!acquired) {
                        String msg = "Serialized access attempt on method " + inv.beanMethod + " for ejb "
                            + ejbDescriptor.getName() + " timed out after " + +lockInfo.getTimeout() + " "
                            + lockInfo.getTimeUnit();
                        throw new ConcurrentAccessTimeoutException(msg);
                    }

                } catch (InterruptedException ie) {
                    String msg = "Serialized access attempt on method " + inv.beanMethod + " for ejb "
                        + ejbDescriptor.getName() + " was interrupted within " + +lockInfo.getTimeout() + " "
                        + lockInfo.getTimeUnit();
                    ConcurrentAccessException cae = new ConcurrentAccessTimeoutException(msg);
                    cae.initCause(ie);
                    throw cae;
                }
            } else {
                sc.getStatefulWriteLock().lock();
            }

            // Explicitly set state to track that we're holding the lock for this invocation.
            // No matter what we need to ensure that the lock is released.   In some
            // cases releaseContext() isn't called so for safety we'll have more than one
            // place that can potentially release the lock.  The invocation state will ensure
            // we don't accidently unlock too many times.
            inv.setHoldingSFSBSerializedLock(true);
        }

        SessionContextImpl context = null;
        try {
            synchronized (sc) {
                SessionContextImpl newSC = sc;
                if (sc.getState() == BeanState.PASSIVATED) {
                    // This is possible if the EJB was passivated after
                    // the last lookupEJB. Try to activate it again.
                    newSC = (SessionContextImpl) sessionBeanCache.lookupEJB(sessionKey, this, ejbo);
                    if (newSC == null) {
                        if (_logger.isLoggable(Level.FINE)) {
                            logTraceInfo(inv, sessionKey, "Context does not exist");
                        }
                        // EJB2.0 section 7.6
                        throw new NoSuchObjectLocalException("The EJB does not exist. key: " + sessionKey);
                    }
                    // Swap any stateful lock that was set on the original sc
                    newSC.setStatefulWriteLock(sc);
                }
                // acquire the lock again, in case a new sc was returned.
                synchronized (newSC) { // newSC could be same as sc
                    // Check & set the state of the EJB
                    if (newSC.getState() == BeanState.DESTROYED) {
                        if (_logger.isLoggable(Level.FINE)) {
                            logTraceInfo(inv, sessionKey, "Got destroyed context");
                        }
                        throw new NoSuchObjectLocalException("The EJB does not exist. session-key: " + sessionKey);
                    } else if (newSC.getState() == BeanState.INVOKING) {
                        handleConcurrentInvocation(allowSerializedAccess, inv, newSC, sessionKey);
                    }
                    if (newSC.getState() == BeanState.READY) {
                        decrementMethodReadyStat();
                    }
                    if (isHAEnabled) {
                        doVersionCheck(inv, sessionKey, sc);
                    }
                    newSC.setState(BeanState.INVOKING);
                    context = newSC;
                }
            }

            // touch the context here so timestamp is set & timeout is prevented
            context.touch();

            if (context.existsInStore() && removalGracePeriodInSeconds > 0) {
                long now = System.currentTimeMillis();
                long threshold = now - (removalGracePeriodInSeconds * 1000L);
                if (context.getLastPersistedAt() <= threshold) {
                    try {
                        backingStore.updateTimestamp(sessionKey, now);
                        context.setLastPersistedAt(System.currentTimeMillis());
                    } catch (BackingStoreException sfsbEx) {
                        _logger.log(Level.WARNING, COULDNT_UPDATE_TIMESTAMP_FOR_EXCEPTION,
                            new Object[] {sessionKey, sfsbEx});
                        _logger.log(Level.FINE, "Couldn't update timestamp for: " + sessionKey, sfsbEx);
                    }
                }
            }

            if (_logger.isLoggable(Level.FINE)) {
                logTraceInfo(inv, context, "Got Context!!");
            }
        } catch (RuntimeException t) {

            // releaseContext isn't called if this method throws an exception,
            // so make sure to release any sfsb lock
            releaseSFSBSerializedLock(inv, sc);
            throw t;
        }
        return context;
    }


    @Override
    public boolean isHAEnabled() {
        return isHAEnabled;
    }


    private void doVersionCheck(EjbInvocation inv, Object sessionKey, SessionContextImpl sc) {
        EJBLocalRemoteObject ejbLRO = inv.ejbObject;
        long clientVersion = SFSBVersionManager.NO_VERSION;
        if (!inv.isLocal && sfsbVersionManager != null) {
            clientVersion = sfsbVersionManager.getRequestClientVersion();
            sfsbVersionManager.clearRequestClientVersion();
            sfsbVersionManager.clearResponseClientVersion();
        }

        if (ejbLRO != null) {
            if (clientVersion == SFSBVersionManager.NO_VERSION) {
                clientVersion = ejbLRO.getSfsbClientVersion();
            }
            long ctxVersion = sc.getVersion();
            if (_logger.isLoggable(Level.FINE)) {
                _logger.log(Level.FINE,
                    "doVersionCheck(): for: {" + ejbDescriptor.getName() + "." + inv.method.getName() + " <=> "
                        + sessionKey + "} clientVersion: " + clientVersion + " == " + ctxVersion);
            }
            if (clientVersion > ctxVersion) {
                throw new NoSuchObjectLocalException("Found only a stale version " + " clientVersion: " + clientVersion
                    + " contextVersion: " + ctxVersion);
            }
        }
    }


    private void handleConcurrentInvocation(boolean allowSerializedAccess, EjbInvocation inv, SessionContextImpl sc,
        Object sessionKey) {
        if (_logger.isLoggable(Level.FINE)) {
            logTraceInfo(inv, sessionKey, "Another invocation in progress");
        }

        if (allowSerializedAccess) {
            // Check for loopback call to avoid deadlock.
            if (sc.getStatefulWriteLock().getHoldCount() > 1) {
                throw new IllegalLoopbackException(
                    "Illegal Reentrant Access : Attempt to make " + "a loopback call on method '" + inv.beanMethod
                        + " for stateful session bean " + ejbDescriptor.getName());
            }
        } else {
            String errMsg = "Concurrent Access attempt on method " + inv.beanMethod + " of SessionBean "
                + ejbDescriptor.getName() + " is prohibited.  SFSB instance is executing another request. "
                + "[session-key: " + sessionKey + "]";
            ConcurrentAccessException conEx = new ConcurrentAccessException(errMsg);
            if (inv.isBusinessInterface) {
                throw conEx;
            }
            // there is an invocation in progress for this instance
            // throw an exception (EJB2.0 section 7.5.6).
            throw new EJBException(conEx);
        }
    }


    @Override
    protected void postInvokeTx(EjbInvocation inv) throws Exception {
        // Intercept postInvokeTx call to perform any @Remove logic
        // before tx commits.  super.postInvokeTx() must *always* be called.

        // If this was an invocation of a remove-method
        if (inv.invocationInfo.removalInfo != null) {
            InvocationInfo invInfo = inv.invocationInfo;
            EjbRemovalInfo removeInfo = invInfo.removalInfo;
            if (retainAfterRemoveMethod(inv, removeInfo)) {
                // Do nothing
            } else {
                // If there is a tx, remove bean from ContainerSynch so it
                // won't receive any SessionSynchronization callbacks.
                // We delay the PreDestroy callback and instance destruction
                // until releaseContext so that PreDestroy won't run within
                // the business method's tx.
                SessionContextImpl sc = (SessionContextImpl) inv.context;
                Transaction tx = sc.getTransaction();
                if (tx != null) {
                    ContainerSynchronization sync = ejbContainerUtilImpl.getContainerSync(tx);
                    sync.removeBean(sc);
                }
            }
        }
        super.postInvokeTx(inv);
    }


    /**
     * Should only be called when a method is known to be a remove method.
     *
     * @return true if the removal should be skipped, false otherwise.
     */
    private boolean retainAfterRemoveMethod(EjbInvocation inv, EjbRemovalInfo rInfo) {
        return rInfo.getRetainIfException() && inv.exceptionFromBeanMethod != null
            && isApplicationException(inv.exceptionFromBeanMethod);
    }


    /**
     * Called from preInvoke which is called from the EJBObject for local and
     * remote invocations.
     */
    @Override
    public void releaseContext(EjbInvocation inv) {
        SessionContextImpl sc = (SessionContextImpl) inv.context;

        // Make sure everything is within try block so we can be assured that
        // any instance lock is released in the finally block.
        try {
            // check if the bean was destroyed
            if (sc.getState() == BeanState.DESTROYED) {
                return;
            }

            // we're sure that no concurrent thread can be using this
            // context, so no need to synchronize.
            Transaction tx = sc.getTransaction();

            // If this was an invocation of a remove-method
            if (inv.invocationInfo.removalInfo != null) {
                InvocationInfo invInfo = inv.invocationInfo;
                EjbRemovalInfo removeInfo = invInfo.removalInfo;
                if (retainAfterRemoveMethod(inv, removeInfo)) {
                    _logger.log(Level.FINE, "Skipping destruction of SFSB " + invInfo.ejbName + " after @Remove method "
                        + invInfo.method + " due to (retainIfException" + " == true) and exception " + inv.exception);
                } else {
                    try {
                        destroyBean(inv, sc);
                    } catch (Throwable t) {
                        _logger.log(Level.FINE, "@Remove.preDestroy exception", t);
                    }

                    // Explicitly null out transaction association in bean's context.
                    // Otherwise, forceDestroyBean() will mark that tx for rollback,
                    // which could incorrectly rollback a client-propagated transaction.
                    sc.setTransaction(null);

                    forceDestroyBean(sc);

                    // The bean has been detroyed so just skip any remaining processing.
                    return;
                }
            }

            if (tx == null || tx.getStatus() == Status.STATUS_NO_TRANSACTION) {
                // The Bean executed with no tx, or with a tx and
                // container.afterCompletion() was already called.
                if (sc.getState() != BeanState.READY) {
                    if (sc.isAfterCompletionDelayed()) {
                        // ejb.afterCompletion was not called yet
                        // because of container.afterCompletion may have
                        // been called concurrently with this invocation.
                        if (_logger.isLoggable(Level.FINE)) {
                            logTraceInfo(inv, sc, "Calling delayed afterCompletion");
                        }
                        callEjbAfterCompletion(sc, sc.getCompletedTxStatus());
                    }

                    if (sc.getState() != BeanState.DESTROYED) {
                        // callEjbAfterCompletion could make state as DESTROYED
                        sc.setState(BeanState.READY);
                        handleEndOfMethodCheckpoint(sc, inv);
                    }
                }
                if (sc.getState() != BeanState.DESTROYED && isHAEnabled) {
                    syncClientVersion(inv, sc);
                }
            } else {
                if (sc.getState() != BeanState.DESTROYED && isHAEnabled) {
                    syncClientVersion(inv, sc);
                }
                sc.setState(BeanState.INCOMPLETE_TX);
                if (_logger.isLoggable(Level.FINE)) {
                    logTraceInfo(inv, sc, "Marking state == INCOMPLETE_TX");
                }
            }
        } catch (SystemException ex) {
            throw new EJBException(ex);
        } finally {
            releaseSFSBSerializedLock(inv, sc);
        }
    }


    private void releaseSFSBSerializedLock(EjbInvocation inv, SessionContextImpl sc) {
        if (inv.holdingSFSBSerializedLock()) {
            inv.setHoldingSFSBSerializedLock(false);
            sc.getStatefulWriteLock().unlock();
        }
    }


    @Override
    protected void afterBegin(EJBContextImpl context) {
        // TX_BEAN_MANAGED EJBs cannot implement SessionSynchronization
        // Do not call afterBegin if it is a transactional lifecycle callback
        if (isBeanManagedTran || ((SessionContextImpl) context).getInLifeCycleCallback()) {
            return;
        }

        // Note: this is only called for business methods.
        // For SessionBeans non-business methods are never called with a Tx.
        Object ejb = context.getEJB();
        if (afterBeginMethod != null) {
            try {
                afterBeginMethod.invoke(ejb);
            } catch (Exception ex) {
                // Error during afterBegin, so discard bean: EJB2.0 18.3.3
                forceDestroyBean(context);
                throw new EJBException("Error during SessionSynchronization.afterBegin(), EJB instance discarded", ex);
            }
        }

        // Register CMT Beans for end of Tx Checkpointing
        // Note:- We will never reach here for TX_BEAN_MANAGED
        if (isHAEnabled) {
            try {
                final ContainerSynchronization cSync = ejbContainerUtilImpl.getContainerSync(context.getTransaction());
                cSync.registerForTxCheckpoint((SessionContextImpl) context);
            } catch (jakarta.transaction.RollbackException rollEx) {
                _logger.log(Level.WARNING, CANNOT_REGISTER_BEAN_FOR_CHECKPOINTING, rollEx);
            } catch (jakarta.transaction.SystemException sysEx) {
                _logger.log(Level.WARNING, CANNOT_REGISTER_BEAN_FOR_CHECKPOINTING, sysEx);
            }
        }
    }


    @Override
    protected void beforeCompletion(EJBContextImpl context) {
        // SessionSync calls on TX_BEAN_MANAGED SessionBeans
        // are not allowed
        // Do not call beforeCompletion if it is a transactional lifecycle callback
        if (isBeanManagedTran || beforeCompletionMethod == null
            || ((SessionContextImpl) context).getInLifeCycleCallback()) {
            return;
        }

        Object ejb = context.getEJB();

        // No need to check for a concurrent invocation
        // because beforeCompletion can only be called after
        // all business methods are completed.

        EjbInvocation inv = super.createEjbInvocation(ejb, context);
        invocationManager.preInvoke(inv);
        try {
            transactionManager.enlistComponentResources();
            beforeCompletionMethod.invoke(ejb, null);
        } catch (Exception ex) {
            // Error during beforeCompletion, so discard bean: EJB2.0 18.3.3
            try {
                forceDestroyBean(context);
            } catch (Exception e) {
                _logger.log(Level.FINE, "error destroying bean", e);
            }
            throw new EJBException("Error during SessionSynchronization.beforeCompletion, EJB instance discarded", ex);
        } finally {
            invocationManager.postInvoke(inv);
        }
    }


    // Called from SyncImpl.afterCompletion
    // May be called asynchronously during tx timeout
    // or on the same thread as tx.commit
    @Override
    protected void afterCompletion(EJBContextImpl context, int status) {
        if (context.getState() == BeanState.DESTROYED) {
            return;
        }

        SessionContextImpl sc = (SessionContextImpl) context;
        boolean committed = (status == Status.STATUS_COMMITTED) || (status == Status.STATUS_NO_TRANSACTION);

        sc.setTransaction(null);

        // Do not call afterCompletion if it is a transactional lifecycle callback
        if (sc.getInLifeCycleCallback()) {
            return;
        }

        // SessionSync calls on TX_BEAN_MANAGED SessionBeans
        // are not allowed.
        if (!isBeanManagedTran && afterCompletionMethod != null) {

            // Check for a concurrent invocation
            // because afterCompletion can be called asynchronously
            // during rollback because of transaction timeout
            if (sc.getState() == BeanState.INVOKING && !sc.isTxCompleting()) {
                // Cant invoke ejb.afterCompletion now because there is
                // already some invocation in progress on the ejb.
                sc.setAfterCompletionDelayed(true);
                sc.setCompletedTxStatus(committed);
                if (_logger.isLoggable(Level.FINE)) {
                    logTraceInfo(sc, "AfterCompletion delayed");
                }
                return;
            }
            callEjbAfterCompletion(sc, committed);
        }

        // callEjbAfterCompletion can set state as DESTROYED
        if (sc.getState() != BeanState.DESTROYED) {
            if (isHAEnabled) {
                if (isBeanManagedTran) {
                    sc.setTxCheckpointDelayed(true);
                    if (_logger.isLoggable(Level.FINE)) {
                        logTraceInfo(sc, "(BMT)Checkpoint delayed");
                    }
                }
            } else {
                if (!isBeanManagedTran) {
                    if (_logger.isLoggable(Level.FINE)) {
                        logTraceInfo(sc, "Released context");
                    }
                    sc.setState(BeanState.READY);
                    incrementMethodReadyStat();
                }
            }
        }
    }


    SimpleMetadata getSFSBBeanState(final SessionContextImpl sc) {
        // No need to synchronize
        SimpleMetadata simpleMetadata = null;
        try {
            if (containerState != CONTAINER_STARTED && containerState != CONTAINER_STOPPED) {
                _logger.log(Level.FINE, "getSFSBBeanState() returning because " + "containerState: " + containerState);
                return null;
            }

            if (sc.getState() == BeanState.DESTROYED) {
                return null;
            }

            Object ejb = sc.getEJB();
            EjbInvocation ejbInv = createEjbInvocation(ejb, sc);
            invocationManager.preInvoke(ejbInv);
            boolean needToDoPostInvokeTx = false;
            boolean destroyBean = false;

            synchronized (sc) {
                try {
                    needToDoPostInvokeTx = callLifecycleCallbackInTxIfUsed(ejbInv, sc, prePassivateInvInfo,
                        CallbackType.PRE_PASSIVATE);
                    sc.setLastPersistedAt(System.currentTimeMillis());
                    long newCtxVersion = sc.incrementAndGetVersion();
                    byte[] serializedState = serializeContext(sc);
                    simpleMetadata = new SimpleMetadata(sc.getVersion(), System.currentTimeMillis(),
                        removalGracePeriodInSeconds * 1000L, serializedState);
                    simpleMetadata.setVersion(newCtxVersion);
                    needToDoPostInvokeTx = callLifecycleCallbackInTxIfUsed(ejbInv, sc, postActivateInvInfo,
                        CallbackType.POST_ACTIVATE);
                    // Do not set sc.setExistsInStore() here
                } catch (NotSerializableException serEx) {
                    _logger.log(Level.WARNING, ERROR_DURING_CHECKPOINT_3PARAMs,
                        new Object[] {ejbDescriptor.getName(), sc.getInstanceKey(), serEx});
                    _logger.log(Level.FINE, "sfsb checkpoint error. Key: " + sc.getInstanceKey(), serEx);
                    destroyBean = true;
                } catch (Throwable ex) {
                    _logger.log(Level.WARNING, SFSB_CHECKPOINT_ERROR_NAME, new Object[] {ejbDescriptor.getName()});
                    _logger.log(Level.WARNING, SFSB_CHECKPOINT_ERROR_KEY, new Object[] {sc.getInstanceKey(), ex});
                    destroyBean = true;
                } finally {
                    invocationManager.postInvoke(ejbInv);
                    completeLifecycleCallbackTxIfUsed(ejbInv, sc, needToDoPostInvokeTx);
                    if (destroyBean) {
                        try {
                            forceDestroyBean(sc);
                        } catch (Exception e) {
                            _logger.log(Level.FINE, "error destroying bean", e);
                        }
                    }
                }
            } //synchronized
        } catch (Throwable th) {
            _logger.log(Level.WARNING, SFSB_CHECKPOINT_ERROR_NAME, new Object[]{ejbDescriptor.getName(), th});
        }
        return simpleMetadata;
    }


    void txCheckpointCompleted(SessionContextImpl sc) {
        if (sc.getState() != BeanState.DESTROYED) {
            // We did persist this ctx in the store
            sc.setExistsInStore(true);
            sc.setState(BeanState.READY);
            incrementMethodReadyStat();
        }
    }


    private void callEjbAfterCompletion(SessionContextImpl context, boolean status) {
        if (afterCompletionMethod == null) {
            return;
        }
        Object ejb = context.getEJB();
        EjbInvocation ejbInv = createEjbInvocation(ejb, context);
        invocationManager.preInvoke(ejbInv);
        try {
            context.setInAfterCompletion(true);
            afterCompletionMethod.invoke(ejb, status);

            // reset flags
            context.setAfterCompletionDelayed(false);
            context.setTxCompleting(false);
        } catch (Exception ex) {
            Throwable realException = ex;
            if (ex instanceof InvocationTargetException) {
                realException = ((InvocationTargetException) ex).getTargetException();
            }
            // Error during afterCompletion, so discard bean: EJB2.0 18.3.3
            try {
                forceDestroyBean(context);
            } catch (Exception e) {
                _logger.log(Level.FINE, "error destroying bean", e);
            }

            _logger.log(Level.INFO, AFTER_COMPLETION_EXCEPTION, realException);

            // No use throwing an exception here, since the tx has already
            // completed, and afterCompletion may be called asynchronously
            // when there is no client to receive the exception.
        } finally {
            context.setInAfterCompletion(false);
            invocationManager.postInvoke(ejbInv);
        }
    }


    public boolean canPassivateEJB(ComponentContext context) {
        SessionContextImpl sc = (SessionContextImpl) context;
        return sc.getState() == BeanState.READY;
    }


    // called asynchronously from the Recycler
    @Override
    public boolean passivateEJB(ComponentContext context) {
        SessionContextImpl sc = (SessionContextImpl) context;
        boolean success = false;
        try {
            if (ejbDescriptor.getApplication().getKeepStateResolved() == false) {
                if (containerState != CONTAINER_STARTED && containerState != CONTAINER_STOPPED) {
                    _logger.log(Level.WARNING, PASSIVATE_EJB_RETURNING_BECAUSE_CONTAINER_STATE, containerState);
                    return false;
                }
            }

            if (sc.getState() == BeanState.DESTROYED) {
                return false;
            }
            if (_logger.isLoggable(Level.FINE)) {
                _logger.log(Level.FINE, traceInfoPrefix + "Passivating context " + sc.getInstanceKey()
                    + "; current-state = " + convertCtxStateToString(sc));
            }

            Object ejb = sc.getEJB();
            EjbInvocation ejbInv = createEjbInvocation(ejb, sc);
            invocationManager.preInvoke(ejbInv);
            success = false;
            boolean needToDoPostInvokeTx = false;
            boolean destroyBean = false;
            synchronized (sc) {
                try {
                    // dont passivate if there is a Tx/invocation in progress
                    // for this instance.
                    if (!sc.canBePassivated()) {
                        return false;
                    }

                    Serializable instanceKey = (Serializable) sc.getInstanceKey();
                    if (sessionBeanCache.eligibleForRemovalFromCache(sc, instanceKey)) {
                        // remove the EJB since removal-timeout has elapsed
                        sc.setState(BeanState.DESTROYED);
                        needToDoPostInvokeTx = callLifecycleCallbackInTxIfUsed(ejbInv, sc, preDestroyInvInfo,
                            CallbackType.PRE_DESTROY);
                        sessionBeanCache.remove(instanceKey, sc.existsInStore());
                    } else {
                        // passivate the EJB
                        sc.setState(BeanState.PASSIVATED);
                        decrementMethodReadyStat();
                        needToDoPostInvokeTx = callLifecycleCallbackInTxIfUsed(ejbInv, sc, prePassivateInvInfo,
                            CallbackType.PRE_PASSIVATE);
                        sc.setLastPersistedAt(System.currentTimeMillis());
                        boolean saved = false;
                        try {
                            saved = sessionBeanCache.passivateEJB(sc, instanceKey);
                        } catch (EMNotSerializableException emNotSerEx) {
                            _logger.log(Level.WARNING, EXTENDED_EM_NOT_SERIALIZABLE, emNotSerEx);
                            _logger.log(Level.FINE, "Extended EM not serializable", emNotSerEx);
                            saved = false;
                        }
                        if (!saved) {
                            // TODO - add a flag to reactivate in the same tx
                            // Complete previous tx
                            completeLifecycleCallbackTxIfUsed(ejbInv, sc, needToDoPostInvokeTx);

                            needToDoPostInvokeTx = callLifecycleCallbackInTxIfUsed(ejbInv, sc, postActivateInvInfo,
                                CallbackType.POST_ACTIVATE);
                            sc.setState(BeanState.READY);
                            incrementMethodReadyStat();
                            return false;
                        }
                    }

                    // V2: sfsbStoreMonitor.incrementPassivationCount(true);
                    cacheProbeNotifier.ejbBeanPassivatedEvent(getContainerId(), containerInfo.appName,
                        containerInfo.modName, containerInfo.ejbName, true);
                    transactionManager.componentDestroyed(sc);

                    decrementRefCountsForEEMs(sc);

                    if (isRemote) {
                        if (hasRemoteHomeView) {
                            // disconnect the EJBObject from the EJB
                            EJBObjectImpl ejbObjImpl = sc.getEJBObjectImpl();
                            ejbObjImpl.clearContext();
                            sc.setEJBObjectImpl(null);

                            // disconnect the EJBObject from ProtocolManager
                            // so that no state is held by ProtocolManager
                            remoteHomeRefFactory.destroyReference(ejbObjImpl.getStub(), ejbObjImpl.getEJBObject());
                        }
                        if (hasRemoteBusinessView) {
                            // disconnect the EJBObject from the EJB
                            EJBObjectImpl ejbBusinessObjImpl = sc.getEJBRemoteBusinessObjectImpl();
                            ejbBusinessObjImpl.clearContext();
                            sc.setEJBRemoteBusinessObjectImpl(null);

                            for (RemoteBusinessIntfInfo next : remoteBusinessIntfInfo.values()) {
                                next.referenceFactory.destroyReference(ejbBusinessObjImpl.getStub(),
                                    ejbBusinessObjImpl.getEJBObject(next.generatedRemoteIntf.getName()));
                            }
                        }
                    }
                    if (isLocal) {
                        long version = sc.getVersion();

                        if (hasLocalHomeView) {
                            // disconnect the EJBLocalObject from the EJB
                            EJBLocalObjectImpl localObjImpl = sc.getEJBLocalObjectImpl();
                            localObjImpl.setSfsbClientVersion(version);
                            localObjImpl.clearContext();
                            sc.setEJBLocalObjectImpl(null);
                        }
                        if (hasLocalBusinessView) {
                            EJBLocalObjectImpl localBusinessObjImpl = sc.getEJBLocalBusinessObjectImpl();
                            localBusinessObjImpl.setSfsbClientVersion(version);
                            localBusinessObjImpl.clearContext();
                            sc.setEJBLocalBusinessObjectImpl(null);
                        }
                        if (hasOptionalLocalBusinessView) {
                            EJBLocalObjectImpl optLocalBusObjImpl = sc.getOptionalEJBLocalBusinessObjectImpl();
                            optLocalBusObjImpl.setSfsbClientVersion(version);
                            optLocalBusObjImpl.clearContext();
                            sc.setOptionalEJBLocalBusinessObjectImpl(null);
                        }
                    }
                    if (_logger.isLoggable(Level.FINE)) {
                        logTraceInfo(sc, "Successfully passivated");
                    }
                } catch (java.io.NotSerializableException nsEx) {
                    // V2: sfsbStoreMonitor.incrementPassivationCount(false);
                    cacheProbeNotifier.ejbBeanPassivatedEvent(getContainerId(), containerInfo.appName,
                        containerInfo.modName, containerInfo.ejbName, false);
                    _logger.log(Level.WARNING, ERROR_DURING_PASSIVATION, new Object[] {sc, nsEx});
                    _logger.log(Level.FINE, "sfsb passivation error", nsEx);
                    // Error during passivate, so discard bean: EJB2.0 18.3.3
                    destroyBean = true;
                } catch (Throwable ex) {
                    // V2: sfsbStoreMonitor.incrementPassivationCount(false);
                    cacheProbeNotifier.ejbBeanPassivatedEvent(getContainerId(), containerInfo.appName,
                        containerInfo.modName, containerInfo.ejbName, false);
                    _logger.log(Level.WARNING, PASSIVATION_ERROR_1PARAM,
                        new Object[] {ejbDescriptor.getName() + " <==> " + sc});
                    _logger.log(Level.WARNING, SFSB_PASSIVATION_ERROR_1PARAM, new Object[] {sc.getInstanceKey(), ex});
                    // Error during passivate, so discard bean: EJB2.0 18.3.3
                    destroyBean = true;
                } finally {
                    invocationManager.postInvoke(ejbInv);
                    completeLifecycleCallbackTxIfUsed(ejbInv, sc, needToDoPostInvokeTx);
                    if (destroyBean) {
                        try {
                            forceDestroyBean(sc);
                        } catch (Exception e) {
                            _logger.log(Level.FINE, "error destroying bean", e);
                        }
                    }
                }
            } //synchronized
        } catch (Exception ex) {
            _logger.log(Level.WARNING, PASSIVATION_ERROR_1PARAM, new Object[]{ejbDescriptor.getName(), ex});
        }
        return success;

    }


    @Override
    public int getPassivationBatchCount() {
        return this.passivationBatchCount;
    }


    public void setPassivationBatchCount(int count) {
        this.passivationBatchCount = count;
    }


    // called asynchronously from the Recycler
    @Override
    public boolean passivateEJB(StatefulEJBContext sfsbCtx) {
        return passivateEJB((ComponentContext) sfsbCtx.getSessionContext());
    }


    public long getMethodReadyCount() {
        return statMethodReadyCount;
    }


    public long getPassiveCount() {
        return sfsbStoreMonitor == null ? 0 : sfsbStoreMonitor.getNumPassivations();
    }


    // called from StatefulSessionStore
    @Override
    public void activateEJB(Object sessionKey, StatefulEJBContext sfsbCtx, Object cookie) {
        SessionContextImpl context = (SessionContextImpl) sfsbCtx.getSessionContext();

        if (_logger.isLoggable(Level.FINE)) {
            logTraceInfo(context, "Attempting to activate");
        }

        EJBLocalRemoteObject ejbObject = (EJBLocalRemoteObject) cookie;
        Object ejb = context.getEJB();

        EjbInvocation ejbInv = createEjbInvocation(ejb, context);
        invocationManager.preInvoke(ejbInv);
        boolean needToDoPostInvokeTx = false;
        try {
            // we're sure that no concurrent thread can be using this bean
            // so no need to synchronize.

            // No need to call enlistComponentResources here because
            // ejbActivate executes in unspecified tx context (spec 6.6.1)

            // Set the timestamp here, else Recycler might remove this bean!
            context.touch();

            context.setContainer(this);
            context.setState(BeanState.READY);
            incrementMethodReadyStat();
            context.setInstanceKey(sessionKey);
            context.setExistsInStore(true);
            context.initializeStatefulWriteLock();

            if (ejbObject == null) {
                // This MUST be a remote invocation
                if (hasRemoteHomeView) {
                    createEJBObjectImpl(context);
                } else {
                    createRemoteBusinessObjectImpl(context);
                }
            } else if (ejbObject instanceof EJBObjectImpl) {
                EJBObjectImpl eo = (EJBObjectImpl) ejbObject;
                ejbObject.setContext(context);
                ejbObject.setKey(sessionKey);
                byte[] sessionOID = uuidGenerator.keyToByteArray(sessionKey);
                if (eo.isRemoteHomeView()) {
                    // introduce context and EJBObject to each other
                    context.setEJBObjectImpl(eo);

                    EJBObject ejbStub = (EJBObject) remoteHomeRefFactory.createRemoteReference(sessionOID);
                    eo.setStub(ejbStub);
                    context.setEJBStub(ejbStub);

                    if (hasRemoteBusinessView) {
                        createRemoteBusinessObjectImpl(context);
                    }
                } else {
                    context.setEJBRemoteBusinessObjectImpl(eo);
                    for (RemoteBusinessIntfInfo next : remoteBusinessIntfInfo.values()) {
                        Remote stub = next.referenceFactory.createRemoteReference(sessionOID);
                        eo.setStub(next.generatedRemoteIntf.getName(), stub);
                    }
                    if (hasRemoteHomeView) {
                        createEJBObjectImpl(context);
                    }
                }
                if (isLocal) {
                    // create localObj too
                    if (hasLocalHomeView) {
                        createEJBLocalObjectImpl(context);
                    }
                    if (hasLocalBusinessView) {
                        createEJBLocalBusinessObjectImpl(context);
                    }
                    if (hasOptionalLocalBusinessView) {
                        createOptionalEJBLocalBusinessObjectImpl(context);
                    }
                }
            } else if (ejbObject instanceof EJBLocalObjectImpl) {
                EJBLocalObjectImpl elo = (EJBLocalObjectImpl) ejbObject;
                ejbObject.setContext(context);
                ejbObject.setKey(sessionKey);

                if (elo.isLocalHomeView()) {
                    context.setEJBLocalObjectImpl(elo);
                    if (hasLocalBusinessView) {
                        createEJBLocalBusinessObjectImpl(context);
                    }
                    if (hasOptionalLocalBusinessView) {
                        createOptionalEJBLocalBusinessObjectImpl(context);
                    }
                } else if( elo.isOptionalLocalBusinessView() ) {
                    context.setOptionalEJBLocalBusinessObjectImpl(elo);
                    if (hasLocalBusinessView) {
                        createEJBLocalBusinessObjectImpl(context);
                    }
                    if (hasLocalHomeView) {
                        createEJBLocalObjectImpl(context);
                    }
                } else {
                    context.setEJBLocalBusinessObjectImpl(elo);
                    if (hasLocalHomeView) {
                        createEJBLocalObjectImpl(context);
                    }
                    if (hasOptionalLocalBusinessView) {
                        createOptionalEJBLocalBusinessObjectImpl(context);
                    }
                }

                if (hasRemoteHomeView) {
                    // create remote obj too
                    createEJBObjectImpl(context);
                }
                if (hasRemoteBusinessView) {
                    createRemoteBusinessObjectImpl(context);
                }
            }

            // Now populate the EEM maps in this context
            repopulateEEMMapsInContext(sessionKey, context);

            try {
                needToDoPostInvokeTx = callLifecycleCallbackInTxIfUsed(ejbInv, context, postActivateInvInfo,
                    CallbackType.POST_ACTIVATE);
            } catch (Throwable th) {
                EJBException ejbEx = new EJBException("Error during activation" + sessionKey);
                ejbEx.initCause(th);
                throw ejbEx;
            }
            long now = System.currentTimeMillis();
            try {
                backingStore.updateTimestamp((Serializable) sessionKey, now);
                context.setLastPersistedAt(now);
            } catch (BackingStoreException sfsbEx) {
                _logger.log(Level.WARNING, COULDNT_UPDATE_TIMESTAMP_FOR_EXCEPTION, new Object[]{sessionKey, sfsbEx});
                _logger.log(Level.FINE, "Couldn't update timestamp for: " + sessionKey, sfsbEx);
            }

            if (_logger.isLoggable(Level.FINE)) {
                logTraceInfo(context, "Successfully activated");
            }
            _logger.log(Level.FINE, "Activated: {0}", sessionKey);
        } catch (Exception ex) {
            if (_logger.isLoggable(Level.FINE)) {
                logTraceInfo(context, "Failed to activate");
            }
            _logger.log(Level.SEVERE, SFSB_ACTIVATION_ERROR, new Object[]{sessionKey, ex});
            _logger.log(Level.SEVERE, "", ex);

            throw new EJBException("Unable to activate EJB for key: " + sessionKey, ex);
        } finally {
            invocationManager.postInvoke(ejbInv);
            completeLifecycleCallbackTxIfUsed(ejbInv, context, needToDoPostInvokeTx);
        }
    }


    @Override
    public byte[] serializeContext(StatefulEJBContext ctx) throws IOException {
        return serializeContext((SessionContextImpl)ctx.getSessionContext());
    }

    @Override
    public Object deserializeData(byte[] data) throws Exception {
        Object object = ejbContainerUtilImpl.getJavaEEIOUtils().deserializeObject(data, true, getClassLoader());
        if (object instanceof SessionContextImpl) {
            SessionContextImpl ctx = (SessionContextImpl) object;
            Object ejb = ctx.getEJB();
            if (_logger.isLoggable(Level.FINE)) {
                _logger.log(Level.FINE,
                    "StatefulSessionContainer.deserializeData: " + (ejb == null ? null : ejb.getClass()));
            }

            if (ejb instanceof SerializableEJB) {
                SerializableEJB sejb = (SerializableEJB) ejb;
                try (ByteArrayInputStream bis = new ByteArrayInputStream(sejb.serializedFields);
                    ObjectInputStream ois = ejbContainerUtilImpl.getJavaEEIOUtils().createObjectInputStream(bis, true,
                        getClassLoader());) {

                    ejb = ejbClass.getDeclaredConstructor().newInstance();
                    EJBUtils.deserializeObjectFields(ejb, ois, object, false);
                    ctx.setEJB(ejb);
                }
            }
        }
        return object;
    }


    private byte[] serializeContext(SessionContextImpl ctx) throws IOException {
        Object ejb = ctx.getEJB();
        if (!(ejb instanceof Serializable
            || ejb.getClass().getName().equals(getGeneratedSerializableClassName(ejbName)))) {

            ctx.setEJB(null);
            ctx.setEJB(new SerializableEJB(ejb));
        }
        return ejbContainerUtilImpl.getJavaEEIOUtils().serializeObject(ctx, true);
    }


    private void decrementRefCountsForEEMs(SessionContextImpl context) {
        Collection<EEMRefInfo> allRefInfos = context.getAllEEMRefInfos();
        for (EEMRefInfo refInfo : allRefInfos) {
            EEMRefInfoKey key = refInfo.getKey();
            synchronized (extendedEMReferenceCountMap) {
                EEMRefInfo cachedRefInfo = extendedEMReferenceCountMap.get(refInfo.eem);
                if (cachedRefInfo != null) {
                    cachedRefInfo.refCount--;
                    if (cachedRefInfo.refCount == 0) {
                        extendedEMReferenceCountMap.remove(refInfo.eem);
                        eemKey2EEMMap.remove(key);
                    }
                }
            }
        }
    }


    private void repopulateEEMMapsInContext(Object sessionKey, SessionContextImpl context) {
        Collection<EEMRefInfo> allRefInfos = context.getAllEEMRefInfos();
        for (EEMRefInfo refInfo : allRefInfos) {
            EEMRefInfoKey key = refInfo.getKey();
            synchronized (extendedEMReferenceCountMap) {
                EntityManager eMgr = eemKey2EEMMap.get(key);
                EEMRefInfo newRefInfo = null;
                if (eMgr != null) {
                    EEMRefInfo cachedRefInfo = extendedEMReferenceCountMap.get(eMgr);
                    // cachedRefInfo cannot be null
                    context.addExtendedEntityManagerMapping(cachedRefInfo.getEntityManagerFactory(), cachedRefInfo);
                    cachedRefInfo.refCount++;
                    newRefInfo = cachedRefInfo;
                } else {
                    // Deserialize em from the byte[]
                    String emRefName = key.emRefName;
                    String unitName = refInfo.getUnitName();
                    EntityManagerFactory emf = EntityManagerFactoryWrapper.lookupEntityManagerFactory(
                        ComponentInvocationType.EJB_INVOCATION, unitName, ejbDescriptor);
                    if (emf != null) {
                        try (ByteArrayInputStream bis = new ByteArrayInputStream(refInfo.serializedEEM);
                            ObjectInputStream ois = new ObjectInputStream(bis);) {
                            eMgr = (EntityManager) ois.readObject();
                            newRefInfo = new EEMRefInfo(emRefName, unitName, refInfo.getSynchronizationType(),
                                super.getContainerId(), sessionKey, eMgr, emf);
                            newRefInfo.refCount = 1;
                            extendedEMReferenceCountMap.put(eMgr, newRefInfo);
                            eemKey2EEMMap.put(newRefInfo.getKey(), newRefInfo.getEntityManager());
                        } catch (Throwable th) {
                            EJBException ejbEx = new EJBException(
                                "Couldn't create EntityManager for refName: " + emRefName);
                            ejbEx.initCause(th);
                            throw ejbEx;
                        }
                    } else {
                        throw new EJBException(
                            "EMF is null. Couldn't get extended EntityManager for refName: " + emRefName);
                    }
                }
                context.addExtendedEntityManagerMapping(newRefInfo.getEntityManagerFactory(), newRefInfo);
            }
        }
    }


    @Override
    protected void validateEMForClientTx(EjbInvocation inv, JavaEETransaction clientJ2EETx) throws EJBException {
        SessionContextImpl sessionCtx = (SessionContextImpl) inv.context;
        Map<EntityManagerFactory, PhysicalEntityManagerWrapper> entityManagerMap = sessionCtx
            .getExtendedEntityManagerMap();

        for (Map.Entry<EntityManagerFactory, PhysicalEntityManagerWrapper> entry : entityManagerMap.entrySet()) {
            EntityManagerFactory emf = entry.getKey();

            // Make sure there is no Transactional persistence context for the same
            // EntityManagerFactory as this SFSB's Extended persistence context for
            // the propagated transaction.
            if (clientJ2EETx.getTxEntityManagerResource(emf) != null) {
                throw new EJBException(
                    "There is an active transactional persistence context for the same EntityManagerFactory"
                        + " as the current stateful session bean's extended persistence context");
            }

            // Now see if there's already a *different* extended persistence context within this
            // transaction for the same EntityManagerFactory.
            PhysicalEntityManagerWrapper physicalEM = (PhysicalEntityManagerWrapper) clientJ2EETx
                .getExtendedEntityManagerResource(emf);
            if ((physicalEM != null) && entry.getValue().getEM() != physicalEM.getEM()) {
                throw new EJBException(
                    "Detected two different extended persistence contexts for the same EntityManagerFactory"
                        + " within a transaction");
            }
        }
    }


    @Override
    protected void enlistExtendedEntityManagers(ComponentContext ctx) {
        if (ctx.getTransaction() == null) {
            return;
        }
        JavaEETransaction j2eeTx = (JavaEETransaction) ctx.getTransaction();
        SessionContextImpl sessionCtx = (SessionContextImpl) ctx;
        Map<EntityManagerFactory, PhysicalEntityManagerWrapper> entityManagerMap = sessionCtx
            .getExtendedEntityManagerMap();

        for (Map.Entry<EntityManagerFactory, PhysicalEntityManagerWrapper> entry : entityManagerMap.entrySet()) {
            EntityManagerFactory emf = entry.getKey();
            PhysicalEntityManagerWrapper extendedEm = entry.getValue();

            PhysicalEntityManagerWrapper extendedEmAssociatedWithTx = EntityManagerWrapper
                .getExtendedEntityManager(j2eeTx, emf);

            // If there's not already an EntityManager registered for
            // this extended EntityManagerFactory within the current tx
            if (extendedEmAssociatedWithTx == null) {
                j2eeTx.addExtendedEntityManagerMapping(emf, extendedEm);
                sessionCtx.setEmfRegisteredWithTx(emf, true);

                // Tell persistence provider to associate the extended
                // entity manager with the transaction.
                if (extendedEm.getSynchronizationType() == SYNCHRONIZED) {
                    extendedEm.getEM().joinTransaction();
                }
            }
        }
    }


    @Override
    protected void delistExtendedEntityManagers(ComponentContext ctx) {
        if (ctx.getTransaction() == null) {
            return;
        }
        SessionContextImpl sessionCtx = (SessionContextImpl) ctx;
        JavaEETransaction j2eeTx = (JavaEETransaction) sessionCtx.getTransaction();
        Map<EntityManagerFactory, PhysicalEntityManagerWrapper> entityManagerMap = sessionCtx
            .getExtendedEntityManagerMap();
        for (Map.Entry<EntityManagerFactory, PhysicalEntityManagerWrapper> entry : entityManagerMap.entrySet()) {
            EntityManagerFactory emf = entry.getKey();
            if (sessionCtx.isEmfRegisteredWithTx(emf)) {
                j2eeTx.removeExtendedEntityManagerMapping(emf);
                sessionCtx.setEmfRegisteredWithTx(emf, false);
            }
        }
    }


    @Override
    public void invokePeriodically(long delay, long periodicity, Runnable target) {
        Timer timer = ejbContainerUtilImpl.getTimer();
        TimerTask timerTask = new PeriodicTask(super.loader, target, ejbContainerUtilImpl);
        timer.scheduleAtFixedRate(timerTask, delay, periodicity);
        scheduledTimerTasks.add(timerTask);
    }


    // Called from Cache implementation through ContainerCallback
    // when cache.undeploy() is invoked
    public void onUndeploy(StatefulEJBContext sfsbCtx) {
        undeploy((SessionContextImpl) sfsbCtx.getSessionContext());
    }


    @Override
    protected String[] getPre30LifecycleMethodNames() {
        return new String[] {null, null, "ejbRemove", "ejbPassivate", "ejbActivate"};
    }


    @Override
    protected void doConcreteContainerShutdown(boolean appBeingUndeployed) {
        cancelAllTimerTasks();
        if (appBeingUndeployed && (ejbDescriptor.getApplication().getKeepStateResolved() == false)) {
            removeBeansOnUndeploy();
        } else {
            if (_logger.isLoggable(Level.FINE)) {
                _logger.log(Level.FINE,
                    "StatefulSessionContainer.doConcreteContainerShutdown() called with --keepstate="
                        + ejbDescriptor.getApplication().getKeepStateResolved());
            }
            passivateBeansOnShutdown();
        }
    }


    private void passivateBeansOnShutdown() {
        ClassLoader origLoader = Utility.setContextClassLoader(loader);
        try {
            _logger.log(Level.FINE, "Passivating SFSBs before container shutdown");
            if (!isPassivationCapable() && _logger.isLoggable(Level.INFO)) {
                _logger.log(Level.INFO, SFSB_NOT_RESTORED_AFTER_RESTART);
            }
            sessionBeanCache.shutdown();
            while (true) {
                ComponentContext ctx = null;
                synchronized (asyncTaskSemaphore) {
                    int sz = passivationCandidates.size();
                    if (sz > 0) {
                        ctx = (ComponentContext) passivationCandidates.remove(sz - 1);
                    } else {
                        break;
                    }
                }
                passivateEJB(ctx);
            }

            sessionBeanCache.destroy();
            cacheProbeListener.unregister();

            try {
                // backingStore will be null when passivation-capable is false
                if (backingStore != null) {
                    backingStore.close();
                }
            } catch (BackingStoreException sfsbEx) {
                _logger.log(Level.WARNING, ERROR_DURING_BACKING_STORE_SHUTDOWN, new Object[] {ejbName, sfsbEx});
            }
        } catch (Throwable th) {
            _logger.log(Level.WARNING, ERROR_DURING_ON_SHUTDOWN, new Object[] {ejbName, th});
        } finally {
            Utility.setContextClassLoader(origLoader);
        }
    }


    private void removeBeansOnUndeploy() {
        ClassLoader origLoader = Utility.setContextClassLoader(loader);
        long myContainerId = 0;
        try {
            myContainerId = getContainerId();
            _logger.log(Level.FINE, "Removing SFSBs during application undeploy");
            sessionBeanCache.setUndeployedState();
            Iterator iter = sessionBeanCache.values();
            while (iter.hasNext()) {
                SessionContextImpl ctx = (SessionContextImpl) iter.next();
                invokePreDestroyAndUndeploy(ctx);
            }

            while (true) {
                SessionContextImpl ctx = null;
                synchronized (asyncTaskSemaphore) {
                    int sz = passivationCandidates.size();
                    if (sz > 0) {
                        ctx = (SessionContextImpl) passivationCandidates.remove(sz - 1);
                        invokePreDestroyAndUndeploy(ctx);
                    } else {
                        break;
                    }
                }
            }

            sessionBeanCache.destroy();

            try {
                // backingStore will be null when passivation-capable is false
                if (backingStore != null) {
                    backingStore.destroy();
                }
            } catch (BackingStoreException sfsbEx) {
                _logger.log(Level.WARNING, ERROR_DURING_BACKING_STORE_SHUTDOWN, new Object[] {ejbName, sfsbEx});
            }
        } finally {
            if (sfsbVersionManager != null) {
                sfsbVersionManager.removeAll(myContainerId);
            }
            if (origLoader != null) {
                Utility.setContextClassLoader(origLoader);
            }
        }
    }


    private void invokePreDestroyAndUndeploy(SessionContextImpl ctx) {
        try {
            ctx.setInEjbRemove(true);
            destroyBean(null, ctx);
        } catch (Throwable t) {
            _logger.log(Level.FINE, "exception thrown from SFSB PRE_DESTROY", t);
        } finally {
            ctx.setInEjbRemove(false);
        }

        try {
            this.undeploy(ctx);
        } catch (Exception ex) {
            _logger.log(Level.WARNING, ERROR_WHILE_UNDEPLOYING_CTX_KEY, new Object[] {ejbName, ctx.getInstanceKey()});
            _logger.log(Level.FINE,
                "[" + ejbName + "]: Error while undeploying ctx. Key: " + ctx.getInstanceKey(), ex);
        }
    }


    private void cancelAllTimerTasks() {
        try {
            int size = scheduledTimerTasks.size();
            for (int i = 0; i < size; i++) {
                TimerTask task = (TimerTask) scheduledTimerTasks.get(i);
                task.cancel();
            }
        } catch (Exception ex) {
        } finally {
            scheduledTimerTasks.clear();
        }
    }


    private void destroyBean(EjbInvocation ejbInv, EJBContextImpl ctx) {
        if (ejbInv == null) {
            ejbInv = createEjbInvocation(ctx.getEJB(), ctx);
        }
        boolean inTx = false;
        try {
            invocationManager.preInvoke(ejbInv);
            inTx = callLifecycleCallbackInTxIfUsed(ejbInv, ctx, preDestroyInvInfo, CallbackType.PRE_DESTROY);
        } catch (Throwable t) {
            _logger.log(Level.FINE, "exception thrown from SFSB PRE_DESTROY", t);
        } finally {
            invocationManager.postInvoke(ejbInv);
            completeLifecycleCallbackTxIfUsed(ejbInv, ctx, inTx);
        }
    }


    /**
     * Start transaction if necessary and invoke lifecycle callback
     */
    private boolean callLifecycleCallbackInTxIfUsed(EjbInvocation ejbInv, EJBContextImpl ctx, InvocationInfo invInfo,
        CallbackType callbackType) throws Throwable {
        boolean inTx = invInfo.txAttr != -1 && invInfo.txAttr != Container.TX_BEAN_MANAGED;
        if (inTx) {
            ((SessionContextImpl) ctx).setInLifeCycleCallback(true);

            // Call preInvokeTx directly. InvocationInfo containing tx
            // attribute must be set prior to calling preInvoke
            ejbInv.transactionAttribute = invInfo.txAttr;
            ejbInv.invocationInfo = invInfo;
            preInvokeTx(ejbInv);
            enlistExtendedEntityManagers(ctx);
        }

        intercept(callbackType, ctx);
        return inTx;
    }


    /**
     * Complete transaction if necessary after lifecycle callback
     */
    private void completeLifecycleCallbackTxIfUsed(EjbInvocation ejbInv, EJBContextImpl ctx, boolean usedTx) {
        if (usedTx) {
            delistExtendedEntityManagers(ctx);
            try {
                postInvokeTx(ejbInv);
            } catch (Exception pie) {
                _logger.log(Level.FINE, "SFSB postInvokeTx exception", pie);
            }
            ((SessionContextImpl) ctx).setInLifeCycleCallback(false);
        }
    }


    public void undeploy(SessionContextImpl ctx) {
        if (this == ctx.getContainer()) {
            if (hasRemoteHomeView) {
                EJBObjectImpl ejbObjectImpl = ctx.getEJBObjectImpl();
                if (ejbObjectImpl != null) {
                    remoteHomeRefFactory.destroyReference(ejbObjectImpl.getStub(), ejbObjectImpl.getEJBObject());
                }
            }
            if (hasRemoteBusinessView) {
                EJBObjectImpl ejbBusinessObjectImpl = ctx.getEJBRemoteBusinessObjectImpl();
                if (ejbBusinessObjectImpl != null) {
                    for (RemoteBusinessIntfInfo next : remoteBusinessIntfInfo.values()) {
                        next.referenceFactory.destroyReference(
                            ejbBusinessObjectImpl.getStub(next.generatedRemoteIntf.getName()),
                            ejbBusinessObjectImpl.getEJBObject(next.generatedRemoteIntf.getName()));
                    }
                }
            }

            sessionBeanCache.remove(ctx.getInstanceKey(), ctx.existsInStore());
            destroyExtendedEMsForContext(ctx);
            transactionManager.componentDestroyed(ctx);
        }
    }


    // CacheListener interface
    @Override
    public void trimEvent(Object primaryKey, Object context) {
        boolean addTask = false;
        synchronized (asyncTaskSemaphore) {
            containerTrimCount++;
            passivationCandidates.add(context);
            int requiredTaskCount = (passivationCandidates.size() / passivationBatchCount);
            addTask = (asyncTaskCount < requiredTaskCount);

            if (_logger.isLoggable(Level.FINE)) {
                _logger.log(Level.FINE,
                    "qSize: " + passivationCandidates.size() + "; batchCount: " + passivationBatchCount
                        + "; asyncTaskCount: " + asyncTaskCount + "; requiredTaskCount: " + requiredTaskCount
                        + "; ADDED TASK ==> " + addTask);
            }

            if (addTask == false) {
                return;
            }
            asyncTaskCount++;
            asyncCummTaskCount++;
        }

        try {
            ASyncPassivator work = new ASyncPassivator();
            ejbContainerUtilImpl.addWork(work);
        } catch (Exception ex) {
            synchronized (asyncTaskSemaphore) {
                asyncTaskCount--;
            }
            _logger.log(Level.WARNING, ADD_CLEANUP_TASK_ERROR, ex);
        }

    }

    public void setSFSBUUIDUtil(SFSBUUIDUtil util) {
        this.uuidGenerator = util;
    }


    public void setHAEnabled(boolean isHAEnabled) {
        this.isHAEnabled = isHAEnabled;
    }


    public void setSessionCache(LruSessionCache cache) {
        this.sessionBeanCache = cache;
    }


    public void setRemovalGracePeriodInSeconds(int val) {
        this.removalGracePeriodInSeconds = val;
    }


    public void removeExpiredSessions() {
        try {
            _logger.log(Level.FINE, "StatefulContainer Removing expired sessions....");
            long val = 0;
            if (backingStore != null) {
                val = backingStore.removeExpired(this.removalGracePeriodInSeconds * 1000L);
            }

            if (cacheProbeNotifier != null) {
                cacheProbeNotifier.ejbExpiredSessionsRemovedEvent(getContainerId(), containerInfo.appName,
                    containerInfo.modName, containerInfo.ejbName, val);
            }
            _logger.log(Level.FINE, "StatefulContainer Removed " + val + " sessions....");

        } catch (Exception sfsbEx) {
            _logger.log(Level.WARNING, GOT_EXCEPTION_DURING_REMOVE_EXPIRED_SESSIONS, sfsbEx);
        }
    }


    public void setSFSBVersionManager(SFSBVersionManager sfsbVersionManager) {
        this.sfsbVersionManager = sfsbVersionManager;
    }


    private void handleEndOfMethodCheckpoint(SessionContextImpl sc, EjbInvocation inv) {
        int txAttr = inv.invocationInfo.txAttr;
        switch (txAttr) {
            case TX_NEVER:
            case TX_SUPPORTS:
            case TX_NOT_SUPPORTED:
                if (inv.invocationInfo.checkpointEnabled) {
                    checkpointEJB(sc);
                }
                break;
            case TX_BEAN_MANAGED:
                if (sc.isTxCheckpointDelayed() || inv.invocationInfo.checkpointEnabled) {
                    checkpointEJB(sc);
                    sc.setTxCheckpointDelayed(false);
                }
                break;
            default:
                if (inv.invocationInfo.isCreateHomeFinder) {
                    if (inv.invocationInfo.checkpointEnabled) {
                        checkpointEJB(sc);
                    }
                }
                break;
        }

        if (sc.getState() != BeanState.DESTROYED) {
            sc.setState(BeanState.READY);
            incrementMethodReadyStat();
            if (_logger.isLoggable(Level.FINE)) {
                logTraceInfo(inv, sc.getInstanceKey(), "Released context");
            }
        }
    }


    private void syncClientVersion(EjbInvocation inv, SessionContextImpl sc) {
        EJBLocalRemoteObject ejbLRO = inv.ejbObject;
        if (ejbLRO != null) {
            ejbLRO.setSfsbClientVersion(sc.getVersion());
        }

        if (!inv.isLocal && isHAEnabled) {
            long version = sc.getVersion();
            // TODO sfsbVersionManager.setResponseClientVersion(version);
            // TODO SFSBClientVersionManager.setClientVersion(getContainerId(),
            // TODO sc.getInstanceKey(), version);
            if (_logger.isLoggable(Level.FINE)) {
                _logger.log(Level.FINE, "Added [synced] version: " + version + " for key: " + sc.getInstanceKey());
            }
        }
    }


    // methods for StatefulSessionBeanStatsProvider
    public int getMaxCacheSize() {
        return sessionBeanCache.getMaxCacheSize();
    }


    public BackingStore<Serializable, SimpleMetadata> getBackingStore() {
        return backingStore;
    }


    public void setBackingStore(BackingStore<Serializable, SimpleMetadata> store) {
        this.backingStore = store;
    }


    private boolean checkpointEJB(SessionContextImpl sc) {
        boolean checkpointed = false;
        try {
            if ((containerState != CONTAINER_STARTED) && (containerState != CONTAINER_STOPPED)) {
                _logger.log(Level.FINE, "passivateEJB() returning because " + "containerState: " + containerState);
                return false;
            }

            if (sc.getState() == BeanState.DESTROYED) {
                return false;
            }

            Object ejb = sc.getEJB();

            long checkpointStartTime = -1;
            if (sfsbStoreMonitor != null && sfsbStoreMonitor.isMonitoringOn()) {
                checkpointStartTime = System.currentTimeMillis();
            }

            EjbInvocation ejbInv = createEjbInvocation(ejb, sc);
            invocationManager.preInvoke(ejbInv);
            boolean needToDoPostInvokeTx = false;
            boolean destroyBean = false;

            synchronized (sc) {
                try {
                    // dont passivate if there is a Tx/invocation in progress
                    // for this instance.
                    if (sc.getState() != BeanState.READY) {
                        return false;
                    }

                    // passivate the EJB
                    sc.setState(BeanState.PASSIVATED);
                    decrementMethodReadyStat();
                    needToDoPostInvokeTx = callLifecycleCallbackInTxIfUsed(ejbInv, sc, prePassivateInvInfo,
                        CallbackType.PRE_PASSIVATE);
                    sc.setLastPersistedAt(System.currentTimeMillis());
                    byte[] serializedState = null;
                    try {
                        long newCtxVersion = sc.incrementAndGetVersion();
                        serializedState = serializeContext(sc);
                        SimpleMetadata beanState = new SimpleMetadata(sc.getVersion(), sc.getLastAccessTime(),
                            removalGracePeriodInSeconds * 1000L, serializedState);
                        beanState.setVersion(newCtxVersion);
                        backingStore.save((Serializable) sc.getInstanceKey(), beanState, !sc.existsInStore());

                        // Now that we have successfully stored.....

                        sc.setLastPersistedAt(System.currentTimeMillis());
                        sc.setExistsInStore(true);
                        checkpointed = true;
                    } catch (EMNotSerializableException emNotSerEx) {
                        _logger.log(Level.WARNING, ERROR_DURING_CHECKPOINT_SESSION_ALIVE, emNotSerEx);
                    } catch (NotSerializableException notSerEx) {
                        throw notSerEx;
                    } catch (Exception ignorableEx) {
                        _logger.log(Level.WARNING, ERROR_DURING_CHECKPOINT, ignorableEx);
                    }

                    // TODO - add a flag to reactivate in the same tx
                    // Complete previous tx
                    completeLifecycleCallbackTxIfUsed(ejbInv, sc, needToDoPostInvokeTx);

                    needToDoPostInvokeTx = callLifecycleCallbackInTxIfUsed(ejbInv, sc, postActivateInvInfo,
                        CallbackType.POST_ACTIVATE);
                    sc.setState(BeanState.READY);
                    incrementMethodReadyStat();
                    if (sfsbStoreMonitor != null && serializedState != null) {
                        sfsbStoreMonitor.setCheckpointSize(serializedState.length);
                        sfsbStoreMonitor.incrementCheckpointCount(true);
                    }
                } catch (Throwable ex) {
                    if (sfsbStoreMonitor != null) {
                        sfsbStoreMonitor.incrementCheckpointCount(false);
                    }
                    _logger.log(Level.WARNING, SFSB_CHECKPOINT_ERROR_NAME, new Object[] {ejbDescriptor.getName()});
                    _logger.log(Level.WARNING, SFSB_CHECKPOINT_ERROR_KEY, new Object[] {sc.getInstanceKey(), ex});
                    destroyBean = true;
                } finally {
                    invocationManager.postInvoke(ejbInv);
                    completeLifecycleCallbackTxIfUsed(ejbInv, sc, needToDoPostInvokeTx);
                    if (destroyBean) {
                        try {
                            forceDestroyBean(sc);
                        } catch (Exception e) {
                            _logger.log(Level.FINE, "error destroying bean", e);
                        }
                    }
                    if (checkpointStartTime != -1) {
                        long timeSpent = System.currentTimeMillis() - checkpointStartTime;
                        if (sfsbStoreMonitor != null) {
                            sfsbStoreMonitor.setCheckpointTime(timeSpent);
                        }
                    }
                }
            } // synchronized
        } catch (Exception ex) {
            _logger.log(Level.WARNING, PASSIVATION_ERROR_1PARAM, new Object[]{ejbDescriptor.getName(), ex});
        }
        return checkpointed;
    }


    public void incrementMethodReadyStat() {
        statMethodReadyCount++;
        ejbProbeNotifier.methodReadyAddEvent(getContainerId(), containerInfo.appName, containerInfo.modName,
            containerInfo.ejbName);
    }


    public void decrementMethodReadyStat() {
        statMethodReadyCount--;
        ejbProbeNotifier.methodReadyRemoveEvent(getContainerId(), containerInfo.appName, containerInfo.modName,
            containerInfo.ejbName);
    }


    static class EEMRefInfoKey
            implements Serializable {

        private final String emRefName;

        private final long containerID;

        private final Object instanceKey;

        private final int hc;

        EEMRefInfoKey(String en, long cid, Object ikey) {
            this.emRefName = en;
            this.containerID = cid;
            this.instanceKey = ikey;

            this.hc = instanceKey.hashCode();
        }

        @Override
        public int hashCode() {
            return hc;
        }

        @Override
        public boolean equals(Object obj) {
            boolean result = false;
            if (obj instanceof EEMRefInfoKey) {
                EEMRefInfoKey other = (EEMRefInfoKey) obj;
                result = ((this.containerID == other.containerID)
                        && (this.emRefName.equals(other.emRefName))
                        && (this.instanceKey.equals(other.instanceKey))
                );
            }

            return result;
        }

        @Override
        public String toString() {
            return "<" + instanceKey + ":" + emRefName + ":" + containerID + ">";
        }
    }

    static class EEMRefInfo implements IndirectlySerializable, SerializableObjectFactory {

        private transient int refCount = 0;

        private final String unitName;

        private final SynchronizationType synchronizationType;

        private final EEMRefInfoKey eemRefInfoKey;

        private byte[] serializedEEM;

        private transient EntityManager eem;

        private transient EntityManagerFactory emf;

        private int hc;

        EEMRefInfo(String emRefName, String uName, SynchronizationType synchronizationType, long containerID,
            Object instanceKey, EntityManager eem, EntityManagerFactory emf) {
            this.eemRefInfoKey = new EEMRefInfoKey(emRefName, containerID, instanceKey);
            this.eem = eem;
            this.emf = emf;
            this.unitName = uName;
            this.synchronizationType = synchronizationType;
        }

        EntityManager getEntityManager() {
            return eem;
        }

        EntityManagerFactory getEntityManagerFactory() {
            return this.emf;
        }

        EEMRefInfoKey getKey() {
            return eemRefInfoKey;
        }

        Object getSessionKey() {
            return eemRefInfoKey.instanceKey;
        }

        String getUnitName() {
            return unitName;
        }

        SynchronizationType getSynchronizationType() {
            return synchronizationType;
        }

        @Override
        public SerializableObjectFactory getSerializableObjectFactory() throws IOException {
            //Serialize the eem into the serializedEEM
            try (ByteArrayOutputStream bos = new ByteArrayOutputStream();
                ObjectOutputStream oos = new ObjectOutputStream(bos)) {
                oos.writeObject(eem);
                oos.flush();
                bos.flush();
                serializedEEM = bos.toByteArray();
            } catch (NotSerializableException notSerEx) {
                throw new EMNotSerializableException(notSerEx.toString(), notSerEx);
            } catch (IOException ioEx) {
                throw new EMNotSerializableException(ioEx.toString(), ioEx);
            }

            return this;
        }

        @Override
        public Object createObject() throws IOException {
            return this;
        }

    }

    private class ASyncPassivator implements Runnable {

        @Override
        public void run() {
            final Thread currentThread = Thread.currentThread();
            final ClassLoader previousClassLoader = currentThread.getContextClassLoader();
            final ClassLoader myClassLoader = loader;

            boolean decrementedTaskCount = false;
            try {
                // We need to set the context class loader for
                // this (deamon) thread!!
                if (System.getSecurityManager() == null) {
                    currentThread.setContextClassLoader(myClassLoader);
                } else {
                    PrivilegedAction<Void> action = () -> {
                        currentThread.setContextClassLoader(myClassLoader);
                        return null;
                    };
                    AccessController.doPrivileged(action);
                }
                ComponentContext ctx = null;

                do {
                    synchronized (asyncTaskSemaphore) {
                        int sz = passivationCandidates.size();
                        if (sz > 0) {
                            ctx = (ComponentContext) passivationCandidates.remove(sz - 1);
                        } else {
                            return;
                        }
                    }
                    passivateEJB(ctx);
                } while (true);

            } catch (Throwable th) {
                th.printStackTrace();
            } finally {
                if (!decrementedTaskCount) {
                    synchronized (asyncTaskSemaphore) {
                        asyncTaskCount--;
                    }
                }

                if (System.getSecurityManager() == null) {
                    currentThread.setContextClassLoader(previousClassLoader);
                } else {
                    PrivilegedAction<Void> action = () -> {
                        currentThread.setContextClassLoader(previousClassLoader);
                        return null;
                    };
                    AccessController.doPrivileged(action);
                }
            }
        }
    }

    static class EMNotSerializableException extends NotSerializableException {

        private static final long serialVersionUID = 1L;

        public EMNotSerializableException(String className, Throwable th) {
            super(className);
            super.initCause(th);
        }

    }

    static class SerializableEJB implements IndirectlySerializable, SerializableObjectFactory {

        private static final long serialVersionUID = -8157255599519915473L;
        private byte[] serializedFields;

        SerializableEJB(Object ejb) throws IOException {
            //Serialize the ejb fields into the serializedFields
            try (ByteArrayOutputStream bos = new ByteArrayOutputStream();
                ObjectOutputStream oos = EjbContainerUtilImpl.getInstance().getJavaEEIOUtils()
                    .createObjectOutputStream(bos, true)) {
                EJBUtils.serializeObjectFields(ejb, oos, false);
                oos.flush();
                bos.flush();
                serializedFields = bos.toByteArray();
            }
        }


        @Override
        public SerializableObjectFactory getSerializableObjectFactory() throws IOException {
            return this;
        }


        @Override
        public Object createObject() throws IOException {
            return this;
        }
    }
}


class PeriodicTask extends TimerTask {

    AsynchronousTask task;
    EjbContainerUtil ejbContainerUtil;

    PeriodicTask(ClassLoader classLoader, Runnable target, EjbContainerUtil ejbContainerUtil) {
        this.task = new AsynchronousTask(classLoader, target);
        this.ejbContainerUtil = ejbContainerUtil;
    }


    @Override
    public void run() {
        if (!task.isExecuting()) {
            ejbContainerUtil.addWork(task);
        }
    }


    @Override
    public boolean cancel() {
        boolean cancelled = super.cancel();
        this.task = null;
        return cancelled;
    }
}


class AsynchronousTask implements Runnable {

    ClassLoader loader;
    Runnable target;
    boolean executing;

    AsynchronousTask(ClassLoader cloassLoader, Runnable target) {
        this.loader = cloassLoader;
        this.target = target;
        this.executing = false;
    }


    boolean isExecuting() {
        return executing;
    }


    // This will be called with the correct ClassLoader
    @Override
    public void run() {
        ClassLoader prevCL = Thread.currentThread().getContextClassLoader();
        try {
            Utility.setContextClassLoader(loader);
            target.run();
        } finally {
            Utility.setContextClassLoader(prevCL);
            executing = false;
        }
    } // end run
}