EjbDeploymentDescManager.java

package org.objectweb.jonas_ejb.deployment.lib;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.List;
import java.util.StringTokenizer;
import java.util.Vector;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;

import org.objectweb.jonas_ejb.deployment.api.BeanDesc;
import org.objectweb.jonas_ejb.deployment.api.DeploymentDesc;
import org.objectweb.jonas_ejb.deployment.api.DeploymentDescEjb1_1;
import org.objectweb.jonas_ejb.deployment.api.DeploymentDescEjb2;
import org.objectweb.jonas_ejb.deployment.api.EntityDesc;
import org.objectweb.jonas_ejb.deployment.api.MessageDrivenDesc;
import org.objectweb.jonas_ejb.deployment.api.SessionDesc;
import org.objectweb.jonas_ejb.deployment.rules.EjbJarRuleSet;
import org.objectweb.jonas_ejb.deployment.rules.JonasEjbJarRuleSet;
import org.objectweb.jonas_ejb.deployment.xml.EjbJar;
import org.objectweb.jonas_ejb.deployment.xml.JonasEjbJar;
import org.objectweb.jonas_ejb.lib.BeanNaming;

import org.objectweb.jonas_lib.deployment.api.DeploymentDescException;
import org.objectweb.jonas_lib.deployment.api.EjbLocalRefDesc;
import org.objectweb.jonas_lib.deployment.api.EjbRefDesc;
import org.objectweb.jonas_lib.deployment.api.JndiEnvRefsGroup;
import org.objectweb.jonas_lib.deployment.api.MessageDestinationRefDesc;
import org.objectweb.jonas_lib.deployment.digester.JDigester;
import org.objectweb.jonas_lib.deployment.lib.AbsDeploymentDescManager;
import org.objectweb.jonas_lib.deployment.xml.JonasMessageDestination;

import org.objectweb.jonas_ws.deployment.api.PortComponentDesc;
import org.objectweb.jonas_ws.deployment.api.PortComponentRefDesc;
import org.objectweb.jonas_ws.deployment.api.ServiceRefDesc;
import org.objectweb.jonas_ws.deployment.api.WSDeploymentDescException;
import org.objectweb.jonas_ws.deployment.lib.WSDeploymentDescManager;

import org.objectweb.jonas.common.Log;

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

public class EjbDeploymentDescManager extends AbsDeploymentDescManager {

    public static final String EJB_JAR_FILE_NAME = "META-INF/ejb-jar.xml";

    public static final String JONAS_EJB_JAR_FILE_NAME = "META-INF/jonas-ejb-jar.xml";

    private static boolean parsingWithValidation = true;

    private static EjbDeploymentDescManager unique;


    private static JDigester ejbjarDigester = null;

    private static JDigester jonasEjbjarDigester = null;

    private static EjbJarRuleSet ejbjarRuleSet = new EjbJarRuleSet();

    private static JonasEjbJarRuleSet jonasEjbjarRuleSet = new JonasEjbJarRuleSet();


    private WSDeploymentDescManager wsDDManager = null;

    private Hashtable urlJarBindings;

    private Hashtable urlEarCLBindings;

    private Hashtable urlEjbCLBindings;

    private Hashtable urlAltDDBindings = null;

    private Hashtable earCLEjbLinkJar;

    private static Logger logger = Log.getLogger("org.objectweb.jonas_ejb.dd");

    private static Hashtable staticCache = new Hashtable();

    private static String xmlContent = "";

    private static String jonasXmlContent = "";

    private EjbDeploymentDescManager() {
        urlJarBindings = new Hashtable();
        urlEarCLBindings = new Hashtable();
        urlEjbCLBindings = new Hashtable();
        earCLEjbLinkJar = new Hashtable();
        urlAltDDBindings = new Hashtable();
    }

    public static EjbDeploymentDescManager getInstance() {
        if (unique == null) {
            unique = new EjbDeploymentDescManager();
        }
        return unique;
    }

    public static DeploymentDesc getDeploymentDesc(String ejbjar, ClassLoader ejbLoader)
        throws DeploymentDescException {
        if (!staticCache.containsKey(ejbjar)) {
            return getDeploymentDescriptor(ejbjar, ejbLoader, (String) null);
        } else {
            return (DeploymentDesc) staticCache.get(ejbjar);
        }
    }

    public synchronized DeploymentDesc getDeploymentDesc(URL url,
                                                         ClassLoader ejbLoader,
                                                         ClassLoader earLoader)
        throws DeploymentDescException {
        // load an instance of the WebService Manager
        if (wsDDManager == null) {
            wsDDManager = WSDeploymentDescManager.getInstance();
        }

        // Check in the ejb-link is allowed : the ejb-link must be done
        // on an ejb-jar defined in the ear application.
        if (earLoader != null) {
            checkEjbLinkAvailable(earLoader, url);
        }

        DeploymentDesc dd = (DeploymentDesc) urlJarBindings.get(url.getFile());
        if (dd == null) {
            // dd not in cache => load the deployment descriptor.
            dd = loadDeploymentDesc(url, ejbLoader, earLoader);
        }
        return dd;
    }

