JEntitySwitchDB.java

package org.objectweb.jonas_ejb.container;

import java.util.HashMap;
import java.util.Iterator;

import javax.ejb.EJBException;
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 JEntitySwitchDB extends JEntitySwitch {

    protected JEntityContext ihContext = null;

    protected HashMap itsContext;

    public JEntitySwitchDB() {
        lockpolicy = EntityDesc.LOCK_DATABASE;
        txUpdates = true;
        itsContext = new HashMap();
    }

    protected void initpolicy(JEntityFactory bf) {
        // should be false, because usually this policy implies shared=true.
        lazyregister = !bf.isPrefetch() && !shared;
    }

    protected JEntityContext getContext4Tx(Transaction tx) {
        if (tx == null) {
            return ihContext;
        } else {
            return (JEntityContext) itsContext.get(tx);
        }
    }

    protected void setContext4Tx(Transaction tx, JEntityContext ctx) {
        if (tx == null) {
            ihContext = ctx;
        } else {
            if (TraceEjb.isDebugSwapper()) TraceEjb.swapper.log(BasicLevel.DEBUG, ident + " add new Context");
            itsContext.put(tx, ctx);
        }
    }

    protected void removeContext4Tx(Transaction tx) {
        // free this Context
        if (tx == null) {
            ihContext = null;
        } else {
            if (TraceEjb.isDebugSwapper()) TraceEjb.swapper.log(BasicLevel.DEBUG, ident + " get rid of this Context");
            itsContext.remove(tx);
        }
    }

    public void waitmyturn(Transaction tx) {
        // synchro done by database.
    }

    public boolean passivateIH(boolean passivation) {
        // If already passivated, look if we can destroy the objects
        if (ihContext == null && itsContext.size() == 0) {
            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;
            }

            // If passivation done, set the timestamp
            if (itsContext.size() == 0) {
                timestamp = System.currentTimeMillis();
            }

            // Instances used in transaction are already passivated
            // when the transaction is over. (See JEntitySwitch.java)
            if (waiters > 0) {
                TraceEjb.synchro.log(BasicLevel.DEBUG, ident + " notify");
                notifyAll();
            }
        }
        return true;
    }

    public void endIH() {
        return;
    }

    public synchronized void notifyWriting(Transaction tx, JEntityContext bctx) {
        TraceEjb.synchro.log(BasicLevel.DEBUG, ident);
        if (writingtx != null) {
            TraceEjb.logger.log(BasicLevel.WARN, "Conflict: 2 transactions attempt to write the same instance");
            try {
                tx.setRollbackOnly();
            } catch (SystemException e) {
                TraceEjb.logger.log(BasicLevel.ERROR, "cannot setRollbackOnly");
            }
        } else {
            if (lazyregister) {
                // Instance must be written later.
                // In case of prefetch, this has already be done (=
                // !lazyregister)
                registerCtx(tx, bctx);
            }
            writingtx = tx;
        }
    }

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

}

---