JEntitySwitchCRC.java

package org.objectweb.jonas_ejb.container;

import javax.ejb.EJBException;
import javax.ejb.NoSuchObjectLocalException;
import javax.ejb.TransactionRolledbackLocalException;
import javax.transaction.Status;
import javax.transaction.SystemException;
import javax.transaction.Transaction;

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

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

public class JEntitySwitchCRC extends JEntitySwitch {

    protected JEntityContext itContext = null;

    protected JEntityContext ihContext = null;

    // max time to wait when in a transaction, before checking if
    // transaction has been set rollback only (deadlock detection)
    protected static int maxtime = 5000; // 5 sec.

    public JEntitySwitchCRC() {
        lockpolicy = EntityDesc.LOCK_CONTAINER_READ_COMMITTED;
        txUpdates = true;
    }

    protected void initpolicy(JEntityFactory bf) {
        lazyregister = false;
    }

    protected JEntityContext getContext4Tx(Transaction tx) {
        JEntityContext ctx = null;
        if (tx == null) {
            ctx = ihContext;
        } else {
            ctx = itContext;
        }
        return ctx;
    }

    protected void setContext4Tx(Transaction tx, JEntityContext ctx) {
        if (tx == null) {
            ihContext = ctx;
        } else {
            itContext = ctx;
        }
    }

    protected void removeContext4Tx(Transaction tx) {
        // free this Context
        if (tx == null) {
            ihContext = null;
        } else {
            itContext = null;
        }
    }

    public void waitmyturn(Transaction tx) {

        // Synchronization.
        if (tx != null) {
            // Must wait in case of TX or if instance has been modified outside
            // transaction.
            // Don't wait transactions if 1 instance per transaction.
            int waitcount = 0;
            while (runningtx != null && !tx.equals(runningtx)) {
                if (TraceEjb.isDebugSynchro())
                        TraceEjb.synchro.log(BasicLevel.DEBUG, ident + "mapICtx IT: WAIT end IT");
                // deadlock detection
                blockedtx = tx;
                if (waitcount++ > 1 && bf.isBlocked(runningtx) && bf.isBlocking(tx)) {
                    try {
                        tx.setRollbackOnly();
                    } catch (SystemException e) {
                        TraceEjb.logger.log(BasicLevel.ERROR, ident
                                + "getICtx IT: unexpected exception setting rollbackonly");
                    }
                    TraceEjb.logger.log(BasicLevel.WARN, ident + "getICtx IT: transaction rolled back");
                    throw new TransactionRolledbackLocalException("possible deadlock");
                }
                waiters++;
                try {
                    wait(maxtime);
                    if (TraceEjb.isDebugSynchro())
                            TraceEjb.synchro.log(BasicLevel.DEBUG, ident + "mapICtx IT: NOTIFIED");
                } catch (InterruptedException e) {
                    if (TraceEjb.isDebugSynchro())
                            TraceEjb.synchro.log(BasicLevel.DEBUG, ident + "mapICtx IT: INTERRUPTED");
                } catch (Exception e) {
                    throw new EJBException("JEntitySwitch synchronization pb", e);
                } finally {
                    waiters--;
                    blockedtx = null;
                }
                // If transaction has been rolledback or set rollback only, give up.
                int status = Status.STATUS_ROLLEDBACK;
                try {
                    status = tx.getStatus();
                } catch (SystemException e) {
                    TraceEjb.logger.log(BasicLevel.ERROR, ident
                            + "getICtx IT: unexpected exception getting transaction status");
                }
                switch (status) {
                case Status.STATUS_MARKED_ROLLBACK:
                case Status.STATUS_ROLLEDBACK:
                case Status.STATUS_ROLLING_BACK:
                    TraceEjb.logger.log(BasicLevel.WARN, ident + "getICtx IT: transaction rolled back");
                    throw new TransactionRolledbackLocalException("rollback occured while waiting");
                }
            }
        }
    }

    public synchronized boolean passivateIH(boolean passivation) {

        // If already passivated, look if we can destroy the objects
        if (ihContext == null && itContext == null) {
            if (inactivityTimeout > 0 && 
                System.currentTimeMillis() - timestamp > inactivityTimeout) {
                TraceEjb.context.log(BasicLevel.DEBUG, "discard object on timeout");
                discardContext(null, true, false);
            }
            return true;
        }

        // passivate this instance if required.
        if (passivation) {

            if (TraceEjb.isDebugSwapper()) TraceEjb.swapper.log(BasicLevel.DEBUG, ident);

            // Instance used when no transaction.
            JEntityContext jec = ihContext;
            if (jec != null) {
                if (TraceEjb.isDebugContext()) TraceEjb.context.log(BasicLevel.DEBUG, "passivated: " + jec);
                jec.passivate();
                bf.releaseJContext(jec);
                ihContext = null;
            }
            // Instance used for transactions
            jec = itContext;
            if (jec != null && runningtx == null) {
                if (TraceEjb.isDebugContext()) TraceEjb.context.log(BasicLevel.DEBUG, "passivated: " + jec);
                jec.passivate();
                bf.releaseJContext(jec);
                itContext = null;
            }

            // If passivation done, set the timestamp
            if (ihContext == null && itContext == null) {
                timestamp = System.currentTimeMillis();
            }

            if (waiters > 0) {
                TraceEjb.synchro.log(BasicLevel.DEBUG, ident + " notify");
                notifyAll();
            }
        }
        return true;
    }

    public synchronized void endIH() {
        // Not used.
    }

    public synchronized void notifyWriting(Transaction tx, JEntityContext bctx) {
        return; // NEVER
    }

    public int getState() {
        if (ihContext != null) {
            if (ihContext.isMarkedRemoved()) {
                return 4;
            } else {
                if (inDirtyList) {
                    return 1;
                } else {
                    if (itContext == null) {
                        return 2;
                    }
                }
            }
        }
        if (itContext != null) {
            if (itContext.isMarkedRemoved()) {
                return 4;
            } else {
                if (runningtx != null) {
                    return 0;
                } else {
                    return 2;
                }
            }
        }
        return 3;
    }

}

---