    private DeploymentDesc getDeploymentDesc(URL currentUrl, URL urlToLoad)
        throws DeploymentDescException {
        DeploymentDesc ejbLinkDD = (DeploymentDesc) urlJarBindings.get(urlToLoad.getFile());
        if (ejbLinkDD == null) {
            // ejbLinkDD not in cache => load the deployment descriptor.
            String url = currentUrl.getFile();
            URLClassLoader earLoader = (URLClassLoader) urlEarCLBindings.get(url);
            if (new File(url).isFile()) {
                if (!url.toLowerCase().endsWith(".jar")) {
                    String err = "File '" + url + "' is not a jar file";
                    throw new DeploymentDescException(err);
                }
            }

            if (earLoader != null) {
                // In the case of an ear application.

                // Check in the ejb-link is allowed : the ejb-link must be done
                // on an ejb-jar defined in the ear application.
                checkEjbLinkAvailable(earLoader, urlToLoad);

                // get the loader for classes (ejb classloader).
                URLClassLoader loaderForCls = (URLClassLoader) urlEjbCLBindings.get(url);

                // Build a default classloader
                if (loaderForCls == null) {
                    loaderForCls = new URLClassLoader(new URL[] {urlToLoad});
                }

                // get the ear classloader.
                URLClassLoader loader = (URLClassLoader) urlEarCLBindings.get(url);
                ejbLinkDD = loadDeploymentDesc(urlToLoad, loaderForCls, loader);
            } else {
                // In the case of a non ear application.
                if (!currentUrl.getFile().equals(urlToLoad)) {
                    String err = "In '" + url + "' ejb-link is not allowed outside the ejb-jar if you are not in an ear application.";
                    throw new DeploymentDescException(err);
                }
                // else nothing to do.
            }
        }
        return ejbLinkDD;
    }

    private DeploymentDesc loadDeploymentDesc(URL url, ClassLoader ejbLoader, ClassLoader earLoader)
        throws DeploymentDescException {
        // Check if the ejb-jar exists.
        String filename = url.getFile();
        File f = new File(filename);
        if (!f.exists()) {
            throw new DeploymentDescException(filename + " not found");
        }

        // Get the instance of the DeploymentDesc.
        DeploymentDesc dd = null;
        if (f.isDirectory()) {
            dd = getDeploymentDescriptor(filename + EJB_JAR_FILE_NAME,
                                         BeanNaming.getJonasXmlName(filename + EJB_JAR_FILE_NAME),
                                         ejbLoader,
                                         f.getAbsolutePath());

        } else if (filename.toLowerCase().endsWith(".xml")) {
            // This is an XML file name: Treat it for upward compatibility
            // f is the ejb-jar.xml file, jonas specific is colocated to this file.
            File parent = f.getParentFile();
            dd = getDeploymentDescriptor(filename,
                                         BeanNaming.getJonasXmlName(filename),
                                         ejbLoader,
                                         parent.getAbsolutePath());
        } else {
            // This is an ejb-jar
            // Check if there is an altenate DD for this URL (ear only)
            String altname = null;
            URL altDDUrl = (URL) urlAltDDBindings.get(url.getFile());
            if (altDDUrl != null) {
                altname = altDDUrl.getFile();
            }
            dd = getDeploymentDescriptor(filename, ejbLoader, altname);
        }

        // Put it in the cache in case of ear.
        if (earLoader != null) {
            urlEjbCLBindings.put(filename, ejbLoader);
            urlEarCLBindings.put(filename, earLoader);
        }

        BeanDesc[] bd = dd.getBeanDesc();
        for (int j = 0; j < bd.length; j++) {

            // Resolve the ejb-link for ejb-ref
            EjbRefDesc[] ejbRef = bd[j].getEjbRefDesc();
            for (int i = 0; i < ejbRef.length; i++) {
                String jndiName = ejbRef[i].getJndiName();
                String ejbLink = ejbRef[i].getEjbLink();
                String ejbRefType = ejbRef[i].getEjbRefType();
                if (ejbLink != null && jndiName == null) {
                    String ejbName = getJndiName(url, ejbLink, earLoader, ejbRefType, dd, true);
                    ejbRef[i].setJndiName(ejbName);
                }
            }

            // Resolve the ejb-link for ejb-local-ref
            EjbLocalRefDesc[] ejbLocalRef = bd[j].getEjbLocalRefDesc();
            for (int i = 0; i < ejbLocalRef.length; i++) {
                String ejblink = ejbLocalRef[i].getEjbLink();
                if (ejblink == null) {
                    String err = "Ejb-link must be specified for ejb-local-ref " + ejbLocalRef[i].getEjbRefName();
                    throw new DeploymentDescException(err);
                }
                String ejbRefType = ejbLocalRef[i].getEjbRefType();
                String ejbName = getJndiName(url, ejblink, earLoader, ejbRefType, dd, false);
                ejbLocalRef[i].setJndiLocalName(ejbName);
            }

            // Resolve the port-component-link for service-ref
            ServiceRefDesc[] serviceRef = bd[j].getServiceRefDesc();

            for (int i = 0; i < serviceRef.length; i++) {
                List pcRefs = serviceRef[i].getPortComponentRefs();

                for (int k = 0; k < pcRefs.size(); k++) {
                    // for each service portComponents : resolve links
                    PortComponentRefDesc pcr = (PortComponentRefDesc) pcRefs.get(k);
                    String pclink = pcr.getPortComponentLink();
                    if (pclink != null) {
                        // a pc link is defined, we resolve it
                        PortComponentDesc pcDesc = getPCDesc(url, pclink, ejbLoader, earLoader);
                        pcr.setPortComponentDesc(pcDesc);
                    }
                }
            }

            // Resolve the message-destination-link for message-destination-ref
            MessageDestinationRefDesc[] mdRef = bd[j].getMessageDestinationRefDesc();
            for (int i = 0; i < mdRef.length; i++) {
                String jndiName = mdRef[i].getJndiName();
                String mdLink = mdRef[i].getMessageDestinationLink();
                String mdType = mdRef[i].getMessageDestinationType();
                String mdUsage = mdRef[i].getMessageDestinationUsage();
                logger.log(BasicLevel.DEBUG, "" + jndiName + " " + mdLink + " " + mdType + " " + mdUsage);
                if (mdLink != null && jndiName == null) {
                    String mdName = getMDJndiName(url, mdLink, mdType, mdUsage, dd);
                    mdRef[i].setJndiName(mdName);
                }
            }

        }

        // ... and put it in cache if ear case.
        if (earLoader != null) {
            // case of ear application.
            urlJarBindings.put(filename, dd);
        }

        return dd;
    }


