JEntityFactory.java

package org.objectweb.jonas_ejb.container;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;

import javax.ejb.EJBException;
import javax.ejb.EntityBean;
import javax.ejb.FinderException;
import javax.ejb.Timer;
import javax.ejb.TimerService;
import javax.naming.Context;
import javax.naming.NamingException;
import javax.transaction.RollbackException;
import javax.transaction.SystemException;
import javax.transaction.Transaction;

import org.objectweb.jonas_ejb.deployment.api.EntityDesc;
import org.objectweb.jonas_ejb.deployment.api.EntityJdbcCmp1Desc;
import org.objectweb.jonas_ejb.deployment.api.EntityJdbcCmp2Desc;
import org.objectweb.jorm.naming.api.PExceptionNaming;
import org.objectweb.jorm.naming.api.PName;

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

public class JEntityFactory extends JFactory implements TimerService {

    protected JEntityHome home = null;

    protected JEntityLocalHome localhome = null;

    protected boolean reentrant;

    protected boolean shared = false;

    protected int lockPolicy;

    protected boolean prefetch = false;

    protected List bctxlist = new ArrayList();

    protected int minPoolSize;

    protected int instanceCount = 0;

    protected int maxCacheSize;

    protected int inactivityTimeout; // sec.

    protected HashMap pklist = new HashMap();

    protected HashMap txlist = new HashMap();

    private LinkedList dirtyList = new LinkedList();

    private boolean mustSyncDirtyEntities = false;

    // Datasource in case of CMP
    protected Object datasource = null;

    private static int ucount = 1;

    String dsname = null;

    public JEntityFactory() {
        TraceEjb.interp.log(BasicLevel.DEBUG, "");
    }

