if(!jspServlet.getMappings().contains(mapping)) { jspServlet.addMapping(mapping); jspServlet.addHandlerChainWrapper(JspFileHandler.jspFileHandlerWrapper(null)); // we need to clear the file attribute if it is set (WFLY-4106) 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); 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()); 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) {
private boolean hasPermission(Account account, Deployment deployment, ServletInfo servletInfo, Permission permission) { CodeSource codeSource = servletInfo.getServletClass().getProtectionDomain().getCodeSource(); ProtectionDomain domain = new ProtectionDomain(codeSource, null, null, getGrantedRoles(account, deployment)); return hasPermission(domain, permission); }
} else { final io.undertow.servlet.api.ServletInfo jspServlet = new ServletInfo("jsp", JspServlet.class); jspServlet.setRequireWelcomeFileMapping(true); jspServlet.addInitParam("development", Boolean.toString(developmentMode)); jspServlet.addInitParam("keepgenerated", Boolean.toString(keepGenerated)); jspServlet.addInitParam("trimSpaces", Boolean.toString(trimSpaces)); jspServlet.addInitParam("enablePooling", Boolean.toString(tagPooling)); jspServlet.addInitParam("mappedfile", Boolean.toString(mappedFile)); jspServlet.addInitParam("checkInterval", Integer.toString(checkInterval)); jspServlet.addInitParam("modificationTestInterval", Integer.toString(modificationTestInterval)); jspServlet.addInitParam("recompileOnFail", Boolean.toString(recompileOnFail)); jspServlet.addInitParam("suppressSmap", Boolean.toString(!smap)); jspServlet.addInitParam("dumpSmap", Boolean.toString(dumpSmap)); jspServlet.addInitParam("genStringAsCharArray", Boolean.toString(genStringAsCharArray)); jspServlet.addInitParam("errorOnUseBeanInvalidClassAttribute", Boolean.toString(errorOnUseBeanInvalidClassAttribute)); jspServlet.addInitParam("optimizeScriptlets", Boolean.toString(optimizeScriptlets)); if (scratchDir != null) { jspServlet.addInitParam("scratchdir", scratchDir); jspServlet.addInitParam("compilerSourceVM", sourceVm); jspServlet.addInitParam("compilerTargetVM", targetVm); jspServlet.addInitParam("javaEncoding", javaEncoding); jspServlet.addInitParam("xpoweredBy", Boolean.toString(xPoweredBy)); jspServlet.addInitParam("displaySourceFragment", Boolean.toString(displaySourceFragment)); this.servletInfo = jspServlet;
@Override protected void init(DeploymentInfo servletBuilder) { servletBuilder.addServlets( servlet("Unsampled", ServletContainer.class) .setLoadOnStartup(1) .addInitParam("javax.ws.rs.Application", Unsampled.class.getName()) .addMapping("/unsampled"), servlet("Traced", ServletContainer.class) .setLoadOnStartup(1) .addInitParam("javax.ws.rs.Application", TracedApp.class.getName()) .addMapping("/traced"), servlet("TracedExtra", ServletContainer.class) .setLoadOnStartup(1) .addInitParam("javax.ws.rs.Application", TracedExtraApp.class.getName()) .addMapping("/tracedextra"), servlet("Traced128", ServletContainer.class) .setLoadOnStartup(1) .addInitParam("javax.ws.rs.Application", Traced128App.class.getName()) .addMapping("/traced128"), servlet("App", ServletContainer.class) .setLoadOnStartup(1) .addInitParam("javax.ws.rs.Application", App.class.getName()) .addMapping("/*") ); }
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); } else { UndertowLogger.ROOT_LOGGER.duplicateServletMapping(pattern); } } } } }
public SimpleServletServer() { DeploymentInfo deploymentInfo = deployment() .setClassLoader(SimpleServletServer.class.getClassLoader()) .setContextPath("/helloworld") .setDeploymentName("helloworld.war") .addServlets( Servlets.servlet("MyServlet", MyServlet.class) .addInitParam("message", "Hello World") .addMapping("/MyServlet"), Servlets.servlet("MyAnotherServlet", MyAnotherServlet.class) .addMapping("/MyAnotherServlet") ); DeploymentManager manager = defaultContainer().addDeployment(deploymentInfo); manager.deploy (); try { server = Undertow.builder() .addListener(8080, "localhost") .setHandler(manager.start()) .build(); } catch (ServletException ex) { Logger.getLogger(SimpleServletServer.class.getName()).log(Level.SEVERE, null, ex); } }
.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)
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(); }
public static void merge( final DeploymentInfo into, final DeploymentInfo from ) final Map<String, AuthenticationMechanismFactory> authMechs = from.getAuthenticationMechanisms(); if ( authMechs != null ) into.addAuthenticationMechanism( entry.getKey(), entry.getValue() ); if ( from.getAuthorizationManager() != null ) logger.debug( "Found authorization manager: {}", from.getAuthorizationManager() ); .map( si -> si.getName() + " => " + si.getMappings() ) .collect( Collectors.toList() ) ); into.addServlets( servletInfos.values() );
.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);
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; }
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); }
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());
final String value = webInitParam.value(); final String name = webInitParam.name(); servletInfo.addInitParam(name , value); final String[] urlPatterns = annotation.urlPatterns(); for (String urlPattern : urlPatterns) { servletInfo.addMapping(urlPattern); servletInfo.setAsyncSupported(annotation.asyncSupported()); return servletInfo; }) .filter(servletInfo -> ! servletInfo.getMappings().isEmpty()) .collect(Collectors.toList()); .setClassLoader(Main.class.getClassLoader()) .setContextPath(MYAPP) .setDeploymentName("ROOT" + ".war") .setDefaultEncoding("UTF-8");
@Override @SuppressWarnings("unchecked") public void deployServlet(final String contextPath, final String deploymentName, final List<ServletDescriptor> servletDescriptors) throws SilverWareException { final DeploymentInfo servletBuilder = Servlets .deployment() .setClassLoader(this.getClass().getClassLoader()) .setContextPath(contextPath) .setDeploymentName(deploymentName); if (servletDescriptors != null) { servletDescriptors.forEach(servletDescriptor -> { final ServletInfo servletInfo = Servlets .servlet(servletDescriptor.getName(), (Class<Servlet>) servletDescriptor.getServletClass()); servletInfo.addMapping(servletDescriptor.getMapping()); servletDescriptor .getProperties() .forEach((key, value) -> servletInfo.addInitParam((String) key, (String) value)); servletBuilder.addServlet(servletInfo); }); } this.server.deploy(servletBuilder); }
@Override public DeploymentInfo configuration(ServerDescriptor descriptor) { try { App app = descriptor.getApp(); Set<Class<?>> handles = descriptor.getHandlesType(); String name = descriptor.getTestClassName(); ServletContainerInitializer initializer = descriptor.getServletContainerInitializer(); ImmediateInstanceFactory<ServletContainerInitializer> factory = new ImmediateInstanceFactory<>(initializer); URI uri = URI.create("http://0.0.0.0:0/"); ServletContainerInitializerInfo initInfo = new ServletContainerInitializerInfo(initializer.getClass(), factory, handles); ServletInfo servletInfo = Servlets.servlet(name, DefaultServlet.class) .setAsyncSupported(true); DeploymentInfo deploymentInfo = Servlets.deployment() .addServletContainerInitalizer(initInfo) .setClassLoader(descriptor.getTestClass().getClassLoader()) .setHostName(uri.getHost()) .setContextPath(uri.getPath()) .setDeploymentName(name) .addServlet(servletInfo); return deploymentInfo; } catch (Exception e) { throw new IllegalStateException(e); } }
public static void main(String[] args) throws ServletException { MyServer myServer = new MyServer(8080, "0.0.0.0"); DeploymentInfo di = myServer.deployApplication("/rest", MyApplication.class) .setClassLoader(MyServer.class.getClassLoader()) .setContextPath("/myApp") .setDeploymentName("My Application") .addServlets(Servlets.servlet("helloServlet", org.viddu.poc.HelloServlet.class).addMapping("/hello")) .addListeners(Servlets.listener(org.jboss.weld.environment.servlet.Listener.class)); myServer.deploy(di); } }