    private PortComponentDesc getPCDesc(URL ejbjarURL,
                                        String pcLink,
                                        ClassLoader moduleLoader,
                                        ClassLoader earLoader)
        throws WSDeploymentDescException {

        // now ask WS Manager for port-component-desc
        return wsDDManager.getPortComponentDesc(ejbjarURL, pcLink, moduleLoader, earLoader);
    }


    public String getJndiName(URL currentFile, String ejbLink, ClassLoader earCl, String ejbType,
                               DeploymentDesc deploymentDesc, boolean isEjbRef)
        throws DeploymentDescException {
        // Extract from the ejb link
        //   - the name of the file
        //   - the name of the bean
        String ejbJarLink = null;
        String beanNameLink = null;

        //Same jar ?
        if (ejbLink.indexOf(LINK_SEPARATOR) == -1) {
            BeanDesc bd = null;
            //Link to a bean inside the same ejb-jar file.
            if (earCl == null && deploymentDesc == null) {
                    throw new DeploymentDescException("Deployment desc for file ejb-jar '" + currentFile.getFile() + "' not found");
            }
            // Read in its own deployment descriptor if not null
            if (deploymentDesc != null) {
                bd =  deploymentDesc.getBeanDesc(ejbLink);
            }
            String url = currentFile.getFile();
            URLClassLoader earClassLoader = null;
            // get the loader for classes (ejb classloader).
            URLClassLoader ejbLoader = (URLClassLoader) urlEjbCLBindings.get(url);
            if (earCl != null) {
                earClassLoader = (URLClassLoader) earCl;
                //Add it
                urlEarCLBindings.put(url, earCl);
            } else {
                earClassLoader = (URLClassLoader) urlEarCLBindings.get(url);
            }

            //ejb standalone case
            if ((earClassLoader == null) && (bd == null)) {
                String err = "Ejb-link " + ejbLink + " not found inside the file " + currentFile.getFile() + ". The bean doesn't exists.";
                throw new DeploymentDescException(err);
            }

            // ear case, search in all ejbjars
            if (bd == null) {
                logger.log(BasicLevel.DEBUG, "The bean '" + ejbLink + "' was not found in the current ejbjar, searching on all the ejbjars.");
                Vector v = (Vector) earCLEjbLinkJar.get(earClassLoader);
                DeploymentDesc lookupDD = null;
                String fileName = null;
                URL urlRead = null;
                String urlReadString = null;
                boolean found = false;
                BeanDesc bdtmp = null;
                for (Enumeration e = v.elements(); e.hasMoreElements();) {
                    urlReadString = (String) e.nextElement();
                    File f = new File(urlReadString);
                    try {
                        urlRead = f.toURL();
                    } catch (Exception ue) {
                        throw new DeploymentDescException("Cannot make an url with the argument'" + urlReadString + "'.");
                    }
                    // Classloader is null ? try to get it
                    if (ejbLoader == null) {
                        ejbLoader = (URLClassLoader) urlEjbCLBindings.get(urlReadString);
                    }
                    // if it is still null, fails
                    if (ejbLoader == null) {
                        throw new DeploymentDescException("Error while resolving ejb-link. The ejb classloader is not found for url '" + urlReadString + "'.");
                    }

                    // Add it
                    urlEjbCLBindings.put(urlReadString, ejbLoader);

                    fileName = urlRead.getFile();
                    //do not analyse current file
                    if (!fileName.equals(url)) {
                        //Need to load deployment desc without any resolving link
                        // Get the instance of the DeploymentDesc.
                        if (f.isDirectory()) {
                            lookupDD = getDeploymentDescriptor(fileName + EJB_JAR_FILE_NAME,
                                                               BeanNaming.getJonasXmlName(fileName + EJB_JAR_FILE_NAME),
                                                               ejbLoader,
                                                               f.getAbsolutePath());
                        } else if (fileName.toLowerCase().endsWith(".xml")) {
                            // This is an XML file name: Treat it for upward compatibility
                            // f is the ejb-jar.xml file, first paretn is the META-INF directory, and second parent is the root directory of the module
                            File parent = f.getParentFile().getParentFile();
                            lookupDD = getDeploymentDescriptor(fileName,
                                                               BeanNaming.getJonasXmlName(fileName),
                                                               ejbLoader,
                                                               parent.getAbsolutePath());
                        } else {
                            // This is an ejb-jar
                            // Check if there is an altenate DD for this URL (ear only)
                            String altname = null;
                            URL altDDUrl = (URL) urlAltDDBindings.get(url);
                            if (altDDUrl != null) {
                                altname = altDDUrl.getFile();
                            }
                            lookupDD = getDeploymentDescriptor(fileName,
                                                               ejbLoader,
                                                               altname);
                        }

                        if (lookupDD != null) {
                            bdtmp = lookupDD.getBeanDesc(ejbLink);
                            if (bdtmp != null) {
                                logger.log(BasicLevel.DEBUG, "Found a BeanDesc in the Deployment Desc." + urlRead);
                                //ejblink was found ?
                                if (found) {
                                    String err = "There are more than one bean with the name '" + ejbLink + "' which were found in all the ejbjars of this EAR.";
                                    throw new DeploymentDescException(err);
                                } else {
                                    found = true;
                                    bd = bdtmp;
                                }
                            } else {
                                logger.log(BasicLevel.DEBUG, "No BeanDesc found in the Deployment Desc." + urlRead);
                            }
                        }
                    }
                }
                if (!found) {
                    String err = "No ejblink was found for '" + ejbLink + "' in all the ejbjars of this EAR.";
                    throw new DeploymentDescException(err);
                }
            }

            logger.log(BasicLevel.DEBUG, "BeanDesc found = " + bd.getEjbName());
            //Check if the type of the ejb-ref is correct.
            checkType(currentFile, ejbType, bd);

            if (bd == null) {
                String err = "Ejb-link " + ejbLink + " not found inside the file " + currentFile.getFile() + ". The bean doesn't exists.";
                throw new DeploymentDescException(err);
            }

            String jndiname;
            if (isEjbRef) {
                jndiname = bd.getJndiName();
            } else {
                jndiname = bd.getJndiLocalName();
            }
            return jndiname;
        }

        if (earCl != null) {
            String url = currentFile.getFile();
            //Add it
            urlEarCLBindings.put(url, earCl);
        }

        //Ejb-link not in the same ejb-jar file.
        StringTokenizer st = new StringTokenizer(ejbLink, LINK_SEPARATOR);

        // We must have only two elements after this step, one for the fileName
        // before the # and the name of the bean after the # char
        if (st.countTokens() != 2 || ejbLink.startsWith(LINK_SEPARATOR)
            || ejbLink.endsWith(LINK_SEPARATOR)) {

            String err = "Ejb link " + ejbLink + " has a bad format. Correct format :  filename.jar#beanName.";
            throw new DeploymentDescException(err);
        }

        //Get the token
        ejbJarLink = st.nextToken();
        beanNameLink = st.nextToken();

        //Check if ejbJarLink is a jar or not
        if (!ejbJarLink.endsWith(".jar")) {
            String err = "Ejbjar filename " + ejbJarLink + " from the ejb-link " + ejbLink + " has a bad format. Correct format :  filename.jar";
            throw new DeploymentDescException(err);
        }


        // Now construct the URL from the absolute path from the url ejbJar and
        // the relative path from ejbJarLink
        URL ejbJarLinkUrl = null;
        try {
            ejbJarLinkUrl = new File(new File(currentFile.getFile()).getParent() + File.separator + ejbJarLink).getCanonicalFile().toURL();
        } catch (MalformedURLException mue) {
            String err = "Error when creating an url for the ejb jar filename. Error :" + mue.getMessage();
            throw new DeploymentDescException(err);
        } catch (IOException ioe) {
            String err = "Error when creating/accessing a file. Error :" + ioe.getMessage();
            throw new DeploymentDescException(err);
        }

        // We've got the url
        BeanDesc bd = null;
        // The ejb-link with .jar#beanName could reference the current jar file
        if (currentFile.getPath().equalsIgnoreCase(ejbJarLinkUrl.getPath())) {
            logger.log(BasicLevel.DEBUG, "ejblink jar#bean reference our current file");

            // Read in its own deployment descriptor if not null
            if (deploymentDesc != null) {
                bd =  deploymentDesc.getBeanDesc(beanNameLink);
            } else {
                logger.log(BasicLevel.DEBUG, "DD = null, cannot return bean in the current DD");
            }

        } else {
            //Another file :

            // Now, We can ask the Deployment Descriptor of this url
            DeploymentDesc dd = getDeploymentDesc(currentFile, ejbJarLinkUrl);

            // JndiName resolve.
            bd = dd.getBeanDesc(beanNameLink);
        }

        if (bd == null) {
            String err = "Ejb-link " + ejbLink + " not found inside the file " + currentFile.getFile() + ". The bean doesn't exists";
            throw new DeploymentDescException(err);
        }

        //Check if the type of the ejb-ref is correct.
        checkType(currentFile, ejbType, bd);

        String jndiname;
        if (isEjbRef) {
            jndiname = bd.getJndiName();
        } else {
            jndiname = bd.getJndiLocalName();
        }
        return jndiname;
    }

