LoaderManager.java

package org.objectweb.jonas.server;


import java.io.File;
import java.util.Hashtable;
import java.util.Map;
import java.util.StringTokenizer;

import org.objectweb.jonas.common.JProp;

public class LoaderManager {

    private static LoaderManager instance = null;

    private static final String COMMONS = "loader.commons";

    private static final String TOOLS   = "loader.tools";

    private static final String APPS    = "loader.apps";

    private static final String CATALINA = "loader.catalina";

    private static final String CATALINA_BOOTSTRAP_JAR = "bin" + File.separator + "bootstrap.jar";

    private static final String MORTBAY_JETTY_JAR = "lib" + File.separator + "org.mortbay.jetty.jar";

    private JProp jp = null;

    private Map loaders = null;

    private static File jonasLib = null;

    private static File catalinaLib = null;

    private static File jettyLib = null;

    private static String jonasBase = null;

    private static String catalinaHome = null;

    private static String jettyHome = null;

    private boolean hasWeb = false;

    private boolean useDefaultClassPath = false;

    private boolean isCatalina = false;

    private File jonasCommonsDir;

    private File jonasToolsDir;

    private File jonasAppsDir;

    private LoaderManager() {
        // Get the $JONAS_ROOT/lib directories
        String jonasRoot = System.getProperty("install.root");
        if (jonasRoot == null) {
            System.err.println("JONAS_ROOT is not set");
            System.exit(2);
        }

        jonasLib = new File(jonasRoot, "lib");
        jonasCommonsDir = new File(jonasLib, "commons");
        jonasToolsDir = new File(jonasLib, "tools");
        jonasAppsDir = new File(jonasLib, "apps");
        catalinaLib = new File(jonasLib, "catalina");
        jettyLib = new File(jonasLib, "jetty");

        // Init loaders map
        loaders = new Hashtable();
    }

    public static LoaderManager getInstance() {
        if (instance == null) {
            instance = new LoaderManager();
        }
        return instance;
    }

    public void init(JProp props) {
        jp = props;
        // Get $JONAS_BASE
        jonasBase = JProp.getJonasBase();

        useDefaultClassPath = jp.getValueAsBoolean("jonas.default.classloader", false);

        // find web services
        String[] services = props.getValueAsArray("jonas.services");
        if (services != null) {
            for (int i = 0; i < services.length; i++) {
                if (services[i].equals("web")) {
                    hasWeb = true;
                    String classname = props.getValue("jonas.service.web.class");
                    if (classname.matches(".*Catalina.*")) {
                        isCatalina = true;
                    }
                }
            }
        }

        catalinaHome = System.getProperty("catalina.home");
        jettyHome = System.getProperty("jetty.home");

        // Set in all case catalina.home and base to $JONAS_BASE
        // if library is found. Useful if a user want to run in
        // a same environment JOnAS/Tomcat and Tomcat with different
        // versions
        if (hasEmbeddedCatalina()) {
            System.setProperty("catalina.home", catalinaLib.getPath());
            System.setProperty("catalina.base", jonasBase);
            catalinaHome = catalinaLib.getPath();
        }

        // Set jetty.home to $JONAS_BASE if library is found
        // and if jetty.home isn't set.
        if (jettyHome == null) {
            if (hasEmbeddedJetty()) {
                System.setProperty("jetty.home", jettyLib.getPath());
                jettyHome = jettyLib.getPath();
            }
        }

    }

    private boolean hasEmbeddedCatalina() {
        return new File(catalinaLib, CATALINA_BOOTSTRAP_JAR).exists();
    }

    private boolean hasEmbeddedJetty() {
        return new File(jettyLib, MORTBAY_JETTY_JAR).exists();
    }

    public JClassLoader getCommonsLoader() throws Exception {
        JClassLoader commons = getLoader(COMMONS);
        if (commons == null) {
            commons = createCommonsClassLoader();
            setLoader(COMMONS, commons);
        }
        return commons;
    }

    public JClassLoader getToolsLoader() throws Exception {
        JClassLoader tools = getLoader(TOOLS);
        if (tools == null) {
            tools = createToolsClassLoader();
            setLoader(TOOLS, tools);
        }
        return tools;
    }

    public JClassLoader getAppsLoader() throws Exception {
        JClassLoader apps = getLoader(APPS);
        if (apps == null) {
            apps = createAppsClassLoader();
            setLoader(APPS, apps);
        }
        return apps;
    }

    public JClassLoader getCatalinaLoader() throws Exception {
        JClassLoader catalina = getLoader(CATALINA);
        if (catalina == null) {
            catalina = createCatalinaClassLoader();
            setLoader(CATALINA, catalina);
        }
        return catalina;
    }

