AbsJWebContainerServiceImpl.java

package org.objectweb.jonas.web;

import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.rmi.RemoteException;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.Vector;

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

import org.objectweb.jonas.common.JModule;
import org.objectweb.jonas.common.JProp;
import org.objectweb.jonas.common.Log;
import org.objectweb.jonas.server.LoaderManager;
import org.objectweb.jonas.ear.EarServiceImpl;
import org.objectweb.jonas.jmx.JmxService;
import org.objectweb.jonas.jmx.JonasObjectName;
import org.objectweb.jonas.naming.CompNamingContext;
import org.objectweb.jonas.naming.NamingManager;
import org.objectweb.jonas.service.AbsServiceImpl;
import org.objectweb.jonas.service.ServiceException;
import org.objectweb.jonas.service.ServiceManager;
import org.objectweb.jonas.web.lib.JarTools;
import org.objectweb.jonas.web.lib.PermissionManager;
import org.objectweb.jonas.ws.AbsWebServicesServiceImpl;
import org.objectweb.jonas.ws.JServiceFactory;
import org.objectweb.jonas.ws.JServiceFactoryFinder;
import org.objectweb.jonas.ws.WebServicesService;
import org.objectweb.jonas_lib.deployment.api.EjbLocalRefDesc;
import org.objectweb.jonas_lib.deployment.api.EjbRefDesc;
import org.objectweb.jonas_lib.deployment.api.EnvEntryDesc;
import org.objectweb.jonas_lib.deployment.api.MessageDestinationRefDesc;
import org.objectweb.jonas_lib.deployment.api.ResourceEnvRefDesc;
import org.objectweb.jonas_lib.deployment.api.ResourceRefDesc;
import org.objectweb.jonas_lib.loader.SimpleWebappClassLoader;
import org.objectweb.jonas_lib.loader.WebappClassLoader;
import org.objectweb.jonas_lib.naming.ContainerNaming;
import org.objectweb.jonas_lib.security.PermissionManagerException;
import org.objectweb.jonas_web.deployment.api.WebContainerDeploymentDesc;
import org.objectweb.jonas_web.deployment.api.WebContainerDeploymentDescException;
import org.objectweb.jonas_web.deployment.lib.wrapper.WebManagerWrapper;
import org.objectweb.jonas_ws.deployment.api.ServiceRefDesc;
import org.objectweb.util.monolog.api.BasicLevel;
import org.objectweb.util.monolog.api.Logger;