    private String getMDJndiName(URL ejbJar, String mdLink, String mdType, String mdUsage,
                                 DeploymentDesc deploymentDesc)
        throws DeploymentDescException {

        logger.log(BasicLevel.DEBUG, "" + ejbJar + " " + mdLink + " " + mdType + " " + mdUsage);
        // Extract from the mdb link
        //   - the name of the file
        //   - the name of the destination
        String ejbJarLink = null;
        String destNameLink = null;
        DeploymentDesc dd = deploymentDesc;

        //Different jar ?
        if (mdLink.indexOf(LINK_SEPARATOR) != -1) {
            //Message-destination-link not in the same ejb-jar file.
            StringTokenizer st = new StringTokenizer(mdLink, LINK_SEPARATOR);

            // We must have only two elements after this step, one for the fileName
            // before the # and the name of the message-destination after the # char
            if (st.countTokens() != 2 || mdLink.startsWith(LINK_SEPARATOR)
                || mdLink.endsWith(LINK_SEPARATOR)) {

                String err = "Message-destination-link " + mdLink + " has a bad format. Correct format :  filename.jar#messageDestinationName.";
                throw new DeploymentDescException(err);
            }

            //Get the token
            ejbJarLink = st.nextToken();
            destNameLink = st.nextToken();

            //Check if ejbJarLink is a jar or not
            if (!ejbJarLink.endsWith(".jar")) {
                String err = "Ejbjar filename " + ejbJarLink + " from the message-destination-link " + mdLink + " has a bad format. Correct format :  filename.jar";
                throw new DeploymentDescException(err);
            }


            // Now construct the URL from the absolute path from the url ejbJar and
            // the relative path from ejbJarLink
            URL ejbJarLinkUrl = null;
            try {
                ejbJarLinkUrl = new File(new File(ejbJar.getFile()).getParent() + File.separator + ejbJarLink).getCanonicalFile().toURL();
            } catch (MalformedURLException mue) {
                String err = "Error when creating an url for the ejb jar filename. Error :" + mue.getMessage();
                throw new DeploymentDescException(err);
            } catch (IOException ioe) {
                String err = "Error when creating/accessing a file. Error :" + ioe.getMessage();
                throw new DeploymentDescException(err);
            }

            // Check if the jar exist.
            if (!new File(ejbJarLinkUrl.getFile()).exists()) {
                String err = "Cannot get the deployment descriptor for '" + ejbJarLinkUrl.getFile() + "'. The file doesn't exist.";
                throw new DeploymentDescException(err);
            }

            // We've got the url
            // Now, We can ask the Deployment Descriptor of this url
            dd = getDeploymentDesc(ejbJar, ejbJarLinkUrl);
        }

        //Link to a destination inside the same ejb-jar file.
        if (dd == null) {
            throw new DeploymentDescException("Deployment desc for file ejb-jar '" + ejbJar.getFile() + "' not found");
        }

        boolean foundMd = dd.getMessageDestination(mdLink);
        if (!foundMd) {
            String err = "No message-destination was found for '" + mdLink + "' in the ejbjar specified.";
            throw new DeploymentDescException(err);
        }

        JonasMessageDestination md = dd.getJonasMessageDestination(mdLink);

        if (md == null) {
            String err = "No jonas-message-destination was found for '" + mdLink + "' in the ejbjar specified.";
            throw new DeploymentDescException(err);
        }

        logger.log(BasicLevel.DEBUG, "Message-destination found = " + md.getJndiName());

        //Check if the type & usage of the message-destination-ref is correct.
        //checkTypeUsage(ejbJar, mdType, mdUsage, mdd);

        return md.getJndiName();

    }

