* JBoss, Home of Professional Open Source.

* Copyright 2013, Red Hat, Inc., and individual contributors

* as indicated by the @author tags. See the copyright.txt file in the

* distribution for a full listing of individual contributors.

*

* This is free software; you can redistribute it and/or modify it

* under the terms of the GNU Lesser General Public License as

* published by the Free Software Foundation; either version 2.1 of

* the License, or (at your option) any later version.

*

* This software is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

* Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public

* License along with this software; if not, write to the Free

* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA

* 02110-1301 USA, or see the FSF site: http://www.fsf.org.

*/

* Service that builds up the undertow metadata.

*

* @author Stuart Douglas

*/

    public static final ServiceName SERVICE_NAME = ServiceName.of("UndertowDeploymentInfoService");

    private static final String TEMP_DIR = "jboss.server.temp.dir";

    public static final String DEFAULT_SERVLET_NAME = "default";

    public static final String OLD_URI_PREFIX = "http://java.sun.com";

    public static final String NEW_URI_PREFIX = "http://xmlns.jcp.org";

    public static final String UNDERTOW = "undertow";

    private DeploymentInfo deploymentInfo;

    private final JBossWebMetaData mergedMetaData;

    private final String deploymentName;

    private final TldsMetaData tldsMetaData;

    private final List<TldMetaData> sharedTlds;

    private final Module module;

    private final ScisMetaData scisMetaData;

    private final VirtualFile deploymentRoot;

    private final String jaccContextId;

    private final String securityDomain;

    private final List<ServletContextAttribute> attributes;

    private final String contextPath;

    private final List<SetupAction> setupActions;

    private final Set<VirtualFile> overlays;

    private final List<ExpressionFactoryWrapper> expressionFactoryWrappers;

    private final List<PredicatedHandler> predicatedHandlers;

    private final List<HandlerWrapper> initialHandlerChainWrappers;

    private final List<HandlerWrapper> innerHandlerChainWrappers;

    private final List<HandlerWrapper> outerHandlerChainWrappers;

    private final List<ThreadSetupAction> threadSetupActions;

    private final List<ServletExtension> servletExtensions;

    private final SharedSessionManagerConfig sharedSessionManagerConfig;

    private final boolean explodedDeployment;

    private final InjectedValue<UndertowService> undertowService = new InjectedValue<>();

    private final InjectedValue<SessionManagerFactory> sessionManagerFactory = new InjectedValue<>();

    private final InjectedValue<SessionIdentifierCodec> sessionIdentifierCodec = new InjectedValue<>();

    private final InjectedValue<SecurityDomainContext> securityDomainContextValue = new InjectedValue<SecurityDomainContext>();

    private final InjectedValue<ServletContainerService> container = new InjectedValue<>();

    private final InjectedValue<PathManager> pathManagerInjector = new InjectedValue<PathManager>();

    private final InjectedValue<ComponentRegistry> componentRegistryInjectedValue = new InjectedValue<>();

    private final InjectedValue<Host> host = new InjectedValue<>();

    private final InjectedValue<ControlPoint> controlPointInjectedValue = new InjectedValue<>();

    private final Map<String, InjectedValue<Executor>> executorsByName = new HashMap<String, InjectedValue<Executor>>();

    private final String topLevelDeploymentName;

    private final WebSocketDeploymentInfo webSocketDeploymentInfo;

    private UndertowDeploymentInfoService(final JBossWebMetaData mergedMetaData, final String deploymentName, final TldsMetaData tldsMetaData, final List<TldMetaData> sharedTlds, final Module module, final ScisMetaData scisMetaData, final VirtualFile deploymentRoot, final String jaccContextId, final String securityDomain, final List<ServletContextAttribute> attributes, final String contextPath, final List<SetupAction> setupActions, final Set<VirtualFile> overlays, final List<ExpressionFactoryWrapper> expressionFactoryWrappers, List<PredicatedHandler> predicatedHandlers, List<HandlerWrapper> initialHandlerChainWrappers, List<HandlerWrapper> innerHandlerChainWrappers, List<HandlerWrapper> outerHandlerChainWrappers, List<ThreadSetupAction> threadSetupActions, boolean explodedDeployment, List<ServletExtension> servletExtensions, SharedSessionManagerConfig sharedSessionManagerConfig, String topLevelDeploymentName, WebSocketDeploymentInfo webSocketDeploymentInfo) {

        this.mergedMetaData = mergedMetaData;

        this.deploymentName = deploymentName;

        this.tldsMetaData = tldsMetaData;

        this.sharedTlds = sharedTlds;

        this.module = module;

        this.scisMetaData = scisMetaData;

        this.deploymentRoot = deploymentRoot;

        this.jaccContextId = jaccContextId;

        this.securityDomain = securityDomain;

        this.attributes = attributes;

        this.contextPath = contextPath;

        this.setupActions = setupActions;

        this.overlays = overlays;

        this.expressionFactoryWrappers = expressionFactoryWrappers;

        this.predicatedHandlers = predicatedHandlers;

        this.initialHandlerChainWrappers = initialHandlerChainWrappers;

        this.innerHandlerChainWrappers = innerHandlerChainWrappers;

        this.outerHandlerChainWrappers = outerHandlerChainWrappers;

        this.threadSetupActions = threadSetupActions;

        this.explodedDeployment = explodedDeployment;

        this.servletExtensions = servletExtensions;

        this.sharedSessionManagerConfig = sharedSessionManagerConfig;

        this.topLevelDeploymentName = topLevelDeploymentName;

        this.webSocketDeploymentInfo = webSocketDeploymentInfo;

    }

    @Override

    public synchronized void start(final StartContext startContext) throws StartException {

        ClassLoader oldTccl = Thread.currentThread().getContextClassLoader();

        try {

            Thread.currentThread().setContextClassLoader(module.getClassLoader());

            DeploymentInfo deploymentInfo = createServletConfig();

            handleDistributable(deploymentInfo);

            handleIdentityManager(deploymentInfo);

            handleJASPIMechanism(deploymentInfo);

            handleJACCAuthorization

                    (deploymentInfo);

            handleAdditionalAuthenticationMechanisms(deploymentInfo);

            handleSecurityCache(deploymentInfo, mergedMetaData);

            if(mergedMetaData.isUseJBossAuthorization()) {

                deploymentInfo.setAuthorizationManager(new JbossAuthorizationManager(deploymentInfo.getAuthorizationManager()));

            }

            SessionConfigMetaData sessionConfig = mergedMetaData.getSessionConfig();

            if(sharedSessionManagerConfig != null && sharedSessionManagerConfig.getSessionConfig() != null) {

                sessionConfig = sharedSessionManagerConfig.getSessionConfig();

            }

            ServletSessionConfig config = null;

            //default session config

            SessionCookieConfig defaultSessionConfig = container.getValue().getSessionCookieConfig();

            if (defaultSessionConfig != null) {

                config = new ServletSessionConfig();

                if (defaultSessionConfig.getName() != null) {

                    config.setName(defaultSessionConfig.getName());

                }

                if (defaultSessionConfig.getDomain() != null) {

                    config.setDomain(defaultSessionConfig.getDomain());

                }

                if (defaultSessionConfig.getHttpOnly() != null) {

                    config.setHttpOnly(defaultSessionConfig.getHttpOnly());

                }

                if (defaultSessionConfig.getSecure() != null) {

                    config.setSecure(defaultSessionConfig.getSecure());

                }

                if (defaultSessionConfig.getMaxAge() != null) {

                    config.setMaxAge(defaultSessionConfig.getMaxAge());

                }

                if (defaultSessionConfig.getComment() != null) {

                    config.setComment(defaultSessionConfig.getComment());

                }

            }

            boolean sessionTimeoutSet = false;

            if (sessionConfig != null) {

                if (sessionConfig.getSessionTimeoutSet()) {

                    deploymentInfo.setDefaultSessionTimeout(sessionConfig.getSessionTimeout() * 60);

                    sessionTimeoutSet = true;

                }

                CookieConfigMetaData cookieConfig = sessionConfig.getCookieConfig();

                if (config == null) {

                    config = new ServletSessionConfig();

                }

                if (cookieConfig != null) {

                    if (cookieConfig.getName() != null) {

                        config.setName(cookieConfig.getName());

                    }

                    if (cookieConfig.getDomain() != null) {

                        config.setDomain(cookieConfig.getDomain());

                    }

                    if (cookieConfig.getComment() != null) {

                        config.setComment(cookieConfig.getComment());

                    }

                    config.setSecure(cookieConfig.getSecure());

                    config.setPath(cookieConfig.getPath());

                    config.setMaxAge(cookieConfig.getMaxAge());

                    config.setHttpOnly(cookieConfig.getHttpOnly());

                }

                List<SessionTrackingModeType> modes = sessionConfig.getSessionTrackingModes();

                if (modes != null && !modes.isEmpty()) {

                    final Set<SessionTrackingMode> trackingModes = new HashSet<>();

                    for (SessionTrackingModeType mode : modes) {

                        switch (mode) {

                            case COOKIE:

                                trackingModes.add(SessionTrackingMode.COOKIE);

                                break;

                            case SSL:

                                trackingModes.add(SessionTrackingMode.SSL);

                                break;

                            case URL:

                                trackingModes.add(SessionTrackingMode.URL);

                                break;

                        }

                    }

                    config.setSessionTrackingModes(trackingModes);

                }

            }

            if(!sessionTimeoutSet) {

                deploymentInfo.setDefaultSessionTimeout(container.getValue().getDefaultSessionTimeout() * 60);

            }

            if (config != null) {

                deploymentInfo.setServletSessionConfig(config);

            }

            for (final SetupAction action : setupActions) {

                deploymentInfo.addThreadSetupAction(new UndertowThreadSetupAction(action));

            }

            if (initialHandlerChainWrappers != null) {

                for (HandlerWrapper handlerWrapper : initialHandlerChainWrappers) {

                    deploymentInfo.addInitialHandlerChainWrapper(handlerWrapper);

                }

            }

            if (innerHandlerChainWrappers != null) {

                for (HandlerWrapper handlerWrapper : innerHandlerChainWrappers) {

                    deploymentInfo.addInnerHandlerChainWrapper(handlerWrapper);

                }

            }

            if (outerHandlerChainWrappers != null) {

                for (HandlerWrapper handlerWrapper : outerHandlerChainWrappers) {

                    deploymentInfo.addOuterHandlerChainWrapper(handlerWrapper);

                }

            }

            if (threadSetupActions != null) {

                for (ThreadSetupAction threadSetupAction : threadSetupActions) {

                    deploymentInfo.addThreadSetupAction(threadSetupAction);

                }

            }

            deploymentInfo.setServerName("WildFly " + Version.AS_VERSION);

            if (undertowService.getValue().isStatisticsEnabled()) {

                deploymentInfo.setMetricsCollector(new UndertowMetricsCollector());

            }

            ControlPoint controlPoint = controlPointInjectedValue.getOptionalValue();

            if (controlPoint != null) {

                deploymentInfo.addInitialHandlerChainWrapper(GlobalRequestControllerHandler.wrapper(controlPoint));

            }

            this.deploymentInfo = deploymentInfo;

        } finally {

            Thread.currentThread().setContextClassLoader(oldTccl);

        }

    }

    private void handleSecurityCache(DeploymentInfo deploymentInfo, JBossWebMetaData mergedMetaData) {

        AuthenticationManager manager = securityDomainContextValue.getValue().getAuthenticationManager();

        if(manager instanceof CacheableManager) {

            deploymentInfo.addNotificationReceiver(new CacheInvalidationNotificationReceiver((CacheableManager<?, java.security.Principal>) manager));

            if(mergedMetaData.isFlushOnSessionInvalidation()) {

                CacheInvalidationSessionListener listener = new CacheInvalidationSessionListener((CacheableManager<?, java.security.Principal>) manager);

                deploymentInfo.addListener(Servlets.listener(CacheInvalidationSessionListener.class, new ImmediateInstanceFactory<EventListener>(listener)));

            }

        }

    }

    @Override

    public synchronized void stop(final StopContext stopContext) {

        IoUtils.safeClose(this.deploymentInfo.getResourceManager());

        AuthenticationManager authManager = securityDomainContextValue.getValue().getAuthenticationManager();

        if (authManager != null && authManager instanceof JBossCachedAuthenticationManager) {

            ((JBossCachedAuthenticationManager)authManager).releaseModuleEntries(module.getClassLoader());

        }

        this.deploymentInfo.setConfidentialPortManager(null);

        this.deploymentInfo = null;

    }

    @Override

    public synchronized DeploymentInfo getValue() throws IllegalStateException, IllegalArgumentException {

        return deploymentInfo;

    }

    /**

     * <p>Adds to the deployment the {@link JASPIAuthenticationMechanism}, if necessary. The handler will be added if the security domain

     * is configured with JASPI authentication.</p>

     *

     * @param deploymentInfo

     */

    private void handleJASPIMechanism(final DeploymentInfo deploymentInfo) {

        ApplicationPolicy applicationPolicy = SecurityConfiguration.getApplicationPolicy(this.securityDomain);

        if (applicationPolicy != null && JASPIAuthenticationInfo.class.isInstance(applicationPolicy.getAuthenticationInfo())) {

            String authMethod = null;

            LoginConfig loginConfig = deploymentInfo.getLoginConfig();

            if (loginConfig != null && loginConfig.getAuthMethods().size() > 0)

                authMethod = loginConfig.getAuthMethods().get(0).getName();

            deploymentInfo.setJaspiAuthenticationMechanism(new JASPIAuthenticationMechanism(this.securityDomain, authMethod));

            deploymentInfo.setSecurityContextFactory(new JASPICSecurityContextFactory(this.securityDomain));

        }

    }

    /**

     * <p>

     * Sets the {@link JACCAuthorizationManager} in the specified {@link DeploymentInfo} if the webapp security domain

     * has defined a JACC authorization module.

     * </p>

     *

     * @param deploymentInfo the {@link DeploymentInfo} instance.

     */

    private void handleJACCAuthorization(final DeploymentInfo deploymentInfo) {

        // TODO make the authorization manager implementation configurable in Undertow or jboss-web.xml

        ApplicationPolicy applicationPolicy = SecurityConfiguration.getApplicationPolicy(this.securityDomain);

        if (applicationPolicy != null) {

            AuthorizationInfo authzInfo = applicationPolicy.getAuthorizationInfo();

            if (authzInfo != null) {

                for (AuthorizationModuleEntry entry : authzInfo.getModuleEntries()) {

                    if (JACCAuthorizationModule.class.getName().equals(entry.getPolicyModuleName())) {

                        deploymentInfo.setAuthorizationManager(new JACCAuthorizationManager());

                        break;

                    }

                }

            }

        }

    }

    private void handleAdditionalAuthenticationMechanisms(final DeploymentInfo deploymentInfo) {

        for (Map.Entry<String, AuthenticationMechanism> am : host.getValue().getAdditionalAuthenticationMechanisms().entrySet()) {

            deploymentInfo.addFirstAuthenticationMechanism(am.getKey(), am.getValue());

        }

    }

    private void handleIdentityManager(final DeploymentInfo deploymentInfo) {

        SecurityDomainContext sdc = securityDomainContextValue.getValue();

        deploymentInfo.setIdentityManager(new JAASIdentityManagerImpl(sdc));

        AuditManager auditManager = sdc.getAuditManager();

        if (auditManager != null && !mergedMetaData.isDisableAudit()) {

            deploymentInfo.addNotificationReceiver(new AuditNotificationReceiver(auditManager));

        }

        deploymentInfo.setConfidentialPortManager(getConfidentialPortManager());

    }

    private ConfidentialPortManager getConfidentialPortManager() {

        return new ConfidentialPortManager() {

            @Override

            public int getConfidentialPort(HttpServerExchange exchange) {

                int port = exchange.getConnection().getLocalAddress(InetSocketAddress.class).getPort();

                if (port<0){

                    UndertowLogger.ROOT_LOGGER.debugf("Confidential port not defined for port %s", port);

                }

                return host.getValue().getServer().getValue().lookupSecurePort(port);

            }

        };

    }

    private void handleDistributable(final DeploymentInfo deploymentInfo) {

        SessionManagerFactory managerFactory = this.sessionManagerFactory.getOptionalValue();

        if (managerFactory != null) {

            deploymentInfo.setSessionManagerFactory(managerFactory);

        }

        SessionIdentifierCodec codec = this.sessionIdentifierCodec.getOptionalValue();

        if (codec != null) {

            deploymentInfo.setSessionConfigWrapper(new CodecSessionConfigWrapper(codec));

        }

    }

    /*

    This is to address WFLY-1894 but should probably be moved to some other place.

     */

    private String resolveContextPath() {

        if (deploymentName.equals(host.getValue().getDefaultWebModule())) {

            return "/";

        } else {

            return contextPath;

        }

    }

    private DeploymentInfo createServletConfig() throws StartException {

        final ComponentRegistry componentRegistry = componentRegistryInjectedValue.getValue();

        try {

            if (!mergedMetaData.isMetadataComplete()) {

                mergedMetaData.resolveAnnotations();

            }

            final DeploymentInfo d = new DeploymentInfo();

            d.setContextPath(resolveContextPath());

            if (mergedMetaData.getDescriptionGroup() != null) {

                d.setDisplayName(mergedMetaData.getDescriptionGroup().getDisplayName());

            }

            d.setDeploymentName(deploymentName);

            d.setHostName(host.getValue().getName());

            final ServletContainerService servletContainer = container.getValue();

            try {

                //TODO: make the caching limits configurable

                ResourceManager resourceManager = new ServletResourceManager(deploymentRoot, overlays, explodedDeployment);

                resourceManager = new CachingResourceManager(100, 10 * 1024 * 1024, servletContainer.getBufferCache(), resourceManager, explodedDeployment ? 2000 : -1);

                d.setResourceManager(resourceManager);

            } catch (IOException e) {

                throw new StartException(e);

            }

            File tempFile = new File(pathManagerInjector.getValue().getPathEntry(TEMP_DIR).resolvePath(), deploymentName);

            tempFile.mkdirs();

            d.setTempDir(tempFile);

            d.setClassLoader(module.getClassLoader());

            final String servletVersion = mergedMetaData.getServletVersion();

            if (servletVersion != null) {

                d.setMajorVersion(Integer.parseInt(servletVersion.charAt(0) + ""));

                d.setMinorVersion(Integer.parseInt(servletVersion.charAt(2) + ""));

            } else {

                d.setMajorVersion(3);

                d.setMinorVersion(1);

            }

            //in most cases flush just hurts performance for no good reason

            d.setIgnoreFlush(servletContainer.isIgnoreFlush());

            //controls initialization of filters on start of application

            d.setEagerFilterInit(servletContainer.isEagerFilterInit());

            d.setAllowNonStandardWrappers(servletContainer.isAllowNonStandardWrappers());

            d.setServletStackTraces(servletContainer.getStackTraces());

            d.setDisableCachingForSecuredPages(servletContainer.isDisableCachingForSecuredPages());

            if (servletContainer.getSessionPersistenceManager() != null) {

                d.setSessionPersistenceManager(servletContainer.getSessionPersistenceManager());

            }

            //for 2.2 apps we do not require a leading / in path mappings

            boolean is22OrOlder;

            if (d.getMajorVersion() == 1) {

                is22OrOlder = true;

            } else if (d.getMajorVersion() == 2) {

                is22OrOlder = d.getMinorVersion() < 3;

            } else {

                is22OrOlder = false;

            }

            JSPConfig jspConfig = servletContainer.getJspConfig();

            final Set<String> seenMappings = new HashSet<>();

            HashMap<String, TagLibraryInfo> tldInfo = createTldsInfo(tldsMetaData, sharedTlds);

            //default JSP servlet

            final ServletInfo jspServlet = jspConfig != null ? jspConfig.createJSPServletInfo() : null;

            if (jspServlet != null) { //this would be null if jsp support is disabled

                HashMap<String, JspPropertyGroup> propertyGroups = createJspConfig(mergedMetaData);

                JspServletBuilder.setupDeployment(d, propertyGroups, tldInfo, new UndertowJSPInstanceManager(new WebInjectionContainer(module.getClassLoader(), componentRegistryInjectedValue.getValue())));

                if (mergedMetaData.getJspConfig() != null) {

                    d.setJspConfigDescriptor(new JspConfigDescriptorImpl(tldInfo.values(), propertyGroups.values()));

                }

                d.addServlet(jspServlet);

                final Set<String> jspPropertyGroupMappings = propertyGroups.keySet();

                for (final String mapping : jspPropertyGroupMappings) {

                    jspServlet.addMapping(mapping);

                }

                seenMappings.addAll(jspPropertyGroupMappings);

                //setup JSP expression factory wrapper

                if (!expressionFactoryWrappers.isEmpty()) {

                    d.addListener(new ListenerInfo(JspInitializationListener.class));

                    d.addServletContextAttribute(JspInitializationListener.CONTEXT_KEY, expressionFactoryWrappers);

                }

            }

            d.setClassIntrospecter(new ComponentClassIntrospector(componentRegistry));

            final Map<String, List<ServletMappingMetaData>> servletMappings = new HashMap<>();

            if (mergedMetaData.getExecutorName() != null) {

                d.setExecutor(executorsByName.get(mergedMetaData.getExecutorName()).getValue());

            }

            if (servletExtensions != null) {

                for (ServletExtension extension : servletExtensions) {

                    d.addServletExtension(extension);

                }

            }

            if (mergedMetaData.getServletMappings() != null) {

                for (final ServletMappingMetaData mapping : mergedMetaData.getServletMappings()) {

                    List<ServletMappingMetaData> list = servletMappings.get(mapping.getServletName());

                    if (list == null) {

                        servletMappings.put(mapping.getServletName(), list = new ArrayList<>());

                    }

                    list.add(mapping);

                }

            }

            if (jspServlet != null) {

                List<ServletMappingMetaData> list = servletMappings.get(jspServlet.getName());

                if(list != null && ! list.isEmpty()) {

                    for (final ServletMappingMetaData mapping : list) {

                        for(String urlPattern : mapping.getUrlPatterns()) {

                            jspServlet.addMapping(urlPattern);

                        }

                        seenMappings.addAll(mapping.getUrlPatterns());

                    }

                }

            }

            final List<JBossServletMetaData> servlets = new ArrayList<JBossServletMetaData>();

            for (JBossServletMetaData servlet : mergedMetaData.getServlets()) {

                servlets.add(servlet);

            }

            for (final JBossServletMetaData servlet : mergedMetaData.getServlets()) {

                final ServletInfo s;

                if (servlet.getJspFile() != null) {

                    s = new ServletInfo(servlet.getName(), JspServlet.class);

                    s.addHandlerChainWrapper(JspFileHandler.jspFileHandlerWrapper(servlet.getJspFile()));

                } else {

                    if (servlet.getServletClass() == null) {

                        if(DEFAULT_SERVLET_NAME.equals(servlet.getName())) {

                            s = new ServletInfo(servlet.getName(), DefaultServlet.class);

                        } else {

                            throw UndertowLogger.ROOT_LOGGER.servletClassNotDefined(servlet.getServletName());

                        }

                    } else {

                        Class<? extends Servlet> servletClass = (Class<? extends Servlet>) module.getClassLoader().loadClass(servlet.getServletClass());

                        ManagedReferenceFactory creator = componentRegistry.createInstanceFactory(servletClass);

                        if (creator != null) {

                            InstanceFactory<Servlet> factory = createInstanceFactory(creator);

                            s = new ServletInfo(servlet.getName(), servletClass, factory);

                        } else {

                            s = new ServletInfo(servlet.getName(), servletClass);

                        }

                    }

                }

                s.setAsyncSupported(servlet.isAsyncSupported())

                        .setJspFile(servlet.getJspFile())

                        .setEnabled(servlet.isEnabled());

                if (servlet.getRunAs() != null) {

                    s.setRunAs(servlet.getRunAs().getRoleName());

                }

                if (servlet.getLoadOnStartupSet()) {//todo why not cleanup api and just use int everywhere

                    s.setLoadOnStartup(servlet.getLoadOnStartupInt());

                }

                if (servlet.getExecutorName() != null) {

                    s.setExecutor(executorsByName.get(servlet.getExecutorName()).getValue());

                }

                handleServletMappings(is22OrOlder, seenMappings, servletMappings, s);

                if (servlet.getInitParam() != null) {

                    for (ParamValueMetaData initParam : servlet.getInitParam()) {

                        if (!s.getInitParams().containsKey(initParam.getParamName())) {

                            s.addInitParam(initParam.getParamName(), initParam.getParamValue());

                        }

                    }

                }

                if (servlet.getServletSecurity() != null) {

                    ServletSecurityInfo securityInfo = new ServletSecurityInfo();

                    s.setServletSecurityInfo(securityInfo);

                    securityInfo.setEmptyRoleSemantic(servlet.getServletSecurity().getEmptyRoleSemantic() == EmptyRoleSemanticType.DENY ? DENY : PERMIT)

                        .setTransportGuaranteeType(transportGuaranteeType(servlet.getServletSecurity().getTransportGuarantee()))

                        .addRolesAllowed(servlet.getServletSecurity().getRolesAllowed());

                    if (servlet.getServletSecurity().getHttpMethodConstraints() != null) {

                        for (HttpMethodConstraintMetaData method : servlet.getServletSecurity().getHttpMethodConstraints()) {

                        securityInfo.addHttpMethodSecurityInfo(

                                new HttpMethodSecurityInfo()

                                    .setEmptyRoleSemantic(method.getEmptyRoleSemantic() == EmptyRoleSemanticType.DENY ? DENY : PERMIT)

                                    .setTransportGuaranteeType(transportGuaranteeType(method.getTransportGuarantee()))

                                    .addRolesAllowed(method.getRolesAllowed())

                                    .setMethod(method.getMethod()));

                        }

                    }

                }

                if (servlet.getSecurityRoleRefs() != null) {

                    for (final SecurityRoleRefMetaData ref : servlet.getSecurityRoleRefs()) {

                        s.addSecurityRoleRef(ref.getRoleName(), ref.getRoleLink());

                    }

                }

                if (servlet.getMultipartConfig() != null) {

                    MultipartConfigMetaData mp = servlet.getMultipartConfig();

                    s.setMultipartConfig(Servlets.multipartConfig(mp.getLocation(), mp.getMaxFileSize(), mp.getMaxRequestSize(), mp.getFileSizeThreshold()));

                }

                d.addServlet(s);

            }

            //we explicitly add the default servlet, to allow it to be mapped

            if (!mergedMetaData.getServlets().containsKey(ServletPathMatches.DEFAULT_SERVLET_NAME)) {

                ServletInfo defaultServlet = Servlets.servlet(DEFAULT_SERVLET_NAME, DefaultServlet.class);

                handleServletMappings(is22OrOlder, seenMappings, servletMappings, defaultServlet);

                d.addServlet(defaultServlet);

            }

            if (mergedMetaData.getFilters() != null) {

                for (final FilterMetaData filter : mergedMetaData.getFilters()) {

                    Class<? extends Filter> filterClass = (Class<? extends Filter>) module.getClassLoader().loadClass(filter.getFilterClass());

                    ManagedReferenceFactory creator = componentRegistry.createInstanceFactory(filterClass);

                    FilterInfo f;

                    if (creator != null) {

                        InstanceFactory<Filter> instanceFactory = createInstanceFactory(creator);

                        f = new FilterInfo(filter.getName(), filterClass, instanceFactory);

                    } else {

                        f = new FilterInfo(filter.getName(), filterClass);

                    }

                    f.setAsyncSupported(filter.isAsyncSupported());

                    d.addFilter(f);

                    if (filter.getInitParam() != null) {

                        for (ParamValueMetaData initParam : filter.getInitParam()) {

                            f.addInitParam(initParam.getParamName(), initParam.getParamValue());

                        }

                    }

                }

            }

            if (mergedMetaData.getFilterMappings() != null) {

                for (final FilterMappingMetaData mapping : mergedMetaData.getFilterMappings()) {

                    if (mapping.getUrlPatterns() != null) {

                        for (String url : mapping.getUrlPatterns()) {

                            if (is22OrOlder && !url.startsWith("*") && !url.startsWith("/")) {

                                url = "/" + url;

                            }

                            if (mapping.getDispatchers() != null && !mapping.getDispatchers().isEmpty()) {

                                for (DispatcherType dispatcher : mapping.getDispatchers()) {

                                    d.addFilterUrlMapping(mapping.getFilterName(), url, javax.servlet.DispatcherType.valueOf(dispatcher.name()));

                                }

                            } else {

                                d.addFilterUrlMapping(mapping.getFilterName(), url, javax.servlet.DispatcherType.REQUEST);

                            }

                        }

                    }

                    if (mapping.getServletNames() != null) {

                        for (String servletName : mapping.getServletNames()) {

                            if (mapping.getDispatchers() != null && !mapping.getDispatchers().isEmpty()) {

                                for (DispatcherType dispatcher : mapping.getDispatchers()) {

                                    d.addFilterServletNameMapping(mapping.getFilterName(), servletName, javax.servlet.DispatcherType.valueOf(dispatcher.name()));

                                }

                            } else {

                                d.addFilterServletNameMapping(mapping.getFilterName(), servletName, javax.servlet.DispatcherType.REQUEST);

                            }

                        }

                    }

                }

            }

            if (scisMetaData != null && scisMetaData.getHandlesTypes() != null) {

                for (final ServletContainerInitializer sci : scisMetaData.getScis()) {

                    final ImmediateInstanceFactory<ServletContainerInitializer> instanceFactory = new ImmediateInstanceFactory<>(sci);

                    d.addServletContainerInitalizer(new ServletContainerInitializerInfo(sci.getClass(), instanceFactory, scisMetaData.getHandlesTypes().get(sci)));

                }

            }

            if (mergedMetaData.getListeners() != null) {

                for (ListenerMetaData listener : mergedMetaData.getListeners()) {

                    addListener(module.getClassLoader(), componentRegistry, d, listener);

                }

            }

            if (mergedMetaData.getContextParams() != null) {

                for (ParamValueMetaData param : mergedMetaData.getContextParams()) {

                    d.addInitParameter(param.getParamName(), param.getParamValue());

                }

            }

            if (mergedMetaData.getWelcomeFileList() != null &&

                    mergedMetaData.getWelcomeFileList().getWelcomeFiles() != null) {

                List<String> welcomeFiles = mergedMetaData.getWelcomeFileList().getWelcomeFiles();

                for (String file : welcomeFiles) {

                    if (file.startsWith("/")) {

                        d.addWelcomePages(file.substring(1));

                    } else {

                        d.addWelcomePages(file);

                    }

                }

            } else {

                d.addWelcomePages("index.html", "index.htm", "index.jsp");

            }

            if (mergedMetaData.getErrorPages() != null) {

                for (final ErrorPageMetaData page : mergedMetaData.getErrorPages()) {

                    final ErrorPage errorPage;

                    if (page.getExceptionType() != null && !page.getExceptionType().isEmpty()) {

                        errorPage = new ErrorPage(page.getLocation(), (Class<? extends Throwable>) module.getClassLoader().loadClass(page.getExceptionType()));

                    } else if (page.getErrorCode() != null && !page.getErrorCode().isEmpty()) {

                        errorPage = new ErrorPage(page.getLocation(), Integer.parseInt(page.getErrorCode()));

                    } else {

                        errorPage = new ErrorPage(page.getLocation());

                    }

                    d.addErrorPages(errorPage);

                }

            }

            if (mergedMetaData.getMimeMappings() != null) {

                for (final MimeMappingMetaData mapping : mergedMetaData.getMimeMappings()) {

                    d.addMimeMapping(new MimeMapping(mapping.getExtension(), mapping.getMimeType()));

                }

            }

            d.setDenyUncoveredHttpMethods(mergedMetaData.getDenyUncoveredHttpMethods() != null);

            Set<String> securityRoleNames = mergedMetaData.getSecurityRoleNames();

            if (mergedMetaData.getSecurityConstraints() != null) {

                for (SecurityConstraintMetaData constraint : mergedMetaData.getSecurityConstraints()) {

                    SecurityConstraint securityConstraint = new SecurityConstraint()

                            .setTransportGuaranteeType(transportGuaranteeType(constraint.getTransportGuarantee()));

                    List<String> roleNames = constraint.getRoleNames();

                    if (constraint.getAuthConstraint() == null) {

                        // no auth constraint means we permit the empty roles

                        securityConstraint.setEmptyRoleSemantic(PERMIT);

                    } else if (roleNames.size() == 1 && roleNames.contains("*") && securityRoleNames.contains("*")) {

                        // AS7-6932 - Trying to do a * to * mapping which JBossWeb passed through, for Undertow enable

                        // authentication only mode.

                        // TODO - AS7-6933 - Revisit workaround added to allow switching between JBoss Web and Undertow.

                        securityConstraint.setEmptyRoleSemantic(AUTHENTICATE);

                    } else {

                        securityConstraint.addRolesAllowed(roleNames);

                    }

                    if (constraint.getResourceCollections() != null) {

                        for (final WebResourceCollectionMetaData resourceCollection : constraint.getResourceCollections()) {

                            securityConstraint.addWebResourceCollection(new WebResourceCollection()

                                    .addHttpMethods(resourceCollection.getHttpMethods())

                                    .addHttpMethodOmissions(resourceCollection.getHttpMethodOmissions())

                                    .addUrlPatterns(resourceCollection.getUrlPatterns()));

                        }

                    }

                    d.addSecurityConstraint(securityConstraint);

                }

            }

            final LoginConfigMetaData loginConfig = mergedMetaData.getLoginConfig();

            if (loginConfig != null) {

                List<AuthMethodConfig> authMethod = authMethod(loginConfig.getAuthMethod());

                if (loginConfig.getFormLoginConfig() != null) {

                    d.setLoginConfig(new LoginConfig(loginConfig.getRealmName(), loginConfig.getFormLoginConfig().getLoginPage(), loginConfig.getFormLoginConfig().getErrorPage()));

                } else {

                    d.setLoginConfig(new LoginConfig(loginConfig.getRealmName()));

                }

                for (AuthMethodConfig method : authMethod) {

                    d.getLoginConfig().addLastAuthMethod(method);

                }

            }

            d.addSecurityRoles(mergedMetaData.getSecurityRoleNames());

            Map<String, Set<String>> principalVersusRolesMap = mergedMetaData.getPrincipalVersusRolesMap();

            d.addThreadSetupAction(new SecurityContextThreadSetupAction(securityDomain, securityDomainContextValue.getValue(), principalVersusRolesMap));

            d.addInnerHandlerChainWrapper(SecurityContextAssociationHandler.wrapper(mergedMetaData.getRunAsIdentity()));

            d.addOuterHandlerChainWrapper(JACCContextIdHandler.wrapper(jaccContextId));

            d.addLifecycleInterceptor(new RunAsLifecycleInterceptor(mergedMetaData.getRunAsIdentity()));

            if (principalVersusRolesMap != null) {

                for (Map.Entry<String, Set<String>> entry : principalVersusRolesMap.entrySet()) {

                    d.addPrincipalVsRoleMappings(entry.getKey(), entry.getValue());

                }

            }

            // Setup an deployer configured ServletContext attributes

            if(attributes != null) {

                for (ServletContextAttribute attribute : attributes) {

                    d.addServletContextAttribute(attribute.getName(), attribute.getValue());

                }

            }

            //now setup websockets if they are enabled

            if(servletContainer.isWebsocketsEnabled() && webSocketDeploymentInfo != null) {

                webSocketDeploymentInfo.setBuffers(servletContainer.getWebsocketsBufferPool().getValue());

                webSocketDeploymentInfo.setWorker(servletContainer.getWebsocketsWorker().getValue());

                webSocketDeploymentInfo.setDispatchToWorkerThread(servletContainer.isDispatchWebsocketInvocationToWorker());

                d.addServletContextAttribute(WebSocketDeploymentInfo.ATTRIBUTE_NAME, webSocketDeploymentInfo);

            }

            if (mergedMetaData.getLocalEncodings() != null &&

                    mergedMetaData.getLocalEncodings().getMappings() != null) {

                for (LocaleEncodingMetaData locale : mergedMetaData.getLocalEncodings().getMappings()) {

                    d.addLocaleCharsetMapping(locale.getLocale(), locale.getEncoding());

                }

            }

            if (predicatedHandlers != null && !predicatedHandlers.isEmpty()) {

                d.addInitialHandlerChainWrapper(new HandlerWrapper() {

                    @Override

                    public HttpHandler wrap(HttpHandler handler) {

                        if (predicatedHandlers.size() == 1) {

                            PredicatedHandler ph = predicatedHandlers.get(0);

                            return Handlers.predicate(ph.getPredicate(), ph.getHandler().wrap(handler), handler);

                        } else {

                            return Handlers.predicates(predicatedHandlers, handler);

                        }

                    }

                });

            }

            if (mergedMetaData.getDefaultEncoding() != null) {

                d.setDefaultEncoding(mergedMetaData.getDefaultEncoding());

            } else if (servletContainer.getDefaultEncoding() != null) {

                d.setDefaultEncoding(servletContainer.getDefaultEncoding());

            }

            return d;

        } catch (ClassNotFoundException e) {

            throw new StartException(e);

        }

    }

    private void handleServletMappings(boolean is22OrOlder, Set<String> seenMappings, Map<String, List<ServletMappingMetaData>> servletMappings, ServletInfo s) {

        List<ServletMappingMetaData> mappings = servletMappings.get(s.getName());

        if (mappings != null) {

            for (ServletMappingMetaData mapping : mappings) {

                for (String pattern : mapping.getUrlPatterns()) {

                    if (is22OrOlder && !pattern.startsWith("*") && !pattern.startsWith("/")) {

                        pattern = "/" + pattern;

                    }

                    if (!seenMappings.contains(pattern)) {

                        s.addMapping(pattern);

                        seenMappings.add(pattern);

                    }

                }

            }

        }

    }

    /**

     * Convert the authentication method name from the format specified in the web.xml to the format used by

     * {@link javax.servlet.http.HttpServletRequest}.

     * <p/>

     * If the auth method is not recognised then it is returned as-is.

     *

     * @return The converted auth method.

     * @throws NullPointerException if no configuredMethod is supplied.

     */

    private static List<AuthMethodConfig> authMethod(String configuredMethod) {

        if (configuredMethod == null) {

            return Collections.singletonList(new AuthMethodConfig(HttpServletRequest.BASIC_AUTH));

        }

        return AuthMethodParser.parse(configuredMethod, Collections.singletonMap("CLIENT-CERT", HttpServletRequest.CLIENT_CERT_AUTH));

    }

    private static io.undertow.servlet.api.TransportGuaranteeType transportGuaranteeType(final TransportGuaranteeType type) {

        if (type == null) {

            return io.undertow.servlet.api.TransportGuaranteeType.NONE;

        }

        switch (type) {

            case CONFIDENTIAL:

                return io.undertow.servlet.api.TransportGuaranteeType.CONFIDENTIAL;

            case INTEGRAL:

                return io.undertow.servlet.api.TransportGuaranteeType.INTEGRAL;

            case NONE:

                return io.undertow.servlet.api.TransportGuaranteeType.NONE;

        }

        throw new RuntimeException("UNREACHABLE");

    }

    private static HashMap<String, JspPropertyGroup> createJspConfig(JBossWebMetaData metaData) {

        final HashMap<String, JspPropertyGroup> result = new HashMap<>();

        // JSP Config

        JspConfigMetaData config = metaData.getJspConfig();

        if (config != null) {

            // JSP Property groups

            List<JspPropertyGroupMetaData> groups = config.getPropertyGroups();

            if (groups != null) {

                for (JspPropertyGroupMetaData group : groups) {

                    org.apache.jasper.deploy.JspPropertyGroup jspPropertyGroup = new org.apache.jasper.deploy.JspPropertyGroup();

                    for (String pattern : group.getUrlPatterns()) {

                        jspPropertyGroup.addUrlPattern(pattern);

                    }

                    jspPropertyGroup.setElIgnored(group.getElIgnored());

                    jspPropertyGroup.setPageEncoding(group.getPageEncoding());

                    jspPropertyGroup.setScriptingInvalid(group.getScriptingInvalid());

                    jspPropertyGroup.setIsXml(group.getIsXml());

                    if (group.getIncludePreludes() != null) {

                        for (String includePrelude : group.getIncludePreludes()) {

                            jspPropertyGroup.addIncludePrelude(includePrelude);

                        }

                    }

                    if (group.getIncludeCodas() != null) {

                        for (String includeCoda : group.getIncludeCodas()) {

                            jspPropertyGroup.addIncludeCoda(includeCoda);

                        }

                    }

                    jspPropertyGroup.setDeferredSyntaxAllowedAsLiteral(group.getDeferredSyntaxAllowedAsLiteral());

                    jspPropertyGroup.setTrimDirectiveWhitespaces(group.getTrimDirectiveWhitespaces());

                    jspPropertyGroup.setDefaultContentType(group.getDefaultContentType());

                    jspPropertyGroup.setBuffer(group.getBuffer());

                    jspPropertyGroup.setErrorOnUndeclaredNamespace(group.getErrorOnUndeclaredNamespace());

                    for (String pattern : jspPropertyGroup.getUrlPatterns()) {

                        // Split off the groups to individual mappings

                        result.put(pattern, jspPropertyGroup);

                    }

                }

            }

        }

        //it looks like jasper needs these in order of least specified to most specific

        final LinkedHashMap<String, JspPropertyGroup> ret = new LinkedHashMap<>();

        final ArrayList<String> paths = new ArrayList<>(result.keySet());

        Collections.sort(paths, new Comparator<String>() {

            @Override

            public int compare(final String o1, final String o2) {

                return o1.length() - o2.length();

            }

        });

        for (String path : paths) {

            ret.put(path, result.get(path));

        }

        return ret;

    }

    private static HashMap<String, TagLibraryInfo> createTldsInfo(final TldsMetaData tldsMetaData, List<TldMetaData> sharedTlds) throws ClassNotFoundException {

        final HashMap<String, TagLibraryInfo> ret = new HashMap<>();

        if (tldsMetaData != null) {

            if (tldsMetaData.getTlds() != null) {

                for (Map.Entry<String, TldMetaData> tld : tldsMetaData.getTlds().entrySet()) {

                    createTldInfo(tld.getKey(), tld.getValue(), ret);

                }

            }

            if (sharedTlds != null) {

                for (TldMetaData metaData : sharedTlds) {

                    createTldInfo(null, metaData, ret);

                }

            }

        }

        //we also register them under the new namespaces

        for (String k : new HashSet<>(ret.keySet())) {

            if (k != null) {

                if (k.startsWith(OLD_URI_PREFIX)) {

                    String newUri = k.replace(OLD_URI_PREFIX, NEW_URI_PREFIX);

                    ret.put(newUri, ret.get(k));

                }

            }

        }

        return ret;

    }

    private static TagLibraryInfo createTldInfo(final String location, final TldMetaData tldMetaData, final HashMap<String, TagLibraryInfo> ret) throws ClassNotFoundException {

        String relativeLocation = location;

        String jarPath = null;

        if (relativeLocation != null && relativeLocation.startsWith("/WEB-INF/lib/")) {

            int pos = relativeLocation.indexOf('/', "/WEB-INF/lib/".length());

            if (pos > 0) {

                jarPath = relativeLocation.substring(pos);

                if (jarPath.startsWith("/")) {

                    jarPath = jarPath.substring(1);

                }

                relativeLocation = relativeLocation.substring(0, pos);

            }

        }

        TagLibraryInfo tagLibraryInfo = new TagLibraryInfo();

        tagLibraryInfo.setTlibversion(tldMetaData.getTlibVersion());

        if (tldMetaData.getJspVersion() == null) {

            tagLibraryInfo.setJspversion(tldMetaData.getVersion());

        } else {

            tagLibraryInfo.setJspversion(tldMetaData.getJspVersion());

        }

        tagLibraryInfo.setShortname(tldMetaData.getShortName());

        tagLibraryInfo.setUri(tldMetaData.getUri());

        if (tldMetaData.getDescriptionGroup() != null) {

            tagLibraryInfo.setInfo(tldMetaData.getDescriptionGroup().getDescription());

        }

        // Validator

        if (tldMetaData.getValidator() != null) {

            TagLibraryValidatorInfo tagLibraryValidatorInfo = new TagLibraryValidatorInfo();

            tagLibraryValidatorInfo.setValidatorClass(tldMetaData.getValidator().getValidatorClass());

            if (tldMetaData.getValidator().getInitParams() != null) {

                for (ParamValueMetaData paramValueMetaData : tldMetaData.getValidator().getInitParams()) {

                    tagLibraryValidatorInfo.addInitParam(paramValueMetaData.getParamName(), paramValueMetaData.getParamValue());

                }

            }

            tagLibraryInfo.setValidator(tagLibraryValidatorInfo);