    private static JURLs getClassPath(boolean xtracp) throws Exception {
        String cpprop = "java.class.path";
        if (xtracp) {
            cpprop = "jonas.classpath";
        }
        String cpValue = System.getProperty(cpprop);
        //System.out.println("classpath=" + cpValue); // DEBUG
        String sep = File.pathSeparator;
        JURLs jurls = new JURLs();
        StringTokenizer tokenizer = new StringTokenizer(cpValue, sep);
        while (tokenizer.hasMoreTokens()) {
            File file = new File(tokenizer.nextToken());
            if (file.isDirectory()) {
                jurls.addDir(file);
            } else {
                // TODO check for ${jonas.root}/lib/bootstrap
                // do not re-add bootstrap.jar inside classloader
                if (!file.getName().equals("ow_jonas_bootstrap.jar")) {
                    jurls.add(file);
                }
            }
        }
        return jurls;
    }

    private JClassLoader getLoader(String name) {
        return (JClassLoader) loaders.get(name);
    }

    private void setLoader(String name, JClassLoader loader) {
        loaders.put(name, loader);
    }

    private JClassLoader createCommonsClassLoader() throws Exception {

        JURLs jurls = new JURLs();

        // add classpath in loader
        jurls.merge(getClassPath(useDefaultClassPath));

        // Load $JONAS_ROOT/lib/commons/**/*.jar
        jurls.add(jonasCommonsDir, ".jar");

        // add jonas.base/lib/ext only if jonas.base != jonas.root
        // jonas.base/lib/ext is added before jonas.root/lib/ext
        if (!System.getProperty("install.root").toLowerCase().equals(jonasBase.toLowerCase())) {
            File jonasBaseLibExt = new File(jonasBase + File.separator + "lib" + File.separator + "ext");
            if (jonasBaseLibExt.exists()) {
                jurls.add(jonasBaseLibExt, ".jar");
            }
        }

        // add jonas.root/lib/ext
        jurls.add(new File(jonasLib, "ext"), ".jar");

        if (hasWeb) {
            // resources for catalina have been put in apps ClassLoader

            // add resources for jetty if required
            if (jettyHome != null && !isCatalina) {
                File jettyLibDir = new File(jettyHome, "lib");
                File jettyExtDir = new File(jettyHome, "ext");
                jurls.add(jettyLibDir, ".jar");
                jurls.add(jettyExtDir, ".jar");
                if (!hasEmbeddedJetty()) {
                    // load ${jonas.root}/jetty/lib/ow_jonas_jetty.jar
                    File jonasJetty5Glue = new File(new File(jettyLib, "lib"), "ow_jonas_jetty.jar");
                    jurls.add(jonasJetty5Glue);
                }
            }
            // else user has not set the webcontainer HOME var
        }

        return new JClassLoader("Commons", jurls.toURLs());
    }

    private JClassLoader createToolsClassLoader() throws Exception {
        JURLs jurls = new JURLs();

        jurls.add(jonasToolsDir, ".jar");

        return new JClassLoader("Tools", jurls.toURLs(), getCommonsLoader());
    }

    private JClassLoader createAppsClassLoader() throws Exception {
        JURLs jurls = new JURLs();

        // ${jonas.root}/lib/apps
        jurls.add(jonasAppsDir, ".jar");

        if (hasWeb) {
            // add resources for catalina if required
            if (catalinaHome != null && isCatalina) {
                File catalinaBinDir = new File(catalinaHome, "bin");
                File catalinaCommonLibDir = new File(catalinaHome, "common" + File.separator + "lib");
                File catalinaSharedLibDir = new File(catalinaHome, "shared" + File.separator + "lib");
                jurls.add(new File(catalinaBinDir, "bootstrap.jar"));
                jurls.add(catalinaCommonLibDir, ".jar");
                jurls.add(catalinaSharedLibDir, ".jar");
            }
        }
        return new JClassLoader("Apps", jurls.toURLs(), getCommonsLoader());
    }

    private JClassLoader createCatalinaClassLoader() throws Exception {
        JURLs jurls = new JURLs();

        // ${catalina.home}/server/lib/*jar
        File catalinaServerLibDir = new File(catalinaHome, "server" + File.separator + "lib");
        jurls.add(catalinaServerLibDir, ".jar");

        // ${jonas.root}/catalina/server/lib/ow_jonas_tomcat5.jar
        if (!hasEmbeddedCatalina()) {
            // add ow_jonas_tomcat.jar only if using external Tomcat
            File jonasTomcat5Glue = new File(catalinaLib, "server" + File.separator + "lib" + File.separator + "ow_jonas_tomcat5.jar");
            if (jonasTomcat5Glue.exists()) {
                jurls.add(jonasTomcat5Glue);
            } else {
                System.out.println("WARN : No ow_jonas_tomcat5.jar found in " + catalinaLib + "/server/lib directory.");
            }
        }
        return new JClassLoader("Catalina", jurls.toURLs(), getAppsLoader());
    }
}

---