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);
}
}
}
