JEntitySwitch.java

package org.objectweb.jonas_ejb.container;

import java.rmi.NoSuchObjectException;
import java.rmi.RemoteException;

import javax.ejb.EJBException;
import javax.ejb.EntityBean;
import javax.ejb.NoSuchObjectLocalException;
import javax.ejb.ObjectNotFoundException;
import javax.ejb.TimedObject;
import javax.ejb.Timer;
import javax.ejb.TimerService;
import javax.transaction.Status;
import javax.transaction.SystemException;
import javax.transaction.Transaction;

import org.objectweb.jonas_ejb.deployment.api.EntityDesc;
import org.objectweb.jonas_ejb.deployment.api.MethodDesc;
import org.objectweb.jonas_timer.TraceTimer;

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

public abstract class JEntitySwitch {

    protected JEntityFactory bf;

    protected Object pk = null;

    protected JEntityLocal local = null;

    protected JEntityRemote remote = null;

    protected long inactivityTimeout; // millisec.

    protected boolean shared;

    protected int lockpolicy;

    protected boolean txUpdates;

    protected TimerService myTimerService = null;

    protected int countIH = 0;

    protected int countIT = 0;

    protected int waiters = 0;

    protected boolean inDirtyList = false;

    protected boolean mustReload = false;

    protected boolean mustStore = false;

    protected boolean todiscard = false;

    // transaction on which a Context has been registered.
    // used only for policies CS and CRC
    protected Transaction runningtx = null;

    // transaction that has modified an instance
    // used only for policies DB and CRU
    protected Transaction writingtx = null;

    protected Transaction blockedtx = null;

    protected boolean isremoved = false;

    // ident is used mainly for debugging
    protected static int counter = 0;

    protected String ident;

    protected long timestamp = System.currentTimeMillis();

    private final static long FEW_MINUTS = 180000;

    private static final int MAX_NB_RETRY = 2;

    protected boolean lazyregister = false;

    protected boolean reentrant;

    abstract JEntityContext getContext4Tx(Transaction tx);

    abstract void setContext4Tx(Transaction tx, JEntityContext ctx);

    abstract void removeContext4Tx(Transaction tx);

    abstract protected void initpolicy(JEntityFactory bf);

    abstract public boolean passivateIH(boolean passivation);

    abstract public void endIH();

    abstract public void notifyWriting(Transaction tx, JEntityContext bctx);

    public JEntitySwitch() {
    }

    public void init(JEntityFactory bf, Object pk) {
        this.bf = bf;
        this.pk = pk;
        isremoved = false;
        if (pk == null) {
            TraceEjb.logger.log(BasicLevel.ERROR, ident + "Init Entity Switch with a null PK!");
            throw new EJBException("Init Entity Switch with a null PK!");
        }

        shared = bf.isShared();
        reentrant = bf.isReentrant();
        inactivityTimeout = bf.getInactivityTimeout() * 1000;
        initpolicy(bf);

        // generate new ident (debug)
        ident = "<" + counter + ":" + pk + ">";
        counter++;

        countIH = 0;
        countIT = 0;
        waiters = 0;

        // Create EJBObject if bean has a Remote Interface
        if (bf.getHome() != null) {
            try {
                remote = ((JEntityHome) bf.getHome()).createRemoteObject();
                remote.setEntitySwitch(this);
            } catch (RemoteException e) {
                throw new EJBException("cannot create Remote Object", e);
            }
        }

        // Create EJBLocalObject if bean has a Local Interface
        if (bf.getLocalHome() != null) {
            local = ((JEntityLocalHome) bf.getLocalHome()).createLocalObject();
            local.setEntitySwitch(this);
        }
        // Set the timestamp to a big value because instance will be used.
        // This solve a problem in case of findAll() for example :
        // Avoids to discard instance just before it will be used.
        if (inactivityTimeout > 0) {
            timestamp = System.currentTimeMillis() + FEW_MINUTS;
            TraceTimer.logger.log(BasicLevel.DEBUG, ident + timestamp);
        }
    }

    public JEntityLocal getLocal() {
        return local;
    }

    public JEntityRemote getRemote() {
        return remote;
    }

    public TimerService getEntityTimerService() {
        // In case this object is used for a finder method,
        // pk should be null, and TimerService must not be retrieved.
        if (pk == null) {
            throw new java.lang.IllegalStateException();
        }
        if (myTimerService == null) {
            // TODO : Check that instance implements TimedObject ?
            myTimerService = new JTimerService(this);
        }
        return myTimerService;
    }

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

