private void createServletsAndFilters(
     final DeploymentImpl deployment, final DeploymentInfo deploymentInfo) {
   for (Map.Entry<String, ServletInfo> servlet : deploymentInfo.getServlets().entrySet()) {
     deployment.getServlets().addServlet(servlet.getValue());
   }
   for (Map.Entry<String, FilterInfo> filter : deploymentInfo.getFilters().entrySet()) {
     deployment.getFilters().addFilter(filter.getValue());
   }
 }
 @Override
 public Map<String, ? extends ServletRegistration> getServletRegistrations() {
   ensureNotProgramaticListener();
   final Map<String, ServletRegistration> ret = new HashMap<String, ServletRegistration>();
   for (Map.Entry<String, ServletInfo> entry : deploymentInfo.getServlets().entrySet()) {
     ret.put(entry.getKey(), new ServletRegistrationImpl(entry.getValue(), deployment));
   }
   return ret;
 }
 @Override
 public ServletRegistration getServletRegistration(final String servletName) {
   ensureNotProgramaticListener();
   final ServletInfo servlet = deploymentInfo.getServlets().get(servletName);
   if (servlet == null) {
     return null;
   }
   return new ServletRegistrationImpl(servlet, deployment);
 }
 @Override
 public ServletRegistration.Dynamic addServlet(
     final String servletName, final Class<? extends Servlet> servletClass) {
   ensureNotProgramaticListener();
   ensureNotInitialized();
   if (deploymentInfo.getServlets().containsKey(servletName)) {
     return null;
   }
   ServletInfo servlet = new ServletInfo(servletName, servletClass);
   deploymentInfo.addServlet(servlet);
   deployment.getServlets().addServlet(servlet);
   return new ServletRegistrationImpl(servlet, deployment);
 }
 @Override
 public ServletRegistration.Dynamic addServlet(final String servletName, final Servlet servlet) {
   ensureNotProgramaticListener();
   ensureNotInitialized();
   if (deploymentInfo.getServlets().containsKey(servletName)) {
     return null;
   }
   ServletInfo s =
       new ServletInfo(
           servletName, servlet.getClass(), new ImmediateInstanceFactory<Servlet>(servlet));
   deploymentInfo.addServlet(s);
   deployment.getServlets().addServlet(s);
   return new ServletRegistrationImpl(s, deployment);
 }
 @Override
 public ServletRegistration.Dynamic addServlet(final String servletName, final String className) {
   ensureNotProgramaticListener();
   ensureNotInitialized();
   try {
     if (deploymentInfo.getServlets().containsKey(servletName)) {
       return null;
     }
     ServletInfo servlet =
         new ServletInfo(
             servletName,
             (Class<? extends Servlet>) deploymentInfo.getClassLoader().loadClass(className));
     deploymentInfo.addServlet(servlet);
     deployment.getServlets().addServlet(servlet);
     return new ServletRegistrationImpl(servlet, deployment);
   } catch (ClassNotFoundException e) {
     throw UndertowServletMessages.MESSAGES.cannotLoadClass(className, e);
   }
 }
  public DeploymentInfo deployApplication() throws Exception {
    TestIdentityManager identityManager = new TestIdentityManager();
    identityManager.addUser("user1", "password1", "role1");

    LoginConfig basicLoginConfig = new LoginConfig("BASIC", "TESTREALM");
    DeploymentInfo di = server.undertowDeployment(TestSAMLApplication.class);
    di.setContextPath("/test").setDeploymentName("testsaml");

    di.setClassIntrospecter(TestClassIntrospector.INSTANCE)
        .setIdentityManager(identityManager)
        .setLoginConfig(basicLoginConfig);

    SecurityConstraint securityConstraint = new SecurityConstraint();
    securityConstraint
        .addWebResourceCollection(new WebResourceCollection().addUrlPattern("/test/*"))
        .addRoleAllowed("role1")
        .setEmptyRoleSemantic(SecurityInfo.EmptyRoleSemantic.DENY);

    ServletInfo restEasyServlet = di.getServlets().values().iterator().next();
    restEasyServlet.setServletSecurityInfo(new ServletSecurityInfo().addRoleAllowed("role1"));

    di.addSecurityConstraint(securityConstraint);
    return di;
  }
  /**
   * Sets up the handlers in the servlet chain. We setup a chain for every path + extension match
   * possibility. (i.e. if there a m path mappings and n extension mappings we have n*m chains).
   *
   * <p>If a chain consists of only the default servlet then we add it as an async handler, so that
   * resources can be served up directly without using blocking operations.
   *
   * <p>TODO: this logic is a bit convoluted at the moment, we should look at simplifying it
   *
   * @param servletContext
   * @param threadSetupAction
   * @param listeners
   */
  private ServletPathMatches setupServletChains(
      final ServletContextImpl servletContext,
      final CompositeThreadSetupAction threadSetupAction,
      final ApplicationListeners listeners) {
    final List<Lifecycle> lifecycles = new ArrayList<Lifecycle>();
    // create the default servlet
    ServletChain defaultHandler = null;
    ServletHandler defaultServlet = null;

    final Map<String, ManagedFilter> managedFilterMap = new LinkedHashMap<String, ManagedFilter>();
    final Map<String, ServletHandler> allServlets = new HashMap<String, ServletHandler>();
    final Map<String, ServletHandler> extensionServlets = new HashMap<String, ServletHandler>();
    final Map<String, ServletHandler> pathServlets = new HashMap<String, ServletHandler>();

    final Set<String> pathMatches = new HashSet<String>();
    final Set<String> extensionMatches = new HashSet<String>();

    DeploymentInfo deploymentInfo = deployment.getDeploymentInfo();
    for (Map.Entry<String, FilterInfo> entry : deploymentInfo.getFilters().entrySet()) {
      final ManagedFilter mf = new ManagedFilter(entry.getValue(), servletContext);
      managedFilterMap.put(entry.getValue().getName(), mf);
      lifecycles.add(mf);
    }

    for (FilterMappingInfo mapping : deploymentInfo.getFilterMappings()) {
      if (mapping.getMappingType() == FilterMappingInfo.MappingType.URL) {
        String path = mapping.getMapping();
        if (!path.startsWith("*.")) {
          pathMatches.add(path);
        } else {
          extensionMatches.add(path.substring(2));
        }
      }
    }

    for (Map.Entry<String, ServletInfo> entry : deploymentInfo.getServlets().entrySet()) {
      ServletInfo servlet = entry.getValue();
      final ManagedServlet managedServlet = new ManagedServlet(servlet, servletContext);
      lifecycles.add(managedServlet);
      final ServletHandler handler = new ServletHandler(managedServlet);
      allServlets.put(entry.getKey(), handler);
      for (String path : entry.getValue().getMappings()) {
        if (path.equals("/")) {
          // the default servlet
          pathMatches.add("/*");
          if (pathServlets.containsKey("/*")) {
            throw UndertowServletMessages.MESSAGES.twoServletsWithSameMapping(path);
          }
          defaultServlet = handler;
          defaultHandler = servletChain(handler, managedServlet);
        } else if (!path.startsWith("*.")) {
          pathMatches.add(path);
          if (pathServlets.containsKey(path)) {
            throw UndertowServletMessages.MESSAGES.twoServletsWithSameMapping(path);
          }
          pathServlets.put(path, handler);
        } else {
          String ext = path.substring(2);
          extensionMatches.add(ext);
          extensionServlets.put(ext, handler);
        }
      }
    }

    if (defaultServlet == null) {
      final DefaultServletConfig config =
          deploymentInfo.getDefaultServletConfig() == null
              ? new DefaultServletConfig()
              : deploymentInfo.getDefaultServletConfig();
      DefaultServlet defaultInstance =
          new DefaultServlet(deployment, config, deploymentInfo.getWelcomePages());
      final ManagedServlet managedDefaultServlet =
          new ManagedServlet(
              new ServletInfo(
                  "io.undertow.DefaultServlet",
                  DefaultServlet.class,
                  new ImmediateInstanceFactory<Servlet>(defaultInstance)),
              servletContext);
      lifecycles.add(managedDefaultServlet);
      pathMatches.add("/*");
      defaultServlet = new ServletHandler(managedDefaultServlet);
      defaultHandler = new ServletChain(defaultServlet, managedDefaultServlet);
    }

    final ServletPathMatches.Builder builder = ServletPathMatches.builder();

    for (final String path : pathMatches) {
      ServletHandler targetServlet = resolveServletForPath(path, pathServlets);

      final Map<DispatcherType, List<ManagedFilter>> noExtension =
          new HashMap<DispatcherType, List<ManagedFilter>>();
      final Map<String, Map<DispatcherType, List<ManagedFilter>>> extension =
          new HashMap<String, Map<DispatcherType, List<ManagedFilter>>>();
      for (String ext : extensionMatches) {
        extension.put(ext, new HashMap<DispatcherType, List<ManagedFilter>>());
      }

      for (final FilterMappingInfo filterMapping : deploymentInfo.getFilterMappings()) {
        ManagedFilter filter = managedFilterMap.get(filterMapping.getFilterName());
        if (filterMapping.getMappingType() == FilterMappingInfo.MappingType.SERVLET) {
          if (targetServlet != null) {
            if (filterMapping
                .getMapping()
                .equals(targetServlet.getManagedServlet().getServletInfo().getName())) {
              addToListMap(noExtension, filterMapping.getDispatcher(), filter);
              for (Map<DispatcherType, List<ManagedFilter>> l : extension.values()) {
                addToListMap(l, filterMapping.getDispatcher(), filter);
              }
            }
          }
        } else {
          if (filterMapping.getMapping().isEmpty()
              || !filterMapping.getMapping().startsWith("*.")) {
            if (isFilterApplicable(path, filterMapping.getMapping())) {
              addToListMap(noExtension, filterMapping.getDispatcher(), filter);
              for (Map<DispatcherType, List<ManagedFilter>> l : extension.values()) {
                addToListMap(l, filterMapping.getDispatcher(), filter);
              }
            }
          } else {
            addToListMap(
                extension.get(filterMapping.getMapping().substring(2)),
                filterMapping.getDispatcher(),
                filter);
          }
        }
      }

      final ServletChain initialHandler;
      if (noExtension.isEmpty()) {
        if (targetServlet != null) {
          initialHandler = servletChain(targetServlet, targetServlet.getManagedServlet());
        } else {
          initialHandler = defaultHandler;
        }
      } else {
        FilterHandler handler;
        if (targetServlet != null) {
          handler = new FilterHandler(noExtension, targetServlet);
        } else {
          handler = new FilterHandler(noExtension, defaultServlet);
        }
        initialHandler =
            servletChain(
                handler,
                targetServlet == null
                    ? defaultServlet.getManagedServlet()
                    : targetServlet.getManagedServlet());
      }

      if (path.endsWith("/*")) {
        String prefix = path.substring(0, path.length() - 2);
        builder.addPrefixMatch(prefix, initialHandler);

        for (Map.Entry<String, Map<DispatcherType, List<ManagedFilter>>> entry :
            extension.entrySet()) {
          ServletHandler pathServlet = targetServlet;
          if (pathServlet == null) {
            pathServlet = extensionServlets.get(entry.getKey());
          }
          if (pathServlet == null) {
            pathServlet = defaultServlet;
          }
          HttpHandler handler = pathServlet;
          if (!entry.getValue().isEmpty()) {
            handler = new FilterHandler(entry.getValue(), handler);
          }
          builder.addExtensionMatch(
              prefix, entry.getKey(), servletChain(handler, pathServlet.getManagedServlet()));
        }
      } else if (path.isEmpty()) {
        builder.addExactMatch("/", initialHandler);
      } else {
        builder.addExactMatch(path, initialHandler);
      }
    }

    // now setup name based mappings
    // these are used for name based dispatch
    for (Map.Entry<String, ServletHandler> entry : allServlets.entrySet()) {
      final Map<DispatcherType, List<ManagedFilter>> filters =
          new HashMap<DispatcherType, List<ManagedFilter>>();
      for (final FilterMappingInfo filterMapping : deploymentInfo.getFilterMappings()) {
        ManagedFilter filter = managedFilterMap.get(filterMapping.getFilterName());
        if (filterMapping.getMappingType() == FilterMappingInfo.MappingType.SERVLET) {
          if (filterMapping.getMapping().equals(entry.getKey())) {
            addToListMap(filters, filterMapping.getDispatcher(), filter);
          }
        }
      }
      if (filters.isEmpty()) {
        builder.addNameMatch(
            entry.getKey(), servletChain(entry.getValue(), entry.getValue().getManagedServlet()));
      } else {
        builder.addNameMatch(
            entry.getKey(),
            servletChain(
                new FilterHandler(filters, entry.getValue()),
                entry.getValue().getManagedServlet()));
      }
    }

    builder.setDefaultServlet(defaultHandler);

    deployment.addLifecycleObjects(lifecycles);
    return builder.build();
  }