JStatefulContext.java

package org.objectweb.jonas_ejb.container;

import java.rmi.RemoteException;
import java.util.List;

import javax.ejb.RemoveException;
import javax.ejb.SessionBean;
import javax.ejb.SessionSynchronization;
import javax.ejb.TimerService;
import javax.naming.Context;
import javax.naming.NamingException;
import javax.transaction.Status;
import javax.transaction.Synchronization;
import javax.xml.rpc.handler.MessageContext;

import org.objectweb.jonas.naming.NamingManager;
import org.objectweb.jonas_lib.naming.ContainerNaming;
import org.objectweb.util.monolog.api.BasicLevel;

public class JStatefulContext extends JSessionContext implements Synchronization {

    boolean synchro = false;

    boolean timedout = false;

    // ------------------------------------------------------------------
    // constructors
    // ------------------------------------------------------------------

    public JStatefulContext(JSessionFactory bf, SessionBean sb, boolean sync) {
        super(bf, sb);
        TraceEjb.interp.log(BasicLevel.DEBUG, "");
        synchro = sync;
        // Register this Context in java:comp (used by JTimerHandle)
        try {
            ContainerNaming naming = NamingManager.getInstance();
            Context c = naming.getComponentContext();
            c.rebind("MY_SF_CONTEXT", this);
        } catch (NamingException ne) {
            TraceEjb.logger.log(BasicLevel.ERROR, "Cannot bind EJBContext");
        }
    }

    // ------------------------------------------------------------------
    // EJBContext implementation
    // ------------------------------------------------------------------

    public TimerService getTimerService() throws IllegalStateException {
        throw new IllegalStateException("getTimerService Not Allowed on Stateful Session Beans");
    }

    public MessageContext getMessageContext() throws java.lang.IllegalStateException {
        throw new IllegalStateException("getMessageContext Not Allowed on Stateful Session Beans");
    }

    // -------------------------------------------------------------------
    // Synchronization implementation
    // -------------------------------------------------------------------

    public void beforeCompletion() {
        TraceEjb.tx.log(BasicLevel.DEBUG, "");

        if (synchro) {
            // Set classloader for getting the right component context
            ClassLoader old = Thread.currentThread().getContextClassLoader();
            Thread.currentThread().setContextClassLoader(bf.myClassLoader());
            Context bnctx = bf.setComponentContext();
            try {
                SessionSynchronization ss = (SessionSynchronization) getInstance();
                ss.beforeCompletion();
            } catch (RemoteException e) {
                TraceEjb.logger.log(BasicLevel.ERROR, "exception:", e);
            } finally {
                bf.resetComponentContext(bnctx);
                Thread.currentThread().setContextClassLoader(old);
            }
        }
    }

    public void afterCompletion(int status) {
        TraceEjb.tx.log(BasicLevel.DEBUG, "");

        if (synchro) {
            // Set classloader for getting the right component context
            ClassLoader old = Thread.currentThread().getContextClassLoader();
            Thread.currentThread().setContextClassLoader(bf.myClassLoader());
            Context bnctx = bf.setComponentContext();
            try {
                SessionSynchronization ss = (SessionSynchronization) getInstance();
                setState(3);
                ss.afterCompletion(status == Status.STATUS_COMMITTED);
                setState(2);
            } catch (RemoteException e) {
                TraceEjb.logger.log(BasicLevel.ERROR, "exception:", e);
            } finally {
                bf.resetComponentContext(bnctx);
                Thread.currentThread().setContextClassLoader(old);
            }
        }

        // Let the StatefulSwitch now that transaction is over and that it can
        // now dispose of this Context for another transaction.
        // no need to be in the correct component context ?
        JStatefulSwitch jss = (JStatefulSwitch) bs;
        jss.txCompleted();

        // The timeout has expired during the transaction. We can now remove
        // this session.
        if (timedout) {
            TraceEjb.logger.log(BasicLevel.WARN, "timeout expired during the transaction");
            timedout = false;
            // TODO
            // ((JStatefulSession)ejbObject).forceSessionRemove();
        }
    }

    // ------------------------------------------------------------------
    // Other methods
    // ------------------------------------------------------------------

    public void setRemoved() throws RemoteException, RemoveException {
        TraceEjb.interp.log(BasicLevel.DEBUG, "");

        // Cannot remove a stateful session inside a transaction
        JStatefulSwitch jss = (JStatefulSwitch) bs;
        if (jss.isInTransaction()) {
            throw new RemoveException("Cannot remove a statefull session inside a transaction");
        }

        // Call ejbRemove on instance
        // Assume that if this method is transacted (container transaction
        // only), this
        // transaction will be committed by the container (always true normally)
        SessionBean sb = (SessionBean) instance;
        sb.ejbRemove();

        // Set a flag to finish remove at postInvoke.
        // getEJBObject should work in ejbRemove.
        // => we do this only after ejbRemove call.
        ismarkedremoved = true;
    }

    public void setConnectionList(List conlist) {
        JStatefulSwitch jss = (JStatefulSwitch) bs;
        jss.setConnectionList(conlist);
    }
        
}

---