CatalinaJWebContainerServiceImpl.java

package org.objectweb.jonas.web.catalina50;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.net.URL;
import java.rmi.RemoteException;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.StringTokenizer;
import java.util.Vector;

import javax.management.InstanceAlreadyExistsException;
import javax.management.MBeanRegistrationException;
import javax.management.MBeanServer;
import javax.management.MalformedObjectNameException;
import javax.management.NotCompliantMBeanException;
import javax.management.ObjectName;
import javax.naming.LinkRef;
import javax.naming.NamingException;
import javax.naming.Reference;
import javax.naming.StringRefAddr;

import org.apache.catalina.Connector;
import org.apache.catalina.Container;
import org.apache.catalina.Context;
import org.apache.catalina.Engine;
import org.apache.catalina.Host;
import org.apache.catalina.Lifecycle;
import org.apache.catalina.LifecycleException;
import org.apache.catalina.Realm;
import org.apache.catalina.Server;
import org.apache.catalina.Service;
import org.apache.catalina.core.StandardContext;
import org.apache.catalina.core.StandardEngine;
import org.apache.catalina.core.StandardServer;
import org.apache.catalina.deploy.ContextResource;
import org.apache.catalina.deploy.NamingResources;
import org.apache.catalina.deploy.ResourceParams;
import org.apache.catalina.startup.ContextConfig;
import org.apache.commons.digester.Digester;
import org.apache.commons.modeler.Registry;
import org.objectweb.jonas.jmx.J2eeObjectName;
import org.objectweb.jonas.jmx.JonasObjectName;
import org.objectweb.jonas.security.realm.web.catalina50.JACC;
import org.objectweb.jonas.server.J2EEServerMBean;
import org.objectweb.jonas.server.LoaderManager;
import org.objectweb.jonas.service.ServiceException;
import org.objectweb.jonas.web.AbsJWebContainerServiceImpl;
import org.objectweb.jonas.web.JWebContainerServiceException;
import org.objectweb.jonas.web.lib.PermissionManager;
import org.objectweb.jonas.web.wrapper.CatalinaJWebContainerService;
import org.objectweb.jonas_lib.I18n;
import org.objectweb.util.monolog.api.BasicLevel;
import org.xml.sax.InputSource;


