EarClassPathManager.java

package org.objectweb.jonas.ear.lib;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.StringTokenizer;
import java.util.jar.Attributes;
import java.util.jar.JarFile;
import java.util.jar.Manifest;

public class EarClassPathManager {

    private URL[] urls = null;

    private JarList toParse = null;

    private JarList parsed = null;

    private JarList libraries = null;

    private JarList ejbs = null;

    private JarList wars = null;

    private JarList clients = null;

    private URL directory = null;

    public EarClassPathManager(JarList ejbs, JarList wars, URL directory) throws EarClassPathManagerException {

        if ((ejbs == null) || (wars == null) || (directory == null)) {
            throw new EarClassPathManagerException("The constructor EarClassPathManager can't accept null parameters");
        }

        //check protocol
        if (!directory.getProtocol().equalsIgnoreCase("file")) {
            throw new EarClassPathManagerException("Only the file:/ URL can be used");
        }
        this.ejbs = ejbs;
        this.wars = wars;
        this.clients = new JarList();
        this.directory = directory;
    }

    public EarClassPathManager(JarList clients, URL directory) throws EarClassPathManagerException {

        if ((clients == null) || (directory == null)) {
            throw new EarClassPathManagerException("The constructor EarClassPathManager can't accept null parameters");
        }

        //check protocol
        if (!directory.getProtocol().equalsIgnoreCase("file")) {
            throw new EarClassPathManagerException("Only the file:/ URL can be used");
        }
        this.ejbs = new JarList();
        this.wars = new JarList();
        this.clients = clients;
        this.directory = directory;
    }

    private JarList getManifestClassPath(URL url) throws EarClassPathManagerException, IOException {

        if (url == null) {
            throw new EarClassPathManagerException("JarList.getManifestClassPath : The url parameter can't be null");
        }

        Manifest manifest = null;

        if (new File(url.getFile()).isDirectory()) {
            File manifestFile = new File(url.getFile() + File.separator + JarFile.MANIFEST_NAME);
            if (manifestFile.exists()) {
                manifest = new Manifest(new FileInputStream(manifestFile));
            }

        } else {
            //Construct a JarFile in order to access to the manifest
            // IOException it if failed
            JarFile jarFile = new JarFile(url.getFile());

            //get manifest from the jarFile
            manifest = jarFile.getManifest();
        }

        //classpath
        String classPath = null;

        //Only if a manifest is found
        if (manifest != null) {
            //get attributes (classpath)
            Attributes attributes = manifest.getMainAttributes();
            classPath = attributes.getValue(Attributes.Name.CLASS_PATH);
        }

        //New JarList
        JarList jarList = null;

        //The jarList will be Empty if classpath is null or populate with
        // classpath entries
        if (classPath != null) {
            jarList = new JarList(new StringTokenizer(classPath));
        } else {
            jarList = new JarList();
        }

        //Return the list
        return jarList;
    }

    public URL[] getResolvedClassPath() throws EarClassPathManagerException {

        //If we don't have already compute
        if (urls == null) {
            resolveClassPath();
        }

        //return the cache
        return urls;
    }

    private void resolveClassPath() throws EarClassPathManagerException {

        //Set the list to parsed
        toParse = new JarList();

        //Set the list already parsed
        parsed = new JarList();

        //Set the list of libraries
        libraries = new JarList();

        //add the ejbs, wars and clients to this list
        toParse.merge(ejbs);
        toParse.merge(wars);
        toParse.merge(clients);

        //dependencies list
        JarList lstOfFilesDep = new JarList();

        //Url of the current filename
        URL depUrl = null;

        //While there are elements to analyse
        while (toParse.size() > 0) {

            //File to look for Manifest
            String fileName = (String) toParse.firstElement();

            if (fileName.endsWith("/")) {
                throw new EarClassPathManagerException("In j2ee application, Class-Path with directory is forbidden. '"
                        + fileName + "' is not authorized.");
            }
            try {
                //Get dependency entries
                depUrl = new URL(directory.toExternalForm() + "/" + fileName);
                lstOfFilesDep = getManifestClassPath(depUrl);
            } catch (MalformedURLException mue) {
                lstOfFilesDep.removeAllElements();
                throw new EarClassPathManagerException("Error while trying to get the url for "
                        + directory.toExternalForm() + File.separator + fileName + " : " + mue.getMessage());
            } catch (IOException ioe) {
                lstOfFilesDep.removeAllElements();
                throw new EarClassPathManagerException("Error while reading manifest file from the file " + fileName
                        + " : " + ioe.getMessage());
            }

            String parentDir = new File(fileName).getParent();
            //subDirectory (the parent dir or "")
            String subDir = null;
            if (parentDir != null) {
                subDir = parentDir;
            } else {
                subDir = "";
            }

            //Set the relative path of EAR / file
            lstOfFilesDep.setRelativePath(subDir);

            //Merge the list
            toParse.merge(lstOfFilesDep);

            //Add the parsed file
            parsed.add(fileName);

            //Add to the libraries if it's not an EJB or a WEB application
            if (isALibrary(fileName)) {
                libraries.add(fileName);
            }

            //Remove the fileName
            toParse.remove(fileName);

        }

        //We've got the list of files, its the JarList : parsed
        try {
            urls = libraries.getURLs(directory.toExternalForm());
        } catch (JarListException e) {
            throw new EarClassPathManagerException(
                    "Error while geting the URLs of the jars files which must be loaded at the EAR level");

        }

    }

    private boolean isALibrary(String fileName) {
        return (!ejbs.contains(fileName) && !wars.contains(fileName));
    }

}

---