JStatelessFactory.java

package org.objectweb.jonas_ejb.container;

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

import javax.ejb.EJBException;
import javax.ejb.EnterpriseBean;
import javax.ejb.SessionBean;
import javax.ejb.TimedObject;
import javax.ejb.Timer;
import javax.ejb.TimerService;
import javax.naming.Context;
import javax.transaction.Status;
import javax.transaction.SystemException;

import org.objectweb.jonas_ejb.deployment.api.MethodDesc;
import org.objectweb.jonas_ejb.deployment.api.SessionStatelessDesc;
import org.objectweb.jonas_ejb.lib.EJBInvocation;
import org.objectweb.jonas_timer.TraceTimer;

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

public class JStatelessFactory extends JSessionFactory {

    protected List bctxlist = new ArrayList();

    // service endpoint home
    protected JServiceEndpointHome sehome = null;

    protected int instanceCount = 0;

    // initial value for pool size
    protected int minPoolSize = 0;

    // nb max of instances in pool
    protected int maxCacheSize = 0;

        private static final int MAX_NB_RETRY = 2;


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

        // Create the ServiceEndpointHome if defined in DD
        Class sehomeclass = null;
        String clname = dd.getFullWrpSEHomeName();
        if (clname != null) {
            try {
                sehomeclass = 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 JServiceEndpointHome(dd, this)
                int nbp = 2;
                Class[] ptype = new Class[nbp];
                Object[] pobj = new Object[nbp];
                ptype[0] = org.objectweb.jonas_ejb.deployment.api.SessionStatelessDesc.class;
                pobj[0] = (Object) dd;
                ptype[1] = org.objectweb.jonas_ejb.container.JStatelessFactory.class;
                pobj[1] = (Object) this;
                sehome = (JServiceEndpointHome) sehomeclass.getConstructor(ptype).newInstance(pobj);
            } catch (Exception e) {
                throw new EJBException(ejbname + " Cannot create serviceEndpointHome ", e);
            }
            // register it in JNDI
            try {
                sehome.register();
            } catch (Exception e) {
                throw new EJBException(ejbname + " Cannot register serviceEndpointHome ", e);
            }
        }