public class CatalinaJWebContainerServiceImpl
    extends AbsJWebContainerServiceImpl
    implements CatalinaJWebContainerService {

    protected static final String CONFIG_FILE = "conf/server.xml";

    private static I18n i18n = null;

    private Server server = null;

    private ClassLoader parentClassLoader = null;

    private ClassLoader catalinaLoader = null;

    private static final int DEFAUT_DEBUG_LEVEL = 99;

    private boolean tomcatStarted = false;


    protected void doInit(javax.naming.Context ctx) throws ServiceException {
        super.doInit(ctx);

        // Set the environment
        initCatalinaEnvironment();

        // parent ClassLoader
        LoaderManager lm = LoaderManager.getInstance();
        try {
            parentClassLoader = lm.getAppsLoader();
            catalinaLoader = lm.getCatalinaLoader();
        } catch (Exception e1) {
            throw new ServiceException("Cannot get Application/Catalina ClassLoader", e1);
        }

        // Internationalization
        i18n = I18n.getInstance(CatalinaJWebContainerServiceImpl.class, catalinaLoader);

        // Add JOnAS-Tomcat mbean
        getLogger().log(BasicLevel.DEBUG, "Add mbeans descriptions to the JMX Registry");
        InputStream stream = this.getClass().getResourceAsStream("/org/objectweb/jonas/web/catalina50/mbeans-descriptors.xml");
        try {
            Registry.loadRegistry(stream);
            stream.close();
        } catch (Exception e) {
            getLogger().log(BasicLevel.ERROR, "Can't add the mbeans description into Tomcat" + e.getMessage());
        }

        // Add MBean for Catalina Connector creation
        CatalinaConnectorFactory cf = new CatalinaConnectorFactory();
        MBeanServer mbeanServer = getMbeanServer();
        cf.setMyServer(mbeanServer);
        if (mbeanServer != null) {
            ObjectName on = null;
            try {
                on = JonasObjectName.catalinaConnectorFactory(getDomainName());
                mbeanServer.registerMBean(cf, on);
            } catch (MalformedObjectNameException e1) {
                getLogger().log(BasicLevel.WARN, "Can't create Objectname for CatalinaConnectorFactory MBean");
            } catch (InstanceAlreadyExistsException e2) {
                getLogger().log(BasicLevel.WARN, "MBean named " + on.toString() + "already registered in the MBean server");
            } catch (MBeanRegistrationException e2) {
                getLogger().log(BasicLevel.WARN, "Can't register MBean " + on.toString());
                e2.printStackTrace();
            } catch (NotCompliantMBeanException e2) {
                getLogger().log(BasicLevel.WARN, "Can't register MBean " + on.toString());
                e2.printStackTrace();
            }
        }

        // Add MBean for WebModule Proxy creation
        WebModuleProxy px = new WebModuleProxy();
        px.setMyServer(mbeanServer);
        if (mbeanServer != null) {
            ObjectName on = null;
            try {
                on = JonasObjectName.webModuleProxy(getDomainName());
                mbeanServer.registerMBean(px, on);
            } catch (MalformedObjectNameException e1) {
                getLogger().log(BasicLevel.WARN, "Can't create Objectname for WebModuleProxy MBean");
            } catch (InstanceAlreadyExistsException e2) {
                getLogger().log(BasicLevel.WARN, "MBean named " + on.toString() + "already registered in the MBean server");
            } catch (MBeanRegistrationException e2) {
                getLogger().log(BasicLevel.WARN, "Can't register MBean " + on.toString());
                e2.printStackTrace();
            } catch (NotCompliantMBeanException e2) {
                getLogger().log(BasicLevel.WARN, "Can't register MBean " + on.toString());
                e2.printStackTrace();
            }
        }
    }


    protected void initCatalinaEnvironment() throws ServiceException {

        // if the user do not specify catalina.base,
        // set catalina.base to catalina.home.
        String catalinaHome = System.getProperty("catalina.home");
        if (catalinaHome != null) {
            if (System.getProperty("catalina.base") == null) {
                System.setProperty("catalina.base", catalinaHome);
            }
        } else {
            throw new ServiceException("catalina.home property is not set");
        }

        // use the JOnAS naming instead of Tomcat naming
        System.setProperty("catalina.useNaming", "false");
    }


    public void doStart() throws ServiceException {

        // Create the digester for the parsing of the server.xml.
        Digester digester = createServerDigester();

        // Execute the digester for the parsing of the server.xml.
        // And configure the catalina server.
        File configFile = null;

        try {
            configFile = getConfigFile();
        } catch (FileNotFoundException e) {
            String err = i18n.getMessage("CatJWebServ.doStart.fileNotFound", configFile, e.getMessage());
            getLogger().log(BasicLevel.ERROR, err);
            throw new ServiceException(err, e);
        }

        try {
            InputSource is = new InputSource("file://" + configFile.getAbsolutePath());
            FileInputStream fis = new FileInputStream(configFile);
            is.setByteStream(fis);
            digester.push(this);
            digester.parse(is);
            fis.close();
        } catch (Exception e) {
            String err = i18n.getMessage("CatJWebServ.doStart.readfileError", configFile, e.getMessage());
            getLogger().log(BasicLevel.ERROR, err);
            throw new ServiceException(err, e);
        }

        javax.naming.Context ctxOld = setGlobalNamingResources();

        // Set the Domain and the name for each known Engine
        Iterator it = getEngines().iterator();
        while (it.hasNext()) {
            StandardEngine oSE = (StandardEngine) it.next();
            // WARNING : the order of th two next lines is very important.
            // The domain must be set in first and the name after.
            // In the others cases, Tomcat 5 doesn't set correctly these two properties
            // because there are somes controls that forbid to have a difference between
            // the name and the domain. Certainly a bug !
            oSE.setDomain(getDomainName());
            oSE.setName(getDomainName());
        }

        // Finaly start catalina ...
        if (server instanceof Lifecycle) {
            try {
                server.initialize();
                ((Lifecycle) server).start();
            } catch (Exception e) {
                String err = i18n.getMessage("CatJWebServ.doStart.startCatalinaError");
                getLogger().log(BasicLevel.ERROR, err);
                throw new ServiceException(e.getMessage(), e);
            }
        }
        // Reset server context
        getNaming().setComponentContext(ctxOld);

        // Tomcat is started
        tomcatStarted = true;

        // ... and deploy wars of the jonas.properties
        super.doStart();
    }

    protected javax.naming.Context setGlobalNamingResources() throws ServiceException {
        // Set the global context of the server
        NamingResources namingResources = server.getGlobalNamingResources();
        javax.naming.Context globalCtx = null;
        javax.naming.Context ctxold = null;
        try {
            globalCtx = getNaming().createEnvironmentContext("catalina_global");
            ctxold = getNaming().setComponentContext(globalCtx);

            int i;
            // Resources
            ContextResource[] resources = namingResources.findResources();
            for (i = 0; i < resources.length; i++) {
                addResource(globalCtx, namingResources, resources[i]);
            }
        } catch (NamingException e) {
            String err = i18n.getMessage("CatJWebServ.doStart.populateEnvError", e.getMessage());
            getLogger().log(BasicLevel.ERROR, err);
            throw new ServiceException(err, e);
        }
        // Set the global naming context of the server
        ((StandardServer) server).setGlobalNamingContext(globalCtx);
        return ctxold;
    }


    protected void doStop() throws ServiceException {
        // Undeploy the wars ...
        super.doStop();

        // ... and shut down embedded catalina
        if (server instanceof Lifecycle) {
            try {
                ((Lifecycle) server).stop();
            } catch (Exception e) {
                String err = i18n.getMessage("CatJWebServ.doStop.stopCatalinaError");
                getLogger().log(BasicLevel.ERROR, err);
                throw new ServiceException(e.getMessage(), e);
            }
        }

    }


    protected void doRegisterWar(javax.naming.Context ctx)
        throws JWebContainerServiceException {
        // Get the 7 parameters :
        //   - warURL is the URL of the war to register (required param).
        //   - contextRoot is the context root to which this application
        //     should be installed (must be unique) (required param).
        //   - hostName is the name of the host on which deploy the war
        //     (optional param taken into account only if no <context> element
        //      was declared in server.xml for this web application) .
        //   - Name of the Ear application of this war if any
        //   - java2DelegationModel the compliance to java2 delegation model
        //   - parentCL the war classloader of this war.
        //   - jonasDD JOnAS Deployment Desc content
        //   - permissionManager JACC permission manager

        URL warURL = null;
        URL earURL = null;
        URL unpackedWarURL = null;
        String contextRoot = null;
        boolean java2DelegationModel = true;
        PermissionManager permissionManager = null;
        boolean inEarCase = true;
        String earAppName = null;
        String jonasDD = null;
        try {
            warURL = (URL) ctx.lookup("warURL");
            unpackedWarURL = (URL) ctx.lookup("unpackedWarURL");
            contextRoot = (String) ctx.lookup("contextRoot");
            Boolean bool = (Boolean) ctx.lookup("java2DelegationModel");
            java2DelegationModel = bool.booleanValue();
            jonasDD = (String) ctx.lookup("jonasDD");
            permissionManager = (PermissionManager) ctx.lookup("permissionManager");
        } catch (NamingException e) {
            String err = i18n.getMessage("CatJWebServ.doRegisterWar.gettingParamError");
            getLogger().log(BasicLevel.ERROR, err + e.getMessage());
            throw new JWebContainerServiceException(err, e);
        }

        try {
            earAppName = (String) ctx.lookup("earAppName");
            earURL = (URL) ctx.lookup("earURL");
        } catch (NamingException e) {
            // no ear case, so no ear application name
            inEarCase = false;
            // set earURL to something only to avoid null value
            earURL = warURL;
        }

        ClassLoader webClassLoader = null;

        try {
            webClassLoader = (ClassLoader) ctx.lookup("parentCL");
        } catch (NamingException e) {
            String err = i18n.getMessage("CatJWebServ.doRegisterWar.gettingParamError");
            getLogger().log(BasicLevel.ERROR, err + e.getMessage());
            throw new JWebContainerServiceException(err, e);
        }

        String hostName = null;
        try {
            hostName = (String) ctx.lookup("hostName");
        } catch (NamingException e) {
            hostName = "";
        }

        // Install a new web application, whose web application archive is
        // at the specified URL, into this container with the specified
        // context root.
        // A context root of "" (the empty string) should be used for the root
        // application for this container.  Otherwise, the context root must
        // start with a slash.

        if (contextRoot.equals("/")) {
            contextRoot = "";
        } else {
            contextRoot = "/" + contextRoot;
        }

        // Install the war.
        File fWar = new File(warURL.getFile());
        //File fpackedWar = new File(packedWarURL.getFile());

        // Unpacked path of the war
        String destDir = null;
        if (fWar.isDirectory()) {
            destDir = warURL.getPath();
        } else {
            destDir = unpackedWarURL.getPath();
        }

        // Check if some contexts were configured in server.xml
        List jonasContexts = getConfiguredMatchingJonasContexts(contextRoot, fWar, destDir);

        Host deployer = null;
        // The context was not found in server.xml, a new context will be created.
        if (jonasContexts.isEmpty()) {
            // Find host on which deploy the context
            deployer = findHost(hostName);

            // Create context (false because not in server.xml)
            JOnASStandardContext context = new JOnASStandardContext(false, java2DelegationModel, inEarCase);
            if (getLogger().isLoggable(BasicLevel.DEBUG)) {
                context.setDebug(DEFAUT_DEBUG_LEVEL);
            }
            context.setDocBase(destDir);
            context.setPath(contextRoot);
            ContextConfig config = new ContextConfig();

            // add the config
            ((Lifecycle) context).addLifecycleListener(config);
            jonasContexts.add(context);
        }

        // Configure these contexts and start them
        Iterator it = jonasContexts.iterator();
        while (it.hasNext()) {
            JOnASStandardContext jStdCtx = (JOnASStandardContext) it.next();

            // Set the parent class loader
            jStdCtx.setParentClassLoader(webClassLoader);

            // Delegation model
            jStdCtx.setDelegate(java2DelegationModel);
            if (getLogger().isLoggable(BasicLevel.DEBUG)) {
                getLogger().log(BasicLevel.DEBUG, "Webapp class loader java 2 delegation model set to " + java2DelegationModel);
            }

            // JSR 77
            jStdCtx.setJ2EEServer(getJonasServerName());
            jStdCtx.setServer(J2eeObjectName.J2EEServer(getDomainName(), getJonasServerName()).toString());
            if (getMbeanServer() != null) {
                try {
                    String[] as = (String[]) getMbeanServer().getAttribute(J2eeObjectName.J2EEServer(getDomainName()
                        , getJonasServerName()), "javaVMs");
                    jStdCtx.setJavaVMs(as);
                } catch (Exception e) {
                    //String err = i18n.getMessage("CatJWebServ.doRegisterWar.startContextError", jStdCtx);
                    //getLogger().log(BasicLevel.WARN, err + e.getMessage());
                    getLogger().log(BasicLevel.WARN, "Set MBean JVM error : " + e.getClass().getName() + " " + e.getMessage());
                }
            }
            if (earAppName != null) {
                jStdCtx.setJ2EEApplication(earAppName);
            }
            jStdCtx.setJonasDeploymentDescriptor(jonasDD);

            // Set the realm
            Realm ctxRealm = jStdCtx.getRealm();

            // Take realm of parent
            if (ctxRealm == null) {
                ctxRealm = deployer.getRealm();
            }

            if (ctxRealm != null && ctxRealm instanceof JACC) {
                JACC jaccRealm = null;
                try {
                    jaccRealm = (JACC) ((JACC) ctxRealm).clone();
                } catch (CloneNotSupportedException cnse) {
                    String err = "Cannot clone the realm used by the existing context or its parent realm";
                    getLogger().log(BasicLevel.ERROR, err + cnse.getMessage());
                    throw new JWebContainerServiceException(err, cnse);
                }
                if (getLogger().isLoggable(BasicLevel.DEBUG)) {
                    getLogger().log(BasicLevel.DEBUG, "Setting permission manager to " + permissionManager);
                }
                jaccRealm.setPermissionManager(permissionManager);
                jaccRealm.setContext(jStdCtx);
                // Set the new realm
                jStdCtx.setRealm(jaccRealm);
            }


            // Set the attributes transfered from the JOnAS War MBean.
            // Note that 'java2DelegationModel' and 'inEarCase' attributes
            // are passed asarguments to the JOnASStandardContext's constructor
            jStdCtx.setWarURL(warURL);
            if (inEarCase) {
                jStdCtx.setEarURL(earURL);
            }

            // ... and start it or add it
            if (jStdCtx.isInServerXml()) {
                try {
                    jStdCtx.setLoader(null);
                    jStdCtx.start();
                } catch (LifecycleException lce) {
                    String err = i18n.getMessage("CatJWebServ.doRegisterWar.startContextError", jStdCtx);
                    getLogger().log(BasicLevel.ERROR, err + lce.getMessage());
                    throw new JWebContainerServiceException(err, lce);

                }
            } else {
                // add it
                if (deployer == null) {
                    String err = i18n.getMessage("CatJWebServ.doRegisterWar.deployerIsNull", jStdCtx);
                    getLogger().log(BasicLevel.ERROR, err);
                    throw new JWebContainerServiceException(err);
                }
                deployer.addChild(jStdCtx);
            }

            // ...and check if it is now configured
            checkStartedContext(jStdCtx);
        }
    }


    protected List getConfiguredMatchingJonasContexts(String contextRoot, File fpackedWar, String destDir) {
        ArrayList jonasContexts = new ArrayList();
        // Check contexts of all services to see if there is a configured context.
        // that we must use instead of creating a new one.
        // If a context is matching, we set its docbase and start it.
        Iterator it = getContexts().iterator();
        while (it.hasNext()) {
            Context ctx = (Context) it.next();
            // Continue if it is not a JOnAS context
            if (!(ctx instanceof JOnASStandardContext)) {
                continue;
            }
            JOnASStandardContext jStdCtx = (JOnASStandardContext) ctx;
            if (jStdCtx != null) {
                // Not created in server.xml file
                if (!jStdCtx.isInServerXml()) {
                    continue;
                }

                // The context was configured ?
                String serverCtxRoot = jStdCtx.getPath();
                if (!serverCtxRoot.equals(contextRoot)) {
                    continue;
                }
                if (jStdCtx.getPrivileged()) {
                    // Can deploy a privileged context only if it's a .war file
                    if (fpackedWar.isDirectory()) {
                        String err = i18n.getMessage("CatJWebServ.getConfiguredMatchingJonasContexts.privilegedContextError");
                        getLogger().log(BasicLevel.ERROR, err);
                    }
                    jStdCtx.setDocBase(fpackedWar.getPath());
                } else {
                    jStdCtx.setDocBase(destDir);
                }
                jonasContexts.add(jStdCtx);
            }
        }
        return jonasContexts;
    }


    protected void checkStartedContext(Context context) throws JWebContainerServiceException {
        // Check if the context was configured
        if (!context.getConfigured()) {
            String err = i18n.getMessage("CatJWebServ.checkStartedContext.configuredFail", context.getName());
            getLogger().log(BasicLevel.ERROR, err);
            throw new JWebContainerServiceException(err);
        } else {
            ((JOnASStandardContext) context).unsetAuthenticationCaching();
            if (getLogger().isLoggable(BasicLevel.DEBUG)) {
                getLogger().log(BasicLevel.DEBUG, "context " + context + " started");
            }
        }
    }

    protected synchronized List getEngines() throws JWebContainerServiceException {
        List engines = new ArrayList();
        Service[] services = server.findServices();

        // Get contexts of each engine of each service
        for (int s = 0; s < services.length; s++) {
            Container cont = services[s].getContainer();
            if (!(cont instanceof Engine)) {
                String err = "The container of the service must be an engine (server.xml)";
                throw new JWebContainerServiceException(err);
            }
            engines.add(cont);
        }
        return engines;
    }

    protected synchronized List getContexts() throws JWebContainerServiceException {
        List contexts = new ArrayList();

        Iterator itEngines = getEngines().iterator();
        while (itEngines.hasNext()) {
            Engine engine = (Engine) itEngines.next();
            Container[] hosts = engine.findChildren();

            for (int j = 0; j < hosts.length; j++) {
                Container[] containers = hosts[j].findChildren();
                for (int k = 0; k < containers.length; k++) {
                    Container container = containers[k];
                    if (container instanceof Context) {
                        contexts.add(container);
                    }
                }
            }
        }
        return contexts;
    }


    protected void doUnRegisterWar(javax.naming.Context ctx)
        throws JWebContainerServiceException {

        // Get the 2 parameters :
        //   - contextRoot is the context root to be removed (required param).
        //   - hostName is the name of the host to remove the war (optional).
        String contextRoot = null;
        try {
            contextRoot = (String) ctx.lookup("contextRoot");
        } catch (NamingException e) {
            String err = i18n.getMessage("CatJWebServ.doUnRegisterWar.gettingParamError");
            getLogger().log(BasicLevel.ERROR, err + e.getMessage());
            throw new JWebContainerServiceException(err, e);
        }

        if (contextRoot.equals("/")) {
            contextRoot = "";
        } else {
            contextRoot = "/" + contextRoot;
        }

        String hostName = null;
        try {
            hostName = (String) ctx.lookup("hostName");
        } catch (NamingException e) {
            getLogger().log(BasicLevel.DEBUG, "No define hostname for this context");
        }

        // Undeploy all matching context if there is no hostname provided
        if (hostName == null) {
            boolean found = false;
            Iterator it = getContexts().iterator();
            while (it.hasNext()) {
                Context context = (Context) it.next();
                String serverCtxRoot = context.getPath();
                if (serverCtxRoot.equals(contextRoot)) {
                    removeContext(context);
                    found = true;
                }
            }
            if (!found) {
                String err = i18n.getMessage("CatJWebServ.doUnRegisterWar.undeployError", contextRoot);
                getLogger().log(BasicLevel.ERROR, err);
                throw new JWebContainerServiceException(err);
            }
        } else {
            // Remove the specified Context from the set of defined Contexts
            // for its associated Host.
            Host host = findHost(hostName);
            org.apache.catalina.Context context = host.map(contextRoot);
            if (context != null) {
                removeContext(context);
            } else {
                String err = i18n.getMessage("CatJWebServ.doUnRegisterWar.undeployError", contextRoot);
                getLogger().log(BasicLevel.ERROR, err);
                throw new JWebContainerServiceException(err);
            }
        }
    }


    public synchronized void removeContext(Context context) throws JWebContainerServiceException {

        // Is this Context actually among those that are deployed ?
        boolean found = false;
        Iterator it = getContexts().iterator();
        while (it.hasNext() && !found) {
            if (context == (Context) it.next()) {
                found = true;
            }
        }

        if (!found) {
            return;
        }
        // Remove this Context from the associated Host
        // Or stop it if it is a JOnAS standard context (to keep the configuration)
        if (context instanceof JOnASStandardContext) {
            JOnASStandardContext jctx = (JOnASStandardContext) context;
            if (jctx.isInServerXml()) {
                try {
                    ((JOnASStandardContext) context).stop();
                } catch (LifecycleException le) {
                    throw new JWebContainerServiceException("Cannot stop context (" + le.getMessage() + ")");
                }
            } else {
                // must not persist
                context.getParent().removeChild(context);
                // Bug Tomcat 5 doesn't remove MBean WebModule
                // Delete the next line when will be fixed
                // Bug Tomcat 5 : begin
                if (getMbeanServer() != null) {
                    try {
                        // unregister WebModule MBean
                        getMbeanServer().unregisterMBean(jctx.getJmxName());
                    } catch (Exception e) {
                        getLogger().log(BasicLevel.ERROR, "Cannot remove the MBean for the WebModule " + jctx.getObjectName() + " : " + e.getMessage());
                    }
                }
            }
        } else {
            context.getParent().removeChild(context);
            // Bug Tomcat 5 doesn't remove MBean WebModule
            // Delete the next line when will be fixed
            // Bug Tomcat 5 : begin
            if (context instanceof StandardContext) {
                StandardContext ctx = (JOnASStandardContext) context;
                if (getMbeanServer() != null) {
                    try {
                        // unregister WebModule MBean
                        getMbeanServer().unregisterMBean(ctx.getJmxName());
                    } catch (Exception e) {
                        getLogger().log(BasicLevel.ERROR
                            , "Cannot remove the MBean for the WebModule " + ctx.getObjectName()
                            + " : " + e.getMessage());
                    }
                }
            }
        }

    }


    public boolean isTomcatStarted() {
        return tomcatStarted;
    }


    public void setServer(Server server) {
        this.server = server;
    }


    protected File getConfigFile() throws FileNotFoundException {
        String fileName = System.getProperty("catalina.base");
        fileName = fileName + File.separator + CONFIG_FILE;
        File file = new File(fileName);
        if (!file.exists()) {
            String err = i18n.getMessage("CatJWebServ.getConfigFile.findfileError", fileName);
            throw new FileNotFoundException(err);
        }
        return (file);
    }


    public Host findHost(String hostName)
        throws JWebContainerServiceException {

        Service[] services = server.findServices();
        // Check number of services
        if (services.length < 1) {
            String err = "At least one service must be define in the server.xml of Tomcat";
            throw new JWebContainerServiceException(err);
        }

        // Two cases :
        //   1/ No host specified
        //      -> defaulthost of the engine of the first service.
        //   2) A host is specified in the jonas-web.xml
        //      -> find the host and deploy on this host


        if (hostName == null || hostName.equals("")) {
            // First case

            //Take first service
            Service service = services[0];

            Container cont = service.getContainer();
            if (!(cont instanceof Engine)) {
                String err = "The container of the service must be an engine";
                throw new JWebContainerServiceException(err);
            }

            Engine engine = (Engine) cont;
            String defaultHost = engine.getDefaultHost();
            if (defaultHost == null) {
                String err = "Default host must be specified in server.xml or host must be specified in jonas-web.xml";
                throw new JWebContainerServiceException(err);
            }
            Container child = engine.findChild(defaultHost);
            if (child instanceof Host) {
                return (Host) child;
            } else {
                String err = "Default host " + defaultHost + " not found";
                throw new JWebContainerServiceException(err);
            }
        } else {
            // Second case.
            // Get all hosts.
            Vector hosts = new Vector();

            for (int s = 0; s < services.length; s++) {
                Container cont = services[s].getContainer();
                if (!(cont instanceof Engine)) {
                    String err = "The container of a service must be an engine";
                    throw new JWebContainerServiceException(err);
                }
                Engine engine = (Engine) cont;
                Container child = engine.findChild(hostName);
                if (child instanceof Host) {
                    hosts.addElement(child);
                }
            }

            if (hosts.size() == 0) {
                // No host found.
                String err = "Host " + hostName + " not found in all services/Engine of server.xml";
                throw new JWebContainerServiceException(err);
            } else {
                return (Host) hosts.elementAt(0);
            }
        }
    }


    private void addResource(javax.naming.Context ctx, NamingResources resources, ContextResource resource) throws JWebContainerServiceException {

        String name = resource.getName();
        String type = resource.getType();
        String registryName = name;

        // Add only UserDatabase resources
        if (!type.equals("org.apache.catalina.UserDatabase")) {
            return;
        }

        // Create a reference to the resource.
        Reference ref = new Reference("org.apache.catalina.UserDatabase", "org.apache.catalina.users.MemoryUserDatabaseFactory", null);

        // Add extra parameters
        ResourceParams resourceParameters = resources.findResourceParams(name);
        if (resourceParameters != null) {
            Hashtable params = resourceParameters.getParameters();
            Enumeration keys = params.keys();
            while (keys.hasMoreElements()) {
                String paramName = (String) keys.nextElement();
                String paramValue = (String) params.get(paramName);
                StringRefAddr refAddr = new StringRefAddr(paramName, paramValue);
                ref.add(refAddr);
            }
        }
        try {
            javax.naming.Context ictx = getNaming().getInitialContext();

            // Bind into registry
            ictx.bind(registryName, ref);

            // Bind LinkRef
            LinkRef lref = new LinkRef(registryName);
            ctx.bind(name, lref);

        } catch (Exception e) {
            e.printStackTrace();
            String err = "Can't add the resource " + name;
            throw new JWebContainerServiceException(err, e);
        }
    }


    protected Digester createServerDigester() {

        // Initialize the digester
        Digester digester = new Digester();
        digester.setValidating(false);
        digester.addRuleSet(new JCatalinaRuleSet(parentClassLoader));

        // Use context class loader.
        // Could avoid problem for users putting digester in JONAS_ROOT/lib/ext folder
        digester.setUseContextClassLoader(true);
        return (digester);

    }


    protected void updateServerInfos() {
        String infos = org.apache.catalina.util.ServerInfo.getServerInfo();
        StringTokenizer st = new StringTokenizer(infos, "/");
        if (st.countTokens() != 2) {
            setServerName(infos);
            setServerVersion("");
        } else {
            setServerName(st.nextToken());
            setServerVersion(st.nextToken());
        }
    }

    public String getDefaultHost() throws JWebContainerServiceException {
        Service[] svc = server.findServices();
        if (svc.length != 1) {
            String err = "Cannot find defaultHost! Cause of multiple Services";
            throw new JWebContainerServiceException(err);
        }

        Engine engine = (Engine) svc[0].getContainer();
        return engine.getDefaultHost();
    }


    public String getDefaultHttpPort() throws JWebContainerServiceException {
        Service[] svc = server.findServices();
        if (svc.length != 1) {
            String err = "Cannot find Default Http Port! Cause of multiple Services";
            throw new JWebContainerServiceException(err);
        }

        Connector[] conn = svc[0].findConnectors();
        Vector httpConn = new Vector();
        for (int i = 0; i < conn.length; i++) {
            if (conn[i].getScheme().equalsIgnoreCase("http")) {
                httpConn.add(conn[i]);
            }
        }
        if (httpConn.size() != 1) {
            String err = "Cannot find Default Http Port! Cause of multiple Http Connector";
            throw new JWebContainerServiceException(err);
        }

        Class connectorClass = httpConn.get(0).getClass();
        String port = null;
        try {
            Method getPortMethod = connectorClass.getMethod("getPort", new Class[] {});
            port = ((Integer) getPortMethod.invoke(httpConn.get(0), new Object[] {})).toString();
        } catch (Exception e) {
            String err = "Connector does not have a getPort method.";
            throw new JWebContainerServiceException(err, e);
        }

        return port;
    }


    public String getDefaultHttpsPort() throws JWebContainerServiceException {
        Service[] svc = server.findServices();
        if (svc.length != 1) {
            String err = "Cannot find Default Http Port! Cause of multiple Services";
            throw new JWebContainerServiceException(err);
        }

        Connector[] conn = svc[0].findConnectors();
        Vector httpsConn = new Vector();
        for (int i = 0; i < conn.length; i++) {
            if (conn[i].getScheme().equalsIgnoreCase("https")) {
                httpsConn.add(conn[i]);
            }
        }
        if (httpsConn.size() != 1) {
            String err = "Cannot find Default Https Port! Cause of multiple Https Connector";
            throw new JWebContainerServiceException(err);
        }

        Class connectorClass = httpsConn.get(0).getClass();
        String port = null;
        try {
            Method getPortMethod = connectorClass.getMethod("getPort", new Class[] {});
            port = ((Integer) getPortMethod.invoke(httpsConn.get(0), new Object[] {})).toString();
        } catch (Exception e) {
            String err = "Connector does not have a getPort method.";
            throw new JWebContainerServiceException(err, e);
        }

        return port;
    }

    public void registerWarMBean(String fileName) throws RemoteException, JWebContainerServiceException {
        ClassLoader old = null;
        try {
            old = Thread.currentThread().getContextClassLoader();
            Thread.currentThread().setContextClassLoader(catalinaLoader);
            super.registerWarMBean(fileName);
        } catch (Exception e) {
            throw new ServiceException("Exception during registering war", e);
        } finally {
            if (old != null) {
                Thread.currentThread().setContextClassLoader(old);
            }
        }
    }

    public void unRegisterWarMBean(String fileName) throws RemoteException, JWebContainerServiceException {
        ClassLoader old = null;
        try {
            old = Thread.currentThread().getContextClassLoader();
            Thread.currentThread().setContextClassLoader(catalinaLoader);
            super.unRegisterWarMBean(fileName);
        } catch (Exception e) {
            throw new ServiceException("Exception during unregistering war", e);
        } finally {
            if (old != null) {
                Thread.currentThread().setContextClassLoader(old);
            }
        }
    }
}

---