JEntitySwitchCRU.java

package org.objectweb.jonas_ejb.container;

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 JEntitySwitchCRU extends JEntitySwitch {

    protected JEntityContext itContext = null;

    public JEntitySwitchCRU() {
        lockpolicy = EntityDesc.LOCK_CONTAINER_READ_UNCOMMITTED;
        txUpdates = true;
    }

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

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

    protected void setContext4Tx(Transaction tx, JEntityContext ctx) {
        itContext = ctx;
    }

    protected void removeContext4Tx(Transaction tx) {
        itContext = null;
    }

    public void waitmyturn(Transaction tx) {
        // No synchro for this policy.
    }

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

        waitmyturn(tx);

        // Choose the context to use.
        boolean newtrans = false;
        JEntityContext jec = itContext;
        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;
            itContext = jec;
            jec.initEntityContext(this);
            newtrans = true;
        } else {
            if (jec != null) {
                // 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);
                }
                newtrans = true; // TODO: not always a new tx (if more than 1
                                 // modifying call on this)
                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);
                itContext = jec; // after activate
                newtrans = true;
            }
        }

        if (tx == null) {
            if (holdit) {
                countIH++;
                if (TraceEjb.isDebugSynchro())
                        TraceEjb.synchro.log(BasicLevel.DEBUG, ident + "mapICtx IH count=" + countIH);
                if (shared && countIH == 1) {
                    // reload state that could have been modified by
                    // transactions.
                    jec.activate(false);
                }
            }
        } else {
            if (holdit) {
                countIT++;
            }
        }

        return jec;
    }

    public boolean passivateIH(boolean passivation) {
        JEntityContext jec = getContext4Tx(null);
        // If already passivated, look if we can destroy the objects
        if (jec == 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.isDebugContext()) TraceEjb.context.log(BasicLevel.DEBUG, "TODO: passivate: " + jec);
        }
        return true;
    }

    public void endIH() {
        return; // NEVER
    }

    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 set current transaction RollbackOnly");
            }
            // Since we share the same instance, we must rollback also
            // the current transaction (else data would be corrupted).
            try {
                writingtx.setRollbackOnly();
            } catch (SystemException e) {
                TraceEjb.logger.log(BasicLevel.ERROR, "cannot set other transaction RollbackOnly");
            }
            // We should also avoid modifying instance, in case writingtx is
            // already committing (setRollbackOnly will fail)
            throw new EJBException("Conflict writing entity bean");
        } else {
            // Instance must be written later.
            registerCtx(tx, bctx);
            writingtx = tx;
        }
    }

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

}

---