@Override
public void deploy(final DeploymentPhaseContext phaseContext)
throws DeploymentUnitProcessingException {
// Check if we already have an OSGi deployment
final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
Deployment deployment = OSGiDeploymentAttachment.getDeployment(deploymentUnit);
ServiceRegistry serviceRegistry = phaseContext.getServiceRegistry();
String location =
DeploymentHolderService.getLocation(serviceRegistry, deploymentUnit.getName());
VirtualFile virtualFile = deploymentUnit.getAttachment(Attachments.DEPLOYMENT_ROOT).getRoot();
// Check for attached BundleInfo
BundleInfo info = BundleInfoAttachment.getBundleInfo(deploymentUnit);
if (deployment == null && info != null) {
deployment = DeploymentFactory.createDeployment(info);
deployment.addAttachment(BundleInfo.class, info);
OSGiDeploymentAttachment.attachDeployment(deploymentUnit, deployment);
}
// Check for attached OSGiMetaData
OSGiMetaData metadata = OSGiMetaDataAttachment.getOSGiMetaData(deploymentUnit);
if (deployment == null && metadata != null) {
String symbolicName = metadata.getBundleSymbolicName();
Version version = metadata.getBundleVersion();
deployment =
DeploymentFactory.createDeployment(
AbstractVFS.adapt(virtualFile), location, symbolicName, version);
deployment.addAttachment(OSGiMetaData.class, metadata);
OSGiDeploymentAttachment.attachDeployment(deploymentUnit, deployment);
}
// Check for attached XModule
XModule resModule = XModuleAttachment.getXModuleAttachment(deploymentUnit);
if (deployment == null && resModule != null) {
String symbolicName = resModule.getName();
Version version = resModule.getVersion();
deployment =
DeploymentFactory.createDeployment(
AbstractVFS.adapt(virtualFile), location, symbolicName, version);
deployment.addAttachment(XModule.class, resModule);
OSGiDeploymentAttachment.attachDeployment(deploymentUnit, deployment);
}
// Create the {@link OSGiDeploymentService}
if (deployment != null) {
// Prevent garbage collection of the MountHandle which will close the file
MountHandle mount =
deploymentUnit.getAttachment(Attachments.DEPLOYMENT_ROOT).getMountHandle();
deployment.addAttachment(MountHandle.class, mount);
// Mark the bundle to start automatically
deployment.setAutoStart(true);
OSGiDeploymentService.addService(phaseContext);
}
}
public static String pathNameOfDeployment(
final DeploymentUnit deploymentUnit, final JBossWebMetaData metaData) {
String pathName;
if (metaData.getContextRoot() == null) {
final EEModuleDescription description =
deploymentUnit.getAttachment(org.jboss.as.ee.component.Attachments.EE_MODULE_DESCRIPTION);
if (description != null) {
// if there is a EEModuleDescription we need to take into account that the module name
// may have been overridden
pathName = "/" + description.getModuleName();
} else {
pathName =
"/" + deploymentUnit.getName().substring(0, deploymentUnit.getName().length() - 4);
}
} else {
pathName = metaData.getContextRoot();
if ("/".equals(pathName)) {
pathName = "";
} else if (pathName.length() > 0 && pathName.charAt(0) != '/') {
pathName = "/" + pathName;
}
}
return pathName;
}
private String getModuleName(final DeploymentUnit deploymentUnit) {
final DeploymentUnit parent = deploymentUnit.getParent();
if (parent != null && isEarDeployment(parent)) {
return parent.getName() + "/" + deploymentUnit.getName();
}
return deploymentUnit.getName();
}
public static ServiceName getServiceName(final DeploymentUnit unit, final String endpointName) {
if (unit.getParent() != null) {
return WSServices.ENDPOINT_SERVICE
.append(unit.getParent().getName())
.append(unit.getName())
.append(endpointName);
} else {
return WSServices.ENDPOINT_SERVICE.append(unit.getName()).append(endpointName);
}
}
public void deploy(final DeploymentPhaseContext phaseContext)
throws DeploymentUnitProcessingException {
final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
final WarMetaData warMetaData = deploymentUnit.getAttachment(WarMetaData.ATTACHMENT_KEY);
if (warMetaData == null) {
return; // Nothing we can do without WarMetaData
}
final ResourceRoot deploymentRoot =
deploymentUnit.getAttachment(org.jboss.as.server.deployment.Attachments.DEPLOYMENT_ROOT);
if (deploymentRoot == null) {
return; // We don't have a root to work with
}
final DeploymentUnit parent = deploymentUnit.getParent();
if (parent == null || !DeploymentTypeMarker.isType(DeploymentType.EAR, parent)) {
return; // Only care if this war is nested in an EAR
}
final EarMetaData earMetaData = parent.getAttachment(Attachments.EAR_METADATA);
if (earMetaData == null) {
return; // Nothing to see here
}
final ModulesMetaData modulesMetaData = earMetaData.getModules();
if (modulesMetaData != null)
for (ModuleMetaData moduleMetaData : modulesMetaData) {
if (Web.equals(moduleMetaData.getType())
&& moduleMetaData.getFileName().equals(deploymentRoot.getRootName())) {
String contextRoot =
WebModuleMetaData.class.cast(moduleMetaData.getValue()).getContextRoot();
if (contextRoot == null
&& (warMetaData.getJbossWebMetaData() == null
|| warMetaData.getJbossWebMetaData().getContextRoot() == null)) {
contextRoot =
"/"
+ parent.getName().substring(0, parent.getName().length() - 4)
+ "/"
+ deploymentUnit.getName().substring(0, deploymentUnit.getName().length() - 4);
}
if (contextRoot != null) {
JBossWebMetaData jBossWebMetaData = warMetaData.getJbossWebMetaData();
if (jBossWebMetaData == null) {
jBossWebMetaData = new JBoss70WebMetaData();
warMetaData.setJbossWebMetaData(jBossWebMetaData);
}
jBossWebMetaData.setContextRoot(contextRoot);
}
return;
}
}
}
@Override
public void deploy(final DeploymentPhaseContext phaseContext)
throws DeploymentUnitProcessingException {
final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
final EEModuleDescription moduleDescription =
deploymentUnit.getAttachment(org.jboss.as.ee.component.Attachments.EE_MODULE_DESCRIPTION);
final DeploymentReflectionIndex deploymentReflectionIndex =
deploymentUnit.getAttachment(Attachments.REFLECTION_INDEX);
final Module module = deploymentUnit.getAttachment(Attachments.MODULE);
Boolean activate = deploymentUnit.getAttachment(AppClientAttachments.START_APP_CLIENT);
if (activate == null || !activate) {
return;
}
final Class<?> mainClass = deploymentUnit.getAttachment(AppClientAttachments.MAIN_CLASS);
if (mainClass == null) {
throw MESSAGES.cannotStartAppClient(deploymentUnit.getName());
}
final ApplicationClientComponentDescription component =
deploymentUnit.getAttachment(AppClientAttachments.APPLICATION_CLIENT_COMPONENT);
ClassReflectionIndex<?> index = deploymentReflectionIndex.getClassIndex(mainClass);
Method method = index.getMethod(void.class, "main", String[].class);
if (method == null) {
throw MESSAGES.cannotStartAppClient(deploymentUnit.getName(), mainClass);
}
final ApplicationClientStartService startService =
new ApplicationClientStartService(
method,
parameters,
hostUrl,
moduleDescription.getNamespaceContextSelector(),
module.getClassLoader());
phaseContext
.getServiceTarget()
.addService(
deploymentUnit.getServiceName().append(ApplicationClientStartService.SERVICE_NAME),
startService)
.addDependency(
ApplicationClientDeploymentService.SERVICE_NAME,
ApplicationClientDeploymentService.class,
startService.getApplicationClientDeploymentServiceInjectedValue())
.addDependency(
component.getCreateServiceName(),
Component.class,
startService.getApplicationClientComponent())
.install();
}
@Override
public synchronized void start(final StartContext context) throws StartException {
super.start(context);
ApplicationSecurityDomain applicationSecurityDomain = getApplicationSecurityDomain();
Function<String, Registration> securityFunction =
applicationSecurityDomain != null ? applicationSecurityDomain.getSecurityFunction() : null;
if (securityFunction != null) {
final DeploymentUnit deploymentUnit = getDeploymentUnitInjector().getValue();
final String deploymentName =
deploymentUnit.getParent() == null
? deploymentUnit.getName()
: deploymentUnit.getParent().getName() + "." + deploymentUnit.getName();
registration = securityFunction.apply(deploymentName);
}
}
public void deploy(final DeploymentPhaseContext phaseContext)
throws DeploymentUnitProcessingException {
final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
final String deploymentUnitName = deploymentUnit.getName();
final String moduleName;
if (deploymentUnitName.endsWith(".war")
|| deploymentUnitName.endsWith(".wab")
|| deploymentUnitName.endsWith(".jar")
|| deploymentUnitName.endsWith(".ear")
|| deploymentUnitName.endsWith(".rar")) {
moduleName = deploymentUnitName.substring(0, deploymentUnitName.length() - 4);
} else {
moduleName = deploymentUnitName;
}
final String appName;
final String earApplicationName =
deploymentUnit.getAttachment(Attachments.EAR_APPLICATION_NAME);
// the ear application name takes into account the name set in application.xml
// if this is non-null this is always the one we want to use
if (earApplicationName != null) {
appName = earApplicationName;
} else {
// an appname of null means use the module name
appName = null;
}
deploymentUnit.putAttachment(
Attachments.EE_MODULE_DESCRIPTION,
new EEModuleDescription(appName, moduleName, earApplicationName, appClient));
}
@Override
public void deploy(final DeploymentPhaseContext phaseContext)
throws DeploymentUnitProcessingException {
final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
if (!DeploymentTypeMarker.isType(DeploymentType.EAR, deploymentUnit)) {
if (deploymentUnit.getParent() == null) {
deploymentUnit.putAttachment(AppClientAttachments.START_APP_CLIENT, true);
}
return;
}
final List<DeploymentUnit> appClients = new ArrayList<DeploymentUnit>();
for (DeploymentUnit subDeployment :
deploymentUnit.getAttachmentList(
org.jboss.as.server.deployment.Attachments.SUB_DEPLOYMENTS)) {
if (DeploymentTypeMarker.isType(DeploymentType.APPLICATION_CLIENT, subDeployment)) {
if (deploymentName != null && deploymentName.equals(subDeployment.getName())) {
subDeployment.putAttachment(AppClientAttachments.START_APP_CLIENT, true);
return;
}
appClients.add(subDeployment);
}
}
if (deploymentName != null && !deploymentName.isEmpty()) {
throw AppClientLogger.ROOT_LOGGER.cannotFindAppClient(deploymentName);
}
if (appClients.size() == 1) {
appClients.get(0).putAttachment(AppClientAttachments.START_APP_CLIENT, true);
} else if (appClients.isEmpty()) {
throw AppClientLogger.ROOT_LOGGER.cannotFindAppClient();
} else {
throw AppClientLogger.ROOT_LOGGER.multipleAppClientsFound();
}
}
public static PersistenceUnitMetadata resolvePersistenceUnitSupplier(
DeploymentUnit deploymentUnit, String persistenceUnitName) {
if (traceEnabled) {
ROOT_LOGGER.tracef(
"pu search for name '%s' inside of %s", persistenceUnitName, deploymentUnit.getName());
}
int scopeSeparatorCharacter =
(persistenceUnitName == null ? -1 : persistenceUnitName.indexOf('#'));
if (scopeSeparatorCharacter != -1) {
final String path = persistenceUnitName.substring(0, scopeSeparatorCharacter);
final String name = persistenceUnitName.substring(scopeSeparatorCharacter + 1);
PersistenceUnitMetadata pu = getPersistenceUnit(deploymentUnit, path, name);
if (traceEnabled) {
ROOT_LOGGER.tracef("pu search found %s", pu.getScopedPersistenceUnitName());
}
return pu;
} else {
PersistenceUnitMetadata name =
findPersistenceUnitSupplier(deploymentUnit, persistenceUnitName);
if (traceEnabled) {
if (name != null) {
ROOT_LOGGER.tracef("pu search found %s", name.getScopedPersistenceUnitName());
}
}
return name;
}
}
@Override
public void deploy(final DeploymentPhaseContext phaseContext)
throws DeploymentUnitProcessingException {
final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
if (deploymentUnit.hasAttachment(Attachments.MODULE)) {
BatchLogger.LOGGER.tracef("Processing deployment '%s' for batch.", deploymentUnit.getName());
// Get the class loader
final Module module = deploymentUnit.getAttachment(Attachments.MODULE);
final ClassLoader moduleClassLoader = module.getClassLoader();
final ServiceTarget serviceTarget = phaseContext.getServiceTarget();
final BatchEnvironmentService service = new BatchEnvironmentService();
final ServiceBuilder<BatchEnvironment> serviceBuilder =
serviceTarget.addService(
BatchServiceNames.batchDeploymentServiceName(deploymentUnit), service);
serviceBuilder.addDependency(
BatchServiceNames.BATCH_PROPERTIES, Properties.class, service.getPropertiesInjector());
serviceBuilder.addDependency(
BatchServiceNames.BATCH_THREAD_POOL_NAME,
ExecutorService.class,
service.getExecutorServiceInjector());
// Set the class loader
service.getClassLoaderInjector().setValue(new ImmediateValue<>(moduleClassLoader));
// Only add transactions and the BeanManager if this is a batch deployment
if (isBatchDeployment(deploymentUnit)) {
serviceBuilder.addDependency(
TxnServices.JBOSS_TXN_USER_TRANSACTION,
UserTransaction.class,
service.getUserTransactionInjector());
// Add the bean manager
serviceBuilder.addDependency(
BatchServiceNames.beanManagerServiceName(deploymentUnit),
new CastingInjector<>(service.getBeanManagerInjector(), BeanManager.class));
} else {
BatchLogger.LOGGER.tracef(
"Skipping UserTransaction and BeanManager service dependencies for deployment %s",
deploymentUnit.getName());
}
serviceBuilder.install();
}
}
@Override
public void deploy(DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException {
DeploymentUnit unit = phaseContext.getDeploymentUnit();
if (!unit.getName().endsWith(this.archiveSuffix)) {
return;
}
ArchivedDeploymentMarker.applyMark(unit);
// Tell AS to treat it as an archive and mount them exploded
MountExplodedMarker.setMountExploded(unit);
}
@Override
protected void doDeploy(DeploymentPhaseContext phaseContext)
throws DeploymentUnitProcessingException {
final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
final WarMetaData warMetaData = deploymentUnit.getAttachment(WarMetaData.ATTACHMENT_KEY);
final ResourceRoot deploymentRoot =
deploymentUnit.getAttachment(org.jboss.as.server.deployment.Attachments.DEPLOYMENT_ROOT);
final DeploymentUnit parent = deploymentUnit.getParent();
final EarMetaData earMetaData = parent.getAttachment(Attachments.EAR_METADATA);
final ModulesMetaData modulesMetaData = earMetaData.getModules();
if (modulesMetaData != null)
for (ModuleMetaData moduleMetaData : modulesMetaData) {
if (Web.equals(moduleMetaData.getType())
&& moduleMetaData.getFileName().equals(deploymentRoot.getRootName())) {
String contextRoot =
WebModuleMetaData.class.cast(moduleMetaData.getValue()).getContextRoot();
if (contextRoot == null
&& (warMetaData.getJbossWebMetaData() == null
|| warMetaData.getJbossWebMetaData().getContextRoot() == null)) {
contextRoot =
"/"
+ parent.getName().substring(0, parent.getName().length() - 4)
+ "/"
+ deploymentUnit.getName().substring(0, deploymentUnit.getName().length() - 4);
}
if (contextRoot != null) {
JBossWebMetaData jBossWebMetaData = warMetaData.getJbossWebMetaData();
if (jBossWebMetaData == null) {
// jBossWebMetaData = new JBoss70WebMetaData();
jBossWebMetaData = new JBoss70ConvergedSipMetaData(); // josemrecio
warMetaData.setJbossWebMetaData(jBossWebMetaData);
}
jBossWebMetaData.setContextRoot(contextRoot);
}
return;
}
}
}
/** {@inheritDoc} */
@Override
public void deploy(final DeploymentPhaseContext phaseContext)
throws DeploymentUnitProcessingException {
final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
final Module module = deploymentUnit.getAttachment(Attachments.MODULE);
final ServicesAttachment servicesAttachment =
deploymentUnit.getAttachment(Attachments.SERVICES);
if (module != null && servicesAttachment != null) {
final ModuleClassLoader classLoader = module.getClassLoader();
final List<String> driverNames =
servicesAttachment.getServiceImplementations(Driver.class.getName());
for (String driverClassName : driverNames) {
try {
final Class<? extends Driver> driverClass =
classLoader.loadClass(driverClassName).asSubclass(Driver.class);
final Constructor<? extends Driver> constructor = driverClass.getConstructor();
final Driver driver = constructor.newInstance();
final int majorVersion = driver.getMajorVersion();
final int minorVersion = driver.getMinorVersion();
final boolean compliant = driver.jdbcCompliant();
if (compliant) {
log.infof(
"Deploying JDBC-compliant driver %s (version %d.%d)",
driverClass, Integer.valueOf(majorVersion), Integer.valueOf(minorVersion));
} else {
log.infof(
"Deploying non-JDBC-compliant driver %s (version %d.%d)",
driverClass, Integer.valueOf(majorVersion), Integer.valueOf(minorVersion));
}
String driverName = deploymentUnit.getName();
InstalledDriver driverMetadata =
new InstalledDriver(
driverName, driverClass.getName(), null, majorVersion, minorVersion, compliant);
DriverService driverService = new DriverService(driverMetadata, driver);
phaseContext
.getServiceTarget()
.addService(
ServiceName.JBOSS.append("jdbc-driver", driverName.replaceAll(".", "_")),
driverService)
.addDependency(
ConnectorServices.JDBC_DRIVER_REGISTRY_SERVICE,
DriverRegistry.class,
driverService.getDriverRegistryServiceInjector())
.setInitialMode(Mode.ACTIVE)
.install();
} catch (Exception e) {
log.warnf("Unable to instantiate driver class \"%s\": %s", driverClassName, e);
}
}
}
}
@Override
public void deploy(DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException {
DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
if (deploymentUnit.hasAttachment(ClojureMetaData.ATTACHMENT_KEY)) {
return;
}
Timer t = new Timer("parsing deployment descriptor");
String deploymentName = deploymentUnit.getName();
try {
VirtualFile descriptor = getDescriptorFile(deploymentUnit);
if (descriptor == null) {
return;
}
ClojureMetaData appMetaData =
new ClojureMetaData(deploymentName, ClojureMetaData.parse(descriptor.getPhysicalFile()));
appMetaData.attachTo(deploymentUnit);
File root = appMetaData.getRoot();
if (root == null) {
throw new DeploymentUnitProcessingException("No application root specified.");
}
if (!root.exists()) {
throw new DeploymentUnitProcessingException(
"Application root does not exist: " + root.getAbsolutePath());
}
VirtualFile virtualRoot = VFS.getChild(root.toURI());
MountHandle mountHandle = null;
if (!root.isDirectory()) {
// Expand the referenced root if it's not a directory (ie .ima archive)
mountHandle =
new MountHandle(
VFS.mountZipExpanded(virtualRoot, virtualRoot, TempFileProviderService.provider()));
}
deploymentUnit.putAttachment(
Attachments.DEPLOYMENT_ROOT, new ResourceRoot(virtualRoot, mountHandle));
deploymentUnit.putAttachment(ClojureMetaData.DESCRIPTOR_FILE, descriptor.getPhysicalFile());
} catch (Exception e) {
throw new DeploymentUnitProcessingException(e);
}
t.done();
}
private void mount(File file, DeploymentUnit unit, JarMountMap mountMap) throws IOException {
VirtualFile mountPath =
VFS.getChild(File.createTempFile(file.getName(), ".jar", tmpMountDir(unit)).toURI());
log.debug(unit.getName() + ": mounting " + file);
final ResourceRoot childResource =
new ResourceRoot(
mountPath,
new MountHandle(VFS.mountZip(file, mountPath, TempFileProviderService.provider())));
ModuleRootMarker.mark(childResource);
unit.addToAttachmentList(Attachments.RESOURCE_ROOTS, childResource);
mountMap.put(mountPath.toURL().toExternalForm(), file.toURI().toURL().toExternalForm());
}
public void deploy(final DeploymentPhaseContext phaseContext)
throws DeploymentUnitProcessingException {
DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
String deploymentName = deploymentUnit.getName().toLowerCase(Locale.ENGLISH);
if (deploymentName.endsWith(".war") || deploymentName.endsWith(".wab")) {
DeploymentTypeMarker.setType(DeploymentType.WAR, deploymentUnit);
return;
}
if (WebApplicationBundleUtils.isWebApplicationBundle(deploymentUnit)) {
DeploymentTypeMarker.setType(DeploymentType.WAR, deploymentUnit);
return;
}
}
@Override
public void deploy(final DeploymentPhaseContext phaseContext)
throws DeploymentUnitProcessingException {
final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
// install the control point for the top level deployment no matter what
if (RequestControllerActivationMarker.isRequestControllerEnabled(deploymentUnit)) {
if (deploymentUnit.getParent() == null) {
ControlPointService.install(
phaseContext.getServiceTarget(),
deploymentUnit.getName(),
UndertowExtension.SUBSYSTEM_NAME);
}
}
final WarMetaData warMetaData = deploymentUnit.getAttachment(WarMetaData.ATTACHMENT_KEY);
if (warMetaData == null) {
return;
}
String hostName = hostNameOfDeployment(warMetaData, defaultHost);
processDeployment(warMetaData, deploymentUnit, phaseContext.getServiceTarget(), hostName);
}
/**
* Creates new Web Service deployment.
*
* @param unit deployment unit
* @return archive deployment
*/
private ArchiveDeployment newDeployment(final DeploymentUnit unit) {
ROOT_LOGGER.creatingUnifiedWebservicesDeploymentModel(unit);
final ResourceRoot deploymentRoot = unit.getAttachment(Attachments.DEPLOYMENT_ROOT);
final VirtualFile root = deploymentRoot != null ? deploymentRoot.getRoot() : null;
final ClassLoader classLoader;
final Module module = unit.getAttachment(Attachments.MODULE);
if (module == null) {
classLoader = unit.getAttachment(CLASSLOADER_KEY);
if (classLoader == null) {
throw MESSAGES.classLoaderResolutionFailed(unit);
}
} else {
classLoader = module.getClassLoader();
}
final ArchiveDeployment dep = this.newDeployment(unit.getName(), classLoader);
if (unit.getParent() != null) {
final String parentDeploymentName = unit.getParent().getName();
final Module parentModule = unit.getParent().getAttachment(Attachments.MODULE);
if (parentModule == null) {
throw MESSAGES.classLoaderResolutionFailed(deploymentRoot);
}
final ClassLoader parentClassLoader = parentModule.getClassLoader();
ROOT_LOGGER.creatingUnifiedWebservicesDeploymentModel(unit.getParent());
final ArchiveDeployment parentDep =
this.newDeployment(parentDeploymentName, parentClassLoader);
dep.setParent(parentDep);
}
if (root != null) {
dep.setRootFile(new VirtualFileAdaptor(root));
} else {
dep.setRootFile(new ResourceLoaderAdapter(classLoader));
}
dep.setRuntimeClassLoader(classLoader);
dep.setType(deploymentType);
return dep;
}
private ModuleIdentifier createAdditionalModule(
final ResourceRoot resourceRoot,
final DeploymentUnit topLevelDeployment,
final VirtualFile topLevelRoot,
final Map<VirtualFile, AdditionalModuleSpecification> additionalModules,
final VirtualFile classPathFile,
final ArrayDeque<RootEntry> resourceRoots)
throws DeploymentUnitProcessingException {
final ResourceRoot root = createResourceRoot(classPathFile);
final String pathName = root.getRoot().getPathNameRelativeTo(topLevelRoot);
ModuleIdentifier identifier =
ModuleIdentifier.create(
ServiceModuleLoader.MODULE_PREFIX + topLevelDeployment.getName() + "." + pathName);
AdditionalModuleSpecification module = new AdditionalModuleSpecification(identifier, root);
topLevelDeployment.addToAttachmentList(Attachments.ADDITIONAL_MODULES, module);
additionalModules.put(classPathFile, module);
resourceRoot.addToAttachmentList(Attachments.CLASS_PATH_RESOURCE_ROOTS, root);
// add this to the list of roots to be processed, so transitive class path entries will be
// respected
resourceRoots.add(new RootEntry(module, root));
return identifier;
}
@Override
public void deploy(DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException {
DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
String deploymentName = deploymentUnit.getName();
KeycloakAdapterConfigService service =
KeycloakAdapterConfigService.find(phaseContext.getServiceRegistry());
// log.info("********* CHECK KEYCLOAK DEPLOYMENT: " + deploymentName);
if (service.isSecureDeployment(deploymentName)) {
addKeycloakAuthData(phaseContext, deploymentName, service);
return;
}
// else check to see if KEYCLOAK is specified as login config
WarMetaData warMetaData = deploymentUnit.getAttachment(WarMetaData.ATTACHMENT_KEY);
if (warMetaData == null) return;
JBossWebMetaData webMetaData = warMetaData.getMergedJBossWebMetaData();
if (webMetaData == null) return;
LoginConfigMetaData loginConfig = webMetaData.getLoginConfig();
if (loginConfig != null && "KEYCLOAK".equalsIgnoreCase(loginConfig.getAuthMethod())) {
addValve(webMetaData);
}
}
private DeploymentInfo createServletConfig(
final JBossWebMetaData mergedMetaData,
final DeploymentUnit deploymentUnit,
final Module module,
final DeploymentClassIndex classReflectionIndex,
final WebInjectionContainer injectionContainer,
final ComponentRegistry componentRegistry,
final ScisMetaData scisMetaData,
final VirtualFile deploymentRoot)
throws DeploymentUnitProcessingException {
try {
mergedMetaData.resolveAnnotations();
final DeploymentInfo d = new DeploymentInfo();
d.setContextPath(mergedMetaData.getContextRoot());
if (mergedMetaData.getDescriptionGroup() != null) {
d.setDisplayName(mergedMetaData.getDescriptionGroup().getDisplayName());
}
d.setDeploymentName(deploymentUnit.getName());
d.setResourceLoader(new DeploymentResourceLoader(deploymentRoot));
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);
}
// for 2.2 apps we do not require a leading / in path mappings
boolean is22OrOlder;
if (d.getMajorVersion() == 1) {
is22OrOlder = true;
} else if (d.getMajorVersion() == 2) {
is22OrOlder = d.getMinorVersion() < 3;
} else {
is22OrOlder = false;
}
HashMap<String, TagLibraryInfo> tldInfo =
createTldsInfo(deploymentUnit, classReflectionIndex, componentRegistry, d);
HashMap<String, JspPropertyGroup> propertyGroups = createJspConfig(mergedMetaData);
JspServletBuilder.setupDeployment(
d, propertyGroups, tldInfo, new UndertowJSPInstanceManager(injectionContainer));
d.setJspConfigDescriptor(
new JspConfigDescriptorImpl(tldInfo.values(), propertyGroups.values()));
d.setDefaultServletConfig(new DefaultServletConfig(true, Collections.<String>emptySet()));
// default JSP servlet
final ServletInfo jspServlet =
new ServletInfo("Default JSP Servlet", JspServlet.class)
.addMapping("*.jsp")
.addMapping("*.jspx")
.addInitParam("development", "false"); // todo: make configurable
d.addServlet(jspServlet);
final Set<String> jspPropertyGroupMappings = propertyGroups.keySet();
for (final String mapping : jspPropertyGroupMappings) {
jspServlet.addMapping(mapping);
}
d.setClassIntrospecter(new ComponentClassIntrospector(componentRegistry));
final Map<String, List<ServletMappingMetaData>> servletMappings = new HashMap<>();
if (mergedMetaData.getServletMappings() != null) {
for (final ServletMappingMetaData mapping : mergedMetaData.getServletMappings()) {
List<ServletMappingMetaData> list = servletMappings.get(mapping.getServletName());
if (list == null) {
servletMappings.put(mapping.getServletName(), list = new ArrayList<>());
}
list.add(mapping);
}
}
final Set<String> seenMappings = new HashSet<>(jspPropertyGroupMappings);
if (mergedMetaData.getServlets() != null) {
for (final JBossServletMetaData servlet : mergedMetaData.getServlets()) {
final ServletInfo s;
if (servlet.getJspFile() != null) {
// TODO: real JSP support
s = new ServletInfo(servlet.getName(), JspServlet.class);
s.addHandlerChainWrapper(new JspFileWrapper(servlet.getJspFile()));
} else {
Class<? extends Servlet> servletClass =
(Class<? extends Servlet>)
classReflectionIndex.classIndex(servlet.getServletClass()).getModuleClass();
ComponentRegistry.ComponentManagedReferenceFactory creator =
componentRegistry.getComponentsByClass().get(servletClass);
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) {
s.setRunAs(servlet.getRunAs().getRoleName());
}
if (servlet
.getLoadOnStartupSet()) { // todo why not cleanup api and just use int everywhere
s.setLoadOnStartup(servlet.getLoadOnStartupInt());
}
List<ServletMappingMetaData> mappings = servletMappings.get(servlet.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);
}
}
}
}
if (servlet.getInitParam() != null) {
for (ParamValueMetaData initParam : servlet.getInitParam()) {
if (!s.getInitParams().containsKey(initParam.getParamName())) {
s.addInitParam(initParam.getParamName(), initParam.getParamValue());
}
}
}
if (servlet.getServletSecurity() != null) {
ServletSecurityInfo securityInfo = new ServletSecurityInfo();
s.setServletSecurityInfo(securityInfo);
securityInfo
.setEmptyRoleSemantic(
servlet.getServletSecurity().getEmptyRoleSemantic()
== EmptyRoleSemanticType.PERMIT
? PERMIT
: DENY)
.setTransportGuaranteeType(
transportGuaranteeType(servlet.getServletSecurity().getTransportGuarantee()))
.addRolesAllowed(servlet.getServletSecurity().getRolesAllowed());
if (servlet.getServletSecurity().getHttpMethodConstraints() != null) {
for (HttpMethodConstraintMetaData method :
servlet.getServletSecurity().getHttpMethodConstraints()) {
securityInfo.addHttpMethodSecurityInfo(
new HttpMethodSecurityInfo()
.setEmptyRoleSemantic(
method.getEmptyRoleSemantic() == EmptyRoleSemanticType.PERMIT
? PERMIT
: DENY)
.setTransportGuaranteeType(
transportGuaranteeType(method.getTransportGuarantee()))
.addRolesAllowed(method.getRolesAllowed())
.setMethod(method.getMethod()));
}
}
}
if (servlet.getSecurityRoleRefs() != null) {
for (final SecurityRoleRefMetaData ref : servlet.getSecurityRoleRefs()) {
s.addSecurityRoleRef(ref.getRoleName(), ref.getRoleLink());
}
}
d.addServlet(s);
}
}
if (mergedMetaData.getFilters() != null) {
for (final FilterMetaData filter : mergedMetaData.getFilters()) {
Class<? extends Filter> filterClass =
(Class<? extends Filter>)
classReflectionIndex.classIndex(filter.getFilterClass()).getModuleClass();
ComponentRegistry.ComponentManagedReferenceFactory creator =
componentRegistry.getComponentsByClass().get(filterClass);
FilterInfo f;
if (creator != null) {
InstanceFactory<Filter> instanceFactory = createInstanceFactory(creator);
f = new FilterInfo(filter.getName(), filterClass, instanceFactory);
} else {
f = new FilterInfo(filter.getName(), filterClass);
}
f.setAsyncSupported(filter.isAsyncSupported());
d.addFilter(f);
if (filter.getInitParam() != null) {
for (ParamValueMetaData initParam : filter.getInitParam()) {
f.addInitParam(initParam.getParamName(), initParam.getParamValue());
}
}
}
}
if (mergedMetaData.getFilterMappings() != null) {
for (final FilterMappingMetaData mapping : mergedMetaData.getFilterMappings()) {
if (mapping.getUrlPatterns() != null) {
for (String url : mapping.getUrlPatterns()) {
if (is22OrOlder && !url.startsWith("*") && !url.startsWith("/")) {
url = "/" + url;
}
if (mapping.getDispatchers() != null && !mapping.getDispatchers().isEmpty()) {
for (DispatcherType dispatcher : mapping.getDispatchers()) {
d.addFilterUrlMapping(
mapping.getFilterName(),
url,
javax.servlet.DispatcherType.valueOf(dispatcher.name()));
}
} else {
d.addFilterUrlMapping(
mapping.getFilterName(), url, javax.servlet.DispatcherType.REQUEST);
}
}
}
if (mapping.getServletNames() != null) {
for (String servletName : mapping.getServletNames()) {
if (mapping.getDispatchers() != null && !mapping.getDispatchers().isEmpty()) {
for (DispatcherType dispatcher : mapping.getDispatchers()) {
d.addFilterServletNameMapping(
mapping.getFilterName(),
servletName,
javax.servlet.DispatcherType.valueOf(dispatcher.name()));
}
} else {
d.addFilterServletNameMapping(
mapping.getFilterName(), servletName, javax.servlet.DispatcherType.REQUEST);
}
}
}
}
}
if (scisMetaData != null && scisMetaData.getHandlesTypes() != null) {
for (final Map.Entry<ServletContainerInitializer, Set<Class<?>>> sci :
scisMetaData.getHandlesTypes().entrySet()) {
final ImmediateInstanceFactory<ServletContainerInitializer> instanceFactory =
new ImmediateInstanceFactory<>(sci.getKey());
d.addServletContainerInitalizer(
new ServletContainerInitializerInfo(
sci.getKey().getClass(), instanceFactory, sci.getValue()));
}
}
if (mergedMetaData.getListeners() != null) {
for (ListenerMetaData listener : mergedMetaData.getListeners()) {
addListener(classReflectionIndex, componentRegistry, d, listener);
}
}
if (mergedMetaData.getContextParams() != null) {
for (ParamValueMetaData param : mergedMetaData.getContextParams()) {
d.addInitParameter(param.getParamName(), param.getParamValue());
}
}
if (mergedMetaData.getWelcomeFileList() != null
&& mergedMetaData.getWelcomeFileList().getWelcomeFiles() != null) {
d.addWelcomePages(mergedMetaData.getWelcomeFileList().getWelcomeFiles());
} else {
d.addWelcomePages("index.html", "index.htm", "index.jsp");
}
if (mergedMetaData.getErrorPages() != null) {
for (final ErrorPageMetaData page : mergedMetaData.getErrorPages()) {
final ErrorPage errorPage;
if (page.getExceptionType() == null || page.getExceptionType().isEmpty()) {
errorPage = new ErrorPage(page.getLocation(), Integer.parseInt(page.getErrorCode()));
} else {
errorPage =
new ErrorPage(
page.getLocation(),
(Class<? extends Throwable>)
classReflectionIndex.classIndex(page.getExceptionType()).getModuleClass());
}
d.addErrorPages(errorPage);
}
}
if (mergedMetaData.getMimeMappings() != null) {
for (final MimeMappingMetaData mapping : mergedMetaData.getMimeMappings()) {
d.addMimeMapping(new MimeMapping(mapping.getExtension(), mapping.getMimeType()));
}
}
if (mergedMetaData.getSecurityConstraints() != null) {
for (SecurityConstraintMetaData constraint : mergedMetaData.getSecurityConstraints()) {
SecurityConstraint securityConstraint =
new SecurityConstraint()
.setTransportGuaranteeType(
transportGuaranteeType(constraint.getTransportGuarantee()))
.addRolesAllowed(constraint.getRoleNames());
if (constraint.getAuthConstraint() == null) {
// no auth constraint means we permit the empty roles
securityConstraint.setEmptyRoleSemantic(PERMIT);
}
if (constraint.getResourceCollections() != null) {
for (final WebResourceCollectionMetaData resourceCollection :
constraint.getResourceCollections()) {
securityConstraint.addWebResourceCollection(
new WebResourceCollection()
.addHttpMethods(resourceCollection.getHttpMethods())
.addHttpMethodOmissions(resourceCollection.getHttpMethodOmissions())
.addUrlPatterns(resourceCollection.getUrlPatterns()));
}
}
d.addSecurityConstraint(securityConstraint);
}
}
final LoginConfigMetaData loginConfig = mergedMetaData.getLoginConfig();
if (loginConfig != null) {
String authMethod = authMethod(loginConfig.getAuthMethod());
if (loginConfig.getFormLoginConfig() != null) {
d.setLoginConfig(
new LoginConfig(
authMethod,
loginConfig.getRealmName(),
loginConfig.getFormLoginConfig().getLoginPage(),
loginConfig.getFormLoginConfig().getErrorPage()));
} else {
d.setLoginConfig(new LoginConfig(authMethod, loginConfig.getRealmName()));
}
}
d.addSecurityRoles(mergedMetaData.getSecurityRoleNames());
if (mergedMetaData.getSecurityDomain() != null) {
String contextId = deploymentUnit.getName();
if (deploymentUnit.getParent() != null) {
contextId = deploymentUnit.getParent().getName() + "!" + contextId;
}
d.addOuterHandlerChainWrapper(
SecurityContextCreationHandler.wrapper(mergedMetaData.getSecurityDomain()));
d.addDispatchedHandlerChainWrapper(
SecurityContextAssociationHandler.wrapper(
mergedMetaData.getPrincipalVersusRolesMap(), contextId));
}
// Setup an deployer configured ServletContext attributes
final List<ServletContextAttribute> attributes =
deploymentUnit.getAttachmentList(ServletContextAttribute.ATTACHMENT_KEY);
for (ServletContextAttribute attribute : attributes) {
d.addServletContextAttribute(attribute.getName(), attribute.getValue());
}
if (mergedMetaData.getLocalEncodings() != null
&& mergedMetaData.getLocalEncodings().getMappings() != null) {
for (LocaleEncodingMetaData locale : mergedMetaData.getLocalEncodings().getMappings()) {
d.addLocaleCharsetMapping(locale.getLocale(), locale.getEncoding());
}
}
return d;
} catch (ClassNotFoundException e) {
throw new DeploymentUnitProcessingException(e);
}
}
@Override
public void deploy(DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException {
final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
final DeploymentUnit topLevelDeployment =
deploymentUnit.getParent() == null ? deploymentUnit : deploymentUnit.getParent();
final ServiceTarget serviceTarget = phaseContext.getServiceTarget();
if (!WeldDeploymentMarker.isPartOfWeldDeployment(topLevelDeployment)) {
return;
}
final Collection<ServiceName> dependencies =
deploymentUnit.getAttachment(Attachments.JNDI_DEPENDENCIES);
BeanDeploymentArchiveImpl rootBda =
deploymentUnit.getAttachment(WeldAttachments.DEPLOYMENT_ROOT_BEAN_DEPLOYMENT_ARCHIVE);
if (rootBda == null) {
// this archive is not actually a bean archive.
// then use the top level root bda
rootBda =
topLevelDeployment.getAttachment(WeldAttachments.DEPLOYMENT_ROOT_BEAN_DEPLOYMENT_ARCHIVE);
}
if (rootBda == null) {
WeldLogger.ROOT_LOGGER.couldNotFindBeanManagerForDeployment(deploymentUnit.getName());
return;
}
final ServiceName weldServiceName =
topLevelDeployment.getServiceName().append(WeldBootstrapService.SERVICE_NAME);
// add the BeanManager service
final ServiceName beanManagerServiceName = BeanManagerService.serviceName(deploymentUnit);
BeanManagerService beanManagerService = new BeanManagerService(rootBda.getId());
serviceTarget
.addService(beanManagerServiceName, beanManagerService)
.addDependency(
weldServiceName, WeldBootstrapService.class, beanManagerService.getWeldContainer())
.install();
;
final EEModuleDescription moduleDescription =
deploymentUnit.getAttachment(org.jboss.as.ee.component.Attachments.EE_MODULE_DESCRIPTION);
if (moduleDescription == null) {
return;
}
// hack to set up a java:comp binding for jar deployments as well as wars
if (DeploymentTypeMarker.isType(DeploymentType.WAR, deploymentUnit)
|| deploymentUnit.getName().endsWith(".jar")) {
// bind the bean manager to JNDI
final ServiceName moduleContextServiceName =
ContextNames.contextServiceNameOfModule(
moduleDescription.getApplicationName(), moduleDescription.getModuleName());
bindBeanManager(
serviceTarget,
beanManagerServiceName,
moduleContextServiceName,
dependencies,
phaseContext.getServiceRegistry());
}
// bind the bm into java:comp for all components that require it
for (ComponentDescription component : moduleDescription.getComponentDescriptions()) {
if (component.getNamingMode() == ComponentNamingMode.CREATE) {
final ServiceName compContextServiceName =
ContextNames.contextServiceNameOfComponent(
moduleDescription.getApplicationName(),
moduleDescription.getModuleName(),
component.getComponentName());
bindBeanManager(
serviceTarget,
beanManagerServiceName,
compContextServiceName,
dependencies,
phaseContext.getServiceRegistry());
}
}
deploymentUnit.addToAttachmentList(Attachments.SETUP_ACTIONS, new WeldContextSetup());
}
@Override
public String toString() {
String uname = depUnit.getName();
String sname = serviceName.getCanonicalName();
return "ArquillianConfig[service=" + sname + ",unit=" + uname + ",tests=" + testClasses + "]";
}
static ServiceName getServiceName(DeploymentUnit depUnit) {
return ServiceName.JBOSS.append("arquillian", "config", depUnit.getName());
}
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 void deploy(DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException {
final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
final DeploymentUnit topLevelDeployment =
deploymentUnit.getParent() == null ? deploymentUnit : deploymentUnit.getParent();
final WeldDeploymentMetadata cdiDeploymentMetadata =
deploymentUnit.getAttachment(WeldDeploymentMetadata.ATTACHMENT_KEY);
if (!WeldDeploymentMarker.isWeldDeployment(deploymentUnit)) {
return;
}
// create a CDI injection factory
EEModuleDescription eeModuleDescription =
deploymentUnit.getAttachment(org.jboss.as.ee.component.Attachments.EE_MODULE_DESCRIPTION);
final Module topLevelModule = topLevelDeployment.getAttachment(Attachments.MODULE);
if (eeModuleDescription != null) {
eeModuleDescription.addInjectionFactory(
new WeldInjectionFactory(
phaseContext.getServiceTarget(), deploymentUnit, topLevelModule.getClassLoader()));
}
final String beanArchiveIdPrefix;
if (deploymentUnit.getParent() == null) {
beanArchiveIdPrefix = deploymentUnit.getName();
} else {
beanArchiveIdPrefix = deploymentUnit.getParent().getName() + "." + deploymentUnit.getName();
}
final Set<BeanDeploymentArchiveImpl> beanDeploymentArchives =
new HashSet<BeanDeploymentArchiveImpl>();
log.info("Processing CDI deployment: " + phaseContext.getDeploymentUnit().getName());
final Map<ResourceRoot, Index> indexes =
AnnotationIndexUtils.getAnnotationIndexes(deploymentUnit);
final Module module = phaseContext.getDeploymentUnit().getAttachment(Attachments.MODULE);
boolean rootArchiveFound = false;
if (cdiDeploymentMetadata != null) {
// this can be null for ear deployments
// however we still want to create a module level bean manager
for (BeanArchiveMetadata beanArchiveMetadata :
cdiDeploymentMetadata.getBeanArchiveMetadata()) {
BeanDeploymentArchiveImpl bda =
createBeanDeploymentArchive(
indexes.get(beanArchiveMetadata.getResourceRoot()),
beanArchiveMetadata,
module,
beanArchiveIdPrefix);
beanDeploymentArchives.add(bda);
if (beanArchiveMetadata.isDeploymentRoot()) {
rootArchiveFound = true;
deploymentUnit.putAttachment(
WeldAttachments.DEPLOYMENT_ROOT_BEAN_DEPLOYMENT_ARCHIVE, bda);
}
}
}
if (!rootArchiveFound) {
BeanDeploymentArchiveImpl bda =
new BeanDeploymentArchiveImpl(
Collections.<String>emptySet(),
BeansXml.EMPTY_BEANS_XML,
module,
beanArchiveIdPrefix);
beanDeploymentArchives.add(bda);
deploymentUnit.putAttachment(WeldAttachments.DEPLOYMENT_ROOT_BEAN_DEPLOYMENT_ARCHIVE, bda);
}
deploymentUnit.putAttachment(
WeldAttachments.BEAN_DEPLOYMENT_MODULE, new BeanDeploymentModule(beanDeploymentArchives));
}
protected void processDeployment(
final String hostName,
final WarMetaData warMetaData,
final DeploymentUnit deploymentUnit,
final ServiceTarget serviceTarget)
throws DeploymentUnitProcessingException {
final VirtualFile deploymentRoot =
deploymentUnit.getAttachment(Attachments.DEPLOYMENT_ROOT).getRoot();
final Module module = deploymentUnit.getAttachment(Attachments.MODULE);
if (module == null) {
throw new DeploymentUnitProcessingException(MESSAGES.failedToResolveModule(deploymentRoot));
}
final ClassLoader classLoader = module.getClassLoader();
final JBossWebMetaData metaData = warMetaData.getMergedJBossWebMetaData();
final List<SetupAction> setupActions =
deploymentUnit.getAttachmentList(org.jboss.as.ee.component.Attachments.WEB_SETUP_ACTIONS);
// Create the context
final StandardContext webContext = new StandardContext();
final JBossContextConfig config = new JBossContextConfig(deploymentUnit);
// Add SecurityAssociationValve right at the beginning
webContext.addValve(new SecurityContextAssociationValve(deploymentUnit));
// Set the deployment root
try {
webContext.setDocBase(deploymentRoot.getPhysicalFile().getAbsolutePath());
} catch (IOException e) {
throw new DeploymentUnitProcessingException(e);
}
webContext.addLifecycleListener(config);
final String pathName = pathNameOfDeployment(deploymentUnit, metaData);
webContext.setPath(pathName);
webContext.setIgnoreAnnotations(true);
webContext.setCrossContext(!metaData.isDisableCrossContext());
final WebInjectionContainer injectionContainer =
new WebInjectionContainer(module.getClassLoader());
// 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 Map<String, ComponentInstantiator> components =
deploymentUnit.getAttachment(WebAttachments.WEB_COMPONENT_INSTANTIATORS);
if (components != null) {
final Set<ServiceName> failed =
deploymentUnit.getAttachment(org.jboss.as.ee.component.Attachments.FAILED_COMPONENTS);
for (Map.Entry<String, ComponentInstantiator> entry : components.entrySet()) {
boolean skip = false;
for (final ServiceName serviceName : entry.getValue().getServiceNames()) {
if (failed.contains(serviceName)) {
skip = true;
break;
}
}
if (!skip) {
injectionContainer.addInstantiator(entry.getKey(), entry.getValue());
}
}
}
final Loader loader = new WebCtxLoader(classLoader);
webContext.setLoader(loader);
// Valves
List<ValveMetaData> valves = metaData.getValves();
if (valves == null) {
metaData.setValves(valves = new ArrayList<ValveMetaData>());
}
for (ValveMetaData valve : valves) {
Valve valveInstance =
(Valve) getInstance(module, valve.getModule(), valve.getValveClass(), valve.getParams());
webContext.getPipeline().addValve(valveInstance);
}
// Container listeners
List<ContainerListenerMetaData> listeners = metaData.getContainerListeners();
if (listeners != null) {
for (ContainerListenerMetaData listener : listeners) {
switch (listener.getListenerType()) {
case CONTAINER:
ContainerListener containerListener =
(ContainerListener)
getInstance(
module,
listener.getModule(),
listener.getListenerClass(),
listener.getParams());
webContext.addContainerListener(containerListener);
break;
case LIFECYCLE:
LifecycleListener lifecycleListener =
(LifecycleListener)
getInstance(
module,
listener.getModule(),
listener.getListenerClass(),
listener.getParams());
if (webContext instanceof Lifecycle) {
((Lifecycle) webContext).addLifecycleListener(lifecycleListener);
}
break;
case SERVLET_INSTANCE:
webContext.addInstanceListener(listener.getListenerClass());
break;
case SERVLET_CONTAINER:
webContext.addWrapperListener(listener.getListenerClass());
break;
case SERVLET_LIFECYCLE:
webContext.addWrapperLifecycle(listener.getListenerClass());
break;
}
}
}
// Set the session cookies flag according to metadata
switch (metaData.getSessionCookies()) {
case JBossWebMetaData.SESSION_COOKIES_ENABLED:
webContext.setCookies(true);
break;
case JBossWebMetaData.SESSION_COOKIES_DISABLED:
webContext.setCookies(false);
break;
}
String metaDataSecurityDomain = metaData.getSecurityDomain();
if (metaDataSecurityDomain != null) {
metaDataSecurityDomain = metaDataSecurityDomain.trim();
}
String securityDomain =
metaDataSecurityDomain == null
? SecurityConstants.DEFAULT_APPLICATION_POLICY
: SecurityUtil.unprefixSecurityDomain(metaDataSecurityDomain);
// Setup an deployer configured ServletContext attributes
final List<ServletContextAttribute> attributes =
deploymentUnit.getAttachment(ServletContextAttribute.ATTACHMENT_KEY);
try {
final ServiceName deploymentServiceName =
WebSubsystemServices.deploymentServiceName(hostName, pathName);
final ServiceName realmServiceName = deploymentServiceName.append("realm");
final JBossWebRealmService realmService = new JBossWebRealmService(deploymentUnit);
ServiceBuilder<?> builder = serviceTarget.addService(realmServiceName, realmService);
builder
.addDependency(
DependencyType.REQUIRED,
SecurityDomainService.SERVICE_NAME.append(securityDomain),
SecurityDomainContext.class,
realmService.getSecurityDomainContextInjector())
.setInitialMode(Mode.ACTIVE)
.install();
final WebDeploymentService webDeploymentService =
new WebDeploymentService(webContext, injectionContainer, setupActions, attributes);
builder =
serviceTarget
.addService(deploymentServiceName, webDeploymentService)
.addDependency(
WebSubsystemServices.JBOSS_WEB_HOST.append(hostName),
VirtualHost.class,
new WebContextInjector(webContext))
.addDependencies(injectionContainer.getServiceNames())
.addDependency(realmServiceName, Realm.class, webDeploymentService.getRealm())
.addDependencies(deploymentUnit.getAttachmentList(Attachments.WEB_DEPENDENCIES))
.addDependency(JndiNamingDependencyProcessor.serviceName(deploymentUnit));
// add any dependencies required by the setup action
for (final SetupAction action : setupActions) {
builder.addDependencies(action.dependencies());
}
if (metaData.getDistributable() != null) {
DistributedCacheManagerFactoryService factoryService =
new DistributedCacheManagerFactoryService();
DistributedCacheManagerFactory factory = factoryService.getValue();
if (factory != null) {
ServiceName factoryServiceName = deploymentServiceName.append("session");
builder.addDependency(
DependencyType.OPTIONAL,
factoryServiceName,
DistributedCacheManagerFactory.class,
config.getDistributedCacheManagerFactoryInjector());
ServiceBuilder<DistributedCacheManagerFactory> factoryBuilder =
serviceTarget.addService(factoryServiceName, factoryService);
boolean enabled = factory.addDependencies(serviceTarget, factoryBuilder, metaData);
factoryBuilder
.setInitialMode(
enabled ? ServiceController.Mode.ON_DEMAND : ServiceController.Mode.NEVER)
.install();
}
}
builder.install();
// adding JACC service
AbstractSecurityDeployer<?> deployer = new WarSecurityDeployer();
JaccService<?> service = deployer.deploy(deploymentUnit);
if (service != null) {
((WarJaccService) service).setContext(webContext);
final ServiceName jaccServiceName =
JaccService.SERVICE_NAME.append(deploymentUnit.getName());
builder = serviceTarget.addService(jaccServiceName, service);
if (deploymentUnit.getParent() != null) {
// add dependency to parent policy
final DeploymentUnit parentDU = deploymentUnit.getParent();
builder.addDependency(
JaccService.SERVICE_NAME.append(parentDU.getName()),
PolicyConfiguration.class,
service.getParentPolicyInjector());
}
// add dependency to web deployment service
builder.addDependency(deploymentServiceName);
builder.setInitialMode(Mode.ACTIVE).install();
}
} catch (ServiceRegistryException e) {
throw new DeploymentUnitProcessingException(MESSAGES.failedToAddWebDeployment(), e);
}
// Process the web related mgmt information
final ModelNode node = deploymentUnit.getDeploymentSubsystemModel("web");
node.get("context-root").set("".equals(pathName) ? "/" : pathName);
node.get("virtual-host").set(hostName);
processManagement(deploymentUnit, metaData);
}