    private void checkEjbLinkAvailable(ClassLoader earClassLoader,
                                       URL url)
        throws DeploymentDescException {

        Vector v = (Vector) earCLEjbLinkJar.get(earClassLoader);

        if (v != null) {
            if (!v.contains(url.getFile())) {
                String err = "The ejb-link or message-destination-link of '" + url.getFile() + "' must be done on an ejb-jar defined in the ear application (application.xml <module><ejb>###</ejb></module>)";
                throw new DeploymentDescException(err);
            }
        } else {
            String err = "setAvailableEjbLinkJar was badly called.";
            throw new DeploymentDescException(err);
        }
    }

    public void setAvailableEjbJarsAndAltDDs(ClassLoader earClassLoader,
                                             URL[] urls,
                                             URL[] altDDs) {
        Vector v = new Vector();
        for (int i = 0; i < urls.length; i++) {
            v.addElement(urls[i].getFile());
            if (altDDs[i] != null) {
                urlAltDDBindings.put(urls[i].getFile(), altDDs[i]);
            }
        }
        earCLEjbLinkJar.put(earClassLoader, v);
    }

    public void removeCache(ClassLoader earClassLoader) {
        Vector v = (Vector) earCLEjbLinkJar.remove(earClassLoader);
        if (v != null) {
            for (int i = 0; i < v.size(); i++) {
                String url = (String) v.elementAt(i);
                urlJarBindings.remove(url);
                urlEarCLBindings.remove(url);
                urlEjbCLBindings.remove(url);
                urlAltDDBindings.remove(url);
            }
        }

        if (earCLEjbLinkJar.size() != 0
            || urlJarBindings.size() != 0
            || urlEarCLBindings.size() != 0
            || urlAltDDBindings.size() != 0
            || urlEjbCLBindings.size() != 0) {

            String buffer = earCLEjbLinkJar.size() + " ";
            buffer += urlJarBindings.size() + " ";
            buffer += urlEarCLBindings.size() + " ";
            buffer += urlEjbCLBindings.size() + " ";
            buffer += urlAltDDBindings.size();

            logger.log(BasicLevel.DEBUG, buffer + " there are some elements in cache");
        }
    }

