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 {
final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
final Map<Class<? extends Annotation>, Set<Class<?>>> instances =
new HashMap<Class<? extends Annotation>, Set<Class<?>>>();
final CompositeIndex compositeIndex =
deploymentUnit.getAttachment(Attachments.COMPOSITE_ANNOTATION_INDEX);
if (compositeIndex == null) {
return; // Can not continue without index
}
final Module module = deploymentUnit.getAttachment(Attachments.MODULE);
if (module == null) {
return; // Can not continue without module
}
final ClassLoader classLoader = module.getClassLoader();
for (FacesAnnotation annotation : FacesAnnotation.values()) {
final List<AnnotationInstance> annotationInstances =
compositeIndex.getAnnotations(annotation.indexName);
if (annotationInstances == null || annotationInstances.isEmpty()) {
continue;
}
final Set<Class<?>> discoveredClasses = new HashSet<Class<?>>();
instances.put(annotation.annotationClass, discoveredClasses);
for (AnnotationInstance annotationInstance : annotationInstances) {
final AnnotationTarget target = annotationInstance.target();
if (target instanceof ClassInfo) {
final DotName className = ClassInfo.class.cast(target).name();
final Class<?> annotatedClass;
try {
annotatedClass = classLoader.loadClass(className.toString());
} catch (ClassNotFoundException e) {
throw new DeploymentUnitProcessingException(
JSFMessages.MESSAGES.classLoadingFailed(className));
}
discoveredClasses.add(annotatedClass);
} else {
throw new DeploymentUnitProcessingException(
JSFMessages.MESSAGES.invalidAnnotationLocation(annotation, target));
}
}
}
deploymentUnit.addToAttachmentList(
ServletContextAttribute.ATTACHMENT_KEY,
new ServletContextAttribute(FACES_ANNOTATIONS_SC_ATTR, instances));
}
private void bindServices(
DeploymentUnit deploymentUnit, ServiceTarget serviceTarget, ServiceName contextServiceName) {
final ServiceName instanceNameServiceName = contextServiceName.append("InstanceName");
final BinderService instanceNameService = new BinderService("InstanceName");
serviceTarget
.addService(instanceNameServiceName, instanceNameService)
.addDependency(
contextServiceName,
ServiceBasedNamingStore.class,
instanceNameService.getNamingStoreInjector())
.addDependency(
ServerEnvironmentService.SERVICE_NAME,
ServerEnvironment.class,
new Injector<ServerEnvironment>() {
@Override
public void inject(final ServerEnvironment serverEnvironment)
throws InjectionException {
instanceNameService
.getManagedObjectInjector()
.inject(
new ManagedReferenceFactory() {
@Override
public ManagedReference getReference() {
return new ManagedReference() {
@Override
public void release() {}
@Override
public Object getInstance() {
final String nodeName = serverEnvironment.getNodeName();
return nodeName == null ? "" : nodeName;
}
};
}
});
}
@Override
public void uninject() {
instanceNameService.getManagedObjectInjector().uninject();
}
})
.install();
deploymentUnit.addToAttachmentList(
org.jboss.as.server.deployment.Attachments.JNDI_DEPENDENCIES, instanceNameServiceName);
}
public void deploy(DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException {
final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
final ResourceRoot resourceRoot = deploymentUnit.getAttachment(Attachments.DEPLOYMENT_ROOT);
if (resourceRoot == null) {
return;
}
final VirtualFile deploymentRoot = resourceRoot.getRoot();
if (deploymentRoot == null || !deploymentRoot.exists()) {
return;
}
final String deploymentRootName = deploymentRoot.getLowerCaseName();
if (!deploymentRootName.endsWith(RAR_EXTENSION)) {
return;
}
// we do not load classes from the module resource root
ModuleRootMarker.mark(resourceRoot, false);
try {
final List<VirtualFile> childArchives = deploymentRoot.getChildren(CHILD_ARCHIVE_FILTER);
for (final VirtualFile child : childArchives) {
final Closeable closable =
child.isFile()
? VFS.mountZip(child, child, TempFileProviderService.provider())
: NO_OP_CLOSEABLE;
final MountHandle mountHandle = new MountHandle(closable);
final ResourceRoot childResource = new ResourceRoot(child, mountHandle);
ModuleRootMarker.mark(childResource);
deploymentUnit.addToAttachmentList(Attachments.RESOURCE_ROOTS, childResource);
resourceRoot.addToAttachmentList(
Attachments.INDEX_IGNORE_PATHS, child.getPathNameRelativeTo(deploymentRoot));
}
} catch (IOException e) {
throw new DeploymentUnitProcessingException(
"Failed to process RA child archives for [" + deploymentRoot + "]", e);
}
}
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;
}
@SuppressWarnings("unchecked")
@Override
public void deploy(DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException {
DeploymentUnit unit = phaseContext.getDeploymentUnit();
ClojureMetaData metaData = unit.getAttachment(ClojureMetaData.ATTACHMENT_KEY);
if (metaData == null && !ArchivedDeploymentMarker.isMarked(unit)) {
return;
}
File root = metaData.getRoot();
JarMountMap mountMap = new JarMountMap();
unit.putAttachment(JarMountMap.ATTACHMENT_KEY, mountMap);
try {
List<File> dependencyJars =
ApplicationBootstrapUtils.getDependencies(
root, metaData.resolveDependencies(), metaData.getLeinProfiles());
boolean clojureProvided = false;
for (File each : dependencyJars) {
if (each.getName().matches("^clojure(-\\d.\\d.\\d)?\\.jar$")) {
clojureProvided = true;
}
mount(each, unit, mountMap);
}
if (!clojureProvided) {
Immutant immutant =
(Immutant)
phaseContext.getServiceRegistry().getService(CoreServices.IMMUTANT).getValue();
log.warn(
"No clojure.jar found within "
+ metaData.getApplicationName()
+ ", Using built-in clojure.jar (v"
+ immutant.getClojureVersion()
+ ")");
// borrow the shipped clojure.jar
String jarPath =
System.getProperty("jboss.home.dir") + "/modules/org/immutant/core/main/clojure.jar";
mount(new File(jarPath), unit, mountMap);
}
// mount the runtime jar
String runtimePath =
System.getProperty("jboss.home.dir")
+ "/modules/org/immutant/core/main/immutant-runtime-impl.jar";
mount(new File(runtimePath), unit, mountMap);
for (String each : ApplicationBootstrapUtils.resourceDirs(root, metaData.getLeinProfiles())) {
final ResourceRoot childResource = new ResourceRoot(VFS.getChild(each), null);
ModuleRootMarker.mark(childResource);
unit.addToAttachmentList(Attachments.RESOURCE_ROOTS, childResource);
}
} catch (Exception e) {
throw new DeploymentUnitProcessingException(e);
}
// disable the annotation index, since we're not an EE app and it spits nasty WARNs to the log
// if
// ring is included as an app dep in relation to some jetty classes
unit.putAttachment(Attachments.COMPUTE_COMPOSITE_ANNOTATION_INDEX, false);
// AS let's us disable the index, but then assumes it's always there, so we give it an empty one
unit.putAttachment(
Attachments.COMPOSITE_ANNOTATION_INDEX, new CompositeIndex(Collections.EMPTY_LIST));
}
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 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());
}
private void process(
final DeploymentUnit deploymentUnit,
final String beanInterface,
final String beanName,
final String lookup,
final ClassInfo classInfo,
final InjectionTarget targetDescription,
final String localContextName,
final EEModuleDescription eeModuleDescription) {
if (!isEmpty(lookup) && !isEmpty(beanName)) {
logger.debug(
"Both beanName = "
+ beanName
+ " and lookup = "
+ lookup
+ " have been specified in @EJB annotation."
+ " lookup will be given preference. Class: "
+ classInfo.name());
}
final EEModuleClassDescription classDescription =
eeModuleDescription.addOrGetLocalClassDescription(classInfo.name().toString());
final InjectionSource valueSource;
EjbInjectionSource ejbInjectionSource = null;
// give preference to lookup
if (!isEmpty(lookup)) {
if (!lookup.startsWith("java:")) {
valueSource =
new EjbLookupInjectionSource(lookup, targetDescription.getDeclaredValueClassName());
} else {
valueSource = createLookup(lookup, appclient);
}
} else if (!isEmpty(beanName)) {
valueSource =
ejbInjectionSource =
new EjbInjectionSource(
beanName, beanInterface, localContextName, deploymentUnit, appclient);
} else {
valueSource =
ejbInjectionSource =
new EjbInjectionSource(beanInterface, localContextName, deploymentUnit, appclient);
}
if (ejbInjectionSource != null) {
deploymentUnit.addToAttachmentList(
EjbDeploymentAttachmentKeys.EJB_INJECTIONS, ejbInjectionSource);
}
// our injection comes from the local lookup, no matter what.
final ResourceInjectionConfiguration injectionConfiguration =
targetDescription != null
? new ResourceInjectionConfiguration(
targetDescription, createLookup(localContextName, appclient))
: null;
// Create the binding from whence our injection comes.
final BindingConfiguration bindingConfiguration =
new BindingConfiguration(localContextName, valueSource);
classDescription.getBindingConfigurations().add(bindingConfiguration);
if (injectionConfiguration != null) {
classDescription.addResourceInjection(injectionConfiguration);
}
}
private void processDeployment(
final WarMetaData warMetaData,
final DeploymentUnit deploymentUnit,
final ServiceTarget serviceTarget,
String hostName)
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(deploymentUnit));
}
final DeploymentClassIndex deploymentClassIndex =
deploymentUnit.getAttachment(Attachments.CLASS_INDEX);
final JBossWebMetaData metaData = warMetaData.getMergedJBossWebMetaData();
final List<SetupAction> setupActions =
deploymentUnit.getAttachmentList(org.jboss.as.ee.component.Attachments.WEB_SETUP_ACTIONS);
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) {
boolean skip = false;
if (!failed.contains(component)) {
dependentComponents.add(component);
}
}
ComponentRegistry componentRegistry =
deploymentUnit.getAttachment(org.jboss.as.ee.component.Attachments.COMPONENT_REGISTRY);
if (componentRegistry == null) {
// 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);
DeploymentInfo deploymentInfo =
createServletConfig(
metaData,
deploymentUnit,
module,
deploymentClassIndex,
injectionContainer,
componentRegistry,
scisMetaData,
deploymentRoot);
final String pathName = pathNameOfDeployment(deploymentUnit, metaData);
deploymentInfo.setContextPath(pathName);
String metaDataSecurityDomain = metaData.getSecurityDomain();
if (metaDataSecurityDomain == null) {
metaDataSecurityDomain = getJBossAppSecurityDomain(deploymentUnit);
}
if (metaDataSecurityDomain != null) {
metaDataSecurityDomain = metaDataSecurityDomain.trim();
}
String securityDomain =
metaDataSecurityDomain == null
? SecurityConstants.DEFAULT_APPLICATION_POLICY
: SecurityUtil.unprefixSecurityDomain(metaDataSecurityDomain);
final ServiceName deploymentServiceName =
UndertowService.deploymentServiceName(hostName, deploymentInfo.getContextPath());
final ServiceName hostServiceName = UndertowService.virtualHostName(defaultServer, hostName);
final UndertowDeploymentService service =
new UndertowDeploymentService(
deploymentInfo, injectionContainer, module, warMetaData.getMergedJBossWebMetaData());
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())
.addDependency(
SecurityDomainService.SERVICE_NAME.append(securityDomain),
SecurityDomainContext.class,
service.getSecurityDomainContextValue())
.addDependency(
UndertowService.UNDERTOW, UndertowService.class, service.getUndertowService());
deploymentUnit.addToAttachmentList(
Attachments.DEPLOYMENT_COMPLETE_SERVICES, deploymentServiceName);
// add any dependencies required by the setup action
for (final SetupAction action : setupActions) {
builder.addDependencies(action.dependencies());
deploymentInfo.addThreadSetupAction(
new ThreadSetupAction() {
@Override
public Handle setup(final HttpServerExchange exchange) {
action.setup(Collections.<String, Object>emptyMap());
return new Handle() {
@Override
public void tearDown() {
action.teardown(Collections.<String, Object>emptyMap());
}
};
}
});
}
if (metaData.getDistributable() != null) {
DistributedCacheManagerFactoryService factoryService =
new DistributedCacheManagerFactoryService();
DistributedCacheManagerFactory factory = factoryService.getValue();
if (factory != null) {
ServiceName factoryServiceName = deploymentServiceName.append("session");
builder.addDependency(
ServiceBuilder.DependencyType.OPTIONAL,
factoryServiceName,
DistributedCacheManagerFactory.class,
service.getDistributedCacheManagerFactoryInjectedValue());
ServiceBuilder<DistributedCacheManagerFactory> factoryBuilder =
serviceTarget.addService(factoryServiceName, factoryService);
boolean enabled =
factory.addDeploymentDependencies(
deploymentServiceName,
deploymentUnit.getServiceRegistry(),
serviceTarget,
factoryBuilder,
metaData);
factoryBuilder.setInitialMode(enabled ? Mode.ON_DEMAND : Mode.NEVER).install();
}
}
// OSGi web applications are activated in {@link WebContextActivationProcessor} according to
// bundle lifecycle changes
if (deploymentUnit.hasAttachment(Attachments.OSGI_MANIFEST)) {
builder.setInitialMode(Mode.NEVER);
UndertowDeploymentService.ContextActivatorImpl activator =
new UndertowDeploymentService.ContextActivatorImpl(builder.install());
deploymentUnit.putAttachment(ContextActivator.ATTACHMENT_KEY, activator);
} else {
builder.setInitialMode(Mode.ACTIVE);
builder.install();
}
// Process the web related mgmt information
final ModelNode node =
deploymentUnit.getDeploymentSubsystemModel(UndertowExtension.SUBSYSTEM_NAME);
node.get(DeploymentDefinition.CONTEXT_ROOT.getName()).set("".equals(pathName) ? "/" : pathName);
node.get(DeploymentDefinition.VIRTUAL_HOST.getName()).set(hostName);
processManagement(deploymentUnit, metaData);
}
private void processSessionBeanMetaData(
final DeploymentUnit deploymentUnit, final SessionBeanMetaData sessionBean)
throws DeploymentUnitProcessingException {
final EjbJarDescription ejbJarDescription = getEjbJarDescription(deploymentUnit);
final EEModuleDescription eeModuleDescription =
deploymentUnit.getAttachment(Attachments.EE_MODULE_DESCRIPTION);
final List<ComponentDescription> additionalComponents =
deploymentUnit.getAttachmentList(Attachments.ADDITIONAL_RESOLVABLE_COMPONENTS);
final String beanName = sessionBean.getName();
// the important bit is to skip already processed EJBs via annotations
if (ejbJarDescription.hasComponent(beanName)) {
final ComponentDescription description = eeModuleDescription.getComponentByName(beanName);
if (description instanceof SessionBeanComponentDescription) {
((SessionBeanComponentDescription) description).setDescriptorData(sessionBean);
} else {
throw new DeploymentUnitProcessingException(
"Session bean with name "
+ beanName
+ " referenced in ejb-jar.xml could not be created, as existing non session bean component with same name already exists: "
+ description);
}
return;
}
if (appclient) {
for (final ComponentDescription component : additionalComponents) {
if (component.getComponentName().equals(beanName)) {
if (component instanceof SessionBeanComponentDescription) {
((SessionBeanComponentDescription) component).setDescriptorData(sessionBean);
} else {
throw new DeploymentUnitProcessingException(
"Session bean with name "
+ beanName
+ " referenced in ejb-jar.xml could not be created, as existing non session bean component with same name already exists: "
+ component);
}
return;
}
}
}
final SessionType sessionType = sessionBean.getSessionType();
if (sessionType == null) {}
if (sessionType == null && sessionBean instanceof GenericBeanMetaData) {
// TODO: this is a hack
return;
}
final String beanClassName = sessionBean.getEjbClass();
final SessionBeanComponentDescription sessionBeanDescription;
switch (sessionType) {
case Stateless:
sessionBeanDescription =
new StatelessComponentDescription(
beanName, beanClassName, ejbJarDescription, deploymentUnit.getServiceName());
break;
case Stateful:
sessionBeanDescription =
new StatefulComponentDescription(
beanName, beanClassName, ejbJarDescription, deploymentUnit.getServiceName());
break;
case Singleton:
sessionBeanDescription =
new SingletonComponentDescription(
beanName, beanClassName, ejbJarDescription, deploymentUnit.getServiceName());
break;
default:
throw new IllegalArgumentException("Unknown session bean type: " + sessionType);
}
if (appclient) {
deploymentUnit.addToAttachmentList(
Attachments.ADDITIONAL_RESOLVABLE_COMPONENTS, sessionBeanDescription);
} else {
// Add this component description to module description
ejbJarDescription.getEEModuleDescription().addComponent(sessionBeanDescription);
}
sessionBeanDescription.setDescriptorData(sessionBean);
}
private void processSessionBeans(
final DeploymentUnit deploymentUnit,
final List<AnnotationInstance> sessionBeanAnnotations,
final SessionBeanComponentDescription.SessionBeanType annotatedSessionBeanType) {
final EjbJarDescription ejbJarDescription = getEjbJarDescription(deploymentUnit);
final ServiceName deploymentUnitServiceName = deploymentUnit.getServiceName();
// process these session bean annotations and create component descriptions out of it
for (final AnnotationInstance sessionBeanAnnotation : sessionBeanAnnotations) {
final AnnotationTarget target = sessionBeanAnnotation.target();
if (!(target instanceof ClassInfo)) {
// Let's just WARN and move on. No need to throw an error
logger.warn(
sessionBeanAnnotation.name()
+ " annotation is expected to be applied on class level. "
+ target
+ " is not a class");
continue;
}
final ClassInfo sessionBeanClassInfo = (ClassInfo) target;
// skip if it's not a valid class for session bean
if (!assertSessionBeanClassValidity(sessionBeanClassInfo)) {
continue;
}
final String ejbName = sessionBeanClassInfo.name().local();
final AnnotationValue nameValue = sessionBeanAnnotation.value("name");
final String beanName =
nameValue == null || nameValue.asString().isEmpty() ? ejbName : nameValue.asString();
final EnterpriseBeanMetaData beanMetaData =
getEnterpriseBeanMetaData(deploymentUnit, beanName);
final SessionBeanComponentDescription.SessionBeanType sessionBeanType;
final String beanClassName;
if (beanMetaData != null && beanMetaData instanceof SessionBeanMetaData) {
sessionBeanType =
override(
annotatedSessionBeanType,
descriptionOf(((SessionBeanMetaData) beanMetaData).getSessionType()));
} else {
sessionBeanType = annotatedSessionBeanType;
}
if (beanMetaData != null) {
beanClassName =
override(sessionBeanClassInfo.name().toString(), beanMetaData.getEjbClass());
} else {
beanClassName = sessionBeanClassInfo.name().toString();
}
final SessionBeanComponentDescription sessionBeanDescription;
switch (sessionBeanType) {
case STATELESS:
sessionBeanDescription =
new StatelessComponentDescription(
beanName, beanClassName, ejbJarDescription, deploymentUnitServiceName);
break;
case STATEFUL:
sessionBeanDescription =
new StatefulComponentDescription(
beanName, beanClassName, ejbJarDescription, deploymentUnitServiceName);
break;
case SINGLETON:
sessionBeanDescription =
new SingletonComponentDescription(
beanName, beanClassName, ejbJarDescription, deploymentUnitServiceName);
break;
default:
throw new IllegalArgumentException("Unknown session bean type: " + sessionBeanType);
}
if (appclient) {
deploymentUnit.addToAttachmentList(
Attachments.ADDITIONAL_RESOLVABLE_COMPONENTS, sessionBeanDescription);
} else {
// Add this component description to module description
ejbJarDescription.getEEModuleDescription().addComponent(sessionBeanDescription);
}
}
EjbDeploymentMarker.mark(deploymentUnit);
}
/** {@inheritDoc} */
public void deploy(final DeploymentPhaseContext phaseContext)
throws DeploymentUnitProcessingException {
final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
final List<ResourceRoot> resourceRoots = DeploymentUtils.allResourceRoots(deploymentUnit);
if (!DeploymentTypeMarker.isType(DeploymentType.EAR, deploymentUnit)) {
return;
}
final DeploymentUnit parent = deploymentUnit.getParent();
final DeploymentUnit topLevelDeployment = parent == null ? deploymentUnit : parent;
final VirtualFile toplevelRoot =
topLevelDeployment.getAttachment(Attachments.DEPLOYMENT_ROOT).getRoot();
final ExternalModuleService externalModuleService =
topLevelDeployment.getAttachment(Attachments.EXTERNAL_MODULE_SERVICE);
final Map<VirtualFile, ResourceRoot> files = new HashMap<VirtualFile, ResourceRoot>();
for (ResourceRoot resourceRoot : resourceRoots) {
files.put(resourceRoot.getRoot(), resourceRoot);
}
final Deque<ResourceRoot> libResourceRoots = new ArrayDeque<ResourceRoot>();
// scan /lib entries for class-path items
for (ResourceRoot resourceRoot : resourceRoots) {
if (ModuleRootMarker.isModuleRoot(resourceRoot)
&& !SubDeploymentMarker.isSubDeployment(resourceRoot)) {
libResourceRoots.add(resourceRoot);
}
}
while (!libResourceRoots.isEmpty()) {
final ResourceRoot resourceRoot = libResourceRoots.pop();
final String[] items = getClassPathEntries(resourceRoot);
for (String item : items) {
final VirtualFile classPathFile = resourceRoot.getRoot().getParent().getChild(item);
if (!classPathFile.exists()) {
log.warnf("Class Path entry %s in %s not found. ", item, resourceRoot.getRoot());
} else if (isInside(classPathFile, toplevelRoot)) {
if (!files.containsKey(classPathFile)) {
log.warnf(
"Class Path entry %s in %s does not point to a valid jar for a Class-Path reference.",
item, resourceRoot.getRoot());
} else {
final ResourceRoot target = files.get(classPathFile);
if (SubDeploymentMarker.isSubDeployment(target)) {
// for now we do not allow ear Class-Path references to subdeployments
log.warnf(
"Class Path entry in "
+ resourceRoot.getRoot()
+ " may not point to a sub deployment.");
} else if (!ModuleRootMarker.isModuleRoot(target)) {
// otherwise just add it to the lib dir
ModuleRootMarker.mark(target);
libResourceRoots.push(target);
log.debugf(
"Resource %s added to logical lib directory due to Class-Path entry in %s",
classPathFile, target.getRoot());
}
// otherwise it is already part of lib, so we leave it alone for now
}
} else if (item.startsWith("/")) {
ModuleIdentifier moduleIdentifier = externalModuleService.addExternalModule(item);
deploymentUnit.addToAttachmentList(Attachments.CLASS_PATH_ENTRIES, moduleIdentifier);
log.debugf("Resource %s added as external jar %s", classPathFile, resourceRoot.getRoot());
} else {
// this is a dep on another deployment
deploymentUnit.addToAttachmentList(
Attachments.CLASS_PATH_ENTRIES,
ModuleIdentifier.create(ServiceModuleLoader.MODULE_PREFIX + classPathFile.getName()));
}
}
}
}
