import org.jboss.as.server.deployment.module.ResourceRoot; //导入依赖的package包/类
public void deploy(DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException {
    final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
    
    if(deploymentUnit.getAttachment(Attachments.DEPLOYMENT_ROOT) != null) {
        return;
    }
    
    final String deploymentName = deploymentUnit.getName();
    final VirtualFile deploymentContents = deploymentUnit.getAttachment(Attachments.DEPLOYMENT_CONTENTS);

    // internal deployments do not have any contents, so there is nothing to mount
    if (deploymentContents == null)
        return;
    
    if (deploymentName.endsWith(DYNAMIC_VDB_STRUCTURE)) {
        // use the contents directly
        // nothing was mounted
        final ResourceRoot resourceRoot = new ResourceRoot(deploymentContents, null);
        ModuleRootMarker.mark(resourceRoot);
        deploymentUnit.putAttachment(Attachments.DEPLOYMENT_ROOT, resourceRoot);
        deploymentUnit.putAttachment(Attachments.MODULE_SPECIFICATION, new ModuleSpecification());            
    }
}
 

import org.jboss.as.server.deployment.module.ResourceRoot; //导入依赖的package包/类
@Override
public void deploy(final DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException {
    final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
    if (TeiidAttachments.isTranslator(deploymentUnit)) {
    	return;
    }

    List<ResourceRoot> resourceRoots = DeploymentUtils.allResourceRoots(deploymentUnit);
    for (ResourceRoot resourceRoot : resourceRoots) {
        final VirtualFile deploymentRoot = resourceRoot.getRoot();

        if (deploymentRoot.getChild("META-INF/services/org.teiid.translator.ExecutionFactory").exists())  { //$NON-NLS-1$
            TeiidAttachments.setAsTranslatorDeployment(deploymentUnit);
            //deploymentUnit.putAttachment(Attachments.IGNORE_OSGI, Boolean.TRUE);
            break;
        }
    }
}
 

import org.jboss.as.server.deployment.module.ResourceRoot; //导入依赖的package包/类
@Override
public final void deploy(final DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException {
    final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
    // If the log context is already defined, skip the rest of the processing
    if (!hasRegisteredLogContext(deploymentUnit)) {
        if (deploymentUnit.hasAttachment(Attachments.MODULE) && deploymentUnit.hasAttachment(Attachments.DEPLOYMENT_ROOT)) {
            // don't process sub-deployments as they are processed by processing methods
            final ResourceRoot root = deploymentUnit.getAttachment(Attachments.DEPLOYMENT_ROOT);
            if (SubDeploymentMarker.isSubDeployment(root)) return;
            processDeployment(phaseContext, deploymentUnit, root);
            // If we still don't have a context registered on the root deployment, register the current context.
            // This is done to avoid any logging from the root deployment to have access to a sub-deployments log
            // context. For example any library logging from a EAR/lib should use the EAR's configured log context,
            // not a log context from a WAR or EJB library.
            if (!hasRegisteredLogContext(deploymentUnit) && !deploymentUnit.hasAttachment(DEFAULT_LOG_CONTEXT_KEY)) {
                // Register the current log context as this could be an embedded server or overridden another way
                registerLogContext(deploymentUnit, DEFAULT_LOG_CONTEXT_KEY, deploymentUnit.getAttachment(Attachments.MODULE), LogContext.getLogContext());
            }
        }
    }
}
 

import org.jboss.as.server.deployment.module.ResourceRoot; //导入依赖的package包/类
@Override
public final void undeploy(final DeploymentUnit context) {
    // OSGi bundles deployments may not have a module attached
    if (context.hasAttachment(Attachments.MODULE)) {
        // don't process sub-deployments as they are processed by processing methods
        final ResourceRoot root = context.getAttachment(Attachments.DEPLOYMENT_ROOT);
        if (SubDeploymentMarker.isSubDeployment(root)) return;
        // Remove any log context selector references
        final Module module = context.getAttachment(Attachments.MODULE);
        // Remove either the default log context or a defined log context. It's safe to attempt to remove a
        // nonexistent context.
        unregisterLogContext(context, DEFAULT_LOG_CONTEXT_KEY, module);
        unregisterLogContext(context, LOG_CONTEXT_KEY, module);
        // Unregister all sub-deployments
        final List<DeploymentUnit> subDeployments = getSubDeployments(context);
        for (DeploymentUnit subDeployment : subDeployments) {
            final Module subDeploymentModule = subDeployment.getAttachment(Attachments.MODULE);
            // Sub-deployment should never have a default log context
            unregisterLogContext(subDeployment, LOG_CONTEXT_KEY, subDeploymentModule);
        }
    }
}
 

import org.jboss.as.server.deployment.module.ResourceRoot; //导入依赖的package包/类
private boolean isExplodedSubUnitOverlay(DeploymentUnit deploymentUnit, VirtualFile mountPoint, String path) {
    final List<ResourceRoot> childRes = deploymentUnit.getAttachmentList(Attachments.RESOURCE_ROOTS);
    if (childRes != null) {
        for (ResourceRoot rs: childRes) {
            if (path.startsWith(rs.getRoot().getName())) {
                String relativePath = mountPoint.getPathNameRelativeTo(rs.getRoot());
                if (relativePath != null
                        && relativePath.length() > 0
                        && SubExplodedDeploymentMarker.isSubExplodedResourceRoot(rs)) {
                    return true;
                }
            }
        }
    }
    return false;
}
 

import org.jboss.as.server.deployment.module.ResourceRoot; //导入依赖的package包/类
public static Map<ResourceRoot, Index> getAnnotationIndexes(final DeploymentUnit deploymentUnit) {
    final List<ResourceRoot> allResourceRoots = new ArrayList<ResourceRoot>();
    allResourceRoots.addAll(deploymentUnit.getAttachmentList(Attachments.RESOURCE_ROOTS));
    allResourceRoots.add(deploymentUnit.getAttachment(Attachments.DEPLOYMENT_ROOT));
    Map<ResourceRoot, Index> indexes = new HashMap<ResourceRoot, Index>();
    for (ResourceRoot resourceRoot : allResourceRoots) {
        if (resourceRoot == null)
            continue;

        Index index = resourceRoot.getAttachment(Attachments.ANNOTATION_INDEX);
        if (index != null) {
            indexes.put(resourceRoot, index);
        }
    }
    return indexes;
}
 

import org.jboss.as.server.deployment.module.ResourceRoot; //导入依赖的package包/类
/**
 * Loops through all resource roots that have been made available transitively via Class-Path entries, and
 * adds them to the list of roots to be processed.
 */
private Collection<? extends ResourceRoot> handleClassPathItems(final DeploymentUnit deploymentUnit) {
    final Set<ResourceRoot> additionalRoots = new HashSet<ResourceRoot>();
    final ArrayDeque<ResourceRoot> toProcess = new ArrayDeque<ResourceRoot>();
    final List<ResourceRoot> resourceRoots = DeploymentUtils.allResourceRoots(deploymentUnit);
    toProcess.addAll(resourceRoots);
    final Set<ResourceRoot> processed = new HashSet<ResourceRoot>(resourceRoots);

    while (!toProcess.isEmpty()) {
        final ResourceRoot root = toProcess.pop();
        final List<ResourceRoot> classPathRoots = root.getAttachmentList(Attachments.CLASS_PATH_RESOURCE_ROOTS);
        for(ResourceRoot cpRoot : classPathRoots) {
            if(!processed.contains(cpRoot)) {
                additionalRoots.add(cpRoot);
                toProcess.add(cpRoot);
                processed.add(cpRoot);
            }
        }
    }
    return additionalRoots;
}
 

import org.jboss.as.server.deployment.module.ResourceRoot; //导入依赖的package包/类
@Override
public void undeploy(final DeploymentUnit deploymentUnit) {
    final ServiceRegistry serviceRegistry = deploymentUnit.getServiceRegistry();
    final List<ResourceRoot> childRoots = deploymentUnit.getAttachmentList(Attachments.RESOURCE_ROOTS);
    for (final ResourceRoot childRoot : childRoots) {
        if (!SubDeploymentMarker.isSubDeployment(childRoot)) {
            continue;
        }
        final ServiceName serviceName = Services.deploymentUnitName(deploymentUnit.getName(), childRoot.getRootName());
        final ServiceController<?> serviceController = serviceRegistry.getService(serviceName);
        if (serviceController != null) {
            serviceController.setMode(ServiceController.Mode.REMOVE);
        }
    }
    deploymentUnit.removeAttachment(Attachments.SUB_DEPLOYMENTS);
}
 

import org.jboss.as.server.deployment.module.ResourceRoot; //导入依赖的package包/类
private void processAnnotationIndex(DeploymentUnit deploymentUnit) {
    DotName dotName = DotName.createSimple(BootstrapDatabase.class.getName());
    CompositeIndex index = deploymentUnit.getAttachment(COMPOSITE_ANNOTATION_INDEX);
    if (index == null) {
        return;
    }

    List<AnnotationInstance> indexAnnotations = index.getAnnotations(dotName);
    if (indexAnnotations.isEmpty()) {
        return;
    }

    ResourceRoot deploymentRoot = deploymentUnit.getAttachment(DEPLOYMENT_ROOT);
    VirtualFile root = deploymentRoot.getRoot();

    DbBootstrapLogger.ROOT_LOGGER.tracef("match on %s", root.getPathName());
    try {
        final Module module = deploymentUnit.getAttachment(MODULE);
        processAnnotatedClasses(indexAnnotations, module.getClassLoader());
    } catch (Exception e) {
        DbBootstrapLogger.ROOT_LOGGER.error("Unable to process the internal jar files", e);
    }
}
 

import org.jboss.as.server.deployment.module.ResourceRoot; //导入依赖的package包/类
@Override
public void deploy(DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException {
    final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
    final ResourceRoot deploymentRoot = deploymentUnit.getAttachment(Attachments.DEPLOYMENT_ROOT);
    final ServiceModuleLoader moduleLoader = deploymentUnit.getAttachment(Attachments.SERVICE_MODULE_LOADER);
    final ModuleSpecification moduleSpecification = deploymentUnit.getAttachment(Attachments.MODULE_SPECIFICATION);
    List<ResourceRoot> resourceRoots = deploymentUnit.getAttachmentList(Attachments.RESOURCE_ROOTS);


    //List<VirtualFile> jars = getJarList(deploymentRoot.getRoot());


    try {
        processBlackList(resourceRoots);
    } catch (IOException e) {
        SDDLogger.ROOT_LOGGER.couldNotProcessBlacklist(e);
    }

}
 

import org.jboss.as.server.deployment.module.ResourceRoot; //导入依赖的package包/类
@Override
public void deploy(final DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException {

    DeploymentUnit depUnit = phaseContext.getDeploymentUnit();
    Resource resource = depUnit.getAttachment(GraviaConstants.RESOURCE_KEY);
    if (resource != null)
        return;

    resource = NamedResourceAssociation.getResource(depUnit.getName());
    if (resource == null) {
        ResourceRoot deploymentRoot = depUnit.getAttachment(Attachments.DEPLOYMENT_ROOT);
        Manifest manifest = deploymentRoot != null ? deploymentRoot.getAttachment(Attachments.MANIFEST) : null;
        if (manifest != null) {
            ManifestResourceBuilder builder = new ManifestResourceBuilder().load(manifest);
            if (builder.isValid()) {
                resource = builder.getResource();
            }
        }
    }

    if (resource != null) {
        depUnit.putAttachment(GraviaConstants.RESOURCE_KEY, resource);
    }
}
 

import org.jboss.as.server.deployment.module.ResourceRoot; //导入依赖的package包/类
public void undeploy(DeploymentUnit context) {
    final ResourceRoot resourceRoot = context.removeAttachment(Attachments.DEPLOYMENT_ROOT);
    if (resourceRoot != null) {
        final Closeable mountHandle = resourceRoot.getMountHandle();
        VFSUtils.safeClose(mountHandle);
    }
}
 

import org.jboss.as.server.deployment.module.ResourceRoot; //导入依赖的package包/类
@Override
public void deploy(DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException {
    final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
    final ResourceRoot deploymentRoot = deploymentUnit.getAttachment(Attachments.DEPLOYMENT_ROOT);
    final VirtualFile switchyardXml;
    
    if (DeploymentTypeMarker.isType(DeploymentType.WAR, deploymentUnit)) {
        // switchyard.xml file located in /WEB-INF
        final VirtualFile warSwitchYardXml = deploymentRoot.getRoot().getChild(SWITCHYARD_XML_WAR);
        if (warSwitchYardXml.exists()) {
            switchyardXml = warSwitchYardXml;
        } else {
            // fall back to original location
            switchyardXml = deploymentRoot.getRoot().getChild(SWITCHYARD_XML);
        }
    } else {
        switchyardXml = deploymentRoot.getRoot().getChild(SWITCHYARD_XML);
    }

    if (!switchyardXml.exists()) {
        return;
    }
    final String archiveName = deploymentUnit.getName();
    final String deploymentName = archiveName.substring(0, archiveName.lastIndexOf('.'));
    final SwitchYardMetaData switchYardMetaData = new SwitchYardMetaData(archiveName, deploymentName);
    switchYardMetaData.setSwitchYardFile(switchyardXml);

    deploymentUnit.putAttachment(SwitchYardMetaData.ATTACHMENT_KEY, switchYardMetaData);
    SwitchYardDeploymentMarker.mark(deploymentUnit);
}
 

import org.jboss.as.server.deployment.module.ResourceRoot; //导入依赖的package包/类
/**
 * Find the logging profile attached to any resource.
 *
 * @param resourceRoot the root resource
 *
 * @return the logging profile name or {@code null} if one was not found
 */
private String findLoggingProfile(final ResourceRoot resourceRoot) {
    final Manifest manifest = resourceRoot.getAttachment(Attachments.MANIFEST);
    if (manifest != null) {
        final String loggingProfile = manifest.getMainAttributes().getValue(LOGGING_PROFILE);
        if (loggingProfile != null) {
            LoggingLogger.ROOT_LOGGER.debugf("Logging profile '%s' found in '%s'.", loggingProfile, resourceRoot);
            return loggingProfile;
        }
    }
    return null;
}
 

import org.jboss.as.server.deployment.module.ResourceRoot; //导入依赖的package包/类
/**
 * Finds the configuration file to be used and returns the first one found.
 * <p/>
 * Preference is for {@literal logging.properties} or {@literal jboss-logging.properties}.
 *
 * @param resourceRoot the resource to check.
 *
 * @return the configuration file if found, otherwise {@code null}.
 *
 * @throws DeploymentUnitProcessingException if an error occurs.
 */
private VirtualFile findConfigFile(ResourceRoot resourceRoot) throws DeploymentUnitProcessingException {
    final VirtualFile root = resourceRoot.getRoot();
    // First check META-INF
    VirtualFile file = root.getChild("META-INF");
    VirtualFile result = findConfigFile(file);
    if (result == null) {
        file = root.getChild("WEB-INF/classes");
        result = findConfigFile(file);
    }
    return result;
}
 

import org.jboss.as.server.deployment.module.ResourceRoot; //导入依赖的package包/类
private static String resolveRelativePath(final ResourceRoot root, final VirtualFile configFile) {
    // Get the parent of the root resource so the deployment name will be included in the path
    final VirtualFile deployment = root.getRoot().getParent();
    if (deployment != null) {
        return configFile.getPathNameRelativeTo(deployment);
    }
    // This shouldn't be reached, but a fallback is always safe
    return configFile.getPathNameRelativeTo(root.getRoot());
}
 

import org.jboss.as.server.deployment.module.ResourceRoot; //导入依赖的package包/类
/**
 * Get all resource roots for a {@link DeploymentUnit}
 *
 * @param deploymentUnit The deployment unit
 * @return The deployment root and any additional resource roots
 */
public static List<ResourceRoot> allResourceRoots(DeploymentUnit deploymentUnit) {
    List<ResourceRoot> roots = new ArrayList<ResourceRoot>();
    // not all deployment units have a deployment root
    final ResourceRoot deploymentRoot = deploymentUnit.getAttachment(Attachments.DEPLOYMENT_ROOT);
    if (deploymentRoot != null)
        roots.add(deploymentRoot);
    roots.addAll(deploymentUnit.getAttachmentList(Attachments.RESOURCE_ROOTS));
    return roots;
}
 

import org.jboss.as.server.deployment.module.ResourceRoot; //导入依赖的package包/类
public void deploy(DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException {
    DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
    if (deploymentUnit.getParent() != null) {
        return;
    }

    final List<DeploymentUnit> deploymentUnits = new ArrayList<DeploymentUnit>();
    deploymentUnits.add(deploymentUnit);
    deploymentUnits.addAll(deploymentUnit.getAttachmentList(Attachments.SUB_DEPLOYMENTS));

    for (DeploymentUnit unit : deploymentUnits) {

        final ResourceRoot mainRoot = unit.getAttachment(Attachments.DEPLOYMENT_ROOT);
        if (mainRoot == null)
            continue;

        VirtualFile root = mainRoot.getRoot();
        for (String path : SEAM_FILES) {
            if (root.getChild(path).exists()) {
                final ModuleSpecification moduleSpecification = deploymentUnit
                        .getAttachment(Attachments.MODULE_SPECIFICATION);
                final ModuleLoader moduleLoader = Module.getBootModuleLoader();
                moduleSpecification.addSystemDependency(new ModuleDependency(moduleLoader, VFS_MODULE, false, false, false,
                        false)); // for VFS scanner

                try {
                    ResourceLoader resourceLoader = ResourceLoaders.createJarResourceLoader(SEAM_INT_JAR, new JarFile(
                            getSeamIntResourceRoot().getRoot().getPathName()));
                    moduleSpecification.addResourceLoader(ResourceLoaderSpec.createResourceLoaderSpec(resourceLoader));
                } catch (Exception e) {
                    throw new DeploymentUnitProcessingException(e);
                }

                unit.addToAttachmentList(Attachments.RESOURCE_ROOTS, getSeamIntResourceRoot());
                return;
            }
        }
    }
}
 

import org.jboss.as.server.deployment.module.ResourceRoot; //导入依赖的package包/类
@Override
public void deploy(final DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException {
    final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
    deploymentUnit.removeAttachment(Attachments.COMPOSITE_ANNOTATION_INDEX);
    for(final ResourceRoot root : DeploymentUtils.allResourceRoots(deploymentUnit)) {
        root.removeAttachment(Attachments.ANNOTATION_INDEX);
    }

}
 

import org.jboss.as.server.deployment.module.ResourceRoot; //导入依赖的package包/类
private void handleDeployment(final DeploymentPhaseContext phaseContext, final DeploymentUnit deploymentUnit, final ModuleSpecification moduleSpec, final ModuleStructureSpec rootDeploymentSpecification, Set<ModuleIdentifier> additionalModules) throws DeploymentUnitProcessingException {
    final Map<VirtualFile, ResourceRoot> resourceRoots = resourceRoots(deploymentUnit);
    moduleSpec.addUserDependencies(rootDeploymentSpecification.getModuleDependencies());
    moduleSpec.addExclusions(rootDeploymentSpecification.getExclusions());
    moduleSpec.addAliases(rootDeploymentSpecification.getAliases());
    moduleSpec.addModuleSystemDependencies(rootDeploymentSpecification.getSystemDependencies());
    for (final ResourceRoot additionalResourceRoot : rootDeploymentSpecification.getResourceRoots()) {

        final ResourceRoot existingRoot = resourceRoots.get(additionalResourceRoot.getRoot());
        if (existingRoot != null) {
            //we already have to the resource root
            //so now we want to merge it
            existingRoot.merge(additionalResourceRoot);
        } else if (!additionalResourceRoot.getRoot().exists()) {
            ServerLogger.DEPLOYMENT_LOGGER.additionalResourceRootDoesNotExist(additionalResourceRoot.getRoot().getPathName());
        } else {
            deploymentUnit.addToAttachmentList(Attachments.RESOURCE_ROOTS, additionalResourceRoot);
            //compute the annotation index for the root
            ResourceRootIndexer.indexResourceRoot(additionalResourceRoot);
            ModuleRootMarker.mark(additionalResourceRoot);
        }
    }
    for (final String classFileTransformer : rootDeploymentSpecification.getClassFileTransformers()) {
        moduleSpec.addClassFileTransformer(classFileTransformer);
    }
    //handle annotations
    for (final ModuleIdentifier dependency : rootDeploymentSpecification.getAnnotationModules()) {
        deploymentUnit.addToAttachmentList(Attachments.ADDITIONAL_ANNOTATION_INDEXES, dependency);
        //additional modules will not be created till much later, a dep on them would fail
        if(dependency.getName().startsWith(ServiceModuleLoader.MODULE_PREFIX) && !additionalModules.contains(dependency)) {
            phaseContext.addToAttachmentList(Attachments.NEXT_PHASE_DEPS, ServiceModuleLoader.moduleServiceName(dependency));
        }
    }
    moduleSpec.setLocalLast(rootDeploymentSpecification.isLocalLast());

    if(rootDeploymentSpecification.getExcludedSubsystems() != null) {
        deploymentUnit.putAttachment(Attachments.EXCLUDED_SUBSYSTEMS, rootDeploymentSpecification.getExcludedSubsystems());
    }
}