JndiEnvRefsGroupDesc.java

package org.objectweb.jonas_lib.deployment.api;

// import java
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Vector;

import org.objectweb.jonas_lib.deployment.xml.EjbLocalRef;
import org.objectweb.jonas_lib.deployment.xml.EjbRef;
import org.objectweb.jonas_lib.deployment.xml.EnvEntry;
import org.objectweb.jonas_lib.deployment.xml.JndiEnvRefsGroupXml;
import org.objectweb.jonas_lib.deployment.xml.JonasEjbRef;
import org.objectweb.jonas_lib.deployment.xml.JonasJndiEnvRefsGroupXml;
import org.objectweb.jonas_lib.deployment.xml.JonasMessageDestinationRef;
import org.objectweb.jonas_lib.deployment.xml.JonasResource;
import org.objectweb.jonas_lib.deployment.xml.JonasResourceEnv;
import org.objectweb.jonas_lib.deployment.xml.JonasServiceRef;
import org.objectweb.jonas_lib.deployment.xml.MessageDestinationRef;
import org.objectweb.jonas_lib.deployment.xml.ResourceEnvRef;
import org.objectweb.jonas_lib.deployment.xml.ResourceRef;
import org.objectweb.jonas_lib.deployment.xml.ServiceRef;

import org.objectweb.jonas_ws.deployment.api.ServiceRefDesc;
import org.objectweb.jonas_ws.deployment.api.WSDeploymentDescException;

import org.objectweb.jonas.common.Log;

import org.objectweb.util.monolog.api.BasicLevel;
import org.objectweb.util.monolog.api.Logger;

public abstract class JndiEnvRefsGroupDesc extends DescriptionGroupDesc implements JndiEnvRefsGroup {

    private Vector resourceEnvRefs = new Vector();

    private Vector resourceRefs = new Vector();

    private Vector envEntries = new Vector();

    private Vector serviceRefs = new Vector();

    private Vector ejbRefs = new Vector();

    private Vector ejbLocalRefs = new Vector();

    private Vector messageDestinationRefs = new Vector();

    private static Logger logger = Log.getLogger(Log.JONAS_WS_PREFIX);

    protected JndiEnvRefsGroupDesc(ClassLoader classLoader,
                                   JndiEnvRefsGroupXml app,
                                   JonasJndiEnvRefsGroupXml jonasApp,
                                   String fileName)
      throws DeploymentDescException {

        // test classloader
        if (classLoader == null) {
            throw new DeploymentDescException("Classloader is null");
        }
        // display name
        displayName = null;
        if (app.getDisplayName() != null) {
            displayName = app.getDisplayName();
        }

        // resource-env-ref
        processResourceEnvRef(classLoader, app, jonasApp);

        // resource-ref
        processResourceRef(classLoader, app, jonasApp);

        // env-entry
        processEnvEntry(app);

        // ejb-ref
        processEjbRef(app, jonasApp);

        // ejb-local-ref
        processEjbLocalRef(app);

        // service-ref
        processServiceRef(classLoader, app, jonasApp, fileName);

        // message-destination-ref
        processMessageDestinationRef(app, jonasApp);


    }

    private void processEnvEntry(JndiEnvRefsGroupXml app) throws DeploymentDescException {
        // env-entry
        for (Iterator i = app.getEnvEntryList().iterator(); i.hasNext();) {
            EnvEntryDesc envEntryDesc = new EnvEntryDesc((EnvEntry) i.next());
            envEntries.addElement(envEntryDesc);
        }
    }

    private void processMessageDestinationRef(JndiEnvRefsGroupXml app, JonasJndiEnvRefsGroupXml jonasApp) throws DeploymentDescException {
        List messageDestinationRefList = app.getMessageDestinationRefList();
        List jonasMessageDestinationRefList = jonasApp.getJonasMessageDestinationRefList();


        HashMap messageDestinationRef = new HashMap();
        for (Iterator i = jonasMessageDestinationRefList.iterator(); i.hasNext();) {
            JonasMessageDestinationRef jonasMessageDestinationRef = (JonasMessageDestinationRef) i.next();
            String mdrName = jonasMessageDestinationRef.getMessageDestinationRefName();
            boolean findMDRef = false;
            for (Iterator j = messageDestinationRefList.iterator(); j.hasNext() && !findMDRef;) {
                MessageDestinationRef mdRef = (MessageDestinationRef) j.next();
                if (mdrName.equals(mdRef.getMessageDestinationRefName())) {
                    findMDRef = true;
                }
            }
            if (!findMDRef) {
                throw new DeploymentDescException("message-destination-ref missing for jonas-message-destination-ref " + mdrName);
            }
            messageDestinationRef.put(mdrName, jonasMessageDestinationRef);
        }
        for (Iterator i = messageDestinationRefList.iterator(); i.hasNext();) {
            MessageDestinationRef mdRef = (MessageDestinationRef) i.next();
            String mdrName = mdRef.getMessageDestinationRefName();
            JonasMessageDestinationRef jonasMessageDestinationRef = (JonasMessageDestinationRef) messageDestinationRef.get(mdrName);
            if (jonasMessageDestinationRef == null) {
                // The message-destination-link must be specified when there is no jonas-message-destination-ref
                if ((mdRef.getMessageDestinationLink() == null)) {
                    // Ignore the message-destination-link syntax "product.jar#ProductMD"
                    throw new DeploymentDescException("message-destination-link missing for message-destination-ref-name " + mdrName);
                }            }
            messageDestinationRefs.addElement(new MessageDestinationRefDesc(mdRef, jonasMessageDestinationRef));
        }
    }

