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(); }
public void stopContext() { final ClassLoader old = Thread.currentThread().getContextClassLoader(); DeploymentInfo deploymentInfo = deploymentInfoInjectedValue.getValue(); Thread.currentThread().setContextClassLoader(deploymentInfo.getClassLoader()); try { if (deploymentManager != null) { Deployment deployment = deploymentManager.getDeployment(); try { host.getValue().unregisterDeployment(deployment); deploymentManager.stop(); } catch (ServletException e) { throw new RuntimeException(e); } deploymentManager.undeploy(); container.getValue().getServletContainer().removeDeployment(deploymentInfoInjectedValue.getValue()); } recursiveDelete(deploymentInfoInjectedValue.getValue().getTempDir()); } finally { Thread.currentThread().setContextClassLoader(old); } }
@Override public void stop() throws Exception { host.getValue().unregisterDeployment(manager.getDeployment()); manager.stop(); }
@Override public void start() throws Exception { HttpHandler handler = manager.start(); host.getValue().registerDeployment(manager.getDeployment(), handler); }
@Override public void stop() throws WebServerException { synchronized (this.monitor) { if (!this.started) { return; } this.started = false; try { this.manager.stop(); this.manager.undeploy(); this.undertow.stop(); } catch (Exception ex) { throw new WebServerException("Unable to stop undertow", ex); } } }
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()); 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); this.manager = defaultContainer().addDeployment(servletBuilder); this.manager.deploy(); HttpHandler httpHandler = this.manager.start(); this.server = Undertow.builder().addHttpListener(0, "localhost").setHandler(httpHandler).build();
} else { final PathHandler root = new PathHandler(); final io.undertow.servlet.api.ServletContainer container = io.undertow.servlet.api.ServletContainer.Factory.newInstance(); final DeploymentInfo builder = new DeploymentInfo() .setClassLoader(clazz.getClassLoader()) .setContextPath("/") .setDeploymentName("ServletContainer.war") .setResourceManager(new FileResourceManager(new File(resource.getFile()), 100)); builder.addServlet(Servlets.servlet("WuicServlet", installServlet).addMapping(WUIC_SERVLET_MAPPING)); final DeploymentManager manager = container.addDeployment(builder); manager.deploy(); servletContext = manager.getDeployment().getServletContext(); root.addPrefixPath(builder.getContextPath(), manager.start()); server = Undertow.builder() .addHttpListener(port, host)
/** * 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; }
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);
registerServletContainerInitializerToDriveServletContextInitializers(deployment, initializers); deployment.setClassLoader(getServletClassLoader()); deployment.setContextPath(getContextPath()); deployment.setDisplayName(getDisplayName()); deployment.setDeploymentName("spring-boot"); if (isRegisterDefaultServlet()) { DeploymentManager manager = Servlets.newContainer().addDeployment(deployment); manager.deploy(); SessionManager sessionManager = manager.getDeployment().getSessionManager(); Duration timeoutDuration = getSession().getTimeout(); int sessionTimeout = (isZeroOrLess(timeoutDuration) ? -1
String contextPath = getContextPath(); deployment = Servlets.deployment().setDeploymentName("nb").setClassLoader(classLoader).setEagerFilterInit(true).setSecurityDisabled(true); deployment.setContextPath(contextPath).setDefaultSessionTimeout(getSessionTimeout()); 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);
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; }
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); ServletInfo servletInfo = convertServletInfo(yggdrasilServletInfo); deployment.addServlet(servletInfo); mappings.addAll(servletInfo.getMappings()); }); di.getWelcomePages().forEach(deployment::addWelcomePage); DeploymentManager manager = Servlets.defaultContainer().addDeployment(deployment); manager.deploy(); HttpHandler servletHandler; try { servletHandler = manager.start(); } catch (ServletException e) { throw new YggdrasilException(e);
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; }
final ServletInfo servletInfo = Servlets.servlet(EndpointServlet.NAME, EndpointServlet.class).addMapping("/*") .setAsyncSupported(true); CamelLogger.LOGGER.debug("Deploying endpoint {}", endPointDeplyomentInfo.getDeploymentName()); Thread.currentThread().setContextClassLoader(endPointDeplyomentInfo.getClassLoader()); try { final DeploymentManager manager = servletContainerServiceSupplier.getValue().getServletContainer() .addDeployment(endPointDeplyomentInfo); manager.deploy(); final Deployment deployment = manager.getDeployment(); try { deploymentConsumer.accept((DeploymentImpl) deployment); manager.start(); hostSupplier.getValue().registerDeployment(deployment, deployment.getHandler());
public void startContext() throws ServletException { final ClassLoader old = Thread.currentThread().getContextClassLoader(); DeploymentInfo deploymentInfo = deploymentInfoInjectedValue.getValue(); Thread.currentThread().setContextClassLoader(deploymentInfo.getClassLoader()); try { StartupContext.setInjectionContainer(webInjectionContainer); try { deploymentManager = container.getValue().getServletContainer().addDeployment(deploymentInfo); deploymentManager.deploy(); HttpHandler handler = deploymentManager.start(); Deployment deployment = deploymentManager.getDeployment(); host.getValue().registerDeployment(deployment, handler); } finally { StartupContext.setInjectionContainer(null); } } finally { Thread.currentThread().setContextClassLoader(old); } }
private HTTPContext registerDeploymentInfo(Archive<?> archive) { UndertowWebArchive servletBuilder = (UndertowWebArchive) archive; final DeploymentInfo deploymentInfo = servletBuilder .getDeploymentInfo(); deploymentManager = defaultContainer().addDeployment( deploymentInfo); deploymentManager.deploy(); try { this.undertow = createUndertow(deploymentManager.start()); this.undertow.start(); } catch (ServletException e) { throw new IllegalArgumentException(e); } HTTPContext httpContext = new HTTPContext( configuration.getBindAddress(), configuration.getBindHttpPort()); final Map<String, ServletInfo> servlets = deploymentInfo.getServlets(); final Collection<ServletInfo> servletsInfo = servlets.values(); for (ServletInfo servletInfo : servletsInfo) { httpContext.add(new Servlet(servletInfo.getName(), deploymentManager.getDeployment().getDeploymentInfo() .getContextPath())); } return httpContext; }