    public void init(EntityDesc dd, JContainer cont) {
        super.init(dd, cont);
        reentrant = dd.isReentrant();
        shared = dd.isShared();
        lockPolicy = dd.getLockPolicy();
        prefetch = dd.isPrefetch();
        if (lockPolicy == EntityDesc.LOCK_CONTAINER_READ_UNCOMMITTED && prefetch) {
            throw new EJBException("Cannot set READ_UNCOMMITTED and prefetch for a bean");
        }
        inactivityTimeout = dd.getInactivityTimeout();
        maxCacheSize = dd.getCacheMax();
        minPoolSize = dd.getPoolMin();

        // Finds the DataSource associated to the bean
        // Useful for Entity with Container Managed Persistence.
        if (dd instanceof EntityJdbcCmp1Desc) {
            dsname = ((EntityJdbcCmp1Desc) dd).getDatasourceJndiName();
            if (dsname != null) {
                try {
                    datasource = getInitialContext().lookup(dsname);
                } catch (NamingException e) {
                    TraceEjb.logger.log(BasicLevel.ERROR, dsname + " is not known by the EJB server.", e);
                    throw new EJBException(dsname + " unknown");
                }
            }
        }

        if (dd instanceof EntityJdbcCmp2Desc) {
            dsname = ((EntityJdbcCmp2Desc) dd).getDatasourceJndiName();
            if (dsname != null) {
                try {
                    datasource = getInitialContext().lookup(dsname);
                } catch (NamingException e) {
                    TraceEjb.logger.log(BasicLevel.ERROR, dsname + " is not known by the EJB server.");
                    throw new EJBException(dsname + " unknown");
                }
            }
        }

        // 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);
            }
            if (TraceEjb.isDebugIc()) {
                TraceEjb.interp.log(BasicLevel.DEBUG, ejbname + ": " + clname + " loaded");
            }
            try {
                // new JEntityHome(dd, this)
                int nbp = 2;
                Class[] ptype = new Class[nbp];
                Object[] pobj = new Object[nbp];
                ptype[0] = org.objectweb.jonas_ejb.deployment.api.EntityDesc.class;
                pobj[0] = (Object) dd;
                ptype[1] = org.objectweb.jonas_ejb.container.JEntityFactory.class;
                pobj[1] = (Object) this;
                home = (JEntityHome) homeclass.getConstructor(ptype).newInstance(pobj);
            } catch (Exception e) {
                if (TraceEjb.isVerbose()) {
                    e.printStackTrace();
                }
                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) {
                TraceEjb.logger.log(BasicLevel.ERROR, ejbname + " cannot load " + clname);
                throw new EJBException("Cannot load " + clname);
            }
            if (TraceEjb.isDebugIc()) {
                TraceEjb.interp.log(BasicLevel.DEBUG, ejbname + ": " + clname + " loaded");
            }
            try {
                // new JEntityLocalHome(dd, this)
                int nbp = 2;
                Class[] ptype = new Class[nbp];
                Object[] pobj = new Object[nbp];
                ptype[0] = org.objectweb.jonas_ejb.deployment.api.EntityDesc.class;
                pobj[0] = (Object) dd;
                ptype[1] = org.objectweb.jonas_ejb.container.JEntityFactory.class;
                pobj[1] = (Object) this;
                localhome = (JEntityLocalHome) 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);
            }
        }
    }
    
    public void initInstancePool() {
        // pre-allocate a set of JEntityContext (bean instances)
        Context bnctx = setComponentContext(); // for createNewInstance
        for (int i = 0; i < minPoolSize; i++) {
            JEntityContext ctx = null;
            try {
                ctx = createNewInstance(null);
                synchronized(bctxlist) {
                    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 synchronized JEntitySwitch getEJB(Object pk) {

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

        if (pk == null) {
            TraceEjb.logger.log(BasicLevel.ERROR, "pk null ???");
            return null;
        }
        JEntitySwitch bs = (JEntitySwitch) pklist.get(pk);
        if (bs == null) {
            bs = getJEntitySwitch();
            bs.init(this, pk);
            TraceEjb.interp.log(BasicLevel.DEBUG, "Adding PK to pklist:" + pk);
            pklist.put(pk, bs);
        }
        return bs;
    }

    public synchronized JEntitySwitch existEJB(Object pk) {
        if (pk == null) {
            TraceEjb.logger.log(BasicLevel.ERROR, "pk null ???");
            return null;
        }
        TraceEjb.interp.log(BasicLevel.DEBUG, "Looking for PK in pklist:" + pk);
        JEntitySwitch ret = (JEntitySwitch) pklist.get(pk);
        TraceEjb.interp.log(BasicLevel.DEBUG, ret == null ? "no" : "yes");
        return ret;
    }

    public boolean rebindEJB(Transaction tx, JEntityContext bctx, Object pk) {
        TraceEjb.interp.log(BasicLevel.DEBUG, ejbname);

        if (pk == null) {
            TraceEjb.logger.log(BasicLevel.ERROR, "pk null ???");
            return false;
        }
        JEntitySwitch bs = bctx.getEntitySwitch();
        JEntitySwitch old = null;
        synchronized (this) {
            old = (JEntitySwitch) pklist.get(pk);
        }
        boolean ret = true;
        if (old != null) {
            // different cases: 
            // - a create after a remove, in the same tx (or no tx)
            // - in CMP2: a "DuplicateKey".
            // - Bean removed by another server (bean shared)

            // Release completely the old EntitySwitch before binding the new one.
            // must be done outside the lock, to avoid a deadlock.
            ret = old.terminate(tx);
        }
        synchronized (this) {
            bs.init(this, pk);
            TraceEjb.interp.log(BasicLevel.DEBUG, "Adding PK to pklist:" + pk);
            pklist.put(pk, bs);
        }
        return ret;
    }

    public synchronized void bindEJB(Object pk, JEntitySwitch bs) {
        TraceEjb.interp.log(BasicLevel.DEBUG, ejbname);
        if (pk == null) {
            TraceEjb.logger.log(BasicLevel.ERROR, "pk null ???");
            return;
        }
        bs.init(this, pk);
        pklist.put(pk, bs);
    }

    public JEntitySwitch getJEntitySwitch() {
        switch (lockPolicy) {
            case EntityDesc.LOCK_CONTAINER_READ_UNCOMMITTED:
                return new JEntitySwitchCRU();
            case EntityDesc.LOCK_CONTAINER_READ_COMMITTED:
                return new JEntitySwitchCRC();
            case EntityDesc.LOCK_DATABASE:
                return new JEntitySwitchDB();
            case EntityDesc.LOCK_READ_ONLY:
                return new JEntitySwitchRO();
            default:
                return new JEntitySwitchCS();
        }
    }

    public synchronized void removeEJB(Object pk) {
        TraceEjb.interp.log(BasicLevel.DEBUG, ejbname);
        if (pk == null) {
            TraceEjb.logger.log(BasicLevel.ERROR, "pk null ???");
            return;
        }
        pklist.remove(pk);
    }

    public synchronized void registerEJB(JEntitySwitch ejb) {
        TraceEjb.swapper.log(BasicLevel.DEBUG, ejbname);
        if (dirtyList.contains(ejb)) {
            TraceEjb.swapper.log(BasicLevel.ERROR, ejbname + " Elt already in the dirty list");
            return;
        }
        dirtyList.addLast(ejb);
        mustSyncDirtyEntities = true;
    }

    public void synchronizeEntities() {
        TraceEjb.swapper.log(BasicLevel.DEBUG, ejbname);
        cont.registerBFS(this);
    }

    public boolean dirtyInstances() {
        return mustSyncDirtyEntities;
    }

    public int getInactivityTimeout() {
        return inactivityTimeout;
    }

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

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

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

    public void sync() {

        if (!mustSyncDirtyEntities) {
            TraceEjb.swapper.log(BasicLevel.DEBUG, ejbname + " cacheSize = " + getCacheSize());
            // nothing to do
            return;
        }

        TraceEjb.swapper.log(BasicLevel.DEBUG, ejbname + " dirtyList size = " + dirtyList.size());

        // Set the JNDI component context (for ejbStore)
        Context bnctx = setComponentContext();

        // try to passivate all instances and build a new list.
        LinkedList wsdone = new LinkedList();
        synchronized (this) {
            for (ListIterator i = dirtyList.listIterator(0); i.hasNext();) {
                JEntitySwitch es = (JEntitySwitch) i.next();
                if (es.passivateIH(false)) {
                    // passivation OK.
                    i.remove();
                    wsdone.addLast(es);
                } else {
                    TraceEjb.swapper.log(BasicLevel.DEBUG, ejbname + " swapper could not passivate an instance");
                }
            }
        }

        // for each instance passivated, notify it's OK to continue.
        // must be done after all instances are passivated, in case of relations.
        mustSyncDirtyEntities = false; // do this before endIH
        for (ListIterator i = wsdone.listIterator(0); i.hasNext();) {
            JEntitySwitch es = (JEntitySwitch) i.next();
            es.endIH();
        }

        // Reset old value for component context
        resetComponentContext(bnctx);
    }

    public void reduceCache() {
        TraceEjb.swapper.log(BasicLevel.DEBUG, ejbname + pklist.size());
        //printAllPks();

        // passivate all instances that are not busy
        // count is the number of busy instances (not freed)
        // other instances should be added to the pool (bctxlist)
        int count = 0;

        // Set classloader for getting the right component context
        ClassLoader old = Thread.currentThread().getContextClassLoader();
        Thread.currentThread().setContextClassLoader(myClassLoader());

        // Set the JNDI component context (for ejbStore)
        Context bnctx = setComponentContext();

        Collection coll = null;
        HashMap clone = null;
        synchronized (this) {
            clone = (HashMap) pklist.clone();
        }
        JEntitySwitch bs = null;
        for (Iterator i = clone.values().iterator(); i.hasNext();) {
            bs = (JEntitySwitch) i.next();
            if (!bs.passivateIH(true)) {
                count++;
            }
        }
        // Reset old value for component context
        resetComponentContext(bnctx);
        Thread.currentThread().setContextClassLoader(old);

        // compute the new size we want for the pool
        // (if more busy instances than min size, we want an empty pool)
        int poolsz = minPoolSize - count;
        if (poolsz < 0) {
            poolsz = 0;
        }

        // reduce the pool to this new value
        synchronized (bctxlist) {
            TraceEjb.swapper.log(BasicLevel.DEBUG, ejbname + ": try to reduce " + bctxlist.size() + " to " + poolsz);
            while (bctxlist.size() > poolsz) {
                ListIterator i = bctxlist.listIterator();
                if (i.hasNext()) {
                    i.next();
                    i.remove();
                    instanceCount--;
                }
            }
        }
        TraceEjb.swapper.log(BasicLevel.DEBUG, ejbname + " cacheSize= " + getCacheSize());
        printMemoryUsage();
    }

    public JHome getHome() {
        return home;
    }

    public JLocalHome getLocalHome() {
        return localhome;
    }

    // ---------------------------------------------------------------
    // Context Pool
    // ---------------------------------------------------------------

    public JEntityContext getJContext(JEntitySwitch es) {
        TraceEjb.interp.log(BasicLevel.DEBUG, ejbname);
        JEntityContext bctx = null;

        // try to find a free context in the pool
        synchronized (bctxlist) {
            try {
                ListIterator i = bctxlist.listIterator();
                if (i.hasNext()) {
                    bctx = (JEntityContext) i.next();
                    i.remove();
                }
                // TODO init es ref in ctxt
            } catch (IndexOutOfBoundsException ex) {
                // pool is empty
            }
        }

        if (bctx == null) {
            // create a new one if pool empty
            try {
                bctx = createNewInstance(es);
            } catch (Exception e) {
                throw new EJBException("Cannot create a new instance: " + e.toString());
            }
        }

        // DEBUG
        if (bctx.getEntitySwitch() != null) {
            TraceEjb.context.log(BasicLevel.ERROR, ejbname + "Context already initialized!");
        }

        return bctx;
    }

    public void releaseJContext(JContext ctx) {
        JEntityContext bctx = (JEntityContext) ctx;
        TraceEjb.context.log(BasicLevel.DEBUG, ejbname);
        bctx.razEntityContext();
        synchronized(bctxlist) {
            // debug
            if (bctxlist.contains(bctx)) {
                TraceEjb.context.log(BasicLevel.ERROR, ejbname + ": try to put twice this ctx " + bctx);
                Thread.dumpStack();
                return;
            }

            bctxlist.add(bctx);
        }
    }

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

    public TimerService getTimerService() {
        return this;
    }

    public int getMinPoolSize() {
        return minPoolSize;
    }

    public int getMaxCacheSize() {
        return maxCacheSize;
    }

    public int getCacheSize() {
        return instanceCount;
    }

    public boolean isReentrant() {
        return reentrant;
    }

    public boolean isShared() {
        return shared;
    }

    public int lockPolicy() {
        return lockPolicy;
    }

    public boolean isPrefetch() {
        return prefetch;
    }

    public Object getDataSource() {
        if (datasource == null) {
            TraceEjb.logger.log(BasicLevel.ERROR, ejbname + ": datasource not defined in JEntityFactory");
        }
        return datasource;
    }

    public void checkTransaction(RequestCtx rctx) {
        checkTransactionContainer(rctx);
    }

    public void syncForFind(Transaction tx) {
        TraceEjb.interp.log(BasicLevel.DEBUG, ejbname);
        if (tx == null) {
            if (lockPolicy == EntityDesc.LOCK_CONTAINER_SERIALIZED) {
                sync();
            }
        } else {
            TxListener txl = (TxListener) txlist.get(tx);
            if (txl != null) {
                txl.storeInstances();
            }
        }
    }

    public boolean isBlocking(Transaction tx) {
        HashMap clone = null;
        synchronized (this) {
            clone = (HashMap) pklist.clone();
        }
        JEntitySwitch bs = null;
        for (Iterator i = clone.values().iterator(); i.hasNext();) {
            bs = (JEntitySwitch) i.next();
            Transaction tb = bs.getBlockingTx();
            if (tb != null && tb.equals(tx)) {
                return true;
            }
        }
        return false;
    }

    public boolean isBlocked(Transaction tx) {
        HashMap clone = null;
        synchronized (this) {
            clone = (HashMap) pklist.clone();
        }
        JEntitySwitch bs = null;
        for (Iterator i = clone.values().iterator(); i.hasNext();) {
            bs = (JEntitySwitch) i.next();
            Transaction tb = bs.getBlockedTx();
            if (tb != null && tb.equals(tx)) {
                return true;
            }
        }
        return false;
    }

    public void removeTxListener(Transaction tx) {
        TraceEjb.interp.log(BasicLevel.DEBUG, ejbname);
        txlist.remove(tx);
    }

    public boolean registerContext(Transaction tx, JEntityContext ec) throws IllegalStateException {
        TraceEjb.interp.log(BasicLevel.DEBUG, ejbname);

        // Get the TXListener associated to this tx, or create it.
        TxListener txl = (TxListener) txlist.get(tx);
        if (txl == null) {
            txl = new TxListener(this, tx);
            // register it as Synchronization.
            try {
                tx.registerSynchronization(txl);
            } catch (RollbackException e) {
                TraceEjb.logger.log(BasicLevel.WARN, ejbname + " transaction has been marked rollbackOnly");
            } catch (SystemException e) {
                TraceEjb.logger.log(BasicLevel.ERROR, ejbname + " cannot register synchro ", e);
                // forget txl.
                throw new IllegalStateException("cannot register synchro");
            }
            txlist.put(tx, txl);
        }

        // Add the JEntityContext
        txl.addInstance(ec);
        return true;
    }

    public synchronized EntityCounters getEntityCounters() {
        EntityCounters ec = new EntityCounters();
        Collection coll = pklist.values();
        for (Iterator i = coll.iterator(); i.hasNext();) {
            JEntitySwitch es = (JEntitySwitch) i.next();
            switch (es.getState()) {
                case 0:
                    ec.inTx++;
                    break;
                case 1:
                    ec.outTx++;
                    break;
                case 2:
                    ec.idle++;
                    break;
                case 3:
                    ec.passive++;
                    break;
                case 4:
                    ec.removed++;
                    break;
            }
        }
        return ec;
    }

    public int calculateAutomaticPk() {
        TraceEjb.interp.log(BasicLevel.DEBUG, ejbname);
        int uid;
        synchronized (getClass()) {
            uid = (int) (System.currentTimeMillis() % (java.lang.Integer.MAX_VALUE / 10));
            uid = uid * 10 + ucount++;
        }
        return uid;
    }

    public void dummyFinderException(boolean dummy) throws FinderException {
        if (!dummy) {
            throw new FinderException("dummy exception !!!");
        }
    }

    public void printAllPks() {
        if (TraceEjb.isDebugSwapper()) {
            HashMap clone = null;
            synchronized (this) {
                clone = (HashMap) pklist.clone();
            }
            JEntitySwitch bs = null;
            for (Iterator i = clone.values().iterator(); i.hasNext();) {
                bs = (JEntitySwitch) i.next();
                TraceEjb.swapper.log(BasicLevel.DEBUG, "PK=" + bs.getPrimaryKey());
            }
        }
    }

    private void printMemoryUsage() {
        if (TraceEjb.isDebugSwapper()) {
            System.gc();
            TraceEjb.swapper.log(BasicLevel.DEBUG, 
                                 " total = " + Runtime.getRuntime().totalMemory() / 1024 +
                                 " free  = " + Runtime.getRuntime().freeMemory() / 1024);
        }
    }

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

    protected JEntityContext createNewInstance(JEntitySwitch es) throws Exception {
        TraceEjb.interp.log(BasicLevel.DEBUG, ejbname);

        // create the bean instance
        EntityBean bean = null;
        try {
            bean = (EntityBean) beanclass.newInstance();
        } catch (InstantiationException e) {
            TraceEjb.logger.log(BasicLevel.ERROR, ejbname + " cannot instantiate bean");
            throw e;
        } catch (IllegalAccessException e) {
            TraceEjb.logger.log(BasicLevel.ERROR, ejbname + " cannot instantiate bean");
            throw e;
        }

        // create a new EntityContext and bind it to the instance
        JEntityContext ec = createNewContext(bean);
        bean.setEntityContext(ec);
        ec.setState(1);

        // If too many instances, ask swapper to clean memory.
        synchronized (this) {
            instanceCount++;
        }
        if (maxCacheSize != 0 && instanceCount > maxCacheSize) {
            // Register this factory, if not already done.
            if (TraceEjb.isDebugSwapper()) {
                TraceEjb.swapper.log(BasicLevel.DEBUG, ejbname + ": Too many instances :" + instanceCount + ", max="
                        + maxCacheSize);
            }
            cont.registerBF(this);
        }

        return ec;
    }

    protected JEntityContext createNewContext(EntityBean bean) {
        return new JEntityContext(this, bean);
    }

    public Serializable encodePK(Serializable pk) {
        return pk;
    }

    public Serializable decodePK(Serializable strpk) {
        return strpk;
    }
    
    /*
     * (non-Javadoc)
     * @see javax.ejb.TimerService#createTimer(long, java.io.Serializable)
     */
    public Timer createTimer(long arg0, Serializable arg1) throws IllegalArgumentException, IllegalStateException, EJBException {
        throw new IllegalStateException("timer are associated with a PK");
    }

    /* (non-Javadoc)
     * @see javax.ejb.TimerService#createTimer(long, long, java.io.Serializable)
     */
    public Timer createTimer(long arg0, long arg1, Serializable arg2) throws IllegalArgumentException, IllegalStateException, EJBException {
        throw new IllegalStateException("timer are associated with a PK");
    }

    /* (non-Javadoc)
     * @see javax.ejb.TimerService#createTimer(java.util.Date, java.io.Serializable)
     */
    public Timer createTimer(Date arg0, Serializable arg1) throws IllegalArgumentException, IllegalStateException, EJBException {
        throw new IllegalStateException("timer are associated with a PK");
    }

    /* (non-Javadoc)
     * @see javax.ejb.TimerService#createTimer(java.util.Date, long, java.io.Serializable)
     */
    public Timer createTimer(Date arg0, long arg1, Serializable arg2) throws IllegalArgumentException, IllegalStateException, EJBException {
        throw new IllegalStateException("timer are associated with a PK");
    }

    /* (non-Javadoc)
     * @see javax.ejb.TimerService#getTimers()
     */
    public Collection getTimers() throws IllegalStateException, EJBException {
        throw new IllegalStateException("timer are associated with a PK");
    }

}

---