EntityDesc.java

package org.objectweb.jonas_ejb.deployment.api;

import java.util.Iterator;

import org.objectweb.jonas_ejb.deployment.xml.AssemblyDescriptor;
import org.objectweb.jonas_ejb.deployment.xml.Entity;
import org.objectweb.jonas_ejb.deployment.xml.JonasEntity;
import org.objectweb.jonas_ejb.lib.BeanNaming;
import org.objectweb.jonas_lib.deployment.api.DeploymentDescException;
import org.objectweb.jonas_lib.deployment.xml.JLinkedList;
import org.objectweb.util.monolog.api.BasicLevel;


public abstract class EntityDesc extends BeanDesc {


    protected static final String METHODS_REMOTE_NO_TX = ",getEJBHome,getHandle,getPrimaryKey,isIdentical,";

    protected static final String METHODS_HOME_NO_TX = ",getEJBMetaData,getHomeHandle,";

    protected Class primaryKeyClass;
    protected boolean reentrant;
    protected int passivationTimeout = 0;
    protected int inactivityTimeout = 0;
    protected boolean shared = false;
    protected boolean prefetch = false;

    // Field used for pk auto-generate
    protected boolean jdbcAutomaticPk = false; // first implementation  with specific tag into JOnAS Descriptor file
    protected boolean pkObjectType = false;   // second implementation with prim-key-type=java.lang.Object (cf spec ?14.1.9.3)

    // mapping cleanup policy
    public static final int CLEANUP_NONE = 0;
    public static final int CLEANUP_CREATE = 1;
    public static final int CLEANUP_REMOVEDATA = 2;
    public static final int CLEANUP_REMOVEALL = 3;
    protected int cleanup = CLEANUP_CREATE;

    // lock policy
    public static final int LOCK_CONTAINER_READ_UNCOMMITTED = 0;
    public static final int LOCK_CONTAINER_SERIALIZED = 1;
    public static final int LOCK_CONTAINER_READ_COMMITTED = 2;
    public static final int LOCK_DATABASE = 3;
    public static final int LOCK_READ_ONLY = 4;
    protected int lockPolicy = LOCK_CONTAINER_SERIALIZED;

    public EntityDesc(ClassLoader classLoader, 
                       Entity ent, 
                       AssemblyDescriptor asd, 
                       JonasEntity jEnt, 
                       JLinkedList jMDRList,
                       String fileName)
        throws DeploymentDescException {

        super(classLoader, ent, jEnt, asd, jMDRList, fileName);

        // primary Key class
        try {
            // Test for automatic PK
            if (ent.getPrimKeyClass().equalsIgnoreCase("Object") || ent.getPrimKeyClass().equalsIgnoreCase("java.lang.Object")) {
                primaryKeyClass = classLoader.loadClass("java.lang.Integer");
                pkObjectType = true;
            }
            else
                primaryKeyClass = classLoader.loadClass(ent.getPrimKeyClass());
        } catch (ClassNotFoundException e) {
            throw new DeploymentDescException("Primary Key class not found for bean " + this.ejbName, e);
        }

        // passivation timeout
        if (jEnt.getPassivationTimeout() != null) {
            String tstr = jEnt.getPassivationTimeout();
            Integer tval = new Integer(tstr);
            passivationTimeout = tval.intValue();
        }

        // inactivity timeout
        if (jEnt.getInactivityTimeout() != null) {
            String tstr = jEnt.getInactivityTimeout();
            Integer tval = new Integer(tstr);
            inactivityTimeout = tval.intValue();
        }

        // reentrant
        if (ent.getReentrant().equalsIgnoreCase("True")) {
            reentrant = true;
        } else if (ent.getReentrant().equalsIgnoreCase("False")) {
            reentrant = false;
        } else {
            throw new DeploymentDescException("Invalid reentrant value for bean " + this.ejbName);
        }

        // prefetch
        if (jEnt.getPrefetch() != null) {
            if (jEnt.getPrefetch().equalsIgnoreCase("True")) {
                prefetch = true;
            } else if (jEnt.getPrefetch().equalsIgnoreCase("False")) {
                prefetch = false;
            } else {
                throw new DeploymentDescException("Invalid prefetch value for bean " + this.ejbName);
            }
        }

        // min-pool-size
        if (jEnt.getMinPoolSize() != null) {
            String tstr = jEnt.getMinPoolSize();
            Integer tval = new Integer(tstr);
            poolMin = tval.intValue();
        }

        // max-cache-size
        if (jEnt.getMaxCacheSize() != null) {
            String tstr = jEnt.getMaxCacheSize();
            Integer tval = new Integer(tstr);
            cacheMax = tval.intValue();
        }

        // lock policy. Possible values are :
        // container-serialized     =
        // container-read-committed =
        // database                 =
        if (jEnt.getLockPolicy() != null) {
            String tstr = jEnt.getLockPolicy();
            if (tstr.equals("container-serialized")) {
                lockPolicy = LOCK_CONTAINER_SERIALIZED;
                shared = false;
            } else if (tstr.equals("container-read-committed")) {
                lockPolicy = LOCK_CONTAINER_READ_COMMITTED;
                shared = true;
            } else if (tstr.equals("container-read-uncommitted")) {
                lockPolicy = LOCK_CONTAINER_READ_UNCOMMITTED;
                shared = true;
            } else if (tstr.equals("database")) {
                lockPolicy = LOCK_DATABASE;
                shared = true;
            } else if (tstr.equals("read-only")) {
                lockPolicy = LOCK_READ_ONLY;
            } else {
                throw new DeploymentDescException("Invalid lock-policy value for bean " + jEnt.getEjbName());
            }
        }

        // shared
        if (jEnt.getShared() != null) {
            if (jEnt.getShared().equalsIgnoreCase("True")) {
                shared = true;
            } else if (jEnt.getShared().equalsIgnoreCase("False")) {
                shared = false;
            } else {
                throw new DeploymentDescException("Invalid shared value for bean " + this.ejbName);
            }
        }

        // cleanup policy. Possible values are :
        // create       = create table only if does not exist yet. (default)
        // none         = nothing is done (not implemented)
        // removeall    = drop table and recreate it.
        // removedata   = remove all data if exist, create table if does not exist.
        if (jEnt.getCleanup() != null) {
            String tstr = jEnt.getCleanup();
            if (tstr.equals("create")) {
                cleanup = CLEANUP_CREATE;
            } else if (tstr.equals("none")) {
                cleanup = CLEANUP_NONE;
            } else if (tstr.equals("removeall")) {
                cleanup = CLEANUP_REMOVEALL;
            } else if (tstr.equals("removedata")) {
                cleanup = CLEANUP_REMOVEDATA;
            } else {
                throw new DeploymentDescException("Invalid cleanup value for bean " + jEnt.getEjbName());
            }
        }

        // cache TxAttribute for ejbTimeout
        for (Iterator i = getMethodDescIterator(); i.hasNext();) {
            MethodDesc methd = (MethodDesc) i.next();
            if (methd.getMethod().getName().equals("ejbTimeout")) {
                timerTxAttribute = methd.getTxAttribute();
                ejbTimeoutSignature = BeanNaming.getSignature(getEjbName(), methd.getMethod());
            }
        }
    }