    public int getCacheSize() {
        return earCLEjbLinkJar.size() + urlJarBindings.size()
            + urlEarCLBindings.size() + urlEjbCLBindings.size()
            + urlAltDDBindings.size();
    }

    public String toString() {
        return earCLEjbLinkJar.size() + " " + urlJarBindings.size() + " "
            + urlEarCLBindings.size() + " " + urlEjbCLBindings.size() + " "
            + urlAltDDBindings.size();
    }

    public static DeploymentDesc getDeploymentDesc(String ejbJarXmlFileName,
                                                   String jonasEjbJarXmlFileName,
                                                   String jarFileName)
        throws DeploymentDescException {
        // instantiate deployment descriptor
        ClassLoader cl = DeploymentDesc.class.getClassLoader();
        if (cl == null) {
            cl = Thread.currentThread().getContextClassLoader();
        }
        return getDeploymentDescriptor(ejbJarXmlFileName, jonasEjbJarXmlFileName, cl, jarFileName);
    }

    private static DeploymentDesc getDeploymentDescriptor(String ejbJarXmlFileName,
                                                          String jonasEjbJarXmlFileName,
                                                          ClassLoader cl,
                                                          String moduleDirName)
        throws DeploymentDescException {

        InputStream is;

        // load deployment descriptor data
        try {
            is = new FileInputStream(ejbJarXmlFileName);
            // store file content in a String
            xmlContent = xmlContent(is);
            // reposition to the begining of the stream
            is = new FileInputStream(ejbJarXmlFileName);
        } catch (FileNotFoundException e) {
            throw new DeploymentDescException(ejbJarXmlFileName + " file not found");
        } catch (IOException ioe) {
            throw new DeploymentDescException("Cannot read the content of the xml file " + ejbJarXmlFileName);
        }
        EjbJar ejbJar = loadEjbJar(new InputStreamReader(is), ejbJarXmlFileName);
        String dtdversion = ejbJar.getVersion();
        try {
            is.close();
        } catch (IOException e) {
            logger.log(BasicLevel.WARN, "Can't close '" + ejbJarXmlFileName + "'");
        }

        // load jonas deployment descriptor data
        try {
            is = new FileInputStream(jonasEjbJarXmlFileName);
            // store file content in a String
            jonasXmlContent = xmlContent(is);
            // reposition to the begining of the stream
            is = new FileInputStream(jonasEjbJarXmlFileName);
        } catch (FileNotFoundException e) {
            throw new DeploymentDescException(jonasEjbJarXmlFileName + " file not found");
        } catch (IOException ioe) {
            throw new DeploymentDescException("Cannot read the content of the xml file " + ejbJarXmlFileName);
        }

        JonasEjbJar jonasEjbJar = loadJonasEjbJar(new InputStreamReader(is),
                                                  jonasEjbJarXmlFileName);
        try {
            is.close();
        } catch (IOException e) {
            logger.log(BasicLevel.WARN, "Can't close '" + jonasEjbJarXmlFileName + "'");
        }

        // instantiate deployment descriptor
        DeploymentDesc descEjb = null;
        if (dtdversion.equals("1.1")) {
            descEjb = new DeploymentDescEjb1_1(cl, ejbJar, jonasEjbJar, logger, moduleDirName);
        } else {
            descEjb = new DeploymentDescEjb2(cl, ejbJar, jonasEjbJar, logger, moduleDirName);
        }
        descEjb.setXmlContent(xmlContent);
        descEjb.setJOnASXmlContent(jonasXmlContent);
        return descEjb;
    }


