Application.java

package org.objectweb.jonas_lib.genbase.archive;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Vector;
import java.util.jar.Attributes;
import java.util.jar.JarFile;

import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Document;
import org.xml.sax.SAXException;

import org.objectweb.jonas_ear.deployment.api.EarDeploymentDesc;
import org.objectweb.jonas_ear.deployment.lib.EarDeploymentDescManager;
import org.objectweb.jonas_ear.deployment.xml.Web;

import org.objectweb.jonas_lib.deployment.api.DeploymentDescException;
import org.objectweb.jonas_lib.genbase.GenBaseException;
import org.objectweb.jonas_lib.genbase.utils.FileUtils;
import org.objectweb.jonas_lib.genbase.utils.XMLUtils;
import org.objectweb.jonas_lib.loader.EjbJarClassLoader;


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

public class Application extends J2EEArchive {

    private List clients;

    private List webapps;

    private List ejbjars;

    private EarDeploymentDesc earDD = null;

    private Map descriptors;

    private Document app;

    private URLClassLoader ejbCL = null;

    private URLClassLoader commonCL = null;

    private List pathFiles;

    private String appFilename;

    public Application(Archive archive) throws GenBaseException {
        super(archive);
        appFilename = archive.getRootFile().getName();
        getLogger().log(BasicLevel.DEBUG, "Wrapping '" + archive.getName() + "' in Application");
        init();
    }

    protected void init() throws GenBaseException {

        pathFiles = new Vector();

        ejbjars = new Vector();
        webapps = new Vector();
        clients = new Vector();

        if (isPacked()) {

            try {
                // unpack data
                JarFile jf = new JarFile(getArchive().getRootFile());
                File unpacked = FileUtils.unpack(jf);
                jf.close();
                setArchive(new FileArchive(unpacked));
            } catch (IOException ioe) {
                String err = getI18n().getMessage("Application.init.unpackException", getArchive().getRootFile());
                throw new GenBaseException(err, ioe);
            }
        }

        // load META-INF/application.xml
        try {
            earDD =
                EarDeploymentDescManager.getDeploymentDesc(getRootFile().getAbsolutePath(),
                    Thread.currentThread().getContextClassLoader());
        } catch (DeploymentDescException dde) {
            String err =
                getI18n().getMessage("Application.init.earDDExc",
                    getArchive().getRootFile());
            throw new GenBaseException(err, dde);
        }

        // add EjbJars
        String[] ejbs = earDD.getEjbTags();

        for (int i = 0; i < ejbs.length; i++) {
            File ejbFile = new File(getRootFile(), ejbs[i]);
            Archive ejbArch = null;

            if (ejbFile.isDirectory()) {
                // Unpacked Jar
                ejbArch = new FileArchive(ejbFile);
            } else {
                // Packed Jar
                ejbArch = new JarArchive(ejbFile);
            }
            ejbjars.add(new EjbJar(ejbArch, this));

            // add entries for Class-Path
            addClassPathEntry(ejbArch);
        }

        // add WebApps
        Web[] webs = earDD.getWebTags();

        for (int i = 0; i < webs.length; i++) {
            File webFile = new File(getRootFile(), webs[i].getWebUri());

            if (webFile.isDirectory()) {
                // Unpacked Jar
                webapps.add(new WebApp(new FileArchive(webFile), this));
            } else {
                // Packed Jar
                webapps.add(new WebApp(new JarArchive(webFile), this));
            }
        }

        // add Clients
        String[] clts = earDD.getClientTags();

        for (int i = 0; i < clts.length; i++) {
            File clientFile = new File(getRootFile(), clts[i]);

            if (clientFile.isDirectory()) {
                // Unpacked Jar
                clients.add(new Client(new FileArchive(clientFile), this));
            } else {
                // Packed Jar
                clients.add(new Client(new JarArchive(clientFile), this));
            }
        }

        // Create ear ClassLoader (from MANIFEST/Class-Path general entry)
        setModuleClassloader(createEARClassLoader());

        // Create EJB ClassLoader
        ejbCL = createEJBClassLoader();

        loadDescriptors();
    }

    protected void loadDescriptors() throws GenBaseException {
        try {
            app = XMLUtils.newDocument(getApplicationInputStream(), "META-INF/application.xml", isDTDsAllowed());
        } catch (SAXException saxe) {
            String err = getI18n().getMessage("Application.loadDescriptors.parseError");
            throw new GenBaseException(err, saxe);
        } catch (ParserConfigurationException pce) {
            String err = getI18n().getMessage("Application.loadDescriptors.prepare");
            throw new GenBaseException(err, pce);
        } catch (IOException ioe) {
            String err = getI18n().getMessage("Application.loadDescriptors.parseError");
            throw new GenBaseException(err, ioe);
        }

        descriptors = new Hashtable();
        descriptors.put("META-INF/application.xml", app);
    }

