AbsWebServicesServiceImpl.java

package org.objectweb.jonas.ws;

import java.io.File;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.net.URLEncoder;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Stack;
import java.util.StringTokenizer;

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.naming.Reference;
import javax.naming.StringRefAddr;
import javax.xml.namespace.QName;

import org.objectweb.jonas_lib.I18n;
import org.objectweb.jonas_lib.loader.WebappClassLoader;
import org.objectweb.jonas_lib.naming.ContainerNaming;
import org.objectweb.jonas_lib.naming.factory.URLFactory;

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.JaxRpcPortComponentDesc;
import org.objectweb.jonas_ws.deployment.api.PortComponentDesc;
import org.objectweb.jonas_ws.deployment.api.SSBPortComponentDesc;
import org.objectweb.jonas_ws.deployment.api.ServiceDesc;
import org.objectweb.jonas_ws.deployment.api.WSDLFile;
import org.objectweb.jonas_ws.deployment.api.WSDeploymentDesc;
import org.objectweb.jonas_ws.deployment.api.WSDeploymentDescException;
import org.objectweb.jonas_ws.deployment.lib.wrapper.WSManagerWrapper;

import org.objectweb.jonas.common.JProp;
import org.objectweb.jonas.common.Log;
import org.objectweb.jonas.ear.EarServiceImpl;
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.JWebContainerService;
import org.objectweb.jonas.web.JWebContainerServiceException;
import org.objectweb.jonas.ws.handler.WSDLHandler;
import org.objectweb.jonas.ws.handler.WSDLHandlerFactory;

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