    private static DeploymentDesc getDeploymentDescriptor(String ejbJarFileName,
                                                          ClassLoader cl,
                                                          String altWebXmlFilename)
        throws DeploymentDescException {

        ZipFile zf = null;
        InputStream isDd = null;
        InputStream isJdd = null;
        EjbJar ejbJar;
        JonasEjbJar jonasEjbJar;

        // Check if the Alt deploymentDesc file exists. (optional value)
        if ((altWebXmlFilename != null) && (!new File(altWebXmlFilename).exists())) {
            String err = "The file for the altdd tag for the EAR case '" + altWebXmlFilename + "' was not found.";
            throw new DeploymentDescException(err);
        }

        // Get the XML DD files of the ejb-jar as InputStream
        try {
            zf = new ZipFile(ejbJarFileName);

            if (altWebXmlFilename == null) {
                // No alt-dd case ( standard)
                ZipEntry ejbEntry = zf.getEntry(EJB_JAR_FILE_NAME);
                if (ejbEntry == null) {
                    throw new DeploymentDescException("The entry '" + EJB_JAR_FILE_NAME
                            + "' was not found in the file '" + ejbJarFileName + "'.");
                }
                isDd = zf.getInputStream(ejbEntry);
                xmlContent = xmlContent(isDd);
                isDd = zf.getInputStream(zf.getEntry(EJB_JAR_FILE_NAME));
            } else {
                // AltDD (Ear and optional)
                isDd = new FileInputStream(altWebXmlFilename);
                xmlContent = xmlContent(isDd);
                isDd = new FileInputStream(altWebXmlFilename);
            }
            ZipEntry jEjbEntry = zf.getEntry(JONAS_EJB_JAR_FILE_NAME);
            if (jEjbEntry != null) {
                isJdd = zf.getInputStream(jEjbEntry);
                jonasXmlContent = xmlContent(isJdd);
                isJdd = zf.getInputStream(zf.getEntry(JONAS_EJB_JAR_FILE_NAME));
            } else {
                logger.log(BasicLevel.WARN, "No entry '" + JONAS_EJB_JAR_FILE_NAME + "' was found in the file '" + ejbJarFileName + "'.");
            }
        } catch (Exception e) {
            if (zf != null) {
                try {
                    zf.close();
                } catch (IOException i) {
                    logger.log(BasicLevel.WARN, "Can't close '" + ejbJarFileName + "'");
                }
            }
            logger.log(BasicLevel.ERROR, "Cannot read the XML deployment descriptors for " + ejbJarFileName + ":", e);
            throw new DeploymentDescException("Cannot read the XML deployment descriptors for " + ejbJarFileName + ":" + e);
        }

        // load standard deployment descriptor data
        ejbJar = loadEjbJar(new InputStreamReader(isDd), EJB_JAR_FILE_NAME);
        String dtdversion = ejbJar.getVersion();
        try {
            isDd.close();
        } catch (IOException e) {
            logger.log(BasicLevel.WARN, "Can't close META-INF/ejb-jar.xml in '" + ejbJarFileName + "'");
        }

        // load jonas deployment descriptor data
        if (isJdd != null) {
            jonasEjbJar = loadJonasEjbJar(new InputStreamReader(isJdd),
                                      JONAS_EJB_JAR_FILE_NAME);
            try {
                isJdd.close();
            } catch (IOException e) {
                logger.log(BasicLevel.WARN, "Can't close META-INF/jonas-ejb-jar.xml in '" + ejbJarFileName + "'");
            }

        } else {
            jonasEjbJar = new JonasEjbJar();
        }

        // Close the ZipFile
        if (zf != null) {
            try {
                zf.close();
            } catch (IOException e) {
                logger.log(BasicLevel.WARN, "Can't close '" + ejbJarFileName + "'");
            }
        }

        // instantiate deployment descriptor
        DeploymentDesc descEjb = null;
        if (dtdversion.equals("1.1")) {
            descEjb = new DeploymentDescEjb1_1(cl, ejbJar, jonasEjbJar, logger, ejbJarFileName);
        } else {
            descEjb = new DeploymentDescEjb2(cl, ejbJar, jonasEjbJar, logger, ejbJarFileName);
        }
        descEjb.setXmlContent(xmlContent);
        descEjb.setJOnASXmlContent(jonasXmlContent);
        return descEjb;
    }