    private void processServiceRef(ClassLoader classLoader, JndiEnvRefsGroupXml app, JonasJndiEnvRefsGroupXml jonasApp, String fileName) throws WSDeploymentDescException {
        Map links = linksSR2JSR(app, jonasApp);
        List serviceRefList = app.getServiceRefList();
        for (Iterator i = serviceRefList.iterator(); i.hasNext();) {
            ServiceRef serviceRef = ((ServiceRef) i.next());
            JonasServiceRef jsr = (JonasServiceRef) links.get(serviceRef.getServiceRefName());
            serviceRefs.addElement(new ServiceRefDesc(classLoader, serviceRef, jsr, fileName));
        }
    }

    private void processEjbLocalRef(JndiEnvRefsGroupXml app) throws DeploymentDescException {
        List ejbLocalRefList = app.getEjbLocalRefList();
        for (Iterator i = ejbLocalRefList.iterator(); i.hasNext();) {
            EjbLocalRef ejbLocalRef = (EjbLocalRef) i.next();
            if ((ejbLocalRef.getEjbLink() == null)) {
                throw new DeploymentDescException("ejb-link missing for ejb-ref-name " + ejbLocalRef.getEjbRefName());
            }
            ejbLocalRefs.addElement(new EjbLocalRefDesc(ejbLocalRef));
        }
    }

    private void processEjbRef(JndiEnvRefsGroupXml app, JonasJndiEnvRefsGroupXml jonasApp) throws DeploymentDescException {
        List ejbRefList = app.getEjbRefList();
        List jonasEjbRefList = jonasApp.getJonasEjbRefList();

        HashMap ejbRef = new HashMap();
        for (Iterator i = jonasEjbRefList.iterator(); i.hasNext();) {
            JonasEjbRef jonasEjbRef = (JonasEjbRef) i.next();
            String brName = jonasEjbRef.getEjbRefName();
            boolean findBRef = false;
            for (Iterator j = ejbRefList.iterator(); j.hasNext() && !findBRef;) {
                EjbRef eRef = (EjbRef) j.next();
                if (brName.equals(eRef.getEjbRefName())) {
                    findBRef = true;
                }
            }
            if (!findBRef) {
                throw new DeploymentDescException("ejb-ref missing for jonas-ejb-ref " + brName);
            }
            ejbRef.put(brName, jonasEjbRef);
        }
        for (Iterator i = ejbRefList.iterator(); i.hasNext();) {
            EjbRef eRef = (EjbRef) i.next();
            String brName = eRef.getEjbRefName();
            JonasEjbRef jonasEjbRef = (JonasEjbRef) ejbRef.get(brName);
            if (jonasEjbRef == null) {
                // The ejb-link must be specified when there is no jonas-ejb-ref
                if ((eRef.getEjbLink() == null)) {
                    // Ignore the ejb-link syntax "product.jar#ProductEJB"
                    throw new DeploymentDescException("ejb-link missing for ejb-ref-name " + brName);
                }
            }
            ejbRefs.addElement(new EjbRefDesc(eRef, jonasEjbRef));
        }
    }

    private void processResourceRef(ClassLoader classLoader, JndiEnvRefsGroupXml app, JonasJndiEnvRefsGroupXml jonasApp) throws DeploymentDescException {
        List resourceRefList = app.getResourceRefList();
        List jonasResourceList = jonasApp.getJonasResourceList();
        HashMap resource = new HashMap();
        for (Iterator i = jonasResourceList.iterator(); i.hasNext();) {
            JonasResource jonasResource = ((JonasResource) i.next());
            String rName = jonasResource.getResRefName();
            boolean findResRef = false;
            for (Iterator j = resourceRefList.iterator(); j.hasNext() && !findResRef;) {
                if (rName.equals(((ResourceRef) j.next()).getResRefName())) {
                    findResRef = true;
                }
            }
            if (!findResRef) {
                throw new DeploymentDescException("resource-ref missing for jonas-resource " + rName);
            }
            resource.put(rName, jonasResource);
        }

        for (Iterator i = resourceRefList.iterator(); i.hasNext();) {
            ResourceRef resourceRef = ((ResourceRef) i.next());
            String rName = resourceRef.getResRefName();
            if (!resource.containsKey(rName)) {
                throw new DeploymentDescException("jonas-resource missing for res-ref-name " + rName);
            }
            resourceRefs.addElement(new ResourceRefDesc(classLoader, resourceRef, (JonasResource) resource.get(rName)));
        }
    }