        isStateful = false;
        maxCacheSize = dd.getCacheMax();
        minPoolSize = dd.getPoolMin();
        if (TraceEjb.isDebugSwapper()) {
            TraceEjb.swapper.log(BasicLevel.DEBUG, " maxCacheSize = " + maxCacheSize);
        }
    }
    
    public void initInstancePool() {
        // pre-allocate a set of JSessionContext (bean instances)
        if (minPoolSize != 0) {
            TraceEjb.interp.log(BasicLevel.INFO, "pre-allocate a set of " + minPoolSize
                    + " stateless session instances");
            JSessionSwitch ss = null;
            try {
                ss = createNewSession();
            } catch (RemoteException e) {
                TraceEjb.logger.log(BasicLevel.ERROR, ejbname + " cannot create new session", e);
                throw new EJBException(ejbname + " Cannot create session for pool: ", e);
            }
            Context bnctx = setComponentContext(); // for createNewInstance
            synchronized (bctxlist) {
                for (int i = 0; i < minPoolSize; i++) {
                    JSessionContext ctx = null;
                    try {
                        // must pass a session switch (for ejbCreate)
                        ctx = createNewInstance(ss);
                        bctxlist.add(ctx);
                    } catch (Exception e) {
                        TraceEjb.logger.log(BasicLevel.ERROR, ejbname + " cannot create new instance", e);
                        throw new EJBException(ejbname + " Cannot init pool of instances ", e);
                    }
                }
            }
            resetComponentContext(bnctx);
        }
    }

    public JServiceEndpointHome getSEHome() {
        return sehome;
    }
    
    // ---------------------------------------------------------------
    // BeanFactory implementation
    // ---------------------------------------------------------------

    public int getPoolSize() {
        return bctxlist.size();
    }

    public void reduceCache() {
        TraceEjb.swapper.log(BasicLevel.DEBUG, "");
        // reduce the pool to the minPoolSize
        int poolsz = minPoolSize;
        synchronized (bctxlist) {
            if (TraceEjb.isDebugSwapper()) {
                TraceEjb.swapper.log(BasicLevel.DEBUG, "try to reduce " + bctxlist.size() + " to " + poolsz);
            }
            while (bctxlist.size() > poolsz) {
                ListIterator i = bctxlist.listIterator();
                if (i.hasNext()) {
                    i.next();
                    i.remove();
                    instanceCount--;
                }
            }
        }
        if (TraceEjb.isDebugSwapper()) {
            TraceEjb.swapper.log(BasicLevel.DEBUG, "cacheSize= " + getCacheSize());
        }

    }

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

    public TimerService getTimerService() {
        if (myTimerService == null) {
            // TODO : Check that instance implements TimedObject ?
            myTimerService = new JTimerService(this);
        }
        return myTimerService;
    }

    public JSessionSwitch createNewSession() throws RemoteException {
        TraceEjb.interp.log(BasicLevel.DEBUG, "");
        JStatelessSwitch bs = new JStatelessSwitch(this);
        return bs;
    }

    public JSessionContext getJContext(JSessionSwitch ss) {
        TraceEjb.interp.log(BasicLevel.DEBUG, "");
        JStatelessContext bctx = null;

        // try to find a free context in the pool
        synchronized (bctxlist) {
            try {
                ListIterator i = bctxlist.listIterator();
                if (i.hasNext()) {
                    bctx = (JStatelessContext) i.next();
                    bctx.initSessionContext(ss);
                    i.remove();
                }
            } catch (IndexOutOfBoundsException ex) {
                // pool is empty
            }
        }

        if (bctx == null) {
            // create a new one if pool empty
            try {
                bctx = createNewInstance(ss);
            } catch (Exception e) {
                TraceEjb.logger.log(BasicLevel.ERROR, "exception:" + e);
                throw new EJBException("Cannot create a new instance");
            }
        }
        if (TraceEjb.isDebugSwapper()) {
            TraceEjb.swapper.log(BasicLevel.DEBUG, "nb instances " + getCacheSize());
        }
        return bctx;
    }

    public void releaseJContext(JContext ctx) {
        TraceEjb.interp.log(BasicLevel.DEBUG, "");
        JStatelessContext bctx = (JStatelessContext) ctx;

        // if the max number of instances is reached
        // we can reduce the number of instances
        synchronized (bctxlist) {
            if (maxCacheSize != 0 && instanceCount > maxCacheSize) {
                if (TraceEjb.isDebugSwapper()) {
                    TraceEjb.swapper.log(BasicLevel.DEBUG, "too much instances :" + instanceCount + ", max="
                            + maxCacheSize);
                }
                instanceCount--;
            } else {
                bctxlist.add(bctx);
            }
        }
        if (TraceEjb.isDebugSwapper()) {
            TraceEjb.swapper.log(BasicLevel.DEBUG, "nb instances " + getCacheSize());
        }
    }

    public void notifyTimeout(Timer timer) {
        TraceTimer.logger.log(BasicLevel.DEBUG, "");

        // Get a JStatelessSwitch (similar to createEJB)
        // In fact, we don't need the Local and Remote objects here.
        // This object is just needed to initilize the SessionContext.
        JSessionSwitch bs = null;
        if (sessionList.size() > 0) {
            TraceEjb.interp.log(BasicLevel.DEBUG, "get a JStatelessSwitch from the pool");
            bs = (JSessionSwitch) sessionList.remove(0);
            // must re-export the remote object in the Orb since EJBObjects
            // to avoids a fail when object is put in the pool.
            JSessionRemote remote = bs.getRemote();
            if (remote != null) {
                if (!remote.exportObject()) {
                    TraceEjb.logger.log(BasicLevel.ERROR, "bad JSessionSwitch found in pool.");
                }
            }
        } else {
            TraceEjb.interp.log(BasicLevel.DEBUG, "create a new JStatelessSwitch");
            try {
                bs = new JStatelessSwitch(this);
            } catch (RemoteException e) {
                TraceEjb.logger.log(BasicLevel.ERROR, "Notify Timeout - Unexpected : " + e);
                return;
            }
        }
        //EJBInvocation ejbInv = new EJBInvocation();
        //ejbInv.methodPermissionSignature = getEjbTimeoutSignature();
        //ejbInv.arguments = new Object [] {timer};

        for (int nbretry = 0; nbretry < MAX_NB_RETRY; nbretry++) {
            RequestCtx rctx = preInvoke(getTimerTxAttribute());
            JSessionContext bctx = null;
            try {
                bctx = bs.getICtx(rctx.currTx);
                TimedObject instance = (TimedObject) bctx.getInstance();
                //ejbInv.bean = (EnterpriseBean) instance;
                checkSecurity(null);
                instance.ejbTimeout(timer);
                if (rctx.currTx == null
                        || (rctx.currTx.getStatus() != Status.STATUS_MARKED_ROLLBACK)) {
                    break;
                }
            } catch (EJBException e) {
                rctx.sysExc = e;
                throw e;
            } catch (RuntimeException e) {
                rctx.sysExc = e;
                throw new EJBException("RuntimeException thrown by an enterprise Bean", e);
            } catch (Error e) {
                rctx.sysExc = e;
                throw new EJBException("Error thrown by an enterprise Bean" + e);
            } catch (RemoteException e) {
                rctx.sysExc = e;
                throw new EJBException("Remote Exception raised:", e);
            } catch (SystemException e) {
                rctx.sysExc = e;
                throw new EJBException("Cannot get transaction status:", e);
            } finally {
                postInvoke(rctx);
            }
        }

        // release everything - Exactly as if the session timeout had
        // expired.
        bs.timeoutExpired(null);
    }

    public int getMinPoolSize() {
        return minPoolSize;
    }

    public int getMaxCacheSize() {
        return maxCacheSize;
    }

    public int getCacheSize() {
        return instanceCount;
    }

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

    private JStatelessContext createNewInstance(JSessionSwitch ss) throws Exception {
        TraceEjb.interp.log(BasicLevel.DEBUG, "");
        // create the bean instance
        SessionBean bean = null;
        try {
            bean = (SessionBean) beanclass.newInstance();
        } catch (InstantiationException e) {
            TraceEjb.logger.log(BasicLevel.ERROR, ejbname + " cannot instantiate session bean");
            throw e;
        } catch (IllegalAccessException e) {
            TraceEjb.logger.log(BasicLevel.ERROR, ejbname + " Cannot instantiate SessionBean");
            throw e;
        }

        // create a new StatelessContext and bind it to the instance
        JStatelessContext bctx = new JStatelessContext(this, bean);
        bean.setSessionContext(bctx);
        bctx.setState(1);
        bctx.initSessionContext(ss);
        // call ejbCreate on the instance
        TraceEjb.interp.log(BasicLevel.DEBUG, "call ejbCreate on the instance");
        try {
            beanclass.getMethod("ejbCreate", (Class[]) null).invoke(bean, (Object[]) null);
        } catch (Exception e) {
            TraceEjb.logger.log(BasicLevel.ERROR, ejbname + " cannot call ejbCreate on Stateless Session " + e);
        }
        bctx.setState(2);

        // We always create an instance even if the max is reached
        // see releaseJContext
        synchronized (bctxlist) {
            instanceCount++;
        }
        return bctx;
    }

}

---