*

* Copyright 2003-2004 The Apache Software Foundation

*

*  Licensed under the Apache License, Version 2.0 (the "License");

*  you may not use this file except in compliance with the License.

*  You may obtain a copy of the License at

*

*     http://www.apache.org/licenses/LICENSE-2.0

*

*  Unless required by applicable law or agreed to in writing, software

*  distributed under the License is distributed on an "AS IS" BASIS,

*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

*  See the License for the specific language governing permissions and

*  limitations under the License.

*/

* @version $Rev: 357772 $ $Date: 2005-12-19 12:10:21 -0800 (Mon, 19 Dec 2005) $

*/

    private final static Log log = LogFactory.getLog(JettyModuleBuilder.class);

    private final List defaultParentId;

    private final ObjectName jettyContainerObjectName;

    private final Collection defaultServlets;

    private final Collection defaultFilters;

    private final Collection defaultFilterMappings;

    private final GBeanData pojoWebServiceTemplate;

    private final boolean defaultContextPriorityClassloader;

    private final WebServiceBuilder webServiceBuilder;

    private final List defaultWelcomeFiles;

    private final Integer defaultSessionTimeoutSeconds;

    private final Repository repository;

    private final Kernel kernel;

    private static final String JETTY_NAMESPACE = JettyWebAppDocument.type.getDocumentElementName().getNamespaceURI();//GerConnectorDocument.type.getDocumentElementName().getNamespaceURI();

    public JettyModuleBuilder(URI[] defaultParentId,

                              Integer defaultSessionTimeoutSeconds,

                              boolean defaultContextPriorityClassloader,

                              List defaultWelcomeFiles,

                              ObjectName jettyContainerObjectName,

                              Collection defaultServlets,

                              Collection defaultFilters,

                              Collection defaultFilterMappings,

                              Object pojoWebServiceTemplate,

                              WebServiceBuilder webServiceBuilder,

                              Repository repository,

                              Kernel kernel) throws GBeanNotFoundException {

        this.defaultParentId = defaultParentId == null ? Collections.EMPTY_LIST : Arrays.asList(defaultParentId);

        this.defaultSessionTimeoutSeconds = (defaultSessionTimeoutSeconds == null) ? new Integer(30 * 60) : defaultSessionTimeoutSeconds;

        this.defaultContextPriorityClassloader = defaultContextPriorityClassloader;

        this.jettyContainerObjectName = jettyContainerObjectName;

        this.defaultServlets = defaultServlets;

        this.defaultFilters = defaultFilters;

        this.defaultFilterMappings = defaultFilterMappings;

        this.pojoWebServiceTemplate = getGBeanData(kernel, pojoWebServiceTemplate);

        this.webServiceBuilder = webServiceBuilder;

        this.repository = repository;

        this.kernel = kernel;

        //todo locale mappings

        this.defaultWelcomeFiles = defaultWelcomeFiles;

    }

    private static GBeanData getGBeanData(Kernel kernel, Object template) throws GBeanNotFoundException {

        if (template == null) {

            return null;

        }

        ObjectName templateName = kernel.getProxyManager().getProxyTarget(template);

        GBeanData templateData = kernel.getGBeanData(templateName);

        return templateData;

    }

    public Module createModule(File plan, JarFile moduleFile) throws DeploymentException {

        return createModule(plan, moduleFile, "war", null, true, null);

    }

    public Module createModule(Object plan, JarFile moduleFile, String targetPath, URL specDDUrl, URI earConfigId, Object moduleContextInfo) throws DeploymentException {

        return createModule(plan, moduleFile, targetPath, specDDUrl, false, (String) moduleContextInfo);

    }

    private Module createModule(Object plan, JarFile moduleFile, String targetPath, URL specDDUrl, boolean standAlone, String contextRoot) throws DeploymentException {

        assert moduleFile != null: "moduleFile is null";

        assert targetPath != null: "targetPath is null";

        assert !targetPath.endsWith("/"): "targetPath must not end with a '/'";

        // parse the spec dd

        String specDD;

        WebAppType webApp;

        try {

            if (specDDUrl == null) {

                specDDUrl = DeploymentUtil.createJarURL(moduleFile, "WEB-INF/web.xml");

            }

            // read in the entire specDD as a string, we need this for getDeploymentDescriptor

            // on the J2ee management object

            specDD = DeploymentUtil.readAll(specDDUrl);

        } catch (Exception e) {

            //no web.xml, not for us

            return null;

        }

        //we found web.xml, if it won't parse that's an error.

        try {

            // parse it

            XmlObject parsed = XmlBeansUtil.parse(specDD);

            WebAppDocument webAppDoc = SchemaConversionUtils.convertToServletSchema(parsed);

            webApp = webAppDoc.getWebApp();

        } catch (XmlException xmle) {

            throw new DeploymentException("Error parsing web.xml", xmle);

        }

        check(webApp);

        // parse vendor dd

        JettyWebAppType jettyWebApp = getJettyWebApp(plan, moduleFile, standAlone, targetPath, webApp);

        if (contextRoot == null) {

            if (jettyWebApp.isSetContextRoot()) {

                contextRoot = jettyWebApp.getContextRoot();

            } else {

                contextRoot = determineDefaultContextRoot(webApp, standAlone, moduleFile, targetPath);

            }

        }

        Map servletNameToPathMap = buildServletNameToPathMap(webApp, contextRoot);

        //look for a webservices dd

        Map portMap = Collections.EMPTY_MAP;

        try {

            URL wsDDUrl = DeploymentUtil.createJarURL(moduleFile, "WEB-INF/webservices.xml");

            portMap = webServiceBuilder.parseWebServiceDescriptor(wsDDUrl, moduleFile, false, servletNameToPathMap);

        } catch (MalformedURLException e) {

            //no descriptor

        }

        // get the ids from either the application plan or for a stand alone module from the specific deployer

        URI configId = null;

        try {

            configId = new URI(jettyWebApp.getConfigId());

        } catch (URISyntaxException e) {

            throw new DeploymentException("Invalid configId " + jettyWebApp.getConfigId(), e);

        }

        List parentId = ServiceConfigBuilder.getParentID(jettyWebApp.getParentId(), jettyWebApp.getImportArray());

        if (parentId.isEmpty()) {

            parentId = new ArrayList(defaultParentId);

        }

        WebModule module = new WebModule(standAlone, configId, parentId, moduleFile, targetPath, webApp, jettyWebApp, specDD, contextRoot, portMap, JETTY_NAMESPACE);

        return module;

    }

    /**

     * Some servlets will have multiple url patterns.  However, webservice servlets

     * will only have one, which is what this method is intended for.

     *

     * @param webApp

     * @param contextRoot

     */

    private Map buildServletNameToPathMap(WebAppType webApp, String contextRoot) {

        contextRoot = "/" + contextRoot;

        Map map = new HashMap();

        ServletMappingType[] servletMappings = webApp.getServletMappingArray();

        for (int j = 0; j < servletMappings.length; j++) {

            ServletMappingType servletMapping = servletMappings[j];

            String servletName = servletMapping.getServletName().getStringValue().trim();

            map.put(servletName, contextRoot + servletMapping.getUrlPattern().getStringValue().trim());

        }

        return map;

    }

    JettyWebAppType getJettyWebApp(Object plan, JarFile moduleFile, boolean standAlone, String targetPath, WebAppType webApp) throws DeploymentException {

        XmlObject rawPlan = null;

        try {

            // load the geronimo-web.xml from either the supplied plan or from the earFile

            try {

                if (plan instanceof XmlObject) {

                    rawPlan = (XmlObject) plan;

                } else {

                    if (plan != null) {

                        rawPlan = XmlBeansUtil.parse(((File) plan).toURL());

                    } else {

                        URL path = DeploymentUtil.createJarURL(moduleFile, "WEB-INF/geronimo-web.xml");

                        try {

                            rawPlan = XmlBeansUtil.parse(path);

                        } catch (FileNotFoundException e) {

                            path = DeploymentUtil.createJarURL(moduleFile, "WEB-INF/geronimo-jetty.xml");

                            try {

                                rawPlan = XmlBeansUtil.parse(path);

                            } catch (FileNotFoundException e1) {

                                log.warn("Web application does not contain a WEB-INF/geronimo-web.xml deployment plan.  This may or may not be a problem, depending on whether you have things like resource references that need to be resolved.  You can also give the deployer a separate deployment plan file on the command line.");

                            }

                        }

                    }

                }

            } catch (IOException e) {

                log.warn(e);

            }

            JettyWebAppType jettyWebApp = null;

            if (rawPlan != null) {

                XmlObject webPlan = new GenericToSpecificPlanConverter(GerJettyDocument.type.getDocumentElementName().getNamespaceURI(),

                        JettyWebAppDocument.type.getDocumentElementName().getNamespaceURI(), "jetty").convertToSpecificPlan(rawPlan);

                jettyWebApp = (JettyWebAppType) webPlan.changeType(JettyWebAppType.type);

                SchemaConversionUtils.validateDD(jettyWebApp);

            } else {

                String defaultContextRoot = determineDefaultContextRoot(webApp, standAlone, moduleFile, targetPath);

                jettyWebApp = createDefaultPlan(defaultContextRoot);

            }

            return jettyWebApp;

        } catch (XmlException e) {

            throw new DeploymentException("xml problem", e);

        }

    }

    private String determineDefaultContextRoot(WebAppType webApp, boolean isStandAlone, JarFile moduleFile, String targetPath) {

        if (webApp != null && webApp.getId() != null) {

            return webApp.getId();

        }

        if (isStandAlone) {

            // default configId is based on the moduleFile name

            return trimPath(new File(moduleFile.getName()).getName());

        }

        // default configId is based on the module uri from the application.xml

        return trimPath(targetPath);

    }

    private String trimPath(String path) {

        if (path == null) {

            return null;

        }

        if (path.endsWith(".war")) {

            path = path.substring(0, path.length() - 4);

        }

        if (path.endsWith("/")) {

            path = path.substring(0, path.length() - 1);

        }

        return path;

    }

    private JettyWebAppType createDefaultPlan(String contextRoot) {

        JettyWebAppType jettyWebApp = JettyWebAppType.Factory.newInstance();

        // set the parentId, configId and context root

        jettyWebApp.setConfigId(contextRoot);

        jettyWebApp.setContextRoot(contextRoot);

        jettyWebApp.setContextPriorityClassloader(defaultContextPriorityClassloader);

        return jettyWebApp;

    }

    public void installModule(JarFile earFile, EARContext earContext, Module module) throws DeploymentException {

        JettyWebAppType jettyWebApp = (JettyWebAppType) module.getVendorDD();

        earContext.addParentId(defaultParentId);

        try {

            URI baseDir = URI.create(module.getTargetPath() + "/");

            // add the warfile's content to the configuration

            JarFile warFile = module.getModuleFile();

            Enumeration entries = warFile.entries();

            while (entries.hasMoreElements()) {

                ZipEntry entry = (ZipEntry) entries.nextElement();

                URI targetPath = baseDir.resolve(new URI(null, entry.getName(), null));

                if (entry.getName().equals("WEB-INF/web.xml")) {

                    earContext.addFile(targetPath, module.getOriginalSpecDD());

                } else {

                    earContext.addFile(targetPath, warFile, entry);

                }

            }

            // add the manifest classpath entries declared in the war to the class loader

            // we have to explicitly add these since we are unpacking the web module

            // and the url class loader will not pick up a manifest from an unpacked dir

            earContext.addManifestClassPath(warFile, URI.create(module.getTargetPath()));

            // add the dependencies declared in the geronimo-web.xml file

            DependencyType[] dependencies = jettyWebApp.getDependencyArray();

            ServiceConfigBuilder.addDependencies(earContext, dependencies, repository);

        } catch (IOException e) {

            throw new DeploymentException("Problem deploying war", e);

        } catch (URISyntaxException e) {

            throw new DeploymentException("Could not construct URI for location of war entry", e);

        }

        if (jettyWebApp.isSetInverseClassloading()) {

            earContext.setInverseClassloading(jettyWebApp.getInverseClassloading());

        }

        ClassFilterType[] filters = jettyWebApp.getHiddenClassesArray();

        ServiceConfigBuilder.addHiddenClasses(earContext, filters);

        filters = jettyWebApp.getNonOverridableClassesArray();

        ServiceConfigBuilder.addNonOverridableClasses(earContext, filters);

    }

    public void initContext(EARContext earContext, Module module, ClassLoader cl) throws DeploymentException {

        WebAppType webApp = (WebAppType) module.getSpecDD();

        MessageDestinationType[] messageDestinations = webApp.getMessageDestinationArray();

        JettyWebAppType gerWebApp = (JettyWebAppType) module.getVendorDD();

        GerMessageDestinationType[] gerMessageDestinations = gerWebApp.getMessageDestinationArray();

        ENCConfigBuilder.registerMessageDestinations(earContext.getRefContext(), module.getName(), messageDestinations, gerMessageDestinations);

        if((webApp.getSecurityConstraintArray().length > 0 || webApp.getSecurityRoleArray().length > 0) &&

                !gerWebApp.isSetSecurityRealmName()) {

            throw new DeploymentException("web.xml includes security elements but Geronimo deployment plan is not provided or does not contain <security-realm-name> element necessary to configure security accordingly.");

        }

        if (gerWebApp.isSetSecurity()) {

            if (!gerWebApp.isSetSecurityRealmName()) {

                throw new DeploymentException("You have supplied a security configuration for web app " + module.getName() + " but no security-realm-name to allow login");

            }

            SecurityConfiguration securityConfiguration = SecurityBuilder.buildSecurityConfiguration(gerWebApp.getSecurity(), cl);

            earContext.setSecurityConfiguration(securityConfiguration);

        }

    }

    public void addGBeans(EARContext earContext, Module module, ClassLoader cl) throws DeploymentException {

        J2eeContext earJ2eeContext = earContext.getJ2eeContext();

        J2eeContext moduleJ2eeContext = J2eeContextImpl.newModuleContextFromApplication(earJ2eeContext, NameFactory.WEB_MODULE, module.getName());

        WebModule webModule = (WebModule) module;

        WebAppType webApp = (WebAppType) webModule.getSpecDD();

        JettyWebAppType jettyWebApp = (JettyWebAppType) webModule.getVendorDD();

        boolean contextPriorityClassLoader = defaultContextPriorityClassloader;

        if (jettyWebApp.isSetContextPriorityClassloader()) {

            contextPriorityClassLoader = jettyWebApp.getContextPriorityClassloader();

        }

        // construct the webClassLoader

        ClassLoader webClassLoader = getWebClassLoader(earContext, webModule, cl, contextPriorityClassLoader);

        GbeanType[] gbeans = jettyWebApp.getGbeanArray();

        ServiceConfigBuilder.addGBeans(gbeans, webClassLoader, moduleJ2eeContext, earContext);

        ObjectName webModuleName = null;

        try {

            webModuleName = NameFactory.getModuleName(null, null, null, null, null, moduleJ2eeContext);

        } catch (MalformedObjectNameException e) {

            throw new DeploymentException("Could not construct module name", e);

        }

        UserTransaction userTransaction = new OnlineUserTransaction();

        //this may add to the web classpath with enhanced classes.

        Map compContext = buildComponentContext(earContext, webModule, webApp, jettyWebApp, userTransaction, webClassLoader);

        GBeanData webModuleData = new GBeanData(webModuleName, JettyWebAppContext.GBEAN_INFO);

        try {

            webModuleData.setReferencePattern("J2EEServer", earContext.getServerObjectName());

            if (!earContext.getJ2EEApplicationName().equals("null")) {

                webModuleData.setReferencePattern("J2EEApplication", earContext.getApplicationObjectName());

            }

            webModuleData.setAttribute("deploymentDescriptor", module.getOriginalSpecDD());

            Set securityRoles = collectRoleNames(webApp);

            Map rolePermissions = new HashMap();

            webModuleData.setAttribute("uri", URI.create(module.getTargetPath() + "/"));

            String[] hosts = jettyWebApp.getVirtualHostArray();

            for (int i = 0; i < hosts.length; i++) {

                hosts[i] = hosts[i].trim();

            }

            webModuleData.setAttribute("virtualHosts", hosts);

            //session manager

            webModuleData.setAttribute("sessionManager", jettyWebApp.getSessionManager());

           

            //Add dependencies on managed connection factories and ejbs in this app

            //This is overkill, but allows for people not using java:comp context (even though we don't support it)

            //and sidesteps the problem of circular references between ejbs.

            Set dependencies = findGBeanDependencies(earContext);

            webModuleData.getDependencies().addAll(dependencies);

            webModuleData.setAttribute("componentContext", compContext);

            webModuleData.setAttribute("userTransaction", userTransaction);

            //classpath may have been augmented with enhanced classes

            webModuleData.setAttribute("webClassPath", webModule.getWebClasspath());

            // unsharableResources, applicationManagedSecurityResources

            GBeanResourceEnvironmentBuilder rebuilder = new GBeanResourceEnvironmentBuilder(webModuleData);

            ENCConfigBuilder.setResourceEnvironment(earContext, webModule.getModuleURI(), rebuilder, webApp.getResourceRefArray(), jettyWebApp.getResourceRefArray());

            webModuleData.setAttribute("contextPath", webModule.getContextRoot());

            webModuleData.setAttribute("contextPriorityClassLoader", Boolean.valueOf(contextPriorityClassLoader));

            webModuleData.setReferencePattern("TransactionContextManager", earContext.getTransactionContextManagerObjectName());

            webModuleData.setReferencePattern("TrackedConnectionAssociator", earContext.getConnectionTrackerObjectName());

            webModuleData.setReferencePattern("JettyContainer", jettyContainerObjectName);

            //stuff that jetty used to do

            if (webApp.getDisplayNameArray().length > 0) {

                webModuleData.setAttribute("displayName", webApp.getDisplayNameArray()[0].getStringValue());

            }

            ParamValueType[] contextParamArray = webApp.getContextParamArray();

            Map contextParams = new HashMap();

            for (int i = 0; i < contextParamArray.length; i++) {

                ParamValueType contextParam = contextParamArray[i];

                contextParams.put(contextParam.getParamName().getStringValue().trim(), contextParam.getParamValue().getStringValue().trim());

            }

            webModuleData.setAttribute("contextParamMap", contextParams);

            ListenerType[] listenerArray = webApp.getListenerArray();

            Collection listeners = new ArrayList();

            for (int i = 0; i < listenerArray.length; i++) {

                ListenerType listenerType = listenerArray[i];

                listeners.add(listenerType.getListenerClass().getStringValue());

            }

            webModuleData.setAttribute("listenerClassNames", listeners);

            webModuleData.setAttribute("distributable", webApp.getDistributableArray().length == 1 ? Boolean.TRUE : Boolean.FALSE);

            webModuleData.setAttribute("sessionTimeoutSeconds",

                    (webApp.getSessionConfigArray().length == 1 && webApp.getSessionConfigArray(0).getSessionTimeout() != null) ?

                    new Integer(webApp.getSessionConfigArray(0).getSessionTimeout().getBigIntegerValue().intValue() * 60) :

                    defaultSessionTimeoutSeconds);

            MimeMappingType[] mimeMappingArray = webApp.getMimeMappingArray();

            Map mimeMappingMap = new HashMap();

            for (int i = 0; i < mimeMappingArray.length; i++) {

                MimeMappingType mimeMappingType = mimeMappingArray[i];

                mimeMappingMap.put(mimeMappingType.getExtension().getStringValue(), mimeMappingType.getMimeType().getStringValue());

            }

            webModuleData.setAttribute("mimeMap", mimeMappingMap);

            WelcomeFileListType[] welcomeFileArray = webApp.getWelcomeFileListArray();

            List welcomeFiles;

            if (welcomeFileArray.length > 0) {

                welcomeFiles = new ArrayList();

                for (int i = 0; i < welcomeFileArray.length; i++) {

                    String[] welcomeFileListType = welcomeFileArray[i].getWelcomeFileArray();

                    for (int j = 0; j < welcomeFileListType.length; j++) {

                        String welcomeFile = welcomeFileListType[j].trim();

                        welcomeFiles.add(welcomeFile);

                    }

                }

            } else {

                welcomeFiles = new ArrayList(defaultWelcomeFiles);

            }

            webModuleData.setAttribute("welcomeFiles", welcomeFiles.toArray(new String[welcomeFiles.size()]));

            LocaleEncodingMappingListType[] localeEncodingMappingListArray = webApp.getLocaleEncodingMappingListArray();

            Map localeEncodingMappingMap = new HashMap();

            for (int i = 0; i < localeEncodingMappingListArray.length; i++) {

                LocaleEncodingMappingType[] localeEncodingMappingArray = localeEncodingMappingListArray[i].getLocaleEncodingMappingArray();

                for (int j = 0; j < localeEncodingMappingArray.length; j++) {

                    LocaleEncodingMappingType localeEncodingMapping = localeEncodingMappingArray[j];

                    localeEncodingMappingMap.put(localeEncodingMapping.getLocale(), localeEncodingMapping.getEncoding());

                }

            }

            webModuleData.setAttribute("localeEncodingMapping", localeEncodingMappingMap);

            ErrorPageType[] errorPageArray = webApp.getErrorPageArray();

            Map errorPageMap = new HashMap();

            for (int i = 0; i < errorPageArray.length; i++) {

                ErrorPageType errorPageType = errorPageArray[i];

                if (errorPageType.isSetErrorCode()) {

                    errorPageMap.put(errorPageType.getErrorCode().getStringValue(), errorPageType.getLocation().getStringValue());

                } else {

                    errorPageMap.put(errorPageType.getExceptionType().getStringValue(), errorPageType.getLocation().getStringValue());

                }

            }

            webModuleData.setAttribute("errorPages", errorPageMap);

            JspConfigType[] jspConfigArray = webApp.getJspConfigArray();

            if (jspConfigArray.length > 1) {

                throw new DeploymentException("At most one jsp-config element, not " + jspConfigArray.length);

            }

            Map tagLibMap = new HashMap();

            for (int i = 0; i < jspConfigArray.length; i++) {

                TaglibType[] tagLibArray = jspConfigArray[i].getTaglibArray();

                for (int j = 0; j < tagLibArray.length; j++) {

                    TaglibType taglib = tagLibArray[j];

                    tagLibMap.put(taglib.getTaglibUri().getStringValue().trim(), taglib.getTaglibLocation().getStringValue().trim());

                }

            }

            webModuleData.setAttribute("tagLibMap", tagLibMap);

            LoginConfigType[] loginConfigArray = webApp.getLoginConfigArray();

            if (loginConfigArray.length > 1) {

                throw new DeploymentException("At most one login-config element, not " + loginConfigArray.length);

            }

            if (loginConfigArray.length == 1) {

                LoginConfigType loginConfig = loginConfigArray[0];

                if (loginConfig.isSetAuthMethod()) {

                    String authMethod = loginConfig.getAuthMethod().getStringValue();

                    if ("BASIC".equals(authMethod)) {

                        webModuleData.setAttribute("authenticator", new BasicAuthenticator());

                    } else if ("DIGEST".equals(authMethod)) {

                        webModuleData.setAttribute("authenticator", new DigestAuthenticator());

                    } else if ("FORM".equals(authMethod)) {

                        FormAuthenticator formAuthenticator = new FormAuthenticator();

                        webModuleData.setAttribute("authenticator", formAuthenticator);

                        if (loginConfig.isSetFormLoginConfig()) {

                            FormLoginConfigType formLoginConfig = loginConfig.getFormLoginConfig();

                            formAuthenticator.setLoginPage(formLoginConfig.getFormLoginPage().getStringValue());

                            formAuthenticator.setErrorPage(formLoginConfig.getFormErrorPage().getStringValue());

                        }

                    } else if ("CLIENT-CERT".equals(authMethod)) {

                        webModuleData.setAttribute("authenticator", new ClientCertAuthenticator());

                    }

                }

                if (loginConfig.isSetRealmName()) {

                    webModuleData.setAttribute("realmName", loginConfig.getRealmName().getStringValue());

                }

            }

            earContext.addGBean(webModuleData);

            // Make sure that servlet mappings point to available servlets

            ServletType[] servletTypes = webApp.getServletArray();

            Set knownServlets = new HashSet();

            for (int i = 0; i < servletTypes.length; i++) {

                ServletType type = servletTypes[i];

                knownServlets.add(type.getServletName().getStringValue().trim());

            }

            //never add a duplicate pattern.

            Set knownServletMappings = new HashSet();

            ServletMappingType[] servletMappingArray = webApp.getServletMappingArray();

            Map servletMappings = new HashMap();

            for (int i = 0; i < servletMappingArray.length; i++) {

                ServletMappingType servletMappingType = servletMappingArray[i];

                String servletName = servletMappingType.getServletName().getStringValue().trim();

                if(!knownServlets.contains(servletName)) {

                    throw new DeploymentException("Servlet mapping refers to servlet '"+servletName+"' but no such servlet was found!");

                }

                String urlPattern = servletMappingType.getUrlPattern().getStringValue().trim();

                if (!knownServletMappings.contains(urlPattern)) {

                    knownServletMappings.add(urlPattern);

                    checkString(urlPattern);

                    Set urlsForServlet = (Set) servletMappings.get(servletName);

                    if (urlsForServlet == null) {

                        urlsForServlet = new HashSet();

                        servletMappings.put(servletName, urlsForServlet);

                    }

                    urlsForServlet.add(urlPattern);

                }

            }

            //"previous" filter mapping for linked list to keep dd's ordering.

            ObjectName previous = null;

            //add default filters

            if (defaultFilters != null) {

                for (Iterator iterator = defaultFilters.iterator(); iterator.hasNext();) {

                    Object defaultFilter = iterator.next();

                    GBeanData filterGBeanData = getGBeanData(kernel, defaultFilter);

                    String filterName = (String) filterGBeanData.getAttribute("filterName");

                    ObjectName defaultFilterObjectName = NameFactory.getWebComponentName(null, null, null, null, filterName, NameFactory.WEB_FILTER, moduleJ2eeContext);

                    filterGBeanData.setName(defaultFilterObjectName);

                    filterGBeanData.setReferencePattern("JettyServletRegistration", webModuleName);

                    earContext.addGBean(filterGBeanData);

                    //add a mapping to /*

                    GBeanData filterMappingGBeanData = new GBeanData(JettyFilterMapping.GBEAN_INFO);

                    filterMappingGBeanData.setReferencePattern("Previous", previous);

                    filterMappingGBeanData.setReferencePattern("JettyServletRegistration", webModuleName);

                    String urlPattern = "/*";

                    filterMappingGBeanData.setAttribute("urlPattern", urlPattern);

                    ObjectName filterMappingName = NameFactory.getWebFilterMappingName(null, null, null, null, filterName, null, urlPattern, moduleJ2eeContext);

                    filterMappingGBeanData.setName(filterMappingName);

                    previous = filterMappingName;

                    filterMappingGBeanData.setAttribute("requestDispatch", Boolean.TRUE);

                    filterMappingGBeanData.setAttribute("forwardDispatch", Boolean.TRUE);

                    filterMappingGBeanData.setAttribute("includeDispatch", Boolean.TRUE);

                    filterMappingGBeanData.setAttribute("errorDispatch", Boolean.FALSE);

                    filterMappingGBeanData.setReferencePattern("Filter", defaultFilterObjectName);

                    earContext.addGBean(filterMappingGBeanData);

                }

            }

            //add default filtermappings

//            if (defaultFilterMappings != null) {

//                for (Iterator iterator = defaultFilterMappings.iterator(); iterator.hasNext();) {

//                    Object defaultFilterMapping = iterator.next();

//                    GBeanData filterMappingGBeanData = getGBeanData(kernel, defaultFilterMapping);

//                    String filterName = (String) filterMappingGBeanData.getAttribute("filterName");

//                    ObjectName defaultFilterMappingObjectName;

//                    if (filterMappingGBeanData.getAttribute("urlPattern") != null) {

//                        String urlPattern = (String) filterMappingGBeanData.getAttribute("urlPattern");

//                        defaultFilterMappingObjectName = NameFactory.getWebFilterMappingName(null, null, null, null, filterName, null, urlPattern, moduleJ2eeContext);

//                    } else {

//                        Set servletNames = filterMappingGBeanData.getReferencePatterns("Servlet");

//                        if (servletNames == null || servletNames.size() != 1) {

//                            throw new DeploymentException("Exactly one servlet name must be supplied");

//                        }

//                        ObjectName servletObjectName = (ObjectName) servletNames.iterator().next();

//                        String servletName = servletObjectName.getKeyProperty("name");

//                        defaultFilterMappingObjectName = NameFactory.getWebFilterMappingName(null, null, null, null, filterName, servletName, null, moduleJ2eeContext);

//                    }

//                    filterMappingGBeanData.setName(defaultFilterMappingObjectName);

//                    filterMappingGBeanData.setReferencePattern("JettyFilterMappingRegistration", webModuleName);

//                    earContext.addGBean(filterMappingGBeanData);

//                }

//            }

            FilterMappingType[] filterMappingArray = webApp.getFilterMappingArray();

            for (int i = 0; i < filterMappingArray.length; i++) {

                FilterMappingType filterMappingType = filterMappingArray[i];

                String filterName = filterMappingType.getFilterName().getStringValue().trim();

                GBeanData filterMappingData = new GBeanData(JettyFilterMapping.GBEAN_INFO);

                filterMappingData.setReferencePattern("Previous", previous);

                filterMappingData.setReferencePattern("JettyServletRegistration", webModuleName);

                ObjectName filterMappingName = null;

                if (filterMappingType.isSetUrlPattern()) {

                    //do not trim!

                    String urlPattern = filterMappingType.getUrlPattern().getStringValue().trim();

                    filterMappingData.setAttribute("urlPattern", urlPattern);

                    filterMappingName = NameFactory.getWebFilterMappingName(null, null, null, null, filterName, null, urlPattern, moduleJ2eeContext);

                }

                if (filterMappingType.isSetServletName()) {

                    String servletName = filterMappingType.getServletName().getStringValue().trim();

                    ObjectName servletObjectName = NameFactory.getWebComponentName(null, null, null, null, servletName, NameFactory.SERVLET, moduleJ2eeContext);

                    filterMappingData.setReferencePattern("Servlet", servletObjectName);

                    filterMappingName = NameFactory.getWebFilterMappingName(null, null, null, null, filterName, servletName, null, moduleJ2eeContext);

                }

                filterMappingData.setName(filterMappingName);

                previous = filterMappingName;

                boolean request = filterMappingType.getDispatcherArray().length == 0;

                boolean forward = false;

                boolean include = false;

                boolean error = false;

                for (int j = 0; j < filterMappingType.getDispatcherArray().length; j++) {

                    DispatcherType dispatcherType = filterMappingType.getDispatcherArray()[j];

                    if (dispatcherType.getStringValue().equals("REQUEST")) {

                        request = true;

                    } else if (dispatcherType.getStringValue().equals("FORWARD")) {

                        forward = true;

                    } else if (dispatcherType.getStringValue().equals("INCLUDE")) {

                        include = true;

                    } else if (dispatcherType.getStringValue().equals("ERROR")) {

                        error = true;

                    }

                }

                filterMappingData.setAttribute("requestDispatch", Boolean.valueOf(request));

                filterMappingData.setAttribute("forwardDispatch", Boolean.valueOf(forward));

                filterMappingData.setAttribute("includeDispatch", Boolean.valueOf(include));

                filterMappingData.setAttribute("errorDispatch", Boolean.valueOf(error));

                ObjectName filterObjectName = NameFactory.getWebComponentName(null, null, null, null, filterName, NameFactory.WEB_FILTER, moduleJ2eeContext);

                filterMappingData.setReferencePattern("Filter", filterObjectName);

                earContext.addGBean(filterMappingData);

            }

            FilterType[] filterArray = webApp.getFilterArray();

            for (int i = 0; i < filterArray.length; i++) {

                FilterType filterType = filterArray[i];

                String filterName = filterType.getFilterName().getStringValue().trim();

                ObjectName filterObjectName = NameFactory.getWebComponentName(null, null, null, null, filterName, NameFactory.WEB_FILTER, moduleJ2eeContext);

                GBeanData filterData = new GBeanData(filterObjectName, JettyFilterHolder.GBEAN_INFO);

                filterData.setAttribute("filterName", filterName);

                filterData.setAttribute("filterClass", filterType.getFilterClass().getStringValue().trim());

                Map initParams = new HashMap();

                ParamValueType[] initParamArray = filterType.getInitParamArray();

                for (int j = 0; j < initParamArray.length; j++) {

                    ParamValueType paramValueType = initParamArray[j];

                    initParams.put(paramValueType.getParamName().getStringValue().trim(), paramValueType.getParamValue().getStringValue().trim());

                }

                filterData.setAttribute("initParams", initParams);

                filterData.setReferencePattern("JettyServletRegistration", webModuleName);

                earContext.addGBean(filterData);

            }

            //add default servlets

            if (defaultServlets != null) {

                for (Iterator iterator = defaultServlets.iterator(); iterator.hasNext();) {

                    Object defaultServlet = iterator.next();

                    GBeanData servletGBeanData = getGBeanData(kernel, defaultServlet);

                    ObjectName defaultServletObjectName = NameFactory.getWebComponentName(null, null, null, null, (String) servletGBeanData.getAttribute("servletName"), NameFactory.SERVLET, moduleJ2eeContext);

                    servletGBeanData.setName(defaultServletObjectName);

                    servletGBeanData.setReferencePattern("JettyServletRegistration", webModuleName);

                    Set defaultServletMappings = new HashSet((Collection) servletGBeanData.getAttribute("servletMappings"));

                    defaultServletMappings.removeAll(knownServletMappings);

                    servletGBeanData.setAttribute("servletMappings", defaultServletMappings);

                    earContext.addGBean(servletGBeanData);

                }

            }

            //set up servlet gbeans.

            Map portMap = webModule.getPortMap();

            addServlets(webModuleName, webModule.getModuleFile(), servletTypes, servletMappings, securityRoles, rolePermissions, portMap, webClassLoader, moduleJ2eeContext, earContext);

            if (jettyWebApp.isSetSecurityRealmName()) {

                if (earContext.getSecurityConfiguration() == null) {

                     throw new DeploymentException("You have specified a <security-realm-name> for the webapp " + webModuleName + " but no <security> configuration (role mapping) is supplied in the Geronimo plan for the web application (or the Geronimo plan for the EAR if the web app is in an EAR)");

                }

                String securityRealmName = jettyWebApp.getSecurityRealmName().trim();

                webModuleData.setAttribute("securityRealmName", securityRealmName);

                /**

                 * TODO - go back to commented version when possible.

                 */

                String policyContextID = webModuleName.getCanonicalName().replaceAll("[, :]", "_");

                //String policyContextID = webModuleName.getCanonicalName();

                webModuleData.setAttribute("policyContextID", policyContextID);

                ComponentPermissions componentPermissions = buildSpecSecurityConfig(webApp, securityRoles, rolePermissions);

                webModuleData.setAttribute("excludedPermissions", componentPermissions.getExcludedPermissions());

                PermissionCollection checkedPermissions = new Permissions();

                for (Iterator iterator = rolePermissions.values().iterator(); iterator.hasNext();) {

                    PermissionCollection permissionsForRole = (PermissionCollection) iterator.next();

                    for (Enumeration iterator2 = permissionsForRole.elements(); iterator2.hasMoreElements();) {

                        Permission permission = (Permission) iterator2.nextElement();

                        checkedPermissions.add(permission);

                    }

                }

                webModuleData.setAttribute("checkedPermissions", checkedPermissions);

                earContext.addSecurityContext(policyContextID, componentPermissions);

                DefaultPrincipal defaultPrincipal = earContext.getSecurityConfiguration().getDefaultPrincipal();

                webModuleData.setAttribute("defaultPrincipal", defaultPrincipal);

                webModuleData.setReferencePattern("RoleDesignateSource", earContext.getJaccManagerName());

            }

        } catch (DeploymentException de) {

            throw de;

        } catch (Exception e) {

            throw new DeploymentException("Unable to initialize webapp GBean", e);

        }

    }

    public String getSchemaNamespace() {

        return JETTY_NAMESPACE;

    }

    private ClassLoader getWebClassLoader(EARContext earContext, WebModule webModule, ClassLoader cl, boolean contextPriorityClassLoader) throws DeploymentException {

        getWebClassPath(earContext, webModule);

        URI[] webClassPath = webModule.getWebClasspath();

        URI baseUri = earContext.getBaseDir().toURI();

        URL baseUrl = null;

        try {

            baseUrl = baseUri.resolve(webModule.getTargetPathURI()).toURL();

        } catch (MalformedURLException e) {

            throw new DeploymentException("Invalid module location: " + webModule.getTargetPathURI() + ", baseUri: " + baseUri);

        }

        URL[] webClassPathURLs = new URL[webClassPath.length];

        for (int i = 0; i < webClassPath.length; i++) {

            URI path = baseUri.resolve(webClassPath[i]);

            try {

                webClassPathURLs[i] = path.toURL();

            } catch (MalformedURLException e) {

                throw new DeploymentException("Invalid web class path element: path=" + path + ", baseUri=" + baseUri);

            }

        }

        ClassLoader webClassLoader = new JettyClassLoader(webClassPathURLs, baseUrl, cl, contextPriorityClassLoader);

        return webClassLoader;

    }

    /**

     * Adds the provided servlets, taking into account the load-on-startup ordering.

     *

     * @param webModuleName     an <code>ObjectName</code> value

     * @param moduleFile        a <code>JarFile</code> value

     * @param servletTypes      a <code>ServletType[]</code> value, contains the <code>servlet</code> entries from <code>web.xml</code>.

     * @param servletMappings   a <code>Map</code> value

     * @param securityRoles     a <code>Set</code> value

     * @param rolePermissions   a <code>Map</code> value

     * @param portMap           a <code>Map</code> value

     * @param webClassLoader    a <code>ClassLoader</code> value

     * @param moduleJ2eeContext a <code>J2eeContext</code> value

     * @param earContext        an <code>EARContext</code> value

     * @throws MalformedObjectNameException if an error occurs

     * @throws DeploymentException          if an error occurs

     */

    private void addServlets(ObjectName webModuleName,

                             JarFile moduleFile,

                             ServletType[] servletTypes,

                             Map servletMappings,

                             Set securityRoles,

                             Map rolePermissions, Map portMap,

                             ClassLoader webClassLoader,

                             J2eeContext moduleJ2eeContext,

                             EARContext earContext) throws MalformedObjectNameException, DeploymentException {

        // this TreeSet will order the ServletTypes based on whether

        // they have a load-on-startup element and what its value is

        TreeSet loadOrder = new TreeSet(new StartupOrderComparator());

        // add all of the servlets to the sorted set

        for (int i = 0; i < servletTypes.length; i++) {

            loadOrder.add(servletTypes[i]);

        }

        // now that they're sorted, read them in order and add them to

        // the context.  we'll use a GBean reference to enforce the

        // load order.  Each servlet GBean (except the first) has a

        // reference to the previous GBean.  The kernel will ensure

        // that each "previous" GBean is running before it starts any

        // other GBeans that reference it.  See also

        // o.a.g.jetty.JettyFilterMapping which provided the example

        // of how to do this.

        // http://issues.apache.org/jira/browse/GERONIMO-645

        ServletType previousServlet = null;

        for (Iterator servlets = loadOrder.iterator(); servlets.hasNext();) {

            ServletType servletType = (ServletType) servlets.next();

            addServlet(webModuleName, moduleFile, previousServlet, servletType, servletMappings, securityRoles, rolePermissions, portMap, webClassLoader, moduleJ2eeContext, earContext);

            previousServlet = servletType;

        }

        // JACC v1.0 secion B.19

        addUnmappedJSPPermissions(securityRoles, rolePermissions);

    }

    private void addUnmappedJSPPermissions(Set securityRoles, Map rolePermissions) {

        for (Iterator iter = securityRoles.iterator(); iter.hasNext();) {

            String roleName = (String) iter.next();

            addPermissionToRole(roleName, new WebRoleRefPermission("", roleName), rolePermissions);

        }

    }

    private void addServlet(ObjectName webModuleName,

                            JarFile moduleFile,

                            ServletType previousServlet,

                            ServletType servletType,

                            Map servletMappings,

                            Set securityRoles,

                            Map rolePermissions, Map portMap,

                            ClassLoader webClassLoader,

                            J2eeContext moduleJ2eeContext,

                            EARContext earContext) throws MalformedObjectNameException, DeploymentException {

        String servletName = servletType.getServletName().getStringValue().trim();

        ObjectName servletObjectName = NameFactory.getWebComponentName(null, null, null, null, servletName, NameFactory.SERVLET, moduleJ2eeContext);

        GBeanData servletData;

        if (servletType.isSetServletClass()) {

            String servletClassName = servletType.getServletClass().getStringValue().trim();

            Class servletClass = null;

            try {

                servletClass = webClassLoader.loadClass(servletClassName);

            } catch (ClassNotFoundException e) {

                throw new DeploymentException("Could not load servlet class " + servletClassName, e);

            }

            Class baseServletClass = null;

            try {

                baseServletClass = webClassLoader.loadClass(Servlet.class.getName());

            } catch (ClassNotFoundException e) {

                throw new DeploymentException("Could not load javax.servlet.Servlet in web classloader", e);

            }

            if (baseServletClass.isAssignableFrom(servletClass)) {

                servletData = new GBeanData(servletObjectName, JettyServletHolder.GBEAN_INFO);

                servletData.setAttribute("servletClass", servletClassName);

            } else {

                servletData = new GBeanData(pojoWebServiceTemplate);

                servletData.setName(servletObjectName);

                //let the web service builder deal with configuring the gbean with the web service stack

                Object portInfo = portMap.get(servletName);

                if (portInfo == null) {

                    throw new DeploymentException("No web service deployment info for servlet name " + servletName);

                }

                webServiceBuilder.configurePOJO(servletData, moduleFile, portInfo, servletClassName, webClassLoader);

            }

        } else if (servletType.isSetJspFile()) {

            servletData = new GBeanData(servletObjectName, JettyServletHolder.GBEAN_INFO);

            servletData.setAttribute("jspFile", servletType.getJspFile().getStringValue().trim());

            //TODO MAKE THIS CONFIGURABLE!!! Jetty uses the servlet mapping set up from the default-web.xml

            servletData.setAttribute("servletClass", "org.apache.jasper.servlet.JspServlet");

        } else {

            throw new DeploymentException("Neither servlet class nor jsp file is set for " + servletName);

        }

        // link to previous servlet, if there is one, so that we

        // preserve the <load-on-startup> ordering.

        // http://issues.apache.org/jira/browse/GERONIMO-645

        if (null != previousServlet) {

            String name = previousServlet.getServletName().getStringValue().trim();

            ObjectName oName = NameFactory.getWebComponentName(null, null, null, null, name, NameFactory.SERVLET, moduleJ2eeContext);

            servletData.setReferencePattern("Previous", oName);

        }

        //TODO in init param setter, add classpath if jspFile is not null.

        servletData.setReferencePattern("JettyServletRegistration", webModuleName);

        servletData.setAttribute("servletName", servletName);

        Map initParams = new HashMap();

        ParamValueType[] initParamArray = servletType.getInitParamArray();

        for (int j = 0; j < initParamArray.length; j++) {

            ParamValueType paramValueType = initParamArray[j];

            initParams.put(paramValueType.getParamName().getStringValue().trim(), paramValueType.getParamValue().getStringValue().trim());

        }

        servletData.setAttribute("initParams", initParams);

        if (servletType.isSetLoadOnStartup()) {

            Integer loadOnStartup = new Integer(servletType.getLoadOnStartup().getBigIntegerValue().intValue());

            servletData.setAttribute("loadOnStartup", loadOnStartup);

        }

        Set mappings = (Set) servletMappings.get(servletName);

        servletData.setAttribute("servletMappings", mappings == null ? Collections.EMPTY_SET : mappings);

        //run-as

        if (servletType.isSetRunAs()) {

            servletData.setAttribute("runAsRole", servletType.getRunAs().getRoleName().getStringValue().trim());

        }

        //WebRoleRefPermissions

        SecurityRoleRefType[] securityRoleRefTypeArray = servletType.getSecurityRoleRefArray();

        Set unmappedRoles = new HashSet(securityRoles);

        for (int j = 0; j < securityRoleRefTypeArray.length; j++) {

            SecurityRoleRefType securityRoleRefType = securityRoleRefTypeArray[j];

            String roleName = securityRoleRefType.getRoleName().getStringValue().trim();

            String roleLink = securityRoleRefType.getRoleLink().getStringValue().trim();

            //jacc 3.1.3.2

            /*   The name of the WebRoleRefPermission must be the servlet-name in whose

            * context the security-role-ref is defined. The actions of the  WebRoleRefPermission

            * must be the value of the role-name (that is the  reference), appearing in the security-role-ref.

            * The deployment tools must  call the addToRole method on the PolicyConfiguration object to add the

            * WebRoleRefPermission object resulting from the translation to the role

            * identified in the role-link appearing in the security-role-ref.

            */

            addPermissionToRole(roleLink, new WebRoleRefPermission(servletName, roleName), rolePermissions);

            unmappedRoles.remove(roleName);

        }

        for (Iterator iterator = unmappedRoles.iterator(); iterator.hasNext();) {

            String roleName = (String) iterator.next();

            addPermissionToRole(roleName, new WebRoleRefPermission(servletName, roleName), rolePermissions);

        }

        earContext.addGBean(servletData);

    }

    private ComponentPermissions buildSpecSecurityConfig(WebAppType webApp, Set securityRoles, Map rolePermissions) {

        Map uncheckedPatterns = new HashMap();

        Map uncheckedResourcePatterns = new HashMap();

        Map uncheckedUserPatterns = new HashMap();

        Map excludedPatterns = new HashMap();

        Map rolesPatterns = new HashMap();

        Set allSet = new HashSet();   // == allMap.values()

        Map allMap = new HashMap();   //uncheckedPatterns union excludedPatterns union rolesPatterns.

        SecurityConstraintType[] securityConstraintArray = webApp.getSecurityConstraintArray();

        for (int i = 0; i < securityConstraintArray.length; i++) {

            SecurityConstraintType securityConstraintType = securityConstraintArray[i];

            Map currentPatterns;

            if (securityConstraintType.isSetAuthConstraint()) {

                if (securityConstraintType.getAuthConstraint().getRoleNameArray().length == 0) {

                    currentPatterns = excludedPatterns;

                } else {

                    currentPatterns = rolesPatterns;

                }

            } else {

                currentPatterns = uncheckedPatterns;

            }

            String transport = "";

            if (securityConstraintType.isSetUserDataConstraint()) {

                transport = securityConstraintType.getUserDataConstraint().getTransportGuarantee().getStringValue().trim().toUpperCase();

            }

            WebResourceCollectionType[] webResourceCollectionTypeArray = securityConstraintType.getWebResourceCollectionArray();

            for (int j = 0; j < webResourceCollectionTypeArray.length; j++) {

                WebResourceCollectionType webResourceCollectionType = webResourceCollectionTypeArray[j];

                UrlPatternType[] urlPatternTypeArray = webResourceCollectionType.getUrlPatternArray();

                for (int k = 0; k < urlPatternTypeArray.length; k++) {

                    UrlPatternType urlPatternType = urlPatternTypeArray[k];

                    String url = urlPatternType.getStringValue().trim();

                    URLPattern pattern = (URLPattern) currentPatterns.get(url);

                    if (pattern == null) {

                        pattern = new URLPattern(url);

                        currentPatterns.put(url, pattern);

                    }

                    URLPattern allPattern = (URLPattern) allMap.get(url);

                    if (allPattern == null) {

                        allPattern = new URLPattern(url);

                        allSet.add(allPattern);

                        allMap.put(url, allPattern);

                    }

                    HttpMethodType[] httpMethodTypeArray = webResourceCollectionType.getHttpMethodArray();

                    if (httpMethodTypeArray.length == 0) {

                        pattern.addMethod("");

                        allPattern.addMethod("");

                    } else {

                        for (int l = 0; l < httpMethodTypeArray.length; l++) {

                            HttpMethodType httpMethodType = httpMethodTypeArray[l];

                            //TODO is trim OK?

                            String method = httpMethodType.getStringValue().trim();

                            pattern.addMethod(method);

                            allPattern.addMethod(method);

                        }

                    }

                    if (currentPatterns == rolesPatterns) {

                        RoleNameType[] roleNameTypeArray = securityConstraintType.getAuthConstraint().getRoleNameArray();

                        for (int l = 0; l < roleNameTypeArray.length; l++) {

                            RoleNameType roleNameType = roleNameTypeArray[l];

                            String role = roleNameType.getStringValue().trim();

                            if (role.equals("*")) {

                                pattern.addAllRoles(securityRoles);

                            } else {

                                pattern.addRole(role);

                            }

                        }

                    }

                    pattern.setTransport(transport);

                }

            }

        }

        PermissionCollection excludedPermissions = new Permissions();

        PermissionCollection uncheckedPermissions = new Permissions();

        Iterator iter = excludedPatterns.keySet().iterator();

        while (iter.hasNext()) {

            URLPattern pattern = (URLPattern) excludedPatterns.get(iter.next());

            String name = pattern.getQualifiedPattern(allSet);

            String actions = pattern.getMethods();