public abstract class AbsWebServicesServiceImpl extends AbsServiceImpl implements WebServicesService,
        AbsWebServicesServiceImplMBean {

    public static final String CLASSLOADER_CTX_PARAM = "classloader";

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

    public static final String WSDL_HANDLERS = "jonas.service.ws.wsdlhandlers";

    public static final String WS_BASE = "jonas.service.ws.";

    private static Logger logger = null;

    private static I18n i18n = I18n.getInstance(AbsWebServicesServiceImpl.class);

    private WSDLManager wsdlManager = null;

    private JWebContainerService webService = null;

    private Map deployments = null;

    protected void doInit(Context ctx) throws ServiceException {
        // Init the logger
        logger = Log.getLogger(Log.JONAS_WS_PREFIX);

        // Init variables
        deployments = new HashMap();

        // Set the XML parsing mode to no validation
        String parsingMode = "false";

        try {
            parsingMode = (String) ctx.lookup(PARSINGWITHVALIDATION);
        } catch (NamingException e) {
            // No problem if there is no value for 'parsingwithvalidation'
            // (false by default)
            parsingMode = "false";
        }

        WSManagerWrapper.setParsingWithValidation("true".equalsIgnoreCase(parsingMode));

        if ("false".equalsIgnoreCase(parsingMode)) {
            logger.log(BasicLevel.DEBUG, "WebServices XML parsing without validation");
        } else {
            logger.log(BasicLevel.DEBUG, "WebServices XML parsing with validation");
        }

        // Init the wsdl Manager
        wsdlManager = new WSDLManager();

        // Get publishing parameters in jonas properties
        JProp jp = null;

        try {
            jp = JProp.getInstance();
        } catch (Exception e) {
            String err = i18n.getMessage("AbsWebServicesServiceImpl.doInit.noJProp");
            logger.log(BasicLevel.ERROR, err + " " + e.getMessage());
            throw new WSServiceException(err, e);
        }

        String[] handlers = jp.getValueAsArray(WSDL_HANDLERS);

        if (handlers == null) {
            String err = i18n.getMessage("AbsWebServicesServiceImpl.doInit.noHandlers", WSDL_HANDLERS);
            logger.log(BasicLevel.ERROR, err);
            throw new WSServiceException(err);
        }

        // Build WSDLHandlers

        WSDLHandlerFactory factory = WSDLHandlerFactory.newInstance();

        // build each specified handlers and add it in the WSDLManager.
        for (int i = 0; i < handlers.length; i++) {

            // Create the handler
            WSDLHandler handler = factory.newHandler(handlers[i]);

            if (logger.isLoggable(BasicLevel.DEBUG)) {
                logger.log(BasicLevel.DEBUG, "Adding WSDLHandler '" + handlers[i] + "'");
            }

            // Add the created Handler
            wsdlManager.addHandler(handler);
        }
    }

    public void deployWebServices(Context ctx) throws WSServiceException {
        // Cannot get webContainer at startup (cycles)
        if (webService == null) {
            try {
                webService = (JWebContainerService) ServiceManager.getInstance().getWebContainerService();
            } catch (Exception e) {
                String err = i18n.getMessage("AbsWebServicesServiceImpl.deployWebServices.noWeb");
                logger.log(BasicLevel.ERROR, err);
                throw new WSServiceException(err, e);
            }
        }

        // Get context parameters.
        URL[] jarUrls = null;
        URL[] warUrls = null;
        URL earURL = null;
        ClassLoader ejbClassLoader = null;
        ClassLoader earClassLoader = null;
        Map warCtxRootMapping = null;
        String unpackDir = null;

        // EAR & Webapp case common information
        try {
            jarUrls = (URL[]) ctx.lookup("jarUrls");
            warUrls = (URL[]) ctx.lookup("warUrls");
            unpackDir = (String) ctx.lookup("unpackDir");
        } catch (NamingException e) {
            String err = i18n.getMessage("AbsWebServicesServiceImpl.deployWebServices.ctxParamProblem");
            logger.log(BasicLevel.ERROR, err + e.getMessage());
            throw new WSServiceException(err, e);
        }

        // EAR case specific information
        try {
            earURL = (URL) ctx.lookup("earURL");
            earClassLoader = (ClassLoader) ctx.lookup("earClassLoader");
            warCtxRootMapping = (Map) ctx.lookup("warCtxRootMapping");
            ejbClassLoader = (ClassLoader) ctx.lookup("ejbClassLoader");
        } catch (NamingException ne) {
            // WebApp case
            earURL = null;
            earClassLoader = null;
            warCtxRootMapping = null;
            ejbClassLoader = null;
        }

        // Deploy wars Web services.
        URLClassLoader loaderForCls = null;
        String earAppName = null;
        if (earURL != null) {
            earAppName = EarServiceImpl.buildJ2eeApplicationName(earURL);
        }

        String fileName = null;
        WSDeploymentDesc wsDD = null;

        for (int i = 0; i < warUrls.length; i++) {
            // Get the name of a war to deploy.
            fileName = warUrls[i].getFile();
            logger.log(BasicLevel.DEBUG, "Analyzing war '" + fileName + "' for web services");

            // Get the class loader for the current war.
            loaderForCls = webService.getClassLoader(warUrls[i], earAppName, ejbClassLoader);

            WebappClassLoader webLoader = (WebappClassLoader) loaderForCls;
            URL url = webLoader.getBaseURL();

            // Get the deployment descriptor from file.
            try {
                wsDD = WSManagerWrapper.getDeploymentDesc(warUrls[i], url, loaderForCls, earClassLoader);
            } catch (WSDeploymentDescException wsdde) {
                String err = i18n.getMessage("AbsWebServicesServiceImpl.deployWebServices.wsddEx", fileName);
                logger.log(BasicLevel.ERROR, err + ": " + wsdde);
                throw new WSServiceException(err, wsdde);
            }

            if (wsDD != null) {
                // The current War contains Webservices
                try {
                    Context compCtx = new CompNamingContext(fileName);
                    compCtx.rebind("wsDD", wsDD);
                    compCtx.rebind("cl", loaderForCls);

                    if (earClassLoader != null) {
                        compCtx.rebind("earCL", earClassLoader);
                    }
                    compCtx.rebind("warURL", warUrls[i]);

                    // ear case
                    if (warCtxRootMapping != null) {
                        compCtx.rebind("warContextRoot", warCtxRootMapping.get(warUrls[i]));

                        // non-ear case
                    } else {
                        compCtx.rebind("warContextRoot", "");
                    }

                    doDeployWebServices(compCtx);
                } catch (NamingException ne) {
                    String err = i18n.getMessage("AbsWebServicesServiceImpl.deployWebServices.bindError", fileName);
                    logger.log(BasicLevel.ERROR, err);
                    throw new WSServiceException(err, ne);
                }
            }
        }
        // End deploy wars Web services.

        // Deploy jars Web services.
        // Check warCtxRootMapping presence
        if ((jarUrls.length != 0) && (warCtxRootMapping == null)) {
            String err = i18n.getMessage("AbsWebServicesServiceImpl.deployWebServices.ctxRootMappingMissing");
            logger.log(BasicLevel.ERROR, err);
            throw new WSServiceException(err);
        }

        for (int i = 0; i < jarUrls.length; i++) {
            // Get the name of a war to deploy.
            fileName = jarUrls[i].getFile();
            logger.log(BasicLevel.DEBUG, "Analyzing EjbJar '" + fileName + "' for web services");

            URLClassLoader webClassLoader = null;

            // Get the deployment descriptor from file.
            try {
                wsDD = WSManagerWrapper.getDeploymentDesc(jarUrls[i], ejbClassLoader, earClassLoader);
            } catch (WSDeploymentDescException wsdde) {
                String err = i18n.getMessage("AbsWebServicesServiceImpl.deployWebServices.wsddEx", fileName);
                logger.log(BasicLevel.ERROR, err + ": " + wsdde);
                throw new WSServiceException(err, wsdde);
            }

            if (wsDD != null) {
                // The current Jar contains Webservices
                URL warURL = null;

                try {
                    if (wsDD.getWarFile() != null) {
                        // use getCanonicalFile to fix Bug #300658
                        //new File(new URL(dirName + File.separator + s).getFile()).getCanonicalFile().toURL();
                        warURL = new File(new URL(unpackDir + File.separator + wsDD.getWarFile()).getFile()).getCanonicalFile().toURL();
                        //warURL = new URL(unpackDir + "/" + wsDD.getWarFile());
                    } else {
                        String ejb = new File(jarUrls[i].getFile()).getName();
                        String war = ejb.substring(0, ejb.length() - ".jar".length());
                        //warURL = new URL(unpackDir + "/" + war + ".war");
                        warURL = new File(new URL(unpackDir + File.separator + war + ".war").getFile()).getCanonicalFile().toURL();
                    }
                    logger.log(BasicLevel.DEBUG, "Unpack Dir : " + unpackDir);
                    logger.log(BasicLevel.DEBUG, "Computed URL : " + warURL);

                    // check if webapp is present
                    boolean present = false;

                    for (int w = 0; w < warUrls.length; w++) {
                        if (warUrls[w].equals(warURL)) {
                            present = true;
                        }
                        logger.log(BasicLevel.DEBUG, "warUrls[" + w + "]=" + warUrls[w]);
                    }

                    // get the linked web classloader
                    webClassLoader = webService.getClassLoader(warURL, earAppName, ejbClassLoader);

                    if (!present) {
                        String err = i18n.getMessage("AbsWebServicesServiceImpl.deployWebServices.webappNotFound",
                                warURL);
                        logger.log(BasicLevel.ERROR, err);
                        throw new WSServiceException(err);
                    }
                } catch (MalformedURLException mue) {
                    String err = i18n.getMessage("AbsWebServicesServiceImpl.deployWebServices.mue");
                    logger.log(BasicLevel.ERROR, mue.getMessage());
                    throw new WSServiceException(err, mue);
                } catch (IOException ioe) {
                    // TODO add i18n
                    String err = "Cannot locate file : " + ioe.getMessage();
                    logger.log(BasicLevel.ERROR, err);
                    throw new WSServiceException(err, ioe);
                }

                try {
                    Context compCtx = new CompNamingContext(fileName);
                    compCtx.rebind("wsDD", wsDD);

                    // Using WebClassLoader ()
                    compCtx.rebind("cl", webClassLoader);
                    compCtx.rebind("earCL", earClassLoader);

                    compCtx.rebind("warURL", warURL);

                    // warContextRoot cannot be null in ejb case
                    // because an ejb needs a webapp for webservices
                    compCtx.rebind("warContextRoot", warCtxRootMapping.get(warURL));
                    doDeployWebServices(compCtx);
                } catch (NamingException ne) {
                    String err = i18n.getMessage("AbsWebServicesServiceImpl.deployWebServices.bindError", fileName);
                    logger.log(BasicLevel.ERROR, err);
                    throw new WSServiceException(err, ne);
                }
            }
        }

        // End deploy jars Web services.
    }

    protected void doDeployWebServices(Context ctx) throws WSServiceException {
        WSDeploymentDesc wsDD = null;
        ClassLoader cl = null;
        ClassLoader earCL = null;
        String warContextRoot = null;
        URL warURL = null;

        try {
            wsDD = (WSDeploymentDesc) ctx.lookup("wsDD");
            cl = (ClassLoader) ctx.lookup("cl");
            warContextRoot = (String) ctx.lookup("warContextRoot");
            warURL = (URL) ctx.lookup("warURL");
        } catch (NamingException ne) {
            String err = i18n.getMessage("AbsWebServicesServiceImpl.doDeployWebServices.namingError");
            logger.log(BasicLevel.ERROR, err);
            throw new WSServiceException(err, ne);
        }

        if (logger.isLoggable(BasicLevel.DEBUG)) {
            logger.log(BasicLevel.DEBUG, "Deploying WebServices for '" + warURL + "'");
        }

        try {
            earCL = (ClassLoader) ctx.lookup("earCL");
        } catch (NamingException ne) {
            // Nothing to do : non EAR case
            earCL = null;
        }

        // store WSDeployInfo for later use (completeWSDeployment method)
        ClassLoader key = cl;
        if (earCL != null) {
            key = earCL;
        }
        Stack s = (Stack) deployments.get(key);
        if (s == null) {
            s = new Stack();
            deployments.put(key, s);
        }
        s.push(new WSDeployInfo(warURL, wsDD));

        List sds = wsDD.getServiceDescs();

        // for each WSDL contained in the component
        for (Iterator i = sds.iterator(); i.hasNext();) {
            ServiceDesc sd = (ServiceDesc) i.next();
            WSDLFile wsdl = sd.getWSDL();

            // get the endpoint URL for each port-component
            // update the WSDL Definition
            for (Iterator pc = sd.getPortComponents().iterator(); pc.hasNext();) {
                PortComponentDesc pcd = (PortComponentDesc) pc.next();
                QName portQName = pcd.getQName();
                URL endpoint = null;
                if (pcd.hasJaxRpcImpl()) {
                    endpoint = getEndpointURL(wsDD, (JaxRpcPortComponentDesc) pcd, warURL, warContextRoot);
                } else {
                    endpoint = getEndpointURL(wsDD, (SSBPortComponentDesc) pcd, warURL, cl, earCL, warContextRoot);
                }

                pcd.setEndpointURL(endpoint);
                wsdl.setLocation(portQName, endpoint);

                // add endpoint URL into JNDI namespace to allow application
                // clients (that are not running in the same JVM) to use
                // port-component-link
                Context registry;
                try {
                    registry = new InitialContext();
                    Reference urlRef = new Reference(URL.class.getName(), URLFactory.class.getName(), null);
                    urlRef.add(new StringRefAddr("url", endpoint.toString()));
                    registry.rebind(pcd.getName(), urlRef);
                    logger.log(BasicLevel.DEBUG, "Bind updated URL (" + endpoint + ") in " + pcd.getName());
                } catch (NamingException ne) {
                    throw new WSServiceException("Cannot bind updated URL for port-component '" + pcd.getName()
                            + "'", ne);
                }
            }

            // publish WSDL
            wsdlManager.publish(sd);
        }
    }

    private URL getEndpointURL(WSDeploymentDesc wsDD, JaxRpcPortComponentDesc jpcd, URL warURL, String contextRoot)
            throws WSServiceException {

        logger.log(BasicLevel.DEBUG, "get endpoint for JaxRpc Port Component");

        return getEndpointURL(wsDD, jpcd.getWebDesc(), warURL, contextRoot, jpcd);

    }

    private URL getEndpointURL(WSDeploymentDesc wsDD, SSBPortComponentDesc spcd, URL warURL, ClassLoader cl,
            ClassLoader earCL, String contextRoot) throws WSServiceException {

        logger.log(BasicLevel.DEBUG, "get endpoint for StatelessSessionBean Port Component");

        WebContainerDeploymentDesc webDD = null;

        try {
            webDD = WebManagerWrapper.getDeploymentDesc(warURL, cl, earCL);
        } catch (WebContainerDeploymentDescException e) {
            String err = i18n.getMessage("AbsWebServicesServiceImpl.getEndpointURL.webDDException", warURL.getFile());
            logger.log(BasicLevel.ERROR, err);
            throw new WSServiceException(err, e);
        }

        return getEndpointURL(wsDD, webDD, warURL, contextRoot, spcd);

    }

    private URL getEndpointURL(WSDeploymentDesc wsDD, WebContainerDeploymentDesc webDD, URL warURL,
            String warContextRoot, PortComponentDesc pcd) throws WSServiceException {

        // Resolve :
        // - hostname
        // - http/https port
        // Priority order : 1. the ones specified in jonas-web.xml
        //                  2. default web container values (if any)
        String servletName = pcd.getSibLink();
        String pcName = pcd.getQName().getLocalPart();

        logger.log(BasicLevel.DEBUG, "SOAP Servlet name '" + servletName + "'");

        String hostname = webDD.getHost();
        String port = webDD.getPort();
        String scheme = "";
        String contextRoot = null;
        String mapping = null;

        if (wsDD.getContextRoot() != null && (pcd instanceof SSBPortComponentDesc)) {
            contextRoot = wsDD.getContextRoot();
        } else {
            contextRoot = getContextRoot(warContextRoot, webDD, warURL);
        }

        boolean needPortName = true;
        if (pcd.getEndpointURI() != null) {
            mapping = pcd.getEndpointURI();
            needPortName = false;
        } else {
            mapping = getServletMapping(servletName, webDD);
        }

        // get default host value
        if (hostname == null) {
            // get hostname
            try {
                hostname = webService.getDefaultHost();
            } catch (JWebContainerServiceException e) {
                String err = i18n
                        .getMessage("AbsWebServicesServiceImpl.getEndpointURL.noDefaultHost", warURL.getFile());
                logger.log(BasicLevel.ERROR, err);
                throw new WSServiceException(err, e);
            }
        }

        // get default port and scheme value
        if (port == null) {
            // get Http informations
            try {
                port = webService.getDefaultHttpPort();
                scheme = "http";
            } catch (JWebContainerServiceException e) {
                // Http Fails
                // Try Https informations
                try {
                    port = webService.getDefaultHttpsPort();
                    scheme = "https";
                } catch (JWebContainerServiceException e2) {
                    String err = i18n.getMessage("AbsWebServicesServiceImpl.getEndpointURL.noDefaultHTTPPort", warURL
                            .getFile());
                    logger.log(BasicLevel.ERROR, err);
                    throw new WSServiceException(err, e2);
                }
            }
        }

        // construct URL
        if (port.equals("80")) {
            port = "";
        } else {
            port = ":" + port;
        }

        String url = null;
        if (needPortName) {
            String encodedPortName = null;
            try {
                encodedPortName = URLEncoder.encode(pcName, "UTF-8");
            } catch (UnsupportedEncodingException e) {
                // should never occurs since utf-8 is mandatory on all JVM
                encodedPortName = pcName;
            }
            url = scheme + "://" + hostname + port + "/" + contextRoot + "/" + mapping + "/" + encodedPortName;
        } else {
            url = scheme + "://" + hostname + port + "/" + contextRoot + mapping;
        }

        URL endpoint = null;

        try {
            endpoint = new URL(url);
        } catch (MalformedURLException mue) {
            String err = i18n.getMessage("AbsWebServicesServiceImpl.getEndpointURL.endpointURLError", pcName, url);
            logger.log(BasicLevel.ERROR, err);
            throw new WSServiceException(err, mue);
        }

        if (logger.isLoggable(BasicLevel.DEBUG)) {
            logger.log(BasicLevel.DEBUG, "Constructed URL for '" + pcName + "' : '" + endpoint + "'");
        }

        return endpoint;
    }

    private static String getContextRoot(String ctxRoot, WebContainerDeploymentDesc webDD, URL warURL) {
        // 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.
        String contextRoot = null;

        if ("".equals(ctxRoot)) {
            String cRoot = webDD.getContextRoot();

            if (cRoot == null) {
                String file = new File(warURL.getFile()).getName();

                if (file.toLowerCase().endsWith(".war")) {
                    contextRoot = file.substring(0, file.length() - ".war".length());
                } else {
                    //It's a directory which is deployed
                    contextRoot = file.substring(0, file.length());
                }
            } else {
                contextRoot = cRoot;
            }
        } else {
            contextRoot = ctxRoot;
        }

        return contextRoot;
    }

    public void doStop() throws ServiceException {
    }

    public void doStart() throws ServiceException {
    }

    private String getServletMapping(String servlet, WebContainerDeploymentDesc webDD) throws WSServiceException {

        List mappings = webDD.getServletMappings(servlet);

        logger.log(BasicLevel.DEBUG, "mapping : " + mappings);

        if (mappings == null) {
            String err = i18n.getMessage("AbsWebServicesServiceImpl.getServletMapping.noMapping", servlet);
            logger.log(BasicLevel.ERROR, err);
            throw new WSServiceException(err);
        }

        if (mappings.size() != 1) {
            String err = i18n.getMessage("AbsWebServicesServiceImpl.getServletMapping.1mappingOnly", servlet);
            logger.log(BasicLevel.ERROR, err);
            throw new WSServiceException(err);
        }

        String mapping = (String) mappings.get(0);

        // keep only the first part of the mapping :
        // /services/* becomes services
        StringTokenizer st = new StringTokenizer(mapping, "/");
        mapping = st.nextToken();

        return mapping;

    }

    public void removeCache(ClassLoader cl) {
        WSManagerWrapper.removeCache(cl);
        removeDeploymentInfoStack(cl);
    }

    protected static I18n getI18n() {
        return i18n;
    }

    protected static Logger getLogger() {
        return logger;
    }

    public void completeWSDeployment(Context ctx) throws WSServiceException {
        ClassLoader cl = null;
        try {
            cl = (ClassLoader) ctx.lookup(CLASSLOADER_CTX_PARAM);
        } catch (NamingException ne) {
            throw new WSServiceException("Cannot retrieve '" + CLASSLOADER_CTX_PARAM + "' from given Context", ne);
        }

        Stack s = getDeploymentInfoStack(cl);

        for (; s != null && !s.empty();) {
            WSDeployInfo di = (WSDeployInfo) s.pop();
            URL warURL = di.getWarURL();
            WSDeploymentDesc wsdd = di.getDescriptor();

            ContainerNaming naming = null;
            try {
                naming = NamingManager.getInstance();
            } catch (NamingException ne) {
                throw new WSServiceException("Cannot get NamingManager instance for " + wsdd.getDisplayName(), ne);
            }
            ClassLoader web = webService.getContextLinkedClassLoader(warURL);
            Context c = naming.getComponentContext(web);
            if (c == null) {
                throw new WSServiceException("Cannot get Component Context from ClassLoader : " + web);
            }

            List sds = wsdd.getServiceDescs();

            // for each WSDL contained in the component
            for (Iterator i = sds.iterator(); i.hasNext();) {
                ServiceDesc sd = (ServiceDesc) i.next();

                // get the endpoint URL for each port-component
                // update the WSDL Definition
                for (Iterator pc = sd.getPortComponents().iterator(); pc.hasNext();) {
                    PortComponentDesc pcd = (PortComponentDesc) pc.next();
                    try {
                        c.rebind("comp/jonas/" + pcd.getSibLink() + "/dd", sd);
                    } catch (NamingException ne) {
                        throw new WSServiceException("Cannot bind ServiceDesc instance for servlet '" + sd.getName()
                                + "'", ne);
                    }
                }
            }
        }
    }

    private Stack getDeploymentInfoStack(ClassLoader key) {
        return (Stack) deployments.get(key);
    }

    private void removeDeploymentInfoStack(ClassLoader key) {
        deployments.remove(key);
    }

    public class WSDeployInfo {

        private URL war = null;

        private WSDeploymentDesc wsdd = null;

        public WSDeployInfo(URL war, WSDeploymentDesc wsdd) {
            this.war = war;
            this.wsdd = wsdd;
        }

        public URL getWarURL() {
            return war;
        }

        public WSDeploymentDesc getDescriptor() {
            return wsdd;
        }
    }

}

---