private List<ServletContainerInitializer> loadSci( ClassLoader classLoader, VirtualFile sci, String jar, boolean error, Set<Class<? extends ServletContainerInitializer>> sciClasses) throws DeploymentUnitProcessingException { final List<ServletContainerInitializer> scis = new ArrayList<ServletContainerInitializer>(); InputStream is = null; try { // Get the ServletContainerInitializer class name is = sci.openStream(); BufferedReader reader = new BufferedReader(new InputStreamReader(is, "UTF-8")); String servletContainerInitializerClassName = reader.readLine(); while (servletContainerInitializerClassName != null) { try { int pos = servletContainerInitializerClassName.indexOf('#'); if (pos >= 0) { servletContainerInitializerClassName = servletContainerInitializerClassName.substring(0, pos); } servletContainerInitializerClassName = servletContainerInitializerClassName.trim(); if (!servletContainerInitializerClassName.isEmpty()) { // Instantiate the ServletContainerInitializer ServletContainerInitializer service = (ServletContainerInitializer) classLoader.loadClass(servletContainerInitializerClassName).newInstance(); if (service != null) { if (sciClasses.add(service.getClass())) { scis.add(service); } } } servletContainerInitializerClassName = reader.readLine(); } catch (Exception e) { if (error) { throw UndertowLogger.ROOT_LOGGER.errorProcessingSCI(jar, e); } else { UndertowLogger.ROOT_LOGGER.skippedSCI(jar, e); } } } } catch (Exception e) { if (error) { throw UndertowLogger.ROOT_LOGGER.errorProcessingSCI(jar, e); } else { UndertowLogger.ROOT_LOGGER.skippedSCI(jar, e); } } finally { try { if (is != null) is.close(); } catch (IOException e) { // Ignore } } return scis; }
private static ServiceName installSessionManagerFactory( ServiceTarget target, ServiceName deploymentServiceName, String deploymentName, Module module, JBossWebMetaData metaData) { ServiceName name = deploymentServiceName.append("session"); if (metaData.getDistributable() != null) { DistributableSessionManagerFactoryBuilder sessionManagerFactoryBuilder = new DistributableSessionManagerFactoryBuilderValue().getValue(); if (sessionManagerFactoryBuilder != null) { sessionManagerFactoryBuilder .build( target, name, new SimpleDistributableSessionManagerConfiguration( metaData, deploymentName, module)) .setInitialMode(Mode.ON_DEMAND) .install(); return name; } // Fallback to local session manager if server does not support clustering UndertowLogger.ROOT_LOGGER.clusteringNotSupported(); } Integer maxActiveSessions = metaData.getMaxActiveSessions(); InMemorySessionManagerFactory factory = (maxActiveSessions != null) ? new InMemorySessionManagerFactory(maxActiveSessions.intValue()) : new InMemorySessionManagerFactory(); target .addService(name, new ValueService<>(new ImmediateValue<>(factory))) .setInitialMode(Mode.ON_DEMAND) .install(); return name; }
@Override public HttpHandler createHttpHandler(Predicate predicate, final HttpHandler next) { // this is a bit of a hack at the moment. Basically we only want to create a single mod_cluster // instance // not matter how many filter refs use it, also mod_cluster at this point has no way // to specify the next handler. To get around this we invoke the mod_proxy handler // and then if it has not dispatched or handled the request then we know that we can // just pass it on to the next handler final HttpHandler mcmp = managementAccessPredicate != null ? Handlers.predicate(managementAccessPredicate, config.create(modCluster, next), next) : config.create(modCluster, next); final HttpHandler proxyHandler = modCluster.getProxyHandler(); HttpHandler theHandler = new HttpHandler() { @Override public void handleRequest(HttpServerExchange exchange) throws Exception { proxyHandler.handleRequest(exchange); if (!exchange.isDispatched() && !exchange.isComplete()) { exchange.setResponseCode(200); mcmp.handleRequest(exchange); } } }; UndertowLogger.ROOT_LOGGER.debug("HttpHandler for mod_cluster MCMP created."); if (predicate != null) { return new PredicateHandler(predicate, theHandler, next); } else { return theHandler; } }
public UndertowDeploymentProcessor( String defaultHost, final String defaultContainer, String defaultServer) { this.defaultHost = defaultHost; if (defaultHost == null) { throw UndertowLogger.ROOT_LOGGER.nullDefaultHost(); } this.defaultContainer = defaultContainer; this.defaultServer = defaultServer; }
static String hostNameOfDeployment(final WarMetaData metaData, final String defaultHost) { Collection<String> hostNames = null; if (metaData.getMergedJBossWebMetaData() != null) { hostNames = metaData.getMergedJBossWebMetaData().getVirtualHosts(); } if (hostNames == null || hostNames.isEmpty()) { hostNames = Collections.singleton(defaultHost); } String hostName = hostNames.iterator().next(); if (hostName == null) { throw UndertowLogger.ROOT_LOGGER.nullHostName(); } return hostName; }
private Set<Class<?>> loadClassInfoSet(Set<ClassInfo> classInfos, ClassLoader classLoader) throws DeploymentUnitProcessingException { Set<Class<?>> classes = new HashSet<Class<?>>(); for (ClassInfo classInfo : classInfos) { Class<?> type; try { type = classLoader.loadClass(classInfo.name().toString()); classes.add(type); } catch (Exception e) { UndertowLogger.ROOT_LOGGER.cannotLoadDesignatedHandleTypes(classInfo, e); } } return classes; }
private void processDeployment( final WarMetaData warMetaData, final DeploymentUnit deploymentUnit, final ServiceTarget serviceTarget, String hostName) throws DeploymentUnitProcessingException { ResourceRoot deploymentResourceRoot = deploymentUnit.getAttachment(Attachments.DEPLOYMENT_ROOT); final VirtualFile deploymentRoot = deploymentResourceRoot.getRoot(); final Module module = deploymentUnit.getAttachment(Attachments.MODULE); if (module == null) { throw new DeploymentUnitProcessingException( UndertowLogger.ROOT_LOGGER.failedToResolveModule(deploymentUnit)); } final JBossWebMetaData metaData = warMetaData.getMergedJBossWebMetaData(); final List<SetupAction> setupActions = deploymentUnit.getAttachmentList(org.jboss.as.ee.component.Attachments.WEB_SETUP_ACTIONS); metaData.resolveRunAs(); ScisMetaData scisMetaData = deploymentUnit.getAttachment(ScisMetaData.ATTACHMENT_KEY); final Set<ServiceName> dependentComponents = new HashSet<>(); // see AS7-2077 // basically we want to ignore components that have failed for whatever reason // if they are important they will be picked up when the web deployment actually starts final List<ServiceName> components = deploymentUnit.getAttachmentList(WebComponentDescription.WEB_COMPONENTS); final Set<ServiceName> failed = deploymentUnit.getAttachment(org.jboss.as.ee.component.Attachments.FAILED_COMPONENTS); for (final ServiceName component : components) { if (!failed.contains(component)) { dependentComponents.add(component); } } boolean componentRegistryExists = true; ComponentRegistry componentRegistry = deploymentUnit.getAttachment(org.jboss.as.ee.component.Attachments.COMPONENT_REGISTRY); if (componentRegistry == null) { componentRegistryExists = false; // we do this to avoid lots of other null checks // this will only happen if the EE subsystem is not installed componentRegistry = new ComponentRegistry(null); } final WebInjectionContainer injectionContainer = new WebInjectionContainer(module.getClassLoader(), componentRegistry); String jaccContextId = metaData.getJaccContextID(); if (jaccContextId == null) { jaccContextId = deploymentUnit.getName(); } if (deploymentUnit.getParent() != null) { jaccContextId = deploymentUnit.getParent().getName() + "!" + jaccContextId; } String deploymentName; if (deploymentUnit.getParent() == null) { deploymentName = deploymentUnit.getName(); } else { deploymentName = deploymentUnit.getParent().getName() + "." + deploymentUnit.getName(); } final String pathName = pathNameOfDeployment(deploymentUnit, metaData); boolean securityEnabled = deploymentUnit.hasAttachment(SecurityAttachments.SECURITY_ENABLED); String metaDataSecurityDomain = metaData.getSecurityDomain(); if (metaDataSecurityDomain == null) { metaDataSecurityDomain = getJBossAppSecurityDomain(deploymentUnit); } if (metaDataSecurityDomain != null) { metaDataSecurityDomain = metaDataSecurityDomain.trim(); } final String securityDomain; if (securityEnabled) { securityDomain = metaDataSecurityDomain == null ? SecurityConstants.DEFAULT_APPLICATION_POLICY : SecurityUtil.unprefixSecurityDomain(metaDataSecurityDomain); } else { securityDomain = null; } String serverInstanceName = metaData.getServerInstanceName() == null ? defaultServer : metaData.getServerInstanceName(); final ServiceName deploymentServiceName = UndertowService.deploymentServiceName(serverInstanceName, hostName, pathName); final Set<ServiceName> additionalDependencies = new HashSet<>(); for (final SetupAction setupAction : setupActions) { Set<ServiceName> dependencies = setupAction.dependencies(); if (dependencies != null) { additionalDependencies.addAll(dependencies); } } SharedSessionManagerConfig sharedSessionManagerConfig = deploymentUnit.getParent() != null ? deploymentUnit .getParent() .getAttachment(UndertowAttachments.SHARED_SESSION_MANAGER_CONFIG) : null; if (!deploymentResourceRoot.isUsePhysicalCodeSource()) { try { deploymentUnit.addToAttachmentList( ServletContextAttribute.ATTACHMENT_KEY, new ServletContextAttribute( Constants.CODE_SOURCE_ATTRIBUTE_NAME, deploymentRoot.toURL())); } catch (MalformedURLException e) { throw new DeploymentUnitProcessingException(e); } } deploymentUnit.addToAttachmentList( ServletContextAttribute.ATTACHMENT_KEY, new ServletContextAttribute( Constants.PERMISSION_COLLECTION_ATTRIBUTE_NAME, deploymentUnit.getAttachment(Attachments.MODULE_PERMISSIONS))); additionalDependencies.addAll(warMetaData.getAdditionalDependencies()); final ServiceName hostServiceName = UndertowService.virtualHostName(serverInstanceName, hostName); TldsMetaData tldsMetaData = deploymentUnit.getAttachment(TldsMetaData.ATTACHMENT_KEY); UndertowDeploymentInfoService undertowDeploymentInfoService = UndertowDeploymentInfoService.builder() .setAttributes(deploymentUnit.getAttachmentList(ServletContextAttribute.ATTACHMENT_KEY)) .setTopLevelDeploymentName( deploymentUnit.getParent() == null ? deploymentUnit.getName() : deploymentUnit.getParent().getName()) .setContextPath(pathName) .setDeploymentName( deploymentName) // todo: is this deployment name concept really applicable? .setDeploymentRoot(deploymentRoot) .setMergedMetaData(warMetaData.getMergedJBossWebMetaData()) .setModule(module) .setScisMetaData(scisMetaData) .setJaccContextId(jaccContextId) .setSecurityDomain(securityDomain) .setSharedTlds( tldsMetaData == null ? Collections.<TldMetaData>emptyList() : tldsMetaData.getSharedTlds(deploymentUnit)) .setTldsMetaData(tldsMetaData) .setSetupActions(setupActions) .setSharedSessionManagerConfig(sharedSessionManagerConfig) .setOverlays(warMetaData.getOverlays()) .setExpressionFactoryWrappers( deploymentUnit.getAttachmentList(ExpressionFactoryWrapper.ATTACHMENT_KEY)) .setPredicatedHandlers( deploymentUnit.getAttachment( UndertowHandlersDeploymentProcessor.PREDICATED_HANDLERS)) .setInitialHandlerChainWrappers( deploymentUnit.getAttachmentList( UndertowAttachments.UNDERTOW_INITIAL_HANDLER_CHAIN_WRAPPERS)) .setInnerHandlerChainWrappers( deploymentUnit.getAttachmentList( UndertowAttachments.UNDERTOW_INNER_HANDLER_CHAIN_WRAPPERS)) .setOuterHandlerChainWrappers( deploymentUnit.getAttachmentList( UndertowAttachments.UNDERTOW_OUTER_HANDLER_CHAIN_WRAPPERS)) .setThreadSetupActions( deploymentUnit.getAttachmentList(UndertowAttachments.UNDERTOW_THREAD_SETUP_ACTIONS)) .setServletExtensions( deploymentUnit.getAttachmentList(UndertowAttachments.UNDERTOW_SERVLET_EXTENSIONS)) .setExplodedDeployment(ExplodedDeploymentMarker.isExplodedDeployment(deploymentUnit)) .setWebSocketDeploymentInfo( deploymentUnit.getAttachment(UndertowAttachments.WEB_SOCKET_DEPLOYMENT_INFO)) .setTempDir(warMetaData.getTempDir()) .setExternalResources( deploymentUnit.getAttachmentList(UndertowAttachments.EXTERNAL_RESOURCES)) .createUndertowDeploymentInfoService(); final ServiceName deploymentInfoServiceName = deploymentServiceName.append(UndertowDeploymentInfoService.SERVICE_NAME); ServiceBuilder<DeploymentInfo> infoBuilder = serviceTarget .addService(deploymentInfoServiceName, undertowDeploymentInfoService) .addDependency( UndertowService.SERVLET_CONTAINER.append(defaultContainer), ServletContainerService.class, undertowDeploymentInfoService.getContainer()) .addDependency( UndertowService.UNDERTOW, UndertowService.class, undertowDeploymentInfoService.getUndertowService()) .addDependencies(deploymentUnit.getAttachmentList(Attachments.WEB_DEPENDENCIES)) .addDependency(hostServiceName, Host.class, undertowDeploymentInfoService.getHost()) .addDependency( SuspendController.SERVICE_NAME, SuspendController.class, undertowDeploymentInfoService.getSuspendControllerInjectedValue()) .addDependencies(additionalDependencies); if (securityDomain != null) { infoBuilder.addDependency( SecurityDomainService.SERVICE_NAME.append(securityDomain), SecurityDomainContext.class, undertowDeploymentInfoService.getSecurityDomainContextValue()); } if (RequestControllerActivationMarker.isRequestControllerEnabled(deploymentUnit)) { String topLevelName; if (deploymentUnit.getParent() == null) { topLevelName = deploymentUnit.getName(); } else { topLevelName = deploymentUnit.getParent().getName(); } infoBuilder.addDependency( ControlPointService.serviceName(topLevelName, UndertowExtension.SUBSYSTEM_NAME), ControlPoint.class, undertowDeploymentInfoService.getControlPointInjectedValue()); } final Set<String> seenExecutors = new HashSet<String>(); if (metaData.getExecutorName() != null) { final InjectedValue<Executor> executor = new InjectedValue<Executor>(); infoBuilder.addDependency( IOServices.WORKER.append(metaData.getExecutorName()), Executor.class, executor); undertowDeploymentInfoService.addInjectedExecutor(metaData.getExecutorName(), executor); seenExecutors.add(metaData.getExecutorName()); } if (metaData.getServlets() != null) { for (JBossServletMetaData servlet : metaData.getServlets()) { if (servlet.getExecutorName() != null && !seenExecutors.contains(servlet.getExecutorName())) { final InjectedValue<Executor> executor = new InjectedValue<Executor>(); infoBuilder.addDependency( IOServices.WORKER.append(servlet.getExecutorName()), Executor.class, executor); undertowDeploymentInfoService.addInjectedExecutor(servlet.getExecutorName(), executor); seenExecutors.add(servlet.getExecutorName()); } } } if (componentRegistryExists) { infoBuilder.addDependency( ComponentRegistry.serviceName(deploymentUnit), ComponentRegistry.class, undertowDeploymentInfoService.getComponentRegistryInjectedValue()); } else { undertowDeploymentInfoService .getComponentRegistryInjectedValue() .setValue(new ImmediateValue<>(componentRegistry)); } if (sharedSessionManagerConfig != null) { infoBuilder.addDependency( deploymentUnit .getParent() .getServiceName() .append(SharedSessionManagerConfig.SHARED_SESSION_MANAGER_SERVICE_NAME), SessionManagerFactory.class, undertowDeploymentInfoService.getSessionManagerFactoryInjector()); infoBuilder.addDependency( deploymentUnit .getParent() .getServiceName() .append(SharedSessionManagerConfig.SHARED_SESSION_IDENTIFIER_CODEC_SERVICE_NAME), SessionIdentifierCodec.class, undertowDeploymentInfoService.getSessionIdentifierCodecInjector()); } else { ServiceName sessionManagerFactoryServiceName = installSessionManagerFactory( serviceTarget, deploymentServiceName, deploymentName, module, metaData); infoBuilder.addDependency( sessionManagerFactoryServiceName, SessionManagerFactory.class, undertowDeploymentInfoService.getSessionManagerFactoryInjector()); ServiceName sessionIdentifierCodecServiceName = installSessionIdentifierCodec( serviceTarget, deploymentServiceName, deploymentName, metaData); infoBuilder.addDependency( sessionIdentifierCodecServiceName, SessionIdentifierCodec.class, undertowDeploymentInfoService.getSessionIdentifierCodecInjector()); } infoBuilder.install(); final boolean isWebappBundle = deploymentUnit.hasAttachment(Attachments.OSGI_MANIFEST); final UndertowDeploymentService service = new UndertowDeploymentService(injectionContainer, !isWebappBundle); final ServiceBuilder<UndertowDeploymentService> builder = serviceTarget .addService(deploymentServiceName, service) .addDependencies(dependentComponents) .addDependency( UndertowService.SERVLET_CONTAINER.append(defaultContainer), ServletContainerService.class, service.getContainer()) .addDependency(hostServiceName, Host.class, service.getHost()) .addDependencies(deploymentUnit.getAttachmentList(Attachments.WEB_DEPENDENCIES)) .addDependency( deploymentInfoServiceName, DeploymentInfo.class, service.getDeploymentInfoInjectedValue()); // inject the server executor which can be used by the WebDeploymentService for blocking tasks // in start/stop // of that service Services.addServerExecutorDependency(builder, service.getServerExecutorInjector(), false); deploymentUnit.addToAttachmentList( Attachments.DEPLOYMENT_COMPLETE_SERVICES, deploymentServiceName); // adding JACC service if (securityEnabled) { AbstractSecurityDeployer<WarMetaData> deployer = new WarJACCDeployer(); JaccService<WarMetaData> jaccService = deployer.deploy(deploymentUnit, jaccContextId); if (jaccService != null) { final ServiceName jaccServiceName = deploymentUnit.getServiceName().append(JaccService.SERVICE_NAME); ServiceBuilder<?> jaccBuilder = serviceTarget.addService(jaccServiceName, jaccService); if (deploymentUnit.getParent() != null) { // add dependency to parent policy final DeploymentUnit parentDU = deploymentUnit.getParent(); jaccBuilder.addDependency( parentDU.getServiceName().append(JaccService.SERVICE_NAME), PolicyConfiguration.class, jaccService.getParentPolicyInjector()); } // add dependency to web deployment service jaccBuilder.addDependency(deploymentServiceName); jaccBuilder.setInitialMode(Mode.PASSIVE).install(); } } // OSGi web applications are activated in {@link WebContextActivationProcessor} according to // bundle lifecycle changes if (isWebappBundle) { UndertowDeploymentService.ContextActivatorImpl activator = new UndertowDeploymentService.ContextActivatorImpl(builder.install()); deploymentUnit.putAttachment(ContextActivator.ATTACHMENT_KEY, activator); deploymentUnit.addToAttachmentList( Attachments.BUNDLE_ACTIVE_DEPENDENCIES, deploymentServiceName); } else { builder.install(); } // Process the web related mgmt information final DeploymentResourceSupport deploymentResourceSupport = deploymentUnit.getAttachment(Attachments.DEPLOYMENT_RESOURCE_SUPPORT); final ModelNode node = deploymentResourceSupport.getDeploymentSubsystemModel(UndertowExtension.SUBSYSTEM_NAME); node.get(DeploymentDefinition.CONTEXT_ROOT.getName()).set("".equals(pathName) ? "/" : pathName); node.get(DeploymentDefinition.VIRTUAL_HOST.getName()).set(hostName); node.get(DeploymentDefinition.SERVER.getName()).set(serverInstanceName); processManagement(deploymentUnit, metaData); }
@Override public synchronized void start(StartContext context) throws StartException { super.start(context); SecurityRealm realm = securityRealm.getOptionalValue(); // TODO: SSL support for the client // TODO: wire up idle timeout when new version of undertow arrives final ModCluster.Builder modClusterBuilder; final XnioWorker worker = workerInjectedValue.getValue(); if (realm == null) { modClusterBuilder = ModCluster.builder(worker); } else { SSLContext sslContext = realm.getSSLContext(); OptionMap.Builder builder = OptionMap.builder(); builder.set(Options.USE_DIRECT_BUFFERS, true); OptionMap combined = builder.getMap(); XnioSsl xnioSsl = new UndertowXnioSsl(worker.getXnio(), combined, sslContext); modClusterBuilder = ModCluster.builder(worker, UndertowClient.getInstance(), xnioSsl); } modClusterBuilder .setHealthCheckInterval(healthCheckInterval) .setMaxRequestTime(maxRequestTime) .setCacheConnections(cachedConnections) .setQueueNewRequests(requestQueueSize > 0) .setRequestQueueSize(requestQueueSize) .setRemoveBrokenNodes(removeBrokenNodes) .setTtl(connectionIdleTimeout) .setMaxConnections(connectionsPerThread) .setUseAlias(useAlias); modCluster = modClusterBuilder.build(); MCMPConfig.Builder builder = MCMPConfig.builder(); InetAddress multicastAddress = advertiseSocketBinding.getValue().getMulticastAddress(); if (multicastAddress == null) { throw UndertowLogger.ROOT_LOGGER.advertiseSocketBindingRequiresMulticastAddress(); } if (advertiseFrequency > 0) { builder .enableAdvertise() .setAdvertiseAddress( advertiseSocketBinding.getValue().getSocketAddress().getAddress().getHostAddress()) .setAdvertiseGroup(multicastAddress.getHostAddress()) .setAdvertisePort(advertiseSocketBinding.getValue().getPort()) .setAdvertiseFrequency(advertiseFrequency) .setPath(advertisePath) .setProtocol(advertiseProtocol) .setSecurityKey(securityKey); } builder.setManagementHost(managementSocketBinding.getValue().getSocketAddress().getHostName()); builder.setManagementPort(managementSocketBinding.getValue().getSocketAddress().getPort()); config = builder.build(); if (advertiseFrequency > 0) { try { modCluster.advertise(config); } catch (IOException e) { throw new RuntimeException(e); } } modCluster.start(); }
/** Process SCIs. */ public void deploy(final DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException { final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit(); final ModuleSpecification moduleSpecification = deploymentUnit.getAttachment(Attachments.MODULE_SPECIFICATION); final ServiceModuleLoader loader = deploymentUnit.getAttachment(Attachments.SERVICE_MODULE_LOADER); if (!DeploymentTypeMarker.isType(DeploymentType.WAR, deploymentUnit)) { return; // Skip non web deployments } WarMetaData warMetaData = deploymentUnit.getAttachment(WarMetaData.ATTACHMENT_KEY); assert warMetaData != null; final Module module = deploymentUnit.getAttachment(Attachments.MODULE); if (module == null) { throw UndertowLogger.ROOT_LOGGER.failedToResolveModule(deploymentUnit); } final ClassLoader classLoader = module.getClassLoader(); ScisMetaData scisMetaData = deploymentUnit.getAttachment(ScisMetaData.ATTACHMENT_KEY); if (scisMetaData == null) { scisMetaData = new ScisMetaData(); deploymentUnit.putAttachment(ScisMetaData.ATTACHMENT_KEY, scisMetaData); } Set<ServletContainerInitializer> scis = scisMetaData.getScis(); Set<Class<? extends ServletContainerInitializer>> sciClasses = new HashSet<>(); if (scis == null) { scis = new HashSet<ServletContainerInitializer>(); scisMetaData.setScis(scis); } Map<ServletContainerInitializer, Set<Class<?>>> handlesTypes = scisMetaData.getHandlesTypes(); if (handlesTypes == null) { handlesTypes = new HashMap<ServletContainerInitializer, Set<Class<?>>>(); scisMetaData.setHandlesTypes(handlesTypes); } // Find the SCIs from shared modules for (ModuleDependency dependency : moduleSpecification.getAllDependencies()) { try { Module depModule = loader.loadModule(dependency.getIdentifier()); ServiceLoader<ServletContainerInitializer> serviceLoader = depModule.loadService(ServletContainerInitializer.class); for (ServletContainerInitializer service : serviceLoader) { if (sciClasses.add(service.getClass())) { scis.add(service); } } } catch (ModuleLoadException e) { if (dependency.isOptional() == false) { throw UndertowLogger.ROOT_LOGGER.errorLoadingSCIFromModule(dependency.getIdentifier(), e); } } } // Find local ServletContainerInitializer services List<String> order = warMetaData.getOrder(); Map<String, VirtualFile> localScis = warMetaData.getScis(); if (order != null && localScis != null) { for (String jar : order) { VirtualFile sci = localScis.get(jar); if (sci != null) { scis.addAll(loadSci(classLoader, sci, jar, true, sciClasses)); } } } // Process HandlesTypes for ServletContainerInitializer Map<Class<?>, Set<ServletContainerInitializer>> typesMap = new HashMap<Class<?>, Set<ServletContainerInitializer>>(); for (ServletContainerInitializer service : scis) { if (service.getClass().isAnnotationPresent(HandlesTypes.class)) { HandlesTypes handlesTypesAnnotation = service.getClass().getAnnotation(HandlesTypes.class); Class<?>[] typesArray = handlesTypesAnnotation.value(); if (typesArray != null) { for (Class<?> type : typesArray) { Set<ServletContainerInitializer> servicesSet = typesMap.get(type); if (servicesSet == null) { servicesSet = new HashSet<ServletContainerInitializer>(); typesMap.put(type, servicesSet); } servicesSet.add(service); handlesTypes.put(service, new HashSet<Class<?>>()); } } } } Class<?>[] typesArray = typesMap.keySet().toArray(new Class<?>[0]); final CompositeIndex index = deploymentUnit.getAttachment(Attachments.COMPOSITE_ANNOTATION_INDEX); if (index == null) { throw UndertowLogger.ROOT_LOGGER.unableToResolveAnnotationIndex(deploymentUnit); } // WFLY-4205, look in the parent as well as the war CompositeIndex parentIndex = deploymentUnit.getParent() == null ? null : deploymentUnit.getParent().getAttachment(Attachments.COMPOSITE_ANNOTATION_INDEX); // Find classes which extend, implement, or are annotated by HandlesTypes for (Class<?> type : typesArray) { DotName className = DotName.createSimple(type.getName()); Set<ClassInfo> classInfos = new HashSet<>(); classInfos.addAll(processHandlesType(className, type, index)); if (parentIndex != null) { classInfos.addAll(processHandlesType(className, type, parentIndex)); } Set<Class<?>> classes = loadClassInfoSet(classInfos, classLoader); Set<ServletContainerInitializer> sciSet = typesMap.get(type); for (ServletContainerInitializer sci : sciSet) { handlesTypes.get(sci).addAll(classes); } } }