    public int getCleanupPolicy() {
        return cleanup;
    }

    public int getLockPolicy() {
        return lockPolicy;
    }

    protected void checkTxAttribute(MethodDesc md) throws DeploymentDescException {
        java.lang.reflect.Method m = md.getMethod();
        if (md.getTxAttribute() == MethodDesc.TX_NOT_SET) {
            // exclude method list for home interface
            if (javax.ejb.EJBHome.class.isAssignableFrom(m.getDeclaringClass())
                && (METHODS_HOME_NO_TX.indexOf("," + m.getName() + ",") != -1)) {
                return;
            }
            // exclude method list for remote interface
            if (javax.ejb.EJBObject.class.isAssignableFrom(m.getDeclaringClass())
                && (METHODS_REMOTE_NO_TX.indexOf("," + m.getName() + ",") != -1)) {
                return;
            }
            // exclude ejbSelect methods
            if (md.isEjbSelect()) {
                return;
            }
            // trans-attribute not set !
            // trace a warning and set the tx-attribute with the default value
            logger.log(BasicLevel.WARN,
                       "trans-attribute missing for method "
                       + m.toString() + " in entity bean "
                       + getEjbName()
                       + " (set to the default value "
                       + MethodDesc.TX_STR_DEFAULT_VALUE
                       + ")");
            md.setTxAttribute(MethodDesc.TX_STR_DEFAULT_VALUE);
        }
    }

    public int getPassivationTimeout() {
        return passivationTimeout;
    }

    public int getInactivityTimeout() {
        return inactivityTimeout;
    }

    public Class getPrimaryKeyClass() {
        return primaryKeyClass;
    }

    public boolean isReentrant() {
        return reentrant;
    }

    public boolean isShared() {
        return shared;
    }

    public boolean isPrefetch() {
        return prefetch;
    }

    public boolean isAutomaticPk() {
        return jdbcAutomaticPk;
    }

    public boolean isUndefinedPK() {
        return pkObjectType;
    }

    public String toString() {
        StringBuffer ret = new StringBuffer();
        ret.append(super.toString());
        ret.append("\ngetPrimaryKeyClass()    =" + getPrimaryKeyClass().toString());
        ret.append("\nisReentrant()           =" + isReentrant());
        ret.append("\ngetPassivationTimeout() =" + getPassivationTimeout());
        ret.append("\ngetInactivityTimeout()  =" + getInactivityTimeout());
        ret.append("\nisShared()              =" + isShared());
        ret.append("\ngetPoolMin()            =" + getPoolMin());
        ret.append("\ngetCacheMax()           =" + getCacheMax());
        return ret.toString();
    }

}

---