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()); d.setResourceManager(resourceManager); } catch (IOException e) { throw new StartException(e); d.setTempDir(tempDir); 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); d.setDefaultCookieVersion(servletContainer.getDefaultCookieVersion()); d.setIgnoreFlush(servletContainer.isIgnoreFlush()); d.setEagerFilterInit(servletContainer.isEagerFilterInit());
private String getDeployedContextPath(DeploymentInfo deploymentInfo) { return "".equals(deploymentInfo.getContextPath()) ? "/" : deploymentInfo.getContextPath(); }
public static void addFilterMappings(DeploymentInfo servletBuilder) { servletBuilder.addFilter(new FilterInfo("Unsampled", Unsampled.class)) .addFilterUrlMapping("Unsampled", "/unsampled", REQUEST) .addFilter(new FilterInfo("Traced", Traced.class)) .addFilterUrlMapping("Traced", "/traced", REQUEST) .addFilter(new FilterInfo("TracedExtra", TracedExtra.class)) .addFilterUrlMapping("TracedExtra", "/tracedextra", REQUEST) .addFilter(new FilterInfo("Traced128", Traced128.class)) .addFilterUrlMapping("Traced128", "/traced128", REQUEST); }
@Override protected void init(DeploymentInfo servletBuilder) { servletBuilder.addFilter(new FilterInfo("Unsampled", Unsampled.class)) .addFilterUrlMapping("Unsampled", "/unsampled", REQUEST) .addFilterUrlMapping("Unsampled", "/unsampled/api", REQUEST) .addFilter(new FilterInfo("OnlySampledLocal", OnlySampledLocal.class)) .addFilterUrlMapping("OnlySampledLocal", "/onlysampledlocal", REQUEST) .addFilterUrlMapping("OnlySampledLocal", "/onlysampledlocal/api", REQUEST) .addFilter(new FilterInfo("Traced", Traced.class)) .addFilterUrlMapping("Traced", "/traced", REQUEST) .addFilterUrlMapping("Traced", "/traced/api", REQUEST) .addFilter(new FilterInfo("TracedExtra", TracedExtra.class)) .addFilterUrlMapping("TracedExtra", "/tracedextra", REQUEST) .addFilterUrlMapping("TracedExtra", "/tracedextra/api", REQUEST) .addFilter(new FilterInfo("TracedCorrelated", TracedCorrelated.class)) .addFilterUrlMapping("TracedCorrelated", "/tracedcorrelated", REQUEST) .addFilterUrlMapping("TracedCorrelated", "/tracedcorrelated/api", REQUEST) .addFilter(new FilterInfo("Traced128", Traced128.class)) .addFilterUrlMapping("Traced128", "/traced128", REQUEST) .addFilterUrlMapping("Traced128", "/traced128/api", REQUEST) .addServlets(Servlets.servlet("HelloServlet", HelloServlet.class).addMapping("/*")); }
protected int initServer() throws Exception { DeploymentInfo servletBuilder = Servlets.deployment() .setClassLoader(getClass().getClassLoader()) .setContextPath("/") .setDeploymentName("test.war"); init(servletBuilder); DeploymentManager manager = Servlets.defaultContainer().addDeployment(servletBuilder); manager.deploy(); server = Undertow.builder() .addHttpListener(0, "127.0.0.1") .setHandler(manager.start()).build(); server.start(); return ((InetSocketAddress) server.getListenerInfo().get(0).getAddress()).getPort(); }
final String deploymentName = src.getDeploymentName() + ":" + uri.getPath(); final DeploymentInfo info = new DeploymentInfo() .setClassLoader(src.getClassLoader()) .setContextPath(contextPath) .setResourceManager(src.getResourceManager()) .setMajorVersion(src.getMajorVersion()) .setMinorVersion(src.getMinorVersion()) .setDeploymentName(deploymentName) .setClassIntrospecter(src.getClassIntrospecter()); info.addServlet(servletInfo); for (Map.Entry<String, FilterInfo> e : src.getFilters().entrySet()) { info.addFilter(e.getValue().clone()); info.setDisplayName(src.getDisplayName()); for (FilterMappingInfo fmi : src.getFilterMappings()) { switch (fmi.getMappingType()) { case URL: info.addFilterUrlMapping(fmi.getFilterName(), fmi.getMapping(), fmi.getDispatcher()); break; case SERVLET: info.addFilterServletNameMapping(fmi.getFilterName(), fmi.getMapping(), fmi.getDispatcher()); break; default: final List<ListenerInfo> listeners = src.getListeners(); final List<String> approvedListeners = Arrays.asList(
private Undertow configureUndertow(MockitoSpringWebApplicationContext context, URL url) throws ServletException { // https://github.com/yarosla/spring-undertow/blob/master/src/main/java/ys/undertow/UndertowMain.java DeploymentInfo servletBuilder = Servlets.deployment() .setClassLoader(Undertow.class.getClassLoader()) .setContextPath(url.getPath()) .setDeploymentName("mock") .addServlet(createDispatcherServlet(context)) .addListener(createContextLoaderListener(context)); DeploymentManager manager = Servlets.defaultContainer().addDeployment(servletBuilder); manager.deploy(); PathHandler path = Handlers.path(Handlers.redirect("/")) .addPrefixPath(CONTEXT_PATH, manager.start()); return Undertow.builder() .addHttpListener(url.getPort(), url.getHost()) .setHandler(path) .build(); }
@Override public void start() { DeploymentInfo di = new DeploymentInfo() .setContextPath("/") .setDeploymentName("Undertow") .setResourceManager(new ClassPathResourceManager(getClass().getClassLoader())) .setClassLoader(ClassLoader.getSystemClassLoader()); super.getListeners().forEach(c ->di.addListener(listener(c))); WebSocketDeploymentInfo webSocketDeploymentInfo = new WebSocketDeploymentInfo(); endpoints.forEach(webSocketDeploymentInfo::addEndpoint); di.addServletContextAttribute(WebSocketDeploymentInfo.ATTRIBUTE_NAME, webSocketDeploymentInfo); di.addFilter(filterInfo); for(String url : filterDescriptor.urlPatterns()) { for(DispatcherType dispatcherType : filterDescriptor.dispatcherTypes()) { di.addFilterUrlMapping(filterDescriptor.displayName(), url, dispatcherType); DeploymentManager deploymentManager = Servlets.defaultContainer().addDeployment(di); deploymentManager.deploy(); try { HttpHandler servletHandler = deploymentManager.start(); PathHandler path = path(Handlers.redirect("/")) .addPrefixPath("/", servletHandler); Builder undertowBuilder = Undertow.builder() .addHttpListener(webServerConfiguration.getPort(), webServerConfiguration.getAddress())
.addMapping("/").setAsyncSupported(true); DeploymentInfo servletBuilder = deployment() .setClassLoader(UndertowTestServer.class.getClassLoader()) .setDeploymentName("undertow-websocket-test") .setContextPath("/") .addServlet(servletInfo) .addServletContextAttribute(WebSocketDeploymentInfo.ATTRIBUTE_NAME, info); for (final Filter filter : filters) { String filterName = filter.getClass().getName(); FilterInstanceFactory filterFactory = new FilterInstanceFactory(filter); FilterInfo filterInfo = new FilterInfo(filterName, filter.getClass(), filterFactory); servletBuilder.addFilter(filterInfo.setAsyncSupported(true)); for (DispatcherType type : DispatcherType.values()) { servletBuilder.addFilterUrlMapping(filterName, "/*", type); this.manager = defaultContainer().addDeployment(servletBuilder); this.manager.deploy(); HttpHandler httpHandler = this.manager.start(); this.server = Undertow.builder().addHttpListener(0, "localhost").setHandler(httpHandler).build();
final DeploymentInfo builder = new DeploymentInfo() .setClassLoader(clazz.getClassLoader()) .setContextPath("/") .setDeploymentName("ServletContainer.war") .setResourceManager(new FileResourceManager(new File(resource.getFile()), 100)); builder.addWelcomePage(welcomePage); builder.addFilter(new FilterInfo("Filter", installFilter)); builder.addFilterUrlMapping("Filter", "/*", DispatcherType.REQUEST); builder.addServlet(Servlets.servlet("WuicServlet", installServlet).addMapping(WUIC_SERVLET_MAPPING)); builder.addListener(new ListenerInfo(installListener)); final JspPropertyGroup jspPropertyGroup = new JspPropertyGroup(); jspPropertyGroups.put("", jspPropertyGroup); builder.addServlet(JspServletBuilder.createServlet("Default Jsp Servlet", "*.jsp")); final HashMap<String, TagLibraryInfo> tagLibs = new HashMap<String, TagLibraryInfo>(); final TagInfo wuic = new TagInfo(); builder.addInitParameter("c.g.wuic.facade.contextPath", WUIC_SERVLET_PATH); final DeploymentManager manager = container.addDeployment(builder); manager.deploy(); servletContext = manager.getDeployment().getServletContext(); root.addPrefixPath(builder.getContextPath(), manager.start()); server = Undertow.builder() .addHttpListener(port, host)
private ServletContext buildServletContext(String contextName) throws ServletException { ServletContainer servletContainer = new ServletContainerImpl(); DeploymentInfo deploymentInfo = new DeploymentInfo(); deploymentInfo.setClassLoader(Thread.currentThread().getContextClassLoader()); deploymentInfo.setDeploymentName("cxf-undertow"); deploymentInfo.setContextPath(contextName); ServletInfo asyncServlet = new ServletInfo(ServletPathMatches.DEFAULT_SERVLET_NAME, CxfUndertowServlet.class); deploymentInfo.addServlet(asyncServlet); servletContainer.addDeployment(deploymentInfo); DeploymentManager deploymentManager = servletContainer.getDeployment(deploymentInfo.getDeploymentName()); deploymentManager.deploy(); deploymentManager.start(); return deploymentManager.getDeployment().getServletContext(); }
.setClassLoader(Application.class.getClassLoader()) .setContextPath("/") .addListeners(listener(Listener.class)) .setResourceManager(new ClassPathResourceManager(Application.class.getClassLoader())) .addServlets( Servlets.servlet("jerseyServlet", ServletContainer.class) .setLoadOnStartup(1) .addInitParam("javax.ws.rs.Application", JerseyConfig.class.getName()) .addMapping("/api/*")) .setDeploymentName("application.war"); deploymentManager = Servlets.defaultContainer().addDeployment(servletBuilder); deploymentManager.deploy(); path.addPrefixPath("/", deploymentManager.start()); } catch (ServletException e) { throw new RuntimeException(e);
/** * Adds an arbitrary web deployment to underlying Undertow server. This is for your own deployments * * @param builder * @return */ public UndertowJaxrsServer deploy(DeploymentInfo builder) { DeploymentManager manager = container.addDeployment(builder); manager.deploy(); try { root.addPrefixPath(builder.getContextPath(), manager.start()); } catch (ServletException e) { throw new RuntimeException(e); } return this; }
String contextPath = getContextPath(); deployment = Servlets.deployment().setDeploymentName("nb").setClassLoader(classLoader).setEagerFilterInit(true).setSecurityDisabled(true); deployment.setContextPath(contextPath).setDefaultSessionTimeout(getSessionTimeout()); deployment.setResourceManager(resourceManager); deployment.addWelcomePages(getWelcomeFiles()); for (Map.Entry<String, String> en : getErrorPages().entrySet()) { String key = en.getKey(); if (Strings.isNumber(key)) { log.debugf("add error page code=%s location=%s", key, en.getValue()); deployment.addErrorPage(new ErrorPage(en.getValue(), Integer.parseInt(key))); deployment.addErrorPage(new ErrorPage(en.getValue(), klass)); DeploymentManager manager = Servlets.defaultContainer().addDeployment(deployment); manager.deploy(); HttpHandler servletHandler = manager.start(); PathHandler pathHandler; if ("/".equals(contextPath)) { pathHandler = Handlers.path(servletHandler); } else { pathHandler = Handlers.path(Handlers.redirect(contextPath)).addPrefixPath(contextPath, servletHandler);
registerServletContainerInitializerToDriveServletContextInitializers(deployment, initializers); deployment.setClassLoader(getServletClassLoader()); deployment.setContextPath(getContextPath()); deployment.setDisplayName(getDisplayName()); deployment.setDeploymentName("spring-boot"); if (isRegisterDefaultServlet()) { deployment.addServlet(Servlets.servlet("default", DefaultServlet.class)); deployment.setServletStackTraces(ServletStackTraces.NONE); deployment.setResourceManager(getDocumentRootResourceManager()); deployment.setEagerFilterInit(this.eagerInitFilters); configureMimeMappings(deployment); for (UndertowDeploymentInfoCustomizer customizer : this.deploymentInfoCustomizers) { deployment.setSessionPersistenceManager(new FileSessionPersistence(dir)); DeploymentManager manager = Servlets.newContainer().addDeployment(deployment); manager.deploy(); SessionManager sessionManager = manager.getDeployment().getSessionManager(); Duration timeoutDuration = getSession().getTimeout(); int sessionTimeout = (isZeroOrLess(timeoutDuration) ? -1
Servlets.deployment().setClassLoader(this.getClass().getClassLoader()).setContextPath(contextPath) .setDeploymentName(deploymentName).addListener(Servlets.listener(org.jboss.weld.environment.servlet.Listener.class)) .addInitParameter(WeldServletLifecycle.class.getPackage().getName() + ".archive.isolation", "false") .addServletContextAttribute(WeldServletLifecycle.BEAN_MANAGER_ATTRIBUTE_NAME, beanManager); di.getServlets().forEach(yggdrasilServletInfo -> { ServletInfo servletInfo = convertServletInfo(yggdrasilServletInfo); deployment.addServlet(servletInfo); mappings.addAll(servletInfo.getMappings()); }); di.getWelcomePages().forEach(deployment::addWelcomePage); di.getInitParameters().forEach(deployment::addInitParameter); di.getListeners().forEach(listenerClass -> deployment.addListener(Servlets.listener(listenerClass))); di.getServletContextAttributes().forEach(deployment::addServletContextAttribute); di.getClassPathResources().forEach(path -> combinedResourceManager.addResourceManager(new ClassPathResourceManager(this.getClass().getClassLoader(), path))); di.getPathResources().forEach(path -> combinedResourceManager.addResourceManager(new PathResourceManager(Paths.get(path), 8092))); deployment.setEagerFilterInit(di.isEagerFilterInit()); deploymentInfoMap.put(servletProvider, di); DeploymentManager manager = Servlets.defaultContainer().addDeployment(deployment); manager.deploy(); HttpHandler servletHandler; try { servletHandler = manager.start(); } catch (ServletException e) { throw new YggdrasilException(e);
.setAsyncSupported( true ) .setLoadOnStartup( 1 ) .addMapping( "/api*" ) .addMapping( "/api/*" ) .addMapping( "/api-docs*" ) this.apiVersioningFilter ) ); final DeploymentInfo di = new DeploymentInfo().addListener( Servlets.listener( RequestScopeListener.class ) ) .setContextPath( contextRoot ) .addServletContextAttribute( ResteasyDeployment.class.getName(), deployment ) .addServlet( resteasyServlet ) .addFilter( resourceManagementFilter ) .addFilterUrlMapping( resourceManagementFilter.getName(), "/api/*", DispatcherType.REQUEST ) .addFilter( apiVersioningFilter ) .addFilterUrlMapping( apiVersioningFilter.getName(), "/*", DispatcherType.REQUEST ) .setDeploymentName( "Indy" ) .setClassLoader( ClassLoader.getSystemClassLoader() ) .addOuterHandlerChainWrapper( new HeaderDebugger.Wrapper() ); uiServlet.setInstanceFactory( new ImmediateInstanceFactory<Servlet>( ui ) ); di.addServlet( uiServlet );
protected DeploymentManager createFathomDeploymentManager() throws ServletException { DeploymentInfo info = Servlets.deployment(); info.setDeploymentName("Fathom"); info.setClassLoader(this.getClass().getClassLoader()); info.setContextPath(settings.getContextPath()); info.setIgnoreFlush(true); info.setDefaultEncoding("UTF-8"); FilterInfo guiceFilter = new FilterInfo("GuiceFilter", GuiceFilter.class); guiceFilter.setAsyncSupported(true); info.addFilterUrlMapping("GuiceFilter", "/*", DispatcherType.REQUEST); info.addFilters(guiceFilter); ServletInfo defaultServlet = new ServletInfo("DefaultServlet", DefaultServlet.class); defaultServlet.setAsyncSupported(true); defaultServlet.addMapping("/"); ServletContextListener fathomListener = new ServletContextListener(settings); info.addListeners(new ListenerInfo(ServletContextListener.class, new ImmediateInstanceFactory<>(fathomListener))); MultipartConfigElement multipartConfig = new MultipartConfigElement(settings.getUploadFilesLocation(), settings.getUploadFilesMaxSize(), -1L, 0); defaultServlet.setMultipartConfig(multipartConfig); info.addServlets(defaultServlet); DeploymentManager deploymentManager = Servlets.defaultContainer().addDeployment(info); deploymentManager.deploy(); return deploymentManager; }
protected DeploymentManager createPippoDeploymentManager() { DeploymentInfo info = Servlets.deployment(); info.setDeploymentName("Pippo"); info.setClassLoader(this.getClass().getClassLoader()); info.setContextPath(getSettings().getContextPath()); info.setIgnoreFlush(true); // inject application as context attribute info.addServletContextAttribute(PIPPO_APPLICATION, getApplication()); // add pippo filter addPippoFilter(info); // add initializers info.addListener(new ListenerInfo(PippoServletContextListener.class)); // add listeners listeners.forEach(listener -> info.addListener(new ListenerInfo(listener))); ServletInfo defaultServlet = new ServletInfo("DefaultServlet", DefaultServlet.class); defaultServlet.addMapping("/"); MultipartConfigElement multipartConfig = createMultipartConfigElement(); defaultServlet.setMultipartConfig(multipartConfig); info.addServlets(defaultServlet); DeploymentManager deploymentManager = Servlets.defaultContainer().addDeployment(info); deploymentManager.deploy(); return deploymentManager; }
@Override public WebDeploymentController addWebDeployment(final WebDeploymentBuilder webDeploymentBuilder) throws Exception { DeploymentInfo d = new DeploymentInfo(); d.setDeploymentName(webDeploymentBuilder.getContextRoot()); d.setContextPath(webDeploymentBuilder.getContextRoot()); d.setClassLoader(webDeploymentBuilder.getClassLoader()); d.setResourceManager(new PathResourceManager(webDeploymentBuilder.getDocumentRoot().toPath().toAbsolutePath(), 1024 * 1024)); d.setIgnoreFlush(false); for (ServletBuilder servlet : webDeploymentBuilder.getServlets()) { ServletInfo s; if (servlet.getServlet() == null) { s = new ServletInfo(servlet.getServletName(), (Class<? extends Servlet>) servlet.getServletClass()); } else { s = new ServletInfo(servlet.getServletName(), (Class<? extends Servlet>) servlet.getServletClass(), new ImmediateInstanceFactory<>(servlet.getServlet())); } if (servlet.isForceInit()) { s.setLoadOnStartup(1); } s.addMappings(servlet.getUrlMappings()); for (Map.Entry<String, String> param : servlet.getInitParams().entrySet()) { s.addInitParam(param.getKey(), param.getValue()); } d.addServlet(s); } if (controlPoint != null) { d.addOuterHandlerChainWrapper(GlobalRequestControllerHandler.wrapper(controlPoint, webDeploymentBuilder.getAllowRequestPredicates())); } return new WebDeploymentControllerImpl(d); }