    public static EjbJar loadEjbJar(Reader reader, String name)
        throws DeploymentDescException {
        EjbJar ejbjar = new EjbJar();

        // Create if null
        if (ejbjarDigester == null) {
            // Create and initialize the digester
            ejbjarDigester = new JDigester(ejbjarRuleSet,
                                           parsingWithValidation,
                                           true,
                                           new EjbjarDTDs(),
                                           new EjbjarSchemas());
        }
        try {
            ejbjarDigester.parse(reader, name, ejbjar);
        } catch (DeploymentDescException  e) {
            throw e;
        } finally {
            ejbjarDigester.push(null);
        }
        return ejbjar;
    }

    public static JonasEjbJar loadJonasEjbJar(Reader reader,
                                               String name)
        throws DeploymentDescException {
         JonasEjbJar jonasEjbjar = new JonasEjbJar();
        // Create if null
        if (jonasEjbjarDigester == null) {
            // Create and initialize the digester
            jonasEjbjarDigester = new JDigester(jonasEjbjarRuleSet,
                                           parsingWithValidation,
                                           true,
                                           new JonasEjbjarDTDs(),
                                           new JonasEjbjarSchemas());
        }
        try {
            jonasEjbjarDigester.parse(reader , name, jonasEjbjar);
        } catch (DeploymentDescException  e) {
            throw e;
        } finally {
            jonasEjbjarDigester.push(null);
        }
        return jonasEjbjar;
    }

    public static boolean getParsingWithValidation() {
        return parsingWithValidation;
    }

    public static void setParsingWithValidation(boolean validation) {
        EjbDeploymentDescManager.parsingWithValidation = validation;
    }

    public static String getXmlContent() {
        return xmlContent;
    }

    public static String getJOnASXmlContent() {
        return jonasXmlContent;
    }


    protected void checkType(URL ejbJar, String ejbType, JndiEnvRefsGroup bd) throws DeploymentDescException {

        if (bd instanceof SessionDesc) {
            if (!ejbType.equalsIgnoreCase("Session")) {
                String err = "Deployment desc '" + ejbJar.getFile()
                        + "' has an incompatible ejb-ref-type: Required Session but found " + ejbType;
                throw new DeploymentDescException(err);
            }
        } else if (bd instanceof EntityDesc) {
            if (!ejbType.equalsIgnoreCase("Entity")) {
                String err = "Deployment desc '" + ejbJar.getFile()
                        + "' has an incompatible ejb-ref-type: Required Entity but found " + ejbType;
                throw new DeploymentDescException(err);
            }
        } else {
            String err = "Deployment desc '" + ejbJar.getFile() + "' has a bad ejb-ref-type.";
            throw new DeploymentDescException(err);
        }
    }

    protected void checkTypeUsage(URL url, String mdType, String mdUsage, BeanDesc bd) throws DeploymentDescException {

        if (bd instanceof MessageDrivenDesc) {
            MessageDrivenDesc mdd = (MessageDrivenDesc) bd;
            if (mdd.getDestinationType().equals("javax.jms.Topic")) {
                if (!mdType.equalsIgnoreCase("javax.jms.Topic")) {
                    String err = "Deployment desc '" + url.getFile()
                            + "' has an incompatible message-destination-type: Required javax.jms.Topic but found "
                            + mdType;
                    throw new DeploymentDescException(err);
                }
            } else if (mdd.getDestinationType().equals("javax.jms.Queue")) {
                if (!mdType.equalsIgnoreCase("javax.jms.Queue")) {
                    String err = "Deployment desc '" + url.getFile()
                            + "' has an incompatible message-destination-type: Required javax.jms.Queue but found "
                            + mdType;
                    throw new DeploymentDescException(err);
                }
            }
        } else {
            String err = "Deployment desc '" + url.getFile() + "' has a bad message-destination-ref-type.";
            throw new DeploymentDescException(err);
        }
    }

    public void addClassLoaderUrlMapping(ClassLoader ejbClassloader, URL[] urls) {
        for (int u = 0; u < urls.length; u++) {
            urlEjbCLBindings.put(urls[u].getPath(), ejbClassloader);
        }
    }
}

---