    public void initialize() throws GenBaseException {

        // init ejbjars
        for (Iterator i = ejbjars.iterator(); i.hasNext();) {
            EjbJar ejb = (EjbJar) i.next();
            ejb.initialize();
        }

        // init webapps
        for (Iterator i = webapps.iterator(); i.hasNext();) {
            WebApp web = (WebApp) i.next();
            web.initialize();
        }

        // init clients
        for (Iterator i = clients.iterator(); i.hasNext();) {
            Client client = (Client) i.next();
            client.initialize();
        }

    }

    public String getName() {
        return appFilename;
    }

    private URLClassLoader createEJBClassLoader() throws GenBaseException {

        URL[] urls = new URL[pathFiles.size()];
        int index = 0;
        for (Iterator i = pathFiles.iterator(); i.hasNext(); index++) {
            File f = (File) i.next();
            try {
                urls[index] = f.toURL();
            } catch (IOException ioe) {
                String err = "Cannot convert " + f + " to URL.";
                throw new GenBaseException(err, ioe);
            }
        }

        commonCL = new URLClassLoader(urls, getModuleClassloader());

        urls = new URL[ejbjars.size()];
        index = 0;
        for (Iterator i = ejbjars.iterator(); i.hasNext(); index++) {
            try {
                urls[index] = ((EjbJar) i.next()).getRootFile().toURL();
            } catch (IOException ioe) {
                String err = "Cannot transform as a URL : " + ioe.getMessage();
                throw new GenBaseException(err, ioe);
            }
        }

        try {
            return new EjbJarClassLoader(urls, commonCL);
        } catch (IOException ioe) {
            String err = "Cannot create EjbJarClassLoader";
            throw new GenBaseException(err, ioe);
        }

    }

    private URLClassLoader createEARClassLoader() throws GenBaseException {

        // find parent ClassLoader
        ClassLoader parent = Thread.currentThread().getContextClassLoader();

        // get Manifest Attributes if any
        String classpath = getManifest().getMainAttributes().getValue(Attributes.Name.CLASS_PATH);
        URL[] urls = new URL[0];
        if (classpath != null) {
            // Lookup specified files.
            String[] paths = classpath.split(",");
            urls = new URL[paths.length];
            for (int i = 0; i < paths.length; i++) {
                try {
                    URL path = new File(getRootFile(), paths[i]).toURL();
                    urls[i] = path;
                } catch (IOException ioe) {
                    String err = "Cannot transform '" + paths[i] + "' as a URL";
                    throw new GenBaseException(err, ioe);
                }
            }
        }

        return new URLClassLoader(urls, parent);
    }

    private void addClassPathEntry(Archive a) throws GenBaseException {
        // get Manifest Attributes if any
        String classpath = a.getManifest().getMainAttributes().getValue(Attributes.Name.CLASS_PATH);

        if (classpath != null) {
            // Lookup specified files.
            String[] paths = classpath.split(",");
            for (int i = 0; i < paths.length; i++) {
                try {
                    File path = new File(a.getRootFile().getParentFile(), paths[i]).getCanonicalFile();
                    if (!pathFiles.contains(path)) {
                        pathFiles.add(path);
                    }
                } catch (IOException ioe) {
                    String err = "Cannot add in EAR classpath :" + paths[i];
                    throw new GenBaseException(err, ioe);
                }
            }

        }

    }

    public Document getApplicationDoc() {
        return app;
    }

    public InputStream getApplicationInputStream() throws IOException {
        InputStream is = null;

        if (isPacked()) {
            is = getInputStream("META-INF/application.xml");
        } else {
            is = getInputStream("META-INF" + File.separator + "application.xml");
        }

        return is;
    }

    public void addEjbJar(EjbJar ejbjar) {
        ejbjars.add(ejbjar);
        // add module in application.xml
        XMLUtils.addEjb(app, ejbjar);
    }

    public void addClient(Client client) {
        clients.add(client);
        // add module in application.xml
        XMLUtils.addClient(app, client);
    }

    public void addWebApp(WebApp webapp, String context) {
        webapps.add(webapp);
        // add module in application.xml
        XMLUtils.addWebApp(app, webapp, context);
        addFile(webapp.getRootFile(), webapp.getName());
    }

    public Iterator getEjbJars() {
        return ejbjars.iterator();
    }

    public Iterator getWebApps() {
        return webapps.iterator();
    }

    public Iterator getClients() {
        return clients.iterator();
    }

    public URLClassLoader getEARClassLoader() {
        return commonCL;
    }

    public URLClassLoader getEJBClassLoader() {
        return ejbCL;
    }

    public Map getDescriptors() {
        return descriptors;
    }

    public boolean omit(String name) {
        return (name.equals("META-INF/application.xml") || name.equals("META-INF\\application.xml"));
    }

    public void setClients(List clients) {
        this.clients = clients;
    }

    public void setEjbjars(List ejbjars) {
        this.ejbjars = ejbjars;
    }

    public void setWebapps(List webapps) {
        this.webapps = webapps;
    }

    public Document getApp() {
        return app;
    }
}

---