JormFactory.java

package org.objectweb.jonas_ejb.container.jorm;

import org.objectweb.jonas_ejb.container.JContainer;
import org.objectweb.jonas_ejb.container.JEntityFactory;
import org.objectweb.jonas_ejb.container.JEntitySwitch;
import org.objectweb.jonas_ejb.container.TraceEjb;
import org.objectweb.jonas_ejb.deployment.api.EjbRelationshipRoleDesc;
import org.objectweb.jonas_ejb.deployment.api.EntityCmp2Desc;
import org.objectweb.jonas_ejb.deployment.api.EntityDesc;
import org.objectweb.jonas_ejb.lib.JormType;
import org.objectweb.jorm.api.PBinding;
import org.objectweb.jorm.api.PClassMapping;
import org.objectweb.jorm.api.PClassMappingCtrl;
import org.objectweb.jorm.api.PException;
import org.objectweb.jorm.api.PMapCluster;
import org.objectweb.jorm.api.PMapper;
import org.objectweb.jorm.api.PMappingCallback;
import org.objectweb.jorm.facility.naming.basidir.BasidBinder;
import org.objectweb.jorm.naming.api.PBinder;
import org.objectweb.jorm.naming.api.PExceptionNaming;
import org.objectweb.jorm.naming.api.PName;
import org.objectweb.jorm.naming.api.PNameCoder;
import org.objectweb.jorm.naming.api.PNamingContext;
import org.objectweb.util.monolog.api.BasicLevel;

import javax.ejb.EJBException;
import javax.ejb.EntityBean;

import java.io.Serializable;
import java.util.Iterator;

public abstract class JormFactory extends JEntityFactory implements PClassMapping, PClassMappingCtrl {

    protected int relNonInit;
    protected boolean mapped;
    protected PMapper mapper = null;
    protected EntityCmp2Desc ecd = null;

    public JormFactory() {
        super();
    }

    protected abstract void setMapper(String mapperName) throws PException;
    public abstract Object getConnection(Object hints) throws PException;
    public abstract void releaseConnection(Object conn) throws PException;

    public void init(EntityDesc ed, JContainer c, String mapperName) {
        TraceEjb.factory.log(BasicLevel.DEBUG, ed.getEjbName());

        // First, call the super in order to have the access to the datasource
        // and the beanNaming
        super.init(ed, c);
        ecd = (EntityCmp2Desc) ed;
        try {
            setMapper(mapperName);
        } catch (PException e) {
            throw new EJBException("JormFactory cannot create the mapper", e);
        }

        //----------------------- JORM INITIALIZATION -----------------------//
        TraceEjb.factory.log(BasicLevel.DEBUG, "Jorm initialisation");
        PBinder binder = null;
        Class binderClass = null;
        int binderCT = 0;
        try {

            // Instanciate the binder
            binderClass = c.getClassLoader().loadClass(ecd.getJormBinderClassName());
            binder = (PBinder) binderClass.newInstance();
            if (ecd.hasPrimaryKeyField()) {
                binderCT = JormType.getCodingType(ecd.getCmpFieldDesc(ecd.getPrimaryKeyFieldName()).getFieldType(), true);
                ((BasidBinder) binder).setCodingType(binderCT);
            } else {
                // TODO:
                // - take the initial values of the primary key
                // - put them into the generated binder (use a PNG)
            }
            TraceEjb.factory.log(BasicLevel.DEBUG, "binder " + ecd.getJormBinderClassName() + "instanciated");

            // Link the binder and the PClassMapping
            binder.setPClassMapping(this);
            setPBinder(binder);
            TraceEjb.factory.log(BasicLevel.DEBUG, "binder linked to the mapping");

        } catch (Exception e) {
            TraceEjb.factory.log(BasicLevel.ERROR, "Impossible to create the binder", e);
            throw new EJBException("Impossible to create the binder: bean:" + ecd.getEjbName(), e);
        }

        // for each reference assignes the PNamingcontext if it is possible.
        relNonInit = 0;
        try {
            for (Iterator it = ecd.getEjbRelationshipRoleDescIterator(); it.hasNext();) {
                EjbRelationshipRoleDesc rsr = (EjbRelationshipRoleDesc) it.next();
                String source = rsr.getSourceBean().getEjbName();
                String target = rsr.getTargetBean().getEjbName();
                JormFactory pcm2 = source.equals(target) ? this : (JormFactory) c.getBeanFactory(target);
                TraceEjb.factory.log(BasicLevel.DEBUG,
                                    "treatement of the relation " + rsr.getRelation().getName()
                                    + ": current-bean=" + ecd.getEjbName()
                                    + ", source-bean=" + source
                                    + ", dest-bean=" + target
                                    + ", cmr-field=" + rsr.getCmrFieldName());

                if (rsr.hasCmrField()) {
                    PClassMapping gcm = null;
                    //Multivalued relation
                    if (rsr.isTargetMultiple()) {
                        // Instanciate a GenClassMapping and link it
                        gcm = newGCMInstance(mapperName);
                        gcm.init((PMappingCallback) mapper, null);
                        setGenClassMapping(rsr.getCmrFieldName(), gcm);
                        TraceEjb.factory.log(BasicLevel.DEBUG,
                                            "assign a GenClassMapping for the CMR "
                                            + rsr.getCmrFieldName() + " / gcm=" + gcm);

                        PBinder gcmBinder = null;
                        try {
                            gcmBinder = (PBinder) binderClass.newInstance();
                        } catch (Exception e) {
                            TraceEjb.factory.log(BasicLevel.ERROR,
                                                "Impossible to create the binder of the GCM bean: "
                                                + ecd.getEjbName() + " / CMR: "
                                                + rsr.getCmrFieldName(), e);
                            throw new EJBException(
                                                   "Impossible to create the binder of the GCM bean: "
                                                   + ecd.getEjbName() + " / CMR: "
                                                   + rsr.getCmrFieldName(), e);
                        }
                        if (ecd.hasPrimaryKeyField()) {
                            ((BasidBinder) gcmBinder).setCodingType(binderCT);
                        } else {
                            // TODO: (not so important)
                            // - take the initial values of the primary key
                            // - put them into the generated binder (use a PNG)
                        }
                        gcm.setPBinder(gcmBinder);
                        gcmBinder.setPClassMapping(gcm);
                        setPNameCoder(rsr.getCmrFieldName(), (PNameCoder) gcmBinder);
                    }

                    // As the bean with which the current bean is in relation
                    // may be not load, the test of pcm2!=null is needed
                    if (pcm2 != null) {
                        TraceEjb.factory.log(BasicLevel.DEBUG, "Pnc Assignement");
                        if (rsr.isTargetMultiple()) {
                            ((PClassMappingCtrl)gcm).setPNameCoder((PNameCoder) pcm2.getPBinder());
                        } else {
                            setPNameCoder(rsr.getCmrFieldName(), (PNameCoder) pcm2.getPBinder());
                        }
                    } else {
                        relNonInit++;
                        TraceEjb.factory.log(BasicLevel.DEBUG, "the Pnc is not reachable currently. relNonInit=" + relNonInit);
                        // The PNamingContext has not been set.
                    }
                }
                EjbRelationshipRoleDesc rsr2 = rsr.getOppositeRelationshipRole();
                if (pcm2 != null && rsr2.hasCmrField() && pcm2 != this) {
                    // This case appears when the scheduling of the bean adding
                    // in the container is bad (or cyclic relation): A bean has
                    // been load and have a relation to current bean. We must
                    // therfore set the naming context on the PClassMapping of
                    // the first bean for the opposite CMR field
                    TraceEjb.factory.log(BasicLevel.DEBUG,
                                        "later Pnc assignement of the opposite CMR field: "
                                        + rsr2.getCmrFieldName());
                    pcm2.configurePnc(rsr2.getCmrFieldName(), (PNamingContext) getPBinder(), rsr2.isTargetMultiple());
                }
            }
        } catch (EJBException e) {
            throw e;
        } catch (Exception e) {
            TraceEjb.factory.log(BasicLevel.ERROR,
                                "Impossible to assign the naming context to the PClassMapping", e);
            throw new EJBException("Impossible to assign the naming context to the PClassMapping", e);
        }
        mapped = false;
        if (relNonInit == 0) {
            mapClass();
        }
    }

    public PMapper getMapper() {
        return mapper;
    }

    public void configurePnc(String n, PNamingContext pnc, boolean isMultiple) throws PException {
        if (isMultiple) {
            PClassMappingCtrl gcm = (PClassMappingCtrl) getGenClassMapping(n);
            gcm.setPNameCoder(pnc);
        } else {
            setPNameCoder(n, pnc);
        }
        relNonInit--;
        TraceEjb.factory.log(BasicLevel.DEBUG, "PNamingContext assigned, relNonInit=" + relNonInit);
        if (relNonInit == 0) {
            mapClass();
        }
    }

    private void mapClass() {
        if (mapped) {
            throw new EJBException("The class is already mapped");
        }

        try {
            // Map the user class into the mapper
            mapper.map(this);
            // Drop or Create tables, depending on what is in the DD
            PMapCluster pmapclust = mapper.getPMapCluster(getClassName());
            if (pmapclust.isDefined()) {
                switch (ecd.getCleanupPolicy()) {
                case EntityDesc.CLEANUP_REMOVEDATA:
                    pmapclust.createMappingStructures(false);
                    pmapclust.deleteData();
                    break;
                case EntityDesc.CLEANUP_REMOVEALL:
                    pmapclust.deleteMappingStructures();
                    pmapclust.createMappingStructures(true);
                    break;
                case EntityDesc.CLEANUP_NONE:
                    break;
                case EntityDesc.CLEANUP_CREATE:
                    pmapclust.createMappingStructures(false);
                    break;
                default:
                    throw new EJBException("Unknown cleanup policy: " + ecd.getCleanupPolicy());
                }
            } else {
                // nothing in the JOnAS case because that means several beans have
                // common structure due to the CMR. Then the last element of the
                // PMapCluster should really apply your data action.
            }
            mapped = true;
            TraceEjb.factory.log(BasicLevel.DEBUG, getClassName() + " is mapped");
        } catch (PException pe) {
            Exception e = pe;
            while ((e instanceof PException) && ((PException) e).getNestedException() != null) {
                e = ((PException) e).getNestedException();
            }
            TraceEjb.factory.log(BasicLevel.ERROR, "Impossible to map the class on the rdb mapper", e);
            throw new EJBException("Impossible to map the class on the rdb mapper", e);
        }
    }

    public void stop() {
        super.stop();
        try {
            mapper.unmap(getClassName());
            mapped = false;
        } catch (PException e) {
            TraceEjb.factory.log(BasicLevel.ERROR,
                                "Impossible to unmap the class " + getClassName(), e);
        }
    }

    protected org.objectweb.jonas_ejb.container.JEntityContext createNewContext(EntityBean bean) {
        return new org.objectweb.jonas_ejb.container.jorm.JEntityContext(this, bean);
    }

    public JEntitySwitch getJEntitySwitch() {
        Object result = null;
        String cn = ((EntityCmp2Desc) dd).getJormBindingClassName();
        try {
            result = getContainer().getClassLoader().loadClass(cn).newInstance();
        } catch (ClassNotFoundException e1) {
            TraceEjb.factory.log(BasicLevel.ERROR, "Impossible to create a new JEntitySwitch as specified in BeanNaming: " + cn, e1);
            return null;
        } catch (Exception e) {
            TraceEjb.factory.log(BasicLevel.ERROR, "Impossible to create a new JEntitySwitch as specifief in BeanNaming: " + cn, e);
            return super.getJEntitySwitch();
        }
        try {
            ((PBinding) result).init(this);
        } catch (PException e) {
            TraceEjb.factory.log(BasicLevel.ERROR, "Impossible to initialized the new JEntitySwitch as specifief in BeanNaming: " + cn, e);
        }
        return (JEntitySwitch) result;
    }

    protected PClassMapping newGCMInstance(String mapperName) throws Exception {
        int idx = mapperName.indexOf(".");
        String mn = (idx != -1) ? mapperName.substring(0, idx) : mapperName;
        return (PClassMapping) Class.forName("org.objectweb.jorm.mapper." + mn + ".genclass."
                                             + Character.toUpperCase(mn.charAt(0))
                                             + mn.substring(1, mn.length()) + "GenClassMapping"
                                             ).newInstance();
    }
    
    public Serializable encodePK(Serializable pk) {
        try {
            return (Serializable) ((PName) pk).encodeString();
        } catch (PExceptionNaming e) {
            TraceEjb.factory.log(BasicLevel.ERROR, "impossible to serialize PK" + e);
            return pk;
        }
    }
    
    public Serializable decodePK(Serializable strpk) {
        try {
            return getPBinder().decodeString((String) strpk);
        } catch (PExceptionNaming e) {
            TraceEjb.factory.log(BasicLevel.ERROR, "impossible to deserialize PK" + e);
            return strpk;
        }
    }
}

---