JEntitySwitchCS.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 JEntitySwitchCS extends JEntitySwitch {

    protected JEntityContext itContext = null;

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

    public JEntitySwitchCS() {
        lockpolicy = EntityDesc.LOCK_CONTAINER_SERIALIZED;
        txUpdates = false; // TODO : can set this in DD.
    }

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

    protected JEntityContext getContext4Tx(Transaction tx) {
        return itContext;
    }

    protected void setContext4Tx(Transaction tx, JEntityContext ctx) {
        if (TraceEjb.isDebugContext()) {
            TraceEjb.context.log(BasicLevel.DEBUG, "set itContext=" + ctx);
        }
        itContext = ctx;
    }

    protected void removeContext4Tx(Transaction tx) {
        if (TraceEjb.isDebugContext()) {
            TraceEjb.context.log(BasicLevel.DEBUG, "unset itContext=" + itContext);
        }
        itContext = null;
    }

    public void waitmyturn(Transaction tx) {
        // Synchronization.
        if (tx == null) {
            // Must wait in case of TX
            while (runningtx != null) {
                if (TraceEjb.isDebugSynchro()) {
                    TraceEjb.synchro.log(BasicLevel.DEBUG, ident + "mapICtx IH: WAIT end IT");
                }
                waiters++;
                try {
                    wait(maxtime);
                    if (TraceEjb.isDebugSynchro())
                            TraceEjb.synchro.log(BasicLevel.DEBUG, ident + "mapICtx IH: NOTIFIED");
                } catch (InterruptedException e) {
                    if (TraceEjb.isDebugSynchro())
                            TraceEjb.synchro.log(BasicLevel.DEBUG, ident + "mapICtx IH: INTERRUPTED");
                } catch (Exception e) {
                    throw new EJBException("JEntitySwitch synchronization pb", e);
                } finally {
                    waiters--;
                }
            }
        } else {
            
            // 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 (inDirtyList || (runningtx != null && !tx.equals(runningtx))) {
                // instance is dirty : must write it before working on it again.
                // this is mandatory to be able to retrieve a good state in case
                // of rollback.
                if (inDirtyList) {
                    if (TraceEjb.isDebugSynchro())
                            TraceEjb.synchro.log(BasicLevel.DEBUG, ident + "mapICtx IT: WAIT end IH");
                    // Cannot passivate here, because must be done outside tx
                    // context
                    bf.synchronizeEntities();
                } else {
                    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) {

        JEntityContext jec = getContext4Tx(null);

        // If already passivated, look if we can destroy the objects
        if (jec == null) {
            if (inactivityTimeout > 0) {
                long diff = System.currentTimeMillis() - timestamp;
                if (diff > inactivityTimeout) {
                    TraceEjb.context.log(BasicLevel.DEBUG, ident + timestamp);
                    discardContext(null, true, false);
                }
            }
            return true;
        }

        // If the instance is busy, don't touch it.
        if (countIH > 0 && !txUpdates) {
            // will be stored later, when released by last thread (countIH = 0)
            // return true to remove from the dirty list, since it will be
            // written anyway.
            if (TraceEjb.isDebugSynchro()) TraceEjb.synchro.log(BasicLevel.DEBUG, ident + " used off TX");
            mustStore = true;
            return true;
        }
        if (runningtx != null) {
            if (TraceEjb.isDebugSynchro()) TraceEjb.synchro.log(BasicLevel.DEBUG, ident + " used in TX");
            return false;
        }

        if (TraceEjb.isDebugSynchro()) TraceEjb.synchro.log(BasicLevel.DEBUG, ident);

        if (jec.isMarkedRemoved()) {
            discardContext(null, true, true);
            return true;
        }
        
        // Store the instance state
        // -> only if instance not discarded, and not readonly.
        if (!todiscard && !txUpdates) {
            try {
                jec.storeIfModified();
            } catch (Exception e) {
                TraceEjb.logger.log(BasicLevel.ERROR, ident, "error while storing bean state:", e);
            }
            mustStore = false;
            // don't set dirty false here, will be done in endIH.
            // this prevent duplicates in dirty list.
        }

        // passivate this instance if required.
        if (passivation) {
            if (TraceEjb.isDebugContext()) TraceEjb.context.log(BasicLevel.DEBUG, "passivated: " + jec);
            jec.passivate();
            bf.releaseJContext(jec);
            removeContext4Tx(null);
            // passivation done, set the timestamp
            timestamp = System.currentTimeMillis();
            TraceEjb.context.log(BasicLevel.DEBUG, ident + timestamp);
            if (waiters > 0) {
                TraceEjb.synchro.log(BasicLevel.DEBUG, ident + " notify");
                notifyAll();
            }
        }
        return true;
    }

    public synchronized void endIH() {
        inDirtyList = false;
        if (getContext4Tx(null) == null) {
            if (TraceEjb.isDebugSynchro()) TraceEjb.synchro.log(BasicLevel.DEBUG, ident + " discarded!");
            return;
        }
        // If the instance is busy, don't touch it.
        // If no context mapped, nothing to do
        if (countIH == 0) {
            if (TraceEjb.isDebugSynchro()) TraceEjb.synchro.log(BasicLevel.DEBUG, ident + " ready again");
        } else {
            if (TraceEjb.isDebugSynchro()) TraceEjb.synchro.log(BasicLevel.DEBUG, ident + " busy!");
        }
        if (waiters > 0) {
            TraceEjb.synchro.log(BasicLevel.DEBUG, ident + " notify");
            notifyAll();
        }
    }

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

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

}

---