public abstract class AbsJWebContainerServiceImpl extends AbsServiceImpl implements JWebContainerService,
        AbsJWebContainerServiceImplMBean {

    protected static final String JONAS_BASE = JProp.getJonasBase();

    protected static final String WEBAPPS_DIR = JONAS_BASE + File.separator + "webapps";

    protected static final String WORK_DIR = JProp.getWorkDir();

    protected static final String WORK_WEBAPPS_DIR = WORK_DIR + File.separator + "webapps";

    public static final String DESCRIPTORS = "jonas.service.web.descriptors";

    public static final String AUTOLOADDIR = "jonas.service.web.autoloaddir";

    public static final String PARSINGWITHVALIDATION = "jonas.service.web.parsingwithvalidation";

    private static final int WAR_EXTENSION_LENGTH = 4;

    public static final String CLASS = "jonas.service.web.class";

    private static Logger logger = null;

    private static String nameOfServer = null;

    private ContainerNaming naming;

    private Hashtable warLoaders = new Hashtable();

    private Hashtable warBindings = new Hashtable();

    private MBeanServer mbeanServer = null; // Bug Tomcat 5 doesn't remove MBean
                                            // WebModule, normally the type is
                                            // "private"

    private Vector warNames = new Vector();

    private Vector warDeployed = new Vector();

    private ArrayList autoloadDirectories = new ArrayList();

    private String serverName = null;

    private String serverVersion = null;

    private WebServicesService wsService = null;

    private ClassLoader appsClassLoader;

    protected void doInit(Context ctx) throws ServiceException {

        // Init the logger
        logger = Log.getLogger(Log.JONAS_WEB_PREFIX);

        // get apps ClassLoader
        try {
            LoaderManager lm = LoaderManager.getInstance();
            appsClassLoader = lm.getAppsLoader();
        } catch (Exception e) {
            logger.log(BasicLevel.ERROR, "Cannot get the Applications ClassLoader from Web Container Service: " + e);
            throw new ServiceException("Cannot get the Applications ClassLoader from Web Container Service", e);
        }

        ServiceManager sm = null;
        try {
            sm = ServiceManager.getInstance();
        } catch (Exception e) {
            String err = "Cannot get ServiceManager instance.";
            logger.log(BasicLevel.ERROR, err);
            throw new ServiceException(err, e);
        }

        // Get the JMX Server via JMX Service
        try {
            mbeanServer = ((JmxService) sm.getJmxService()).getJmxServer();
        } catch (ServiceException e) {
            // the JMX service may not be started
            mbeanServer = null;
        }

        // Get the WebServices service
        try {
            wsService = (WebServicesService) sm.getWebServicesService();
        } catch (ServiceException e) {
            logger.log(BasicLevel.DEBUG, "WebServices service not started");
            //not started
            wsService = null;
        }

        // Set the XML parsing mode to no validation
        String parsingMode = "false";
        try {
            parsingMode = (String) ctx.lookup(PARSINGWITHVALIDATION);
        } catch (NamingException e) {
            logger.log(BasicLevel.DEBUG, "No value for parsingWithValidation");
            // No problem if there is no value for 'parsingwithvalidation'
            // (false by default)
        }

        WebManagerWrapper.setParsingWithValidation("true".equalsIgnoreCase(parsingMode));
        if ("false".equalsIgnoreCase(parsingMode)) {
            logger.log(BasicLevel.DEBUG, "Web XML parsing without validation");
        } else {

            logger.log(BasicLevel.DEBUG, "Web XML parsing with validation");
        }

        // Init the war names to be loaded when starting
        String descsValue = null;
        try {
            descsValue = (String) ctx.lookup(DESCRIPTORS);
        } catch (NamingException e) {
            logger.log(BasicLevel.DEBUG, "No " + DESCRIPTORS);
        }
        if (descsValue != null) {
            StringTokenizer st = new StringTokenizer(descsValue, ",");
            while (st.hasMoreTokens()) {
                String fileName = st.nextToken().trim();
                warNames.add(fileName);
            }
        }
        // Add the wars of the jonas.service.web.autoloaddir property
        String dirValue = null;
        ArrayList autoDirs = new ArrayList();
        try {
            dirValue = (String) ctx.lookup(AUTOLOADDIR);
        } catch (NamingException e) {
            logger.log(BasicLevel.DEBUG, "No " + AUTOLOADDIR);
        }
        if (dirValue != null) {
            StringTokenizer st = new StringTokenizer(dirValue, ",");
            while (st.hasMoreTokens()) {
                String dirName = st.nextToken().trim();
                addWars(dirName);
                autoDirs.add(dirName);
            }
        }
        // Build autoload directories
        File oFile;
        Iterator it = autoDirs.iterator();
        while (it.hasNext()) {
            String dirName = (String) it.next();
            try {
                oFile = new File(WEBAPPS_DIR, dirName);
                if (!oFile.exists()) {
                    oFile = new File(dirName);
                }
                if (oFile.exists()) {
                    autoloadDirectories.add(oFile.getCanonicalPath());
                }
            } catch (Exception e) {
                String err = "Error when trying to verify Webapps autoload directory : " + dirName;
                logger.log(BasicLevel.ERROR, err + " " + e.getMessage());
            }
        }

        //Init the naming manager
        try {
            naming = NamingManager.getInstance();
        } catch (NamingException e) {
            throw new ServiceException("Error when getting the reference to the Naming manager");
        }

        JProp jp = null;
        try {
            jp = JProp.getInstance();
        } catch (Exception e) {
            String err = "Error when trying to get jonas name ";
            logger.log(BasicLevel.ERROR, err + " " + e.getMessage());
            throw new ServiceException(err, e);
        }
        AbsJWebContainerServiceImpl.nameOfServer = jp.getValue("jonas.name", "jonas");

    }

    protected void doStart() throws ServiceException {
        // Deploy all wars which are in descriptors section
        for (Enumeration e = warNames.elements(); e.hasMoreElements();) {
            String fileName = (String) e.nextElement();

            URL warURL = checkWarFile(fileName);

            Context contctx = null;
            try {
                contctx = new CompNamingContext(fileName);
                contctx.rebind("warURL", warURL);
                // No context root to rebind because not in ear case.
                // => no rebind("contextRoot", ...)
            } catch (NamingException ne) {
                String err = "Cannot start the WebContainerService";
                throw new ServiceException(err, ne);
            }
            try {
                registerWar(contctx);
            } catch (JWebContainerServiceException jwcse) {
                String err = "Cannot deploy the file '" + warURL + "' : " + jwcse.getMessage();
                logger.log(BasicLevel.WARN, err);
            }
        }

        try {
            // Register JWebContainerService MBean :
            // JWebContainerServiceImplMBean
            if (mbeanServer != null) {
                mbeanServer.registerMBean(this, JonasObjectName.webContainerService());
            }
        } catch (InstanceAlreadyExistsException iae) {
            String err = "Cannot start the WebContainerService Already Exists";
            throw new ServiceException(err, iae);
        } catch (MBeanRegistrationException mbre) {
            throw new ServiceException("Cannot start the WebContainerService (MBean registration error)", mbre);
        } catch (NotCompliantMBeanException ncmbe) {
            throw new ServiceException("Cannot start the WebContainerService (MBean Not compliant error)", ncmbe);
        }
    }

    protected void doStop() throws ServiceException {

        // Get all the deployed war which are not in an ear application file
        // and undeploy them.
        Enumeration wars = warDeployed.elements();
        while (wars.hasMoreElements()) {
            War war = (War) wars.nextElement();
            URL warURL = war.getWarURL();
            String fileName = warURL.getFile();
            try {
                // Test if the war is in an ear application.
                if (!war.isInEarCase()) {
                    Context ctx = new CompNamingContext(fileName);
                    ctx.rebind("warURL", warURL);
                    ctx.rebind("isEarCase", new Boolean(false));
                    unRegisterWar(ctx);
                }
            } catch (Exception e) {
                //We don't stop the process of undeploying the wars.
                //We only display an error in the logger.
                String err = "Error when undeploying the war :" + fileName;
                logger.log(BasicLevel.ERROR, err + e.getMessage());
            }
        }

        if (mbeanServer != null) {
            try {
                // unregister AbsJWebContainerServiceImpl MBean
                mbeanServer.unregisterMBean(JonasObjectName.webContainerService());
            } catch (Exception e) {
                logger.log(BasicLevel.ERROR, "Cannot stop the WebContainerService: " + e);
            }
        }
        logger.log(BasicLevel.DEBUG, "WebContainerService stopped");
    }

    protected abstract void doRegisterWar(Context ctx) throws JWebContainerServiceException;

    protected abstract void doUnRegisterWar(Context ctx) throws JWebContainerServiceException;

    protected URL getUnpackDir(URL warURL, String earAppName) throws JWebContainerServiceException {

        String destDir = WORK_WEBAPPS_DIR + File.separator + nameOfServer + File.separator;

        // Two cases :
        // war is alone --> unpack it in :
        //   WEBAPPS_DIR/servername/filename_without_extension_dir/
        // war come from an ear --> unpack it in :
        //   WEBAPPS_DIR/servername/ear_AppName/filename_without_extension_dir/

        // location of unpacked War
        URL unpackedWarURL = null;

        String fileName = warURL.getFile();

        // War file
        if (new File(fileName).isFile()) {
            // Note : if the war is alone, earAppName is null.
            // ear case
            if (earAppName != null) {
                destDir += earAppName + File.separator;
            }

            String fTemp = new File(fileName).getName();
            destDir += fTemp.substring(0, fTemp.length() - WAR_EXTENSION_LENGTH);

            // Unpack the war into a directory
            JarTools.unpack(fileName, destDir);
        } else {
            // Directory (No unpack)
            destDir = fileName;
        }

        try {
            unpackedWarURL = new File(destDir).toURL();
        } catch (MalformedURLException mue) {
            throw new JWebContainerServiceException("Error", mue);
        }

        return unpackedWarURL;

    }

    public URLClassLoader getClassLoader(URL warURL, String earAppName, ClassLoader parentLoader)
            throws JWebContainerServiceException {

        URLClassLoader loaderForCls = null;
        try {
            WebLoaderHolder holder = (WebLoaderHolder) warLoaders.get(warURL);
            if (holder != null) {
                loaderForCls = holder.getJonasWebLoader();
            }
        } catch (Exception e) {
            throw new JWebContainerServiceException("Error when getting '" + warURL + "' in cache", e);
        }

        if (loaderForCls == null) {
            // the war is not already used

            // Use the unpacked directory
            URL unpackedWarURL = getUnpackDir(warURL, earAppName);

            try {
                if (parentLoader != null) {
                    // ear case.
                    loaderForCls = new WebappClassLoader(unpackedWarURL, parentLoader);
                } else {
                    //Case of non-ear application : only a single war
                    loaderForCls = new WebappClassLoader(unpackedWarURL, appsClassLoader);
                }
            } catch (IOException ioe) {
                throw new JWebContainerServiceException(
                        "Cannot create WebAppClassLoader from '" + unpackedWarURL + "'", ioe);
            }

            // add the class loader in cache.
            try {
                WebLoaderHolder holder = new WebLoaderHolder(loaderForCls, null);
                warLoaders.put(warURL, holder);
            } catch (Exception e) {
                throw new JWebContainerServiceException("Error when adding '" + warURL + "' in cache", e);
            }
        }

        return loaderForCls;

    }

    public ClassLoader getContextLinkedClassLoader(URL warURL) {
        WebLoaderHolder holder = (WebLoaderHolder) warLoaders.get(warURL);
        if (holder != null) {
            return holder.getEnvWebLoader();
        }
        return null;
    }

    private void registerWar(Context ctx) throws JWebContainerServiceException {
        // There are 6 possible parameters :
        //   - warURL is the URL of the war to deploy (required param).
        //   - parentClassLoader is the parent classloader of
        //     the web classloader (optional param).
        //   - earClassLoader is the ear classloader (optional param).
        //   - earURL is the URL of the ear (optional parameter :
        //     if earURL is set it means that we are in the ear case, else it
        //     means that we are in the non ear case).
        //   - altDD is the optional deployment descriptor (optional param).
        //   - contextRoot is the context root for the Web application
        //     (optional param).

        // Get the URL of the ear application file in the case of an
        // ear application, null otherwise.
        URL earURL = null;
        String contextRoot = null;
        String earAppName = null;
        try {
            earURL = (URL) ctx.lookup("earURL");
            contextRoot = (String) ctx.lookup("contextRoot");
            earAppName = EarServiceImpl.buildJ2eeApplicationName(earURL);
        } catch (NamingException e) {
            if (earURL != null || contextRoot != null) {
                String err = "Error while getting parameter from context param :" + e.getMessage();
                logger.log(BasicLevel.ERROR, err);
                throw new JWebContainerServiceException(err, e);
            } // else nothing to do : non-ear case.
        }

        // Get the URL of the war to deploy ...
        URL warURL = null;
        try {
            warURL = (URL) ctx.lookup("warURL");
        } catch (NamingException e) {
            String err = "Error while getting parameter from context param :" + e.getMessage();
            logger.log(BasicLevel.ERROR, err);
            throw new JWebContainerServiceException(err, e);
        }

        // ... and check if the war to deploy exists.
        File warFile = new File(warURL.getFile());
        if (!warFile.exists()) {
            String err = "registerWar: '" + warFile.getPath() + "' not found";
            logger.log(BasicLevel.ERROR, err);
            throw new JWebContainerServiceException(err);
        }

        // Check if the war to deploy is not already deployed.
        War war = getWar(warURL);
        if (war != null) {
            // The war is already deployed.
            String err = "Cannot deploy war '" + warURL.getFile() + "' is already deployed."
                    + " You must undeploy the war before a new deployment.";
            throw new JWebContainerServiceException(err);
        }

        URLClassLoader parentLoader = null;
        URLClassLoader earClassLoader = null;
        try {
            parentLoader = (URLClassLoader) ctx.lookup("parentClassLoader");
            earClassLoader = (URLClassLoader) ctx.lookup("earClassLoader");
        } catch (NamingException ne) {
            logger.log(BasicLevel.DEBUG, "Not an ear case");
            // exception occurs when the earClassLoader is not found.
        }

        // get the war class loader.
        URLClassLoader loaderForCls = getClassLoader(warURL, earAppName, parentLoader);

        // get the directory where the war have been unpacked
        URL unpackedWarURL = getUnpackDir(warURL, earAppName);

        // Only if the WebServicesService is started
        // And in non EAR case
        if (wsService != null && earClassLoader == null) {
            try {
                CompNamingContext contctx = null;
                try {
                    contctx = new CompNamingContext(unpackedWarURL.getFile());
                    contctx.rebind("unpackDir", unpackedWarURL.toExternalForm());
                    contctx.rebind("jarUrls", new URL[0]);
                    contctx.rebind("warUrls", new URL[] {warURL});
                    if (parentLoader != null) {
                        contctx.rebind("ejbClassLoader", parentLoader);
                    }
                } catch (NamingException e) {
                    String err = "Can not bind params for the WebServices service, "
                            + "Can't deploy Web Services Endpoint";
                    throw new JWebContainerServiceException(err, e);
                }
                wsService.deployWebServices(contctx);
            } catch (ServiceException se) {
                String err = "Error during the deployment of the WebServices of the War file '" + warURL + "'";
                logger.log(BasicLevel.ERROR, err + " : " + se.getMessage());
                throw new JWebContainerServiceException(err, se);
            }
        }

        // Get the deployment descriptor from file
        WebContainerDeploymentDesc webDD = null;
        try {
            webDD = WebManagerWrapper.getDeploymentDesc(warURL, loaderForCls, earClassLoader);
        } catch (WebContainerDeploymentDescException e) {
            String err = "Cannot read the deployment descriptors '" + warURL.getFile() + "'";
            logger.log(BasicLevel.ERROR, err + ": " + e);
            e.printStackTrace(System.err);
            throw new JWebContainerServiceException(err, e);
        }

        // Populate the java:comp/env (ENC) environment.
        URLClassLoader webClassLoader = null;
        try {
            logger.log(BasicLevel.DEBUG, "Populating environment of the file " + warURL.getFile());
            Context ctxParam = new CompNamingContext(unpackedWarURL.getFile());
            ctxParam.rebind("DeploymentDesc", webDD);
            ctxParam.rebind("warName", unpackedWarURL.getFile());
            if (parentLoader == null) {
                webClassLoader = new SimpleWebappClassLoader(unpackedWarURL, appsClassLoader);
            } else {
                webClassLoader = new SimpleWebappClassLoader(unpackedWarURL, parentLoader);
            }
            ctxParam.rebind("parentCL", webClassLoader);
            // Do the populating of the java:comp/env (ENC) environment.
            setWebEnvironment(ctxParam);
        } catch (Exception e) {
            //populating environment failed.
            String err = "Error when populating ";
            logger.log(BasicLevel.ERROR, err + e.getMessage());
            throw new JWebContainerServiceException(err, e);
        }

        // TODO maybe to be removed ?
        WebLoaderHolder holder = (WebLoaderHolder) warLoaders.get(warURL);
        holder.setEnvWebLoader(webClassLoader);

        // Set the right context root for the web application, the priority is
        // the following :
        //    1 - context-root of application.xml
        //    2 - context-root of jonas-web.xml
        //    3 - context-root is the name of the file without .war.
        if (earClassLoader == null && contextRoot == null) {
            String cRoot = webDD.getContextRoot();
            if (cRoot == null) {
                String file = new File(unpackedWarURL.getFile()).getName();
                if (file.toLowerCase().endsWith(".war")) {
                    contextRoot = file.substring(0, file.length() - WAR_EXTENSION_LENGTH);
                } else {
                    //It's a directory which is deployed
                    contextRoot = file.substring(0, file.length());
                }
            } else {
                contextRoot = cRoot;
            }
        }

        // Set the name of the host where to deploy the war if it is
        // specified in the jonas-web.xml.
        String hostName = webDD.getHost();

        // Check if the context to deploy is not already deployed.
        List deployedWars = getWar(contextRoot);
        for (Iterator itDeployed = deployedWars.iterator(); itDeployed.hasNext();) {
            War deployedWar = (War) itDeployed.next();
            String hostDeployed = deployedWar.getHostName();
            if ((hostDeployed == null && hostName == null) || (hostDeployed != null && hostDeployed.equals(hostName))) {
                // The war is already deployed.
                String err = "Cannot deploy war '" + warURL.getFile() + "' is already deployed with the context '"
                        + contextRoot + "'." + " You must undeploy the war before a new deployment.";
                throw new JWebContainerServiceException(err);
            }
        }

        // Context classloader must follow the java2 delegation model ?
        boolean java2DelegationModel = webDD.getJava2DelegationModel();

        // Create War
        war = new War(warURL, earURL, hostName, contextRoot, java2DelegationModel, webDD.getXmlContent(), webDD
                .getJOnASXmlContent(), webDD.getServletsName());

        // Configure JACC
        PermissionManager permissionManager = null;
        try {
            permissionManager = new PermissionManager(webDD, war.getContextId());
            permissionManager.translateServletDeploymentDescriptor();
            // if not in ear case, commit the policy configuration, else it is done
            // by EAR service after linking all policy configuration objects
            if (earClassLoader == null) {
                permissionManager.commit();
            }
        } catch (Exception e) {
            e.printStackTrace();
            String err = "Cannot build permission manager object for the webapp '" + unpackedWarURL + "' : ";
            logger.log(BasicLevel.ERROR, err + e.getMessage());
            throw new JWebContainerServiceException(err, e);
        }

        // Configure the context to give to doRegisterWar ...
        Context ctxParam = null;
        try {
            ctxParam = new CompNamingContext(unpackedWarURL.getFile());
            ctxParam.rebind("warURL", warURL);
            if (earURL != null) {
                ctxParam.rebind("earURL", earURL);
            }
            ctxParam.rebind("unpackedWarURL", unpackedWarURL);
            ctxParam.rebind("parentCL", webClassLoader);
            if (hostName != null) {
                ctxParam.rebind("hostName", hostName);
            }
            ctxParam.rebind("contextRoot", contextRoot);
            if (earAppName != null) {
                ctxParam.rebind("earAppName", earAppName);
            }
            ctxParam.rebind("jonasDD", webDD.getJOnASXmlContent());
            ctxParam.rebind("java2DelegationModel", new Boolean(java2DelegationModel));
            ctxParam.rebind("permissionManager", permissionManager);
        } catch (NamingException e) {
            String err = "Error when deploying the war  '" + unpackedWarURL.getFile() + "'";
            logger.log(BasicLevel.ERROR, err + e.getMessage());
            throw new JWebContainerServiceException(err, e);
        }

        war.setPermissionManager(permissionManager);

        // ... and delegate the registration of the war to the wrapper.
        doRegisterWar(ctxParam);

        // Finaly indicates that the war is deployed.
        warDeployed.addElement(war);
        warBindings.put(warURL, webClassLoader);

        try {
            // Register Ear MBean : EarMBean
            if (mbeanServer != null) {
                mbeanServer.registerMBean(war, JonasObjectName.war(warURL.getFile()));
            }
        } catch (Exception ware) {
            logger.log(BasicLevel.ERROR, "Can not register the MBean for the war" + unpackedWarURL + " :"
                    + ware.getMessage());
        }

        // Complete the Deployment of the WebServices
        // Only if the WebServicesService is started
        // And in non EAR case
        if (wsService != null && earClassLoader == null) {
            try {
                CompNamingContext contctx = null;
                try {
                    contctx = new CompNamingContext(unpackedWarURL.getFile());
                    contctx.rebind(AbsWebServicesServiceImpl.CLASSLOADER_CTX_PARAM, loaderForCls);
                } catch (NamingException e) {
                    String err = "Can not bind params for the WebServices service, "
                            + "can't complete deployment of Web Services Endpoints";
                    throw new JWebContainerServiceException(err, e);
                }
                wsService.completeWSDeployment(contctx);
            } catch (ServiceException se) {
                String err = "Error during the deployment of the WebServices of the War file '" + warURL + "'";
                logger.log(BasicLevel.ERROR, err + " : " + se.getMessage());
                throw new JWebContainerServiceException(err, se);
            }
        }

        StringBuffer txtInfo = new StringBuffer("War " + warURL.getFile() + " available at the context ");
        if (!contextRoot.startsWith("/")) {
            txtInfo.append("/");
        }
        txtInfo.append(contextRoot);

        if (hostName != null) {
            txtInfo.append(" on the host ");
            txtInfo.append(hostName);
        }
        txtInfo.append(".");
        logger.log(BasicLevel.INFO, txtInfo.toString());

        // Remove the DD cache (WebServices)
        if (wsService != null && earClassLoader == null) {
            wsService.removeCache(loaderForCls);
        }
    }

    public void registerWarMBean(String fileName) throws RemoteException, JWebContainerServiceException {
        // convert the file name to the appropriate url and check if the file
        // exists.
        URL warURL = checkWarFile(fileName);

        // create the context to call the registerWar method.
        Context ctx = null;
        try {
            ctx = new CompNamingContext(fileName);
            ctx.rebind("warURL", warURL);
        } catch (NamingException e) {
            String err = "Error when deploying the war  '" + fileName + "'";
            logger.log(BasicLevel.ERROR, err + e.getMessage());
            throw new JWebContainerServiceException(err, e);
        }

        // call the registerWar method.
        registerWar(ctx);
    }

    private void setWebEnvironment(Context ctxParam) throws JWebContainerServiceException {

        WebContainerDeploymentDesc dd = null;
        String warName = null;
        ClassLoader parentClassLoader = null;

        /*
         * get the parameters - Deployment desc of xml - Name of the war -
         * Parent Class loader
         */
        try {
            dd = (WebContainerDeploymentDesc) ctxParam.lookup("DeploymentDesc");
            warName = (String) ctxParam.lookup("warName");
        } catch (NamingException e) {
            String err = "Error while getting parameter from context param ";
            logger.log(BasicLevel.ERROR, err + e.getMessage());
            throw new JWebContainerServiceException(err, e);
        }

        //Get the parentCL
        try {
            parentClassLoader = (ClassLoader) ctxParam.lookup("parentCL");
        } catch (NamingException e) {
            String err = "Error while getting parameter from context param ";
            logger.log(BasicLevel.ERROR, err + e.getMessage());
            throw new JWebContainerServiceException(err, e);
        }

        //Create the java:comp/env entry and bind the entries
        try {
            // Create a JNDI context for this war java:comp/env
            Context javaCtx = naming.createEnvironmentContext(warName);
            naming.setComponentContext(javaCtx, parentClassLoader);
            Context envCtx = javaCtx.createSubcontext("comp/env");

            // War Environment entries
            EnvEntryDesc[] envt = dd.getEnvEntryDesc();
            for (int i = 0; i < envt.length; i++) {
                // get information in descriptor
                String name = envt[i].getName();
                Object obj = envt[i].getValue();

                // register object in JNDI
                logger.log(BasicLevel.DEBUG, warName + ": Binding object " + name + " -> " + obj);
                envCtx.rebind(name, obj);
            }

            // Resource References
            ResourceRefDesc[] resref = dd.getResourceRefDesc();
            for (int i = 0; i < resref.length; i++) {
                // get information in descriptor
                String name = resref[i].getName();
                String type = resref[i].getTypeName();
                String resname = resref[i].getJndiName();
                // register object in JNDI
                logger.log(BasicLevel.DEBUG, warName + ": Linking resource " + name + " -> " + resname);

                if (type.equalsIgnoreCase("java.net.URL")) {
                    // Specify the factory to use with the right URL
                    Reference ref = new Reference("java.net.URL", "org.objectweb.jonas_lib.naming.factory.URLFactory",
                            null);
                    StringRefAddr refAddr = new StringRefAddr("url", resname);
                    ref.add(refAddr);
                    envCtx.rebind(name, ref);
                } else {
                    // build the LinkRef that will be registered:
                    // FactoryClassName = null, size = 1, refAddr = resname.
                    LinkRef lref = new LinkRef(resname);
                    envCtx.rebind(name, lref);
                }
            }

            // Resource Environment References
            ResourceEnvRefDesc[] resEnvref = dd.getResourceEnvRefDesc();
            for (int i = 0; i < resEnvref.length; i++) {
                // get information in descriptor
                String name = resEnvref[i].getName();
                String resname = resEnvref[i].getJndiName();
                LinkRef lref = new LinkRef(resname);

                logger.log(BasicLevel.DEBUG, warName + ": Linking resource environment " + name + " -> " + resname);
                envCtx.rebind(name, lref);
            }

            // EJB References
            EjbRefDesc[] ejbref = dd.getEjbRefDesc();
            for (int i = 0; i < ejbref.length; i++) {
                // get information in descriptor
                String name = ejbref[i].getEjbRefName();
                String ejbname = null;
                ejbname = ejbref[i].getJndiName();

                LinkRef lref = new LinkRef(ejbname);

                logger.log(BasicLevel.DEBUG, warName + ": Linking ejb " + name + " -> " + ejbname);
                envCtx.rebind(name, lref);
            }

            // EJB Local Refs
            // We use here ejb-link tag. This should be used also for
            // ejb-ref when we are able to manage references to
            // another jar file.
            EjbLocalRefDesc[] ejblocalref = dd.getEjbLocalRefDesc();
            for (int i = 0; i < ejblocalref.length; i++) {
                String name = ejblocalref[i].getEjbRefName();
                String ejbname = ejblocalref[i].getJndiLocalName();
                LinkRef lref = new LinkRef(ejbname);
                logger.log(BasicLevel.DEBUG, warName + ": Linking ejb " + name + " -> " + ejbname);
                envCtx.rebind(name, lref);
            }

            // Message Destination References
            MessageDestinationRefDesc[] mdref = dd.getMessageDestinationRefDesc();
            for (int i = 0; i < mdref.length; i++) {
                // get information in descriptor
                String name = mdref[i].getMessageDestinationRefName();
                String mdname = null;
                mdname = mdref[i].getJndiName();

                LinkRef lref = new LinkRef(mdname);

                logger.log(BasicLevel.DEBUG, warName + ": Linking message-destination " + name + " -> " + mdname);
                envCtx.rebind(name, lref);
            }

            // Service Ref
            // We bind a Reference when full configuration is provided
            // Otherwise we bind only a LinkRef in JNDI

            // get the JServiceFactory
            JServiceFactory factory = null;

            ServiceRefDesc[] serviceRefs = dd.getServiceRefDesc();
            for (int i = 0; i < serviceRefs.length; i++) {
                
                if (factory == null) {
                    factory = JServiceFactoryFinder.getJOnASServiceFactory();
                }
                
                // Create the Service from the ServiceRef description
                String name = serviceRefs[i].getServiceRefName();
                // create a full Reference
                Reference ref = factory.getServiceReference(serviceRefs[i], parentClassLoader);
                envCtx.rebind(name, ref);
                logger.log(BasicLevel.DEBUG, "Adding service-ref 'java:comp/env/" + name + "'");
            }

        } catch (NamingException e) {
            String err = "Error while populating environment of the war file " + warName;
            logger.log(BasicLevel.ERROR, err + "  :" + e.getMessage());
            throw new JWebContainerServiceException(err, e);
        }
    }

    private void unRegisterWar(Context ctx) throws JWebContainerServiceException {

        // Gets the 2 parameters :
        // warURL, isEarCase, hostName and contextRoot.
        URL warURL = null;
        boolean isEarCase = true;
        try {
            warURL = (URL) ctx.lookup("warURL");
            isEarCase = ((Boolean) ctx.lookup("isEarCase")).booleanValue();
        } catch (NamingException e) {
            String err = "Error while getting parameter from context param.";
            logger.log(BasicLevel.ERROR, err + e.getMessage());
            throw new JWebContainerServiceException(err, e);
        }

        // get the file name for displaying message.
        String fileName = warURL.getFile();

        // Check if the war is deployed.
        War war = null;
        war = getWar(warURL);
        if (war == null) {
            String err = "Cannot undeploy war: '" + fileName + "' is not deployed.";
            logger.log(BasicLevel.ERROR, err);
            throw new JWebContainerServiceException(err);
        }

        // Check if the war can be undeployed (2 case authorized) :
        //    - case EAR and war is in an EAR.
        //    - case non EAR and war isn't in an EAR.
        if (isEarCase != war.isInEarCase()) {
            String err = "Cannot undeploy war: '" + fileName
                    + "' it is in an ear application. You must undeploy the ear associated.";
            logger.log(BasicLevel.ERROR, err);
            throw new JWebContainerServiceException(err);
        }

        // Call the specific method of the implementation of the web container.
        try {
            //ctx.rebind("hostName", war.getHostName());
            ctx.rebind("contextRoot", war.getContextRoot());
            ctx.rebind("webClassLoader", warBindings.get(warURL));
        } catch (NamingException e) {
            String err = "Error when undeploying the war  '" + fileName + "'";
            logger.log(BasicLevel.ERROR, err + e.getMessage());
            throw new JWebContainerServiceException(err, e);
        }

        // Remove permission manager
        PermissionManager permissionManager = war.getPermissionManager();
        try {
            permissionManager.delete();
            permissionManager = null;
        } catch (PermissionManagerException pme) {
            logger.log(BasicLevel.ERROR, "Cannot remove permission manager for file '" + fileName + "'.", pme);
        }

        doUnRegisterWar(ctx);

        // Remove the context.
        URLClassLoader loader = (URLClassLoader) warBindings.remove(warURL);
        naming.unSetComponentContext(loader);

        // Remove classloader
        warLoaders.remove(warURL);

        // Indicates that the war is not in the deployed war.
        // (here we are sure that the war is not null and isn't in an ear).
        warDeployed.removeElement(war);

        //unregister mbean
        if (mbeanServer != null) {
            try {
                // unregister Ear MBean : EarMBean
                mbeanServer.unregisterMBean(JonasObjectName.war(fileName));
            } catch (Exception e) {
                logger
                        .log(BasicLevel.ERROR, "Cannot remove the MBean for the war " + fileName + " : "
                                + e.getMessage());
            }
        }

        logger.log(BasicLevel.INFO, "War " + fileName + " no longer available");
    }

    public void unRegisterWarMBean(String fileName) throws RemoteException, JWebContainerServiceException {

        // Convert the given file name to an url and check if the war is
        // deployed ...
        URL warURL = checkWarDeployed(fileName);

        // ... and do the undeployment.
        Context ctx = null;
        try {
            ctx = new CompNamingContext(fileName);
            ctx.rebind("warURL", warURL);
            ctx.rebind("isEarCase", new Boolean(false));
        } catch (NamingException e) {
            String err = "Error when undeploying the war file '" + fileName + "'";
            logger.log(BasicLevel.ERROR, err + e.getMessage());
            throw new JWebContainerServiceException(err, e);
        }
        unRegisterWar(ctx);
    }

    public void deployWars(Context ctx) throws JWebContainerServiceException {
        // Gets the parameters from the context :
        //    - urls the list of the urls of the wars to deploy.
        //    - earURL the URL of the ear application file.
        //    - parentClassLoader the parent classLoader of the wars.
        //    - earClassLoader the ear classLoader of the j2ee app.
        //    - altDDs the optional URI of deployment descriptor.
        //    - contextRoots the optional context root of the wars.
        URL[] urls = null;
        URL earURL = null;
        ClassLoader parentClassLoader = null;
        ClassLoader earClassLoader = null;
        URL[] altDDs = null;
        String[] contextRoots = null;
        try {
            urls = (URL[]) ctx.lookup("urls");
            earURL = (URL) ctx.lookup("earURL");
            parentClassLoader = (ClassLoader) ctx.lookup("parentClassLoader");
            earClassLoader = (ClassLoader) ctx.lookup("earClassLoader");
            altDDs = (URL[]) ctx.lookup("altDDs");
            contextRoots = (String[]) ctx.lookup("contextRoots");
        } catch (NamingException e) {
            String err = "Error while getting parameter from context param ";
            logger.log(BasicLevel.ERROR, err + e.getMessage());
            throw new JWebContainerServiceException(err, e);
        }
        //webDDManager.setAltDD(earClassLoader, urls, altDDs);

        // Deploy all the wars of the ear application.
        for (int i = 0; i < urls.length; i++) {
            // Get the name of a war to deploy.
            String fileName = urls[i].getFile();
            logger.log(BasicLevel.DEBUG, "Deploy war '" + fileName + "' for the ear service");

            // The context to give for the creation of the container
            // associated to the ejb-jar.
            Context contctx = null;
            try {
                contctx = new CompNamingContext(fileName);
                contctx.rebind("warURL", urls[i]);
                contctx.rebind("parentClassLoader", parentClassLoader);
                contctx.rebind("earClassLoader", earClassLoader);
                contctx.rebind("earURL", earURL);
                if (altDDs[i] != null) {
                    contctx.rebind("altDD", altDDs[i]);
                }
                if (contextRoots[i] != null) {
                    contctx.rebind("contextRoot", contextRoots[i]);
                }
                registerWar(contctx);
            } catch (Exception e) {
                // A war is corrupted so undeploy all the deployed war
                // of the ear application.
                logger.log(BasicLevel.ERROR, "Error when deploying '" + fileName + "'");
                logger.log(BasicLevel.ERROR, e.getMessage());
                logger.log(BasicLevel.ERROR, "Undeploy war of the ear application");

                for (int j = 0; j < i; j++) {
                    String warFileName = urls[j].getFile();
                    try {
                        // Try to undeploy a war of the ear application.
                        CompNamingContext context = new CompNamingContext(warFileName);
                        context.rebind("warURL", urls[j]);
                        context.rebind("isEarCase", new Boolean(true));
                        unRegisterWar(context);
                    } catch (Exception ex) {
                        // Cannot undeploy a war of the ear application
                        // So there is an error message.
                        logger.log(BasicLevel.ERROR, "Error when undeploying '" + warFileName + "'");
                        logger.log(BasicLevel.ERROR, ex.getMessage());
                        logger.log(BasicLevel.ERROR, "Cannot undeploy war of the ear application");
                    }

                }
                throw new JWebContainerServiceException("Error during the deployment", e);
            }
        }
    }

    public void unDeployWars(URL[] urls) {
        for (int i = 0; i < urls.length; i++) {
            String warFileName = urls[i].getFile();
            try {
                // Try to undeploy a war of the ear application.
                CompNamingContext context = new CompNamingContext(warFileName);
                context.rebind("warURL", urls[i]);
                context.rebind("isEarCase", new Boolean(true));
                unRegisterWar(context);
            } catch (Exception ex) {
                // Cannot undeploy a war of the ear application
                // So there is an error message.
                logger.log(BasicLevel.ERROR, "Error when undeploying '" + warFileName + "'");
                logger.log(BasicLevel.ERROR, ex.getMessage());
                logger.log(BasicLevel.ERROR, "Cannot undeploy war of the ear application");
            }
        }
    }

    public War getWar(URL url) {
        Enumeration wars = warDeployed.elements();
        while (wars.hasMoreElements()) {
            War war = (War) wars.nextElement();
            if (war.getWarURL().equals(url)) {
                return war;
            }
        }
        return null;
    }

    private List getWar(String pContext) {
        List checkDeployed = new ArrayList();
        Enumeration wars = warDeployed.elements();
        while (wars.hasMoreElements()) {
            War war = (War) wars.nextElement();
            if (war.getContextRoot().equals(pContext)) {
                checkDeployed.add(war);
            }
        }
        return checkDeployed;
    }

    public void removeCache(ClassLoader earClassLoader) {
        WebManagerWrapper.removeCache(earClassLoader);
    }

    private URL checkWarFile(String fileName) throws JWebContainerServiceException {

        File f = null;
        try {
            f = new File(fileName).getCanonicalFile();
            if (!f.exists()) {
                boolean found = false;
                String warFileName = null;
                // Check also in JONAS_BASE/webapps directory
                warFileName = WEBAPPS_DIR + File.separator + fileName;
                f = new File(warFileName).getCanonicalFile();
                found = f.exists();
                if (found) {
                    fileName = f.getPath();
                } else {
                    String err = "File '" + f.getPath() + "' not found";
                    logger.log(BasicLevel.ERROR, err);
                    throw new JWebContainerServiceException(err);
                }
            }
        } catch (IOException e) {
            String err = "Invalid war file name '" + fileName;
            logger.log(BasicLevel.ERROR, err);
            throw new JWebContainerServiceException(err, e);
        }

        URL warURL = null;
        try {
            warURL = f.toURL();
        } catch (MalformedURLException e) {
            String err = "Invalid war file name '" + fileName + "'.";
            logger.log(BasicLevel.ERROR, err + e.getMessage());
            throw new JWebContainerServiceException(err, e);
        }
        return warURL;
    }

    private URL checkWarDeployed(String fileName) throws JWebContainerServiceException {

        URL url = null;
        try {
            Enumeration wars = warDeployed.elements();
            while (wars.hasMoreElements()) {
                War war = (War) wars.nextElement();
                url = (new File(fileName).getCanonicalFile()).toURL();
                if (war.getWarURL().equals(url)) {
                    return url;
                }
            }
            String warFileName = WEBAPPS_DIR + File.separator + fileName;
            wars = warDeployed.elements();
            while (wars.hasMoreElements()) {
                War war = (War) wars.nextElement();
                url = (new File(warFileName).getCanonicalFile()).toURL();
                if (war.getWarURL().equals(url)) {
                    return url;
                }
            }

            String err = "Cannot undeploy war: '" + fileName + "' is not deployed.";
            logger.log(BasicLevel.ERROR, err);
            throw new JWebContainerServiceException(err);

        } catch (MalformedURLException e) {
            String err = "Invalid war file name '" + fileName + "'.";
            logger.log(BasicLevel.ERROR, err + e.getMessage());
            throw new JWebContainerServiceException(err, e);
        } catch (IOException e) {
            String err = "Invalid war file name '" + fileName;
            logger.log(BasicLevel.ERROR, err);
            throw new JWebContainerServiceException(err, e);
        }
    }

    public Integer getCurrentNumberOfWars() {
        return new Integer(warDeployed.size());
    }

    public List getInstalledWars() throws Exception {
        // get WAR files found in JONAS_BASE/webapps
        ArrayList al = JModule.getInstalledContainersInDir(WEBAPPS_DIR, JModule.WAR_EXTENSION, JModule.WAR_CHILD_DIR,
                JModule.WAR_CONFIRM_FILE);
        // get WAR files found in all autoload directories
        for (Iterator it = autoloadDirectories.iterator(); it.hasNext();) {
            al.addAll(JModule.getInstalledContainersInDir((String) it.next(), JModule.WAR_EXTENSION,
                    JModule.WAR_CHILD_DIR, JModule.WAR_CONFIRM_FILE));
        }
        return al;
    }

    public Set getWarNames() {
        HashSet names = new HashSet();
        for (Enumeration wars = warDeployed.elements(); wars.hasMoreElements();) {
            War war = (War) wars.nextElement();
            URL warURL = war.getWarURL();
            names.add(warURL.getFile());
        }
        return names;
    }

    private void addWars(String dirPath) {
        boolean found = false;

        // Look the directory relative to where the JOnAS server is launch or
        // if the path is absolute.
        File dir = new File(dirPath);
        found = dir.isDirectory();

        if (!found) {
            // Look the directory relative to the $WEBAPPS_DIR directory
            dir = new File(WEBAPPS_DIR + File.separator + dirPath);
            found = dir.isDirectory();
        }

        if (found) {
            addWarsFrom(dir);
        } else {
            String err = "Warning: Cannot load dir: '" + dirPath + "' ";
            err += "is not a directory or directory doesn't exist";
            logger.log(BasicLevel.WARN, err);
        }
    }

    private void addWarsFrom(File dir) throws JWebContainerServiceException {
        try {
            if (dir.isDirectory()) {
                File[] files = dir.listFiles();
                for (int i = 0; i < files.length; i++) {
                    if (files[i].isFile()) {
                        if (files[i].getPath().toLowerCase().endsWith(".war")) {
                            // War file
                            warNames.add(files[i].getCanonicalPath());
                        }
                    } else {
                        // Directory webapp
                        warNames.add(files[i].getCanonicalPath());
                    }
                }
            }
        } catch (IOException e) {
            String err = "Invalid file name '" + dir.getPath();
            logger.log(BasicLevel.ERROR, err);
            throw new JWebContainerServiceException(err, e);
        }
    }

    public boolean isWarLoaded(String fileName) {

        URL url = null;
        boolean isLoaded = false;
        try {
            // Absolute filename
            try {
                url = new File(fileName).getCanonicalFile().toURL();
                //Check if the war is already deployed or not
                if (getWar(url) != null) {
                    isLoaded = true;
                } else {
                    // Not found force to test in relative Webapps directory
                    url = null;
                }
            } catch (Exception e) {
                url = null;
            }
            // Relative filename
            if (url == null) {
                url = new File(WEBAPPS_DIR + File.separator + fileName).getCanonicalFile().toURL();
                //Check if the war is already deployed or not
                if (getWar(url) != null) {
                    isLoaded = true;
                }
            }
        } catch (Exception e) {
            String err = "Can not found if the war is deployed or not";
            logger.log(BasicLevel.ERROR, err);
            return false;
        }

        return isLoaded;
    }

    public List getDeployedWars() {
        ArrayList al = new ArrayList();
        for (Enumeration wars = warDeployed.elements(); wars.hasMoreElements();) {
            War war = (War) wars.nextElement();
            URL warURL = war.getWarURL();
            al.add(warURL.getFile());
        }
        return al;
    }

    public List getDeployableWars() throws Exception {
        List al = getInstalledWars();
        al.removeAll(getDeployedWars());
        return al;
    }

    public List getAutoloadDirectories() {
        ArrayList al = new ArrayList();
        for (Iterator it = autoloadDirectories.iterator(); it.hasNext();) {
            try {
                al.add(new File((String) it.next()).toURL().getPath());
            } catch (Exception e) {
                logger.log(BasicLevel.DEBUG, "Can't get autoload directories " + e.getMessage());
                // none
            }
        }
        return al;
    }

    public String getWebappsDirectory() {
        String sRet = null;
        try {
            sRet = (new File(WEBAPPS_DIR)).toURL().getPath();
        } catch (Exception e) {
            logger.log(BasicLevel.DEBUG, "Can't get webapps directory " + e.getMessage());
            // none
        }
        return sRet;
    }

    public String getServerName() {
        if (serverName == null) {
            updateServerInfos();
        }
        return serverName;
    }

    public String getServerVersion() {
        if (serverVersion == null) {
            updateServerInfos();
        }
        return serverVersion;
    }

    protected abstract void updateServerInfos();

    public abstract String getDefaultHost() throws JWebContainerServiceException;

    public abstract String getDefaultHttpPort() throws JWebContainerServiceException;

    public abstract String getDefaultHttpsPort() throws JWebContainerServiceException;

    protected static Logger getLogger() {
        return logger;
    }

    protected ContainerNaming getNaming() {
        return naming;
    }

    protected MBeanServer getMbeanServer() {
        return mbeanServer;
    }

    protected void setServerName(String serverName) {
        this.serverName = serverName;
    }

    protected void setServerVersion(String serverVersion) {
        this.serverVersion = serverVersion;
    }

    public class WebLoaderHolder {

        private URLClassLoader jonasWebLoader;

        private ClassLoader envWebLoader;

        public WebLoaderHolder(URLClassLoader jonas, ClassLoader env) {
            jonasWebLoader = jonas;
            envWebLoader = env;
        }

        public URLClassLoader getJonasWebLoader() {
            return jonasWebLoader;
        }

        public ClassLoader getEnvWebLoader() {
            return envWebLoader;
        }

        public void setEnvWebLoader(ClassLoader envWebLoader) {
            this.envWebLoader = envWebLoader;
        }

        public void setJonasWebLoader(URLClassLoader jonasWebLoader) {
            this.jonasWebLoader = jonasWebLoader;
        }
    }

}

---