        boolean committed = false;
        for (int nbretry = 0; ! committed && nbretry < MAX_NB_RETRY; nbretry++) {
            RequestCtx rctx = bf.preInvoke(bf.getTimerTxAttribute());
            try {
                JEntityContext bctx = getICtx(rctx.currTx, false);
                EntityBean eb = bctx.getInstance();
                bf.checkSecurity(null);
                if (eb instanceof TimedObject) {
                    TimedObject instance = (TimedObject) eb;
                    instance.ejbTimeout(timer);
                } else {
                    throw new EJBException("The bean does not implement the `TimedObject` interface");
                }
                committed = (rctx.currTx == null) || 
                (rctx.currTx.getStatus() != Status.STATUS_MARKED_ROLLBACK);
            } 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 {
                try {
                    bf.postInvoke(rctx);
                } finally {
                    if (rctx.sysExc != null) {
                        discardICtx(rctx.currTx);
                    } else {
                        releaseICtx(rctx.currTx);
                    }
                }
            }
        }
    }

    public Object getPrimaryKey() {
        if (pk == null) {
            throw new java.lang.IllegalStateException();
        }
        return pk;
    }

    public void bindICtx(Transaction tx, JEntityContext bctx) {
        mapICtx(tx, bctx, true, false, false);
    }

    public synchronized boolean tryBindICtx(Transaction tx, JEntityContext bctx) throws ObjectNotFoundException {

        // Don't bind if already a context.
        if (getContext4Tx(tx) != null) {
            TraceEjb.context.log(BasicLevel.DEBUG, ident + "context already mapped!");
            if (getContext4Tx(tx).isMarkedRemoved()) {
                TraceEjb.context.log(BasicLevel.DEBUG, ident + "Removed in the current tx");
                throw new ObjectNotFoundException("Removed in the current tx");
            }
            // bctx will be released by caller. (See JEntityHome.vm)
            return false;
        }

        // No synchronization, since this is used for readonly methods (finder);
        bctx.initEntityContext(this);
        bctx.activate(true);
        setContext4Tx(tx, bctx); // after activate (CRU => full parallellism)
        if (!lazyregister) {
            if (tx == null) {
                if (TraceEjb.isDebugSynchro()) TraceEjb.synchro.log(BasicLevel.DEBUG, ident + "IH find");
            } else {
                if (TraceEjb.isDebugSynchro()) TraceEjb.synchro.log(BasicLevel.DEBUG, ident + "IT find");
                registerCtx(tx, bctx);
            }
        }
        return true;
    }

    public JEntityContext getICtx(Transaction tx, JEntityContext newctx) {
        return mapICtx(tx, newctx, false, false, false);
    }

    public JEntityContext getICtx(Transaction tx, boolean checkr) {
        return mapICtx(tx, null, false, true, checkr);
    }

    public synchronized boolean terminate(Transaction tx) {
        TraceEjb.swapper.log(BasicLevel.DEBUG, ident);
        waitmyturn(tx);
        JEntityContext jec = getContext4Tx(tx);
        if (jec != null) {
            if (todiscard || jec.isMarkedRemoved()) {
                discardContext(tx, true, true);
            } else {
                try {
                    jec.storeIfModified();
                } catch (Exception e) {
                    TraceEjb.logger.log(BasicLevel.ERROR, ident, "error while storing bean state:", e);
                }
                jec.passivate();
                discardContext(tx, false, true);
            }
            if (waiters > 0) {
                TraceEjb.synchro.log(BasicLevel.DEBUG, ident + " notify");
                notifyAll();
            }
        }
        return true;
    }

    abstract void waitmyturn(Transaction tx);

    public synchronized JEntityContext mapICtx(Transaction tx, JEntityContext bctx, boolean forced, boolean holdit, boolean checkreentrance) {

        // DEBUG only
        if (bf == null) {
            TraceEjb.synchro.log(BasicLevel.ERROR, "JEntitySwitch not initialized!");
            throw new EJBException("JEntitySwitch not initialized");
        }
        if (TraceEjb.isDebugSynchro()) {
            TraceEjb.synchro.log(BasicLevel.DEBUG, ident + " tx=" + tx);
        }

        // Check non-reentrance (See spec EJB 2.1 section 12.1.13)
        if (!reentrant && checkreentrance) {
            if (runningtx != null && countIT > 0 && tx != null && tx.equals(runningtx)) {
                throw new EJBException("non-reentrant bean accessed twice in same transaction");
            }
            if (tx == null && countIH > 0) {
                throw new EJBException("non-reentrant bean accessed twice outside transaction");
            }
        }
        // synchro (lock-policy dependant)
        waitmyturn(tx);

        // Set the timestamp to a big value because instance will be used.
        if (inactivityTimeout > 0) {
            timestamp = System.currentTimeMillis() + FEW_MINUTS;
            TraceTimer.logger.log(BasicLevel.DEBUG, ident + timestamp);
        }

        // Choose the context to use.
        boolean newtrans = false;
        JEntityContext jec = getContext4Tx(tx);
        if (forced) {
            // If the new context is enforced, we must first release the older
            if (jec != null) {
                TraceEjb.context.log(BasicLevel.DEBUG, ident + "new context is enforced!");
                discardContext(tx, false, true);
            }
            jec = bctx;
            setContext4Tx(tx, jec);
            jec.initEntityContext(this);
            newtrans = true;
            isremoved = false;  // in case of create following a remove
        } else {
            // First check if bean still exists
            if (isremoved) {
                TraceEjb.logger.log(BasicLevel.WARN, ident + " has been removed.");
                throw new NoSuchObjectLocalException("Try to access a bean previously removed");
            }
            if (jec != null) {
                if (todiscard) {
                    TraceEjb.logger.log(BasicLevel.WARN, ident + " has been discarded.");
                    throw new NoSuchObjectLocalException("Try to access a bean previously discarded");
                }
                // Reuse the Context for this transaction.
                // If a context was supplied, release it first.
                if (bctx != null) {
                    if (TraceEjb.isDebugContext())
                            TraceEjb.context.log(BasicLevel.DEBUG, ident + "a context was supplied!");
                    bf.releaseJContext(bctx);
                }
                // In case the same instance is used for all tx, must check if
                // new one. For LOCK_DATABASE policy, it cannot be a new tx.
                if (runningtx == null && lockpolicy != EntityDesc.LOCK_DATABASE) {
                    newtrans = true;
                }
                jec.reuseEntityContext(newtrans);
            } else {
                if (bctx != null) {
                    jec = bctx;
                } else {
                    // no Context available : get one from the pool.
                    jec = (JEntityContext) bf.getJContext(this);
                }
                jec.initEntityContext(this);
                jec.activate(true);
                setContext4Tx(tx, jec); // after activate
                newtrans = true;
            }
        }

        if (tx != null) {
            if (holdit) {
                countIT++;
            }
            // Register Context now, except if no new transaction
            if (newtrans && !lazyregister) {
                try {
                    registerCtx(tx, jec);
                    if (TraceEjb.isDebugSynchro())
                        TraceEjb.synchro.log(BasicLevel.DEBUG, ident + "mapICtx IT: new tx, registerSynchronization");
                } catch (IllegalStateException e) {
                    TraceEjb.synchro.log(BasicLevel.WARN, ident + "mapICtx IT: not registered!");
                }
            }
        } else {
            if (holdit) {
                countIH++;
                if (TraceEjb.isDebugSynchro())
                        TraceEjb.synchro.log(BasicLevel.DEBUG, ident + "mapICtx IH count=" + countIH);
                if ((shared || mustReload) && countIH == 1) {
                    // reload state that could have been modified by
                    // transactions.
                    jec.activate(false);
                    mustReload = false;
                }
            }
            if (!inDirtyList && !txUpdates) {
                inDirtyList = true;
                bf.registerEJB(this);
            }
        }

        return jec;
    }

    public Transaction getBlockedTx() {
        return blockedtx;
    }

    public Transaction getBlockingTx() {
        return runningtx;
    }

    public synchronized void releaseICtx(Transaction tx) {

        if (tx == null) {
            // ------------- IH end -------------
            countIH--;
            if (TraceEjb.isDebugSynchro())
                    TraceEjb.synchro.log(BasicLevel.DEBUG, ident + "releaseICtx IH count=" + countIH);
            if (countIH == 0) {
                JEntityContext jec = getContext4Tx(tx);
                if (jec == null) {
                    TraceEjb.context.log(BasicLevel.ERROR, ident + " No context!");
                    Thread.dumpStack();
                    return;
                }
                if (todiscard || jec.isMarkedRemoved()) {
                    // TODO why test todiscard here ?
                    discardContext(tx, true, true);
                } else {
                    if (mustStore) {
                        try {
                            jec.storeIfModified();
                        } catch (EJBException e) {
                            TraceEjb.logger.log(BasicLevel.WARN, ident + " ejbexception:" + e);
                        }
                        mustStore = false;
                    }
                }
                if (waiters > 0) {
                    TraceEjb.synchro.log(BasicLevel.DEBUG, ident + " notify");
                    notifyAll();
                }
            }
        } else {
            // ------------- IT end -------------
            // nothing to do now. Wait for tx completed.
            if (TraceEjb.isDebugSynchro()) TraceEjb.synchro.log(BasicLevel.DEBUG, ident + "releaseICtx IT");
            countIT--;
        }
    }

    public synchronized void discardICtx(Transaction tx) {
        if (tx == null) {
            countIH--;
            if (countIH == 0) {
                discardContext(tx, false, false);
                return;
            }
        } else {
            countIT--;
            if (runningtx == null) {
                // The transaction has already been committed.
                return;
            }
        }
        // to be done later.
        todiscard = true;
    }

    public synchronized void txCompleted(Transaction tx, boolean committed) {
        JEntityContext jec = getContext4Tx(tx);
        if (jec == null) {
            TraceEjb.context.log(BasicLevel.ERROR, ident + " No context for this tx");
            return;
        }
        runningtx = null;
        if (writingtx != null && tx.equals(writingtx)) {
            writingtx = null;
        }

        if (TraceEjb.isDebugSynchro()) TraceEjb.synchro.log(BasicLevel.DEBUG, ident + " txCompleted " + committed);

        // The create was eventually rolled back or instance has been discarded.
        // We must remove PK entry.
        if (todiscard || (jec.isNewInstance() && !committed)) {
            discardContext(tx, !todiscard, false);
            return;
        }

        if (jec.isMarkedRemoved()) {
            if (TraceEjb.isDebugContext()) TraceEjb.context.log(BasicLevel.DEBUG, ident + "remove!");
            discardContext(tx, committed, true);
        } else {
            if (shared || !committed) {
                // TODO read-only policy: keep instance until a specified timeout.
                // LOCK_DATABASE policy should go here (shared = true)
                if (TraceEjb.isDebugContext()) TraceEjb.context.log(BasicLevel.DEBUG, jec + " passivated!");
                jec.passivate();
                if (committed) {
                    // context is discarded if transaction rolled back
                    bf.releaseJContext(jec);
                }
                removeContext4Tx(tx);
            } else {
                // do this before reallocating the Context for another tx
                // (inside this lock)
                jec.detachTx();
            }
            // If special instance for no transactional accesses, it must be
            // reloaded
            if (lockpolicy == EntityDesc.LOCK_CONTAINER_READ_COMMITTED || lockpolicy == EntityDesc.LOCK_DATABASE) {
                mustReload = true;
            }
        }
        if (waiters > 0) {
            TraceEjb.synchro.log(BasicLevel.DEBUG, ident + " notify");
            notifyAll();
        }
    }

    protected void registerCtx(Transaction tx, JEntityContext bctx) {
        // register this context to the transaction, as a Synchronization.
        try {
            if (bf.registerContext(tx, bctx)) {
                TraceEjb.context.log(BasicLevel.DEBUG, bctx + "registered!");
                bctx.setRunningTx(tx);
                runningtx = tx;
            } else {
                TraceEjb.context.log(BasicLevel.WARN, bctx + "could not be registered!");
            }
        } catch (IllegalStateException e) {
            TraceEjb.logger.log(BasicLevel.ERROR, ident + "Transaction is in an illegal state");
            throw e;
        }
    }

    protected void discardContext(Transaction tx, boolean forgetpk, boolean pool) {
        TraceEjb.context.log(BasicLevel.DEBUG, "");
        JEntityContext jec = getContext4Tx(tx);
        if (jec != null) {
            if (pool) {
                bf.releaseJContext(jec);
            }
            removeContext4Tx(tx);
        }
        if (forgetpk) {
            if (remote != null) {
                try {
                    remote.unexportObject();
                } catch (NoSuchObjectException e) {
                    TraceEjb.logger.log(BasicLevel.ERROR, ident + " unexport entity failed: " + e);
                }
            }
            bf.removeEJB(getPrimaryKey());

            // Cancel all timers for this bean (= remove the TimerService)
            if (myTimerService != null) {
                ((JTimerService) myTimerService).cancelAllTimers();
                myTimerService = null;
            }
            // this Entity switch must not be used any longer.
            isremoved = true;
        }
        todiscard = false;  // done.
    }

    public int getPolicy() {
        return lockpolicy;
    }

    abstract public int getState();
    public JFactory getBeanFactory() {
        return bf;
    }

}

---