    private void processResourceEnvRef(ClassLoader classLoader, JndiEnvRefsGroupXml app, JonasJndiEnvRefsGroupXml jonasApp) throws DeploymentDescException {
        List resourceEnvRefList = app.getResourceEnvRefList();
        List jonasResourceEnvList = jonasApp.getJonasResourceEnvList();
        HashMap resourceEnv = new HashMap();
        for (Iterator i = jonasResourceEnvList.iterator(); i.hasNext();) {
            JonasResourceEnv jonasResourceEnv = (JonasResourceEnv) i.next();
            String rName = jonasResourceEnv.getResourceEnvRefName();
            boolean findResRef = false;
            for (Iterator j = resourceEnvRefList.iterator(); j.hasNext() && !findResRef;) {
                ResourceEnvRef resourceEnvRef = (ResourceEnvRef) j.next();
                if (rName.equals(resourceEnvRef.getResourceEnvRefName())) {
                    findResRef = true;
                }
            }
            if (!findResRef) {
                throw new DeploymentDescException("resource-env-ref missing for jonas-resource-env " + rName);
            }
            resourceEnv.put(rName, jonasResourceEnv);
        }
        for (Iterator i = resourceEnvRefList.iterator(); i.hasNext();) {
            ResourceEnvRef resourceEnvRef = (ResourceEnvRef) i.next();
            String rName = resourceEnvRef.getResourceEnvRefName();
            if (!resourceEnv.containsKey(rName)) {
                throw new DeploymentDescException("jonas-resource-env missing for resource-env-ref-name " + rName);
            }
            resourceEnvRefs.addElement(new ResourceEnvRefDesc(classLoader, resourceEnvRef,
                    (JonasResourceEnv) resourceEnv.get(rName)));
        }
    }

    private Map linksSR2JSR(JndiEnvRefsGroupXml app, JonasJndiEnvRefsGroupXml jonasApp) {
        Map res = new HashMap();
        // for each sr
        for (Iterator i = app.getServiceRefList().iterator(); i.hasNext();) {
            ServiceRef sr = (ServiceRef) i.next();
            res.put(sr.getServiceRefName(), null);
        }
        // jonas-<desc>.xml
        if (jonasApp != null) {

            // get all ServiceRef.name
            Set keys = res.keySet();

            // for each jonas service ref
            for (Iterator i = jonasApp.getJonasServiceRefList().iterator(); i.hasNext();) {
                JonasServiceRef jsr = (JonasServiceRef) i.next();
                String srName = jsr.getServiceRefName();

                if (keys.contains(srName)) {
                    // jonas-service-ref linked to service-ref
                    res.put(srName, jsr);
                } else {
                    String err = "jonas-service-ref '" + srName + "' is not linked to any service-ref. It will be ignored."; //getI18n().getMessage("WSDeploymentDesc.wsdlDeclareUnknownPort", wsdlf.getName());
                    logger.log(BasicLevel.WARN, err);
                }
            }
        }
        return res;
    }

    public ResourceEnvRefDesc[] getResourceEnvRefDesc() {
        ResourceEnvRefDesc[] ret = new ResourceEnvRefDesc[resourceEnvRefs.size()];
        resourceEnvRefs.copyInto(ret);
        return ret;
    }

    public ResourceRefDesc[] getResourceRefDesc() {
        ResourceRefDesc[] ret = new ResourceRefDesc[resourceRefs.size()];
        resourceRefs.copyInto(ret);
        return ret;
    }

    public EnvEntryDesc[] getEnvEntryDesc() {
        EnvEntryDesc[] ret = new EnvEntryDesc[envEntries.size()];
        envEntries.copyInto(ret);
        return ret;
    }

    public EjbRefDesc[] getEjbRefDesc() {
        EjbRefDesc[] ret = new EjbRefDesc[ejbRefs.size()];
        ejbRefs.copyInto(ret);
        return ret;
    }

    public EjbLocalRefDesc[] getEjbLocalRefDesc() {
        EjbLocalRefDesc[] ret = new EjbLocalRefDesc[ejbLocalRefs.size()];
        ejbLocalRefs.copyInto(ret);
        return ret;
    }

    public ServiceRefDesc[] getServiceRefDesc() {
        ServiceRefDesc[] ret = new ServiceRefDesc[serviceRefs.size()];
        serviceRefs.copyInto(ret);
        return ret;
    }

    public MessageDestinationRefDesc[] getMessageDestinationRefDesc() {
        MessageDestinationRefDesc[] ret = new MessageDestinationRefDesc[messageDestinationRefs.size()];
        messageDestinationRefs.copyInto(ret);
        return ret;
    }
}

---