JEntityContext.java

package org.objectweb.jonas_ejb.container;

import java.rmi.RemoteException;

import javax.ejb.EJBException;
import javax.ejb.EJBLocalObject;
import javax.ejb.EJBObject;
import javax.ejb.EntityBean;
import javax.ejb.EntityContext;
import javax.ejb.NoSuchObjectLocalException;
import javax.ejb.RemoveException;
import javax.ejb.TimerService;
import javax.transaction.Status;
import javax.transaction.Synchronization;
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 JEntityContext extends JContext implements EntityContext, Synchronization {

    private boolean dirty = false;

    Transaction beanCoord = null;

    private boolean mustnotifywriting = false;

    private JEntitySwitch bs = null;

    boolean ismarkedremoved;

    boolean isnewinstance = false;

    // ------------------------------------------------------------------
    // constructors
    // ------------------------------------------------------------------

    public JEntityContext(JEntityFactory bf, EntityBean eb) {
        super(bf, eb);
        // entity beans may have home or localHome
        this.home = bf.getHome();
        this.localhome = bf.getLocalHome();
    }

    // ------------------------------------------------------------------
    // EJBContext implementation
    // ------------------------------------------------------------------

    public TimerService getTimerService() throws IllegalStateException {
        int mystate = getState();
        TraceEjb.interp.log(BasicLevel.DEBUG, "" + mystate);
        switch (mystate) {
            case 0:
                TraceEjb.logger.log(BasicLevel.ERROR, "not allowed here");
                throw new IllegalStateException("getTimerService not allowed here");
            case 4:
                TraceEjb.logger.log(BasicLevel.ERROR, "not allowed here");
                throw new IllegalStateException("getTimerService not allowed here");
            case 1:
                // should work when called from ejbCreate,
                // but timer operations should not -> return a dummy
                // TimerService.
                return bf.getTimerService();
            default:
                return bs == null ? bf.getTimerService() : bs.getEntityTimerService();
        }
    }

    // ------------------------------------------------------------------
    // EntityContext implementation
    // ------------------------------------------------------------------

    public EJBObject getEJBObject() throws IllegalStateException {
        TraceEjb.interp.log(BasicLevel.DEBUG, "");
        if (ismarkedremoved) {
            TraceEjb.logger.log(BasicLevel.ERROR, "marked removed");
            throw new IllegalStateException("EJB is removed");
        }
        if (bs == null) {
            TraceEjb.logger.log(BasicLevel.ERROR, "no EntitySwitch");
            throw new IllegalStateException("no EntitySwitch");
        }
        EJBObject ejbobject = bs.getRemote();
        if (ejbobject == null) {
            throw new IllegalStateException("No Remote Interface for this bean");
        }
        return ejbobject;
    }

    private EJBLocalObject getEJBLocalObject(boolean check) throws IllegalStateException {
        TraceEjb.interp.log(BasicLevel.DEBUG, "");
        if (check) {
            if (!bf.dd.hasDefinedLocalInterface()) {
                TraceEjb.logger.log(BasicLevel.ERROR, "No Local Interface declared for this bean");
                throw new IllegalStateException("No Local Interface declared for this bean");
            }
        }
        if (ismarkedremoved) {
            TraceEjb.logger.log(BasicLevel.ERROR, "marked removed");
            throw new IllegalStateException("EJB is removed");
        }
        if (bs == null) {
            TraceEjb.logger.log(BasicLevel.ERROR, "no EntitySwitch");
            throw new IllegalStateException("no EntitySwitch");
        }
        EJBLocalObject ejblocalobject = bs.getLocal();
        if (ejblocalobject == null) {
            throw new IllegalStateException("No Local Object for this bean");
        }
        return ejblocalobject;
    }

    public EJBLocalObject getEJBLocalObject() throws IllegalStateException {
        return getEJBLocalObject(true);
    }

    public EJBLocalObject get2EJBLocalObject() throws IllegalStateException {
         return getEJBLocalObject(false);
    }

    public Object getPrimaryKey() throws IllegalStateException {
        TraceEjb.interp.log(BasicLevel.DEBUG, "");
        if (ismarkedremoved) {
            TraceEjb.logger.log(BasicLevel.ERROR, "marked removed");
            throw new IllegalStateException("EJB is removed");
        }
        if (bs == null) {
            TraceEjb.logger.log(BasicLevel.ERROR, "no EntitySwitch");
            throw new IllegalStateException("no EntitySwitch");
        }
        return bs.getPrimaryKey();
    }

    // -------------------------------------------------------------------
    // Synchronization implementation
    // -------------------------------------------------------------------

    public void beforeCompletion() {
        TraceEjb.context.log(BasicLevel.DEBUG, "");

        // If isMarkedRemoved, no need to do all this.
        if (ismarkedremoved) {
            TraceEjb.context.log(BasicLevel.DEBUG, "ismarkedremoved -> no ejbStore");
            return;
        }

        if (beanCoord == null) {
            // should not go here!
            TraceEjb.logger.log(BasicLevel.ERROR, "no tx");
        }

        // First check that the primary key is not null.
        // We must avoid accessing the DataBase when ejbCreate has failed.
        if (isnewinstance) {
            try {
                if (getPrimaryKey() == null) {
                    // We do not force abort creation in order
                    // to be able to catch the CreateException
                    // otherwise CreateException will be overloaded
                    // in postInvoke by "cannot commit exception"
                    return;
                }
            } catch (IllegalStateException e) {
                return;
            }
        }

        try {
            storeIfModified();
        } catch (EJBException e) {
            // Could not store bean data: set transaction rollback only
            abortTransaction();
        }
    }

    public void afterCompletion(int status) {

        boolean committed = (status == Status.STATUS_COMMITTED);
        if (committed) {
            TraceEjb.context.log(BasicLevel.DEBUG, "committed");
        } else {
            TraceEjb.context.log(BasicLevel.DEBUG, "rolledback");
        }

        // Just check that we knew we were in a transaction (debug)
        if (beanCoord == null) {
            // should not go here!
            TraceEjb.logger.log(BasicLevel.ERROR, "no tx for " + this);
            return;
        }
        // Check also that the bs is not null (debug)
        if (bs == null) {
            // should not go here!
            TraceEjb.logger.log(BasicLevel.ERROR, "Context without EntitySwitch reference");
            throw new EJBException("Context with no Entity Switch");
        }

        // Let the EntitySwitch know that transaction is over and that it can
        // now dispose of this Context for another transaction.
        // no need to be in the correct component context ?
        bs.txCompleted(beanCoord, committed);
    }

    // -------------------------------------------------------------------
    // Other public methods
    // -------------------------------------------------------------------

    public void razEntityContext() {
        TraceEjb.context.log(BasicLevel.DEBUG, "");
        bs = null;
        beanCoord = null;
        ismarkedremoved = false;
        isnewinstance = false;
    }

    public void detachTx() {
        TraceEjb.context.log(BasicLevel.DEBUG, "");
        beanCoord = null;
        ismarkedremoved = false;
        isnewinstance = false;
    }

    public void initEntityContext(JEntitySwitch bs) {
        TraceEjb.context.log(BasicLevel.DEBUG, "");
        this.bs = bs;
        ismarkedremoved = false;
        mustnotifywriting = (bs.getPolicy() == EntityDesc.LOCK_CONTAINER_READ_UNCOMMITTED || bs.getPolicy() == EntityDesc.LOCK_DATABASE);
    }

    public void setRunningTx(Transaction tx) {
        TraceEjb.context.log(BasicLevel.DEBUG, "");
        beanCoord = tx;
    }

    public void reuseEntityContext(boolean newtrans) {
        TraceEjb.context.log(BasicLevel.DEBUG, "");

        // This prevents reusing an instance removed in the same transaction.
        if (ismarkedremoved) {
            TraceEjb.context.log(BasicLevel.WARN, "Try to access a deleted object");
            throw new NoSuchObjectLocalException("Instance has been removed");
        }
        if (newtrans) {
            isnewinstance = false;
        }
        if (bs == null) {
            TraceEjb.logger.log(BasicLevel.ERROR, "reuse Entity Context with no Entity Switch reference");
        }
    }

    public void setNewInstance() {
        isnewinstance = true;
    }

    public void setRemoved() throws RemoteException, RemoveException {
        TraceEjb.context.log(BasicLevel.DEBUG, "");
        EntityBean eb = (EntityBean) instance;

        if (instance == null) {
            TraceEjb.logger.log(BasicLevel.ERROR, "null instance!");
            return;
        }
        // call ejbRemove() on instance
        eb.ejbRemove();
        // getPrimaryKey and getEJBObject should work in ejbRemove.
        // => we do this only after ejbRemove call.
        ismarkedremoved = true;
    }

    public boolean isMarkedRemoved() {
        return ismarkedremoved;
    }

    public boolean isNewInstance() {
        return isnewinstance;
    }

    // RemoteException is throwned to allow simpler genic templates
    public EntityBean getInstance() throws RemoteException {
        if (instance == null) {
            TraceEjb.logger.log(BasicLevel.ERROR, "null!");
            throw new RemoteException("No instance available");
        }
        return (EntityBean) instance;
    }

    public JEntityFactory getEntityFactory() {
        return (JEntityFactory) bf;
    }

    public JEntitySwitch getEntitySwitch() {
        return (JEntitySwitch) bs;
    }

    public void setEntitySwitch(JEntitySwitch bs) {
        this.bs = bs;
    }

    public boolean isDirty() {
        return dirty;
    }

    public void setDirty(boolean d) {
        // Notify the EntitySwitch at 1st writing
        if (mustnotifywriting && d && !dirty) {
            // retrieve the current transaction.
            Transaction tx = null;
            try {
                tx = tm.getTransaction();
            } catch (SystemException e) {
                TraceEjb.context.log(BasicLevel.ERROR, "getTransaction failed:" + e);
            }
            if (tx == null) {
                TraceEjb.context.log(BasicLevel.DEBUG, "Try to modify bean outside any transaction");
            } else {
                bs.notifyWriting(tx, this);
            }
        }
        dirty = d;
    }

    public void storeIfModified() {

        EntityBean eb = (EntityBean) instance;

        if (ismarkedremoved) {
            // TODO something smart to do here ?
            TraceEjb.context.log(BasicLevel.DEBUG, "marked removed");
            return;
        }
        TraceEjb.context.log(BasicLevel.DEBUG, "");

        try {
            // this method can fail if database serializes transactions
            // This may do nothing if bean has not been modified (isModified
            // optimization)
            eb.ejbStore();
        } catch (RemoteException e) {
            throw new EJBException("Exception while storing data");
        } catch (EJBException e) {
            TraceEjb.logger.log(BasicLevel.ERROR, "raised EJBException ", e);
            throw e;
        } catch (RuntimeException e) {
            TraceEjb.logger.log(BasicLevel.ERROR, "runtime exception: ", e);
            throw new EJBException("Exception while storing data", e);
        } catch (Error e) {
            TraceEjb.logger.log(BasicLevel.ERROR, "error: ", e);
            throw new EJBException("Error while storing data");
        }
    }

    public void passivate() {

        TraceEjb.context.log(BasicLevel.DEBUG, "");

        EntityBean eb = (EntityBean) instance;
        setState(1);

        try {
            eb.ejbPassivate();
        } catch (Exception e) {
            TraceEjb.logger.log(BasicLevel.ERROR, "ejbPassivate failed", e);
        } catch (Error e) {
            TraceEjb.logger.log(BasicLevel.ERROR, "ejbPassivate error", e);
        }
    }

    public void activate(boolean doactivate) {
        TraceEjb.context.log(BasicLevel.DEBUG, "");

        EntityBean eb = (EntityBean) instance;

        try {
            if (doactivate) {
                setState(1);
                // Call ejbActivate
                eb.ejbActivate();
            }
            setState(2);
            // Load bean state from database
            eb.ejbLoad();
        } catch (RemoteException e) {
            TraceEjb.logger.log(BasicLevel.ERROR, "remote exception: ", e);
            throw new EJBException("Cannot activate bean");
        } catch (RuntimeException e) {
            TraceEjb.logger.log(BasicLevel.ERROR, "runtime exception: ", e);
            throw new EJBException("Cannot activate bean");
        } catch (Error e) {
            TraceEjb.logger.log(BasicLevel.ERROR, "error: ", e);
            throw new EJBException("Cannot activate bean");
        }
    }

    // ----------------------------------------------------------------
    // private methods
    // ----------------------------------------------------------------

    private void abortTransaction() {
        TraceEjb.context.log(BasicLevel.DEBUG, "");

        // If we are inside a transaction, it must be rolled back
        if (beanCoord != null) {
            try {
                beanCoord.setRollbackOnly();
            } catch (SystemException e) {
                TraceEjb.logger.log(BasicLevel.ERROR, "cannot setRollbackOnly");
            }
        }
    }

}

---