JSessionFactory.java

package org.objectweb.jonas_ejb.container;

import java.rmi.RemoteException;
import java.util.ArrayList;

import javax.ejb.EJBException;
import javax.naming.NamingException;
import javax.transaction.SystemException;

import org.objectweb.jonas_ejb.deployment.api.SessionDesc;

import org.objectweb.util.monolog.api.BasicLevel;

public abstract class JSessionFactory extends JFactory {

    // Timeout for this session
    int timeout = 0;

    protected JSessionHome home = null;

    protected JSessionLocalHome localhome = null;

    protected boolean isSynchro = false;

    protected boolean isStateful; // set after constructor call

    // Pool of JSessionSwitch
    protected ArrayList sessionList = new ArrayList();

    public JSessionFactory(SessionDesc dd, JContainer cont) {
        super(dd, cont);
        TraceEjb.interp.log(BasicLevel.DEBUG, "");

        txbeanmanaged = dd.isBeanManagedTransaction();
        timeout = dd.getSessionTimeout();

        // Create the Home if defined in DD
        Class homeclass = null;
        String clname = dd.getFullWrpHomeName();
        if (clname != null) {
            try {
                homeclass = cont.getClassLoader().loadClass(clname);
            } catch (ClassNotFoundException e) {
                throw new EJBException(ejbname + " Cannot load " + clname, e);
            }
            if (TraceEjb.isDebugIc()) TraceEjb.interp.log(BasicLevel.DEBUG, ejbname + ": " + clname + " loaded");
            try {
                // new JSessionHome(dd, this)
                int nbp = 2;
                Class[] ptype = new Class[nbp];
                Object[] pobj = new Object[nbp];
                ptype[0] = org.objectweb.jonas_ejb.deployment.api.SessionDesc.class;
                pobj[0] = (Object) dd;
                ptype[1] = org.objectweb.jonas_ejb.container.JSessionFactory.class;
                pobj[1] = (Object) this;
                home = (JSessionHome) homeclass.getConstructor(ptype).newInstance(pobj);
            } catch (Exception e) {
                throw new EJBException(ejbname + " Cannot create home ", e);
            }
            // register it in JNDI
            try {
                home.register();
            } catch (Exception e) {
                throw new EJBException(ejbname + " Cannot register home ", e);
            }
        }

        // Create the LocalHome if defined in DD
        clname = dd.getFullWrpLocalHomeName();
        if (clname != null) {
            try {
                homeclass = cont.getClassLoader().loadClass(clname);
            } catch (ClassNotFoundException e) {
                throw new EJBException(ejbname + " Cannot load " + clname, e);
            }
            if (TraceEjb.isDebugIc()) TraceEjb.interp.log(BasicLevel.DEBUG, ejbname + ": " + clname + " loaded");
            try {
                // new JSessionLocalHome(dd, this)
                int nbp = 2;
                Class[] ptype = new Class[nbp];
                Object[] pobj = new Object[nbp];
                ptype[0] = org.objectweb.jonas_ejb.deployment.api.SessionDesc.class;
                pobj[0] = (Object) dd;
                ptype[1] = org.objectweb.jonas_ejb.container.JSessionFactory.class;
                pobj[1] = (Object) this;
                localhome = (JSessionLocalHome) homeclass.getConstructor(ptype).newInstance(pobj);
            } catch (Exception e) {
                throw new EJBException(ejbname + " Cannot create localhome ", e);
            }
            // register it in JNDI
            try {
                localhome.register();
            } catch (Exception e) {
                throw new EJBException(ejbname + " Cannot register localhome ", e);
            }
        }

    }

    // ---------------------------------------------------------------
    // BeanFactory implementation
    // ---------------------------------------------------------------

    public void stop() {
        TraceEjb.interp.log(BasicLevel.DEBUG, "");
        try {
            if (home != null) {
                home.unregister();
            }
            if (localhome != null) {
                localhome.unregister();
            }
        } catch (NamingException e) {
        }
    }

    public void sync() {
    }

    public JHome getHome() {
        return home;
    }

    public JLocalHome getLocalHome() {
        return localhome;
    }

    // ---------------------------------------------------------------
    // JSessionSwitch pool management
    // ---------------------------------------------------------------

    public synchronized JSessionSwitch createEJB() throws RemoteException {

        TraceEjb.interp.log(BasicLevel.DEBUG, "");

        JSessionSwitch bs = null;
        if (sessionList.size() > 0) {
            bs = (JSessionSwitch) sessionList.remove(0);
            // must re-export the remote object in the Orb since EJBObjects
            // should be un exported when put in the pool.
            JSessionRemote remote = bs.getRemote();
            if (remote != null) {
                if (remote.exportObject() == false) {
                    TraceEjb.logger.log(BasicLevel.ERROR, "bad JSessionSwitch found in pool.");
                    return null;
                }
            }
        } else {
            // This depend on subclass (stateless or stateful)
            // no need to export the EJBObject because it is basically a
            // RemoteObject
            bs = createNewSession();
        }

        // Start a timer for this new session
        if (timeout > 0) {
            bs.startTimer(timeout * 1000);
        }
        return bs;
    }

    public synchronized void removeEJB(JSessionSwitch bs) {

        TraceEjb.interp.log(BasicLevel.DEBUG, "");

        sessionList.add(bs);
    }

    // ---------------------------------------------------------------
    // other public methods
    // ---------------------------------------------------------------

    public void checkTransaction(RequestCtx rctx) {
        if (txbeanmanaged) {
            try {
                rctx.clientTx = tm.suspend();
                TraceEjb.tx.log(BasicLevel.DEBUG, "suspending tx:" + rctx.clientTx);
            } catch (SystemException e) {
                throw new EJBException("cannot suspend transaction");
            }
        } else {
            checkTransactionContainer(rctx);
        }
    }

    public boolean isSessionSynchro() {
        return isSynchro;
    }

    public int getTimeout() {
        return timeout;
    }

    public void setTimeout(int t) {
        TraceEjb.tx.log(BasicLevel.DEBUG, "");
        timeout = t;
    }

    public boolean isStateful() {
        return isStateful;
    }

    public abstract JSessionContext getJContext(JSessionSwitch ss);

    // ---------------------------------------------------------------
    // private methods
    // ---------------------------------------------------------------

    abstract protected JSessionSwitch createNewSession() throws RemoteException;
}

---