/** * Add the EE APIs as a dependency to all deployments * * @param phaseContext the deployment unit context * @throws DeploymentUnitProcessingException * */ public void deploy(DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException { final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit(); final ModuleSpecification moduleSpecification = deploymentUnit.getAttachment(Attachments.MODULE_SPECIFICATION); final ModuleLoader moduleLoader = Module.getBootModuleLoader(); //add jboss-invocation classes needed by the proxies ModuleDependency invocation = new ModuleDependency(moduleLoader, JBOSS_INVOCATION_ID, false, false, false, false); invocation.addImportFilter(PathFilters.is("org/jboss/invocation/proxy/classloading"), true); invocation.addImportFilter(PathFilters.acceptAll(), false); moduleSpecification.addSystemDependency(invocation); ModuleDependency ee = new ModuleDependency(moduleLoader, JBOSS_AS_EE, false, false, false, false); ee.addImportFilter(PathFilters.is("org/jboss/as/ee/component/serialization"), true); ee.addImportFilter(PathFilters.is("org/jboss/as/ee/concurrent"), true); ee.addImportFilter(PathFilters.is("org/jboss/as/ee/concurrent/handle"), true); ee.addImportFilter(PathFilters.acceptAll(), false); moduleSpecification.addSystemDependency(ee); // add dep for naming permission moduleSpecification.addSystemDependency(new ModuleDependency(moduleLoader, ModuleIdentifier.create("org.wildfly.naming"), false, false, false, false)); //we always add all Java EE API modules, as the platform spec requires them to always be available //we do not just add the javaee.api module, as this breaks excludes for (final ModuleIdentifier moduleIdentifier : JAVA_EE_API_MODULES) { moduleSpecification.addSystemDependency(new ModuleDependency(moduleLoader, moduleIdentifier, true, false, true, false)); } }
/** * Add dependencies for modules required for weld deployments, if managed weld configurations are attached to the deployment * */ public void deploy(DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException { final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit(); final ModuleSpecification moduleSpecification = deploymentUnit.getAttachment(Attachments.MODULE_SPECIFICATION); final ModuleLoader moduleLoader = Module.getBootModuleLoader(); addDependency(moduleSpecification, moduleLoader, JAVAX_ENTERPRISE_API); addDependency(moduleSpecification, moduleLoader, JAVAX_INJECT_API); if (!WeldDeploymentMarker.isPartOfWeldDeployment(deploymentUnit)) { return; // Skip if there are no beans.xml files in the deployment } addDependency(moduleSpecification, moduleLoader, JAVAX_PERSISTENCE_API_ID); addDependency(moduleSpecification, moduleLoader, WELD_CORE_ID); addDependency(moduleSpecification, moduleLoader, WELD_PROBE_ID, true); addDependency(moduleSpecification, moduleLoader, WELD_API_ID); addDependency(moduleSpecification, moduleLoader, WELD_SPI_ID); ModuleDependency weldSubsystemDependency = new ModuleDependency(moduleLoader, JBOSS_AS_WELD_ID, false, false, false, false); weldSubsystemDependency.addImportFilter(PathFilters.getMetaInfFilter(), true); weldSubsystemDependency.addImportFilter(PathFilters.is("org/jboss/as/weld/injection"), true); weldSubsystemDependency.addImportFilter(PathFilters.acceptAll(), false); weldSubsystemDependency.addExportFilter(PathFilters.getMetaInfFilter(), true); moduleSpecification.addSystemDependency(weldSubsystemDependency); // Due to serialization of EJBs ModuleDependency weldEjbDependency = new ModuleDependency(moduleLoader, JBOSS_AS_WELD_EJB_ID, true, false, false, false); weldEjbDependency.addImportFilter(PathFilters.is("org/jboss/as/weld/ejb"), true); weldEjbDependency.addImportFilter(PathFilters.acceptAll(), false); moduleSpecification.addSystemDependency(weldEjbDependency); }
deploymentResourceRoot.getExportFilters().add(new FilterSpecification(PathFilters.acceptAll(), false)); ModuleRootMarker.mark(deploymentResourceRoot, true);
/** * Construct a new instance. * * @param repoRoots the repository roots to use */ public LocalModuleFinder(final File[] repoRoots) { this(repoRoots, PathFilters.acceptAll()); }
/** * Construct a new instance. * * @param repoRoots the array of repository roots to look for modules */ public LocalModuleLoader(final File[] repoRoots) { this(repoRoots, PathFilters.acceptAll()); }
/** * Construct a new instance. * * @param repoRoots the array of repository roots to look for modules */ public LocalModuleLoader(final File[] repoRoots) { this(repoRoots, PathFilters.acceptAll()); }
/** * Create a filtered local loader. * * @param classFilter the class filter to apply to classes * @param originalLoader the original loader * @return the filtered loader */ public static IterableLocalLoader createIterableClassFilteredLocalLoader(final ClassFilter classFilter, final IterableLocalLoader originalLoader) { return new FilteredIterableLocalLoader(classFilter, PathFilters.acceptAll(), originalLoader); }
/** * Construct a new instance which accepts all paths in the resource loader. * * @param resourceLoader the resource loader to include * @return the specification */ public static ResourceLoaderSpec createResourceLoaderSpec(final ResourceLoader resourceLoader) { return new ResourceLoaderSpec(resourceLoader, PathFilters.acceptAll()); }
/** * Create a filtered local loader. * * @param classFilter the class filter to apply to classes * @param originalLoader the original loader * @return the filtered loader */ public static LocalLoader createClassFilteredLocalLoader(final ClassFilter classFilter, final LocalLoader originalLoader) { return new FilteredLocalLoader(classFilter, PathFilters.acceptAll(), originalLoader); }
/** * Construct a new instance. */ public LocalDependencySpecBuilder() { // different default import filter setImportFilter(PathFilters.acceptAll()); }
/** * Create a filtered local loader. * * @param classFilter the class filter to apply to classes * @param originalLoader the original loader * @return the filtered loader */ public static IterableLocalLoader createIterableClassFilteredLocalLoader(final ClassFilter classFilter, final IterableLocalLoader originalLoader) { return new FilteredIterableLocalLoader(classFilter, PathFilters.acceptAll(), originalLoader); }
/** * Create a filtered local loader. * * @param classFilter the class filter to apply to classes * @param originalLoader the original loader * @return the filtered loader */ public static LocalLoader createClassFilteredLocalLoader(final ClassFilter classFilter, final LocalLoader originalLoader) { return new FilteredLocalLoader(classFilter, PathFilters.acceptAll(), originalLoader); }
/** * Create a dependency on the given local loader. * * @param importFilter the import filter to apply * @param exportFilter the export filter to apply * @param localLoader the local loader * @param loaderPaths the set of paths that is exposed by the local loader * @return the dependency spec */ public static DependencySpec createLocalDependencySpec(final PathFilter importFilter, final PathFilter exportFilter, final LocalLoader localLoader, final Set<String> loaderPaths) { return createLocalDependencySpec(importFilter, exportFilter, PathFilters.acceptAll(), PathFilters.acceptAll(), ClassFilters.acceptAll(), ClassFilters.acceptAll(), localLoader, loaderPaths); }
/** * Get a class filter which uses a resource path filter to filter classes. * * @param resourcePathFilter the resource path filter * @return the class filter */ public static ClassFilter fromResourcePathFilter(final PathFilter resourcePathFilter) { return resourcePathFilter == PathFilters.acceptAll() ? acceptAll() : new PathClassFilter(resourcePathFilter); } }
/** * Set a simple export filter, based on a {@code boolean} flag. If the flag is {@code true}, the * export filter is set to {@link PathFilters#acceptAll()}, otherwise it is set to {@link PathFilters#rejectAll()}. * Any previous export filter setting is overwritten. * * @param export the export flag * @return this builder */ public DependencySpecBuilder setExport(final boolean export) { return setExportFilter(export ? PathFilters.acceptAll() : PathFilters.rejectAll()); }
/** * Create a dependency on the given class loader. * * @param importFilter the import filter to apply * @param exportFilter the export filter to apply * @param classLoader the class loader * @param loaderPaths the set of paths to use from this class loader * @return the dependency spec */ public static DependencySpec createClassLoaderDependencySpec(final PathFilter importFilter, final PathFilter exportFilter, final ClassLoader classLoader, final Set<String> loaderPaths) { return createLocalDependencySpec(importFilter, exportFilter, PathFilters.acceptAll(), PathFilters.acceptAll(), ClassFilters.acceptAll(), ClassFilters.acceptAll(), new ClassLoaderLocalLoader(classLoader), loaderPaths); }
/** * Create a dependency on the given module. * * @param identifier the module identifier * @param export {@code true} if this is a fully re-exported dependency, {@code false} if it should not be exported * @param optional {@code true} if the dependency is optional, {@code false} if it is mandatory * @return the dependency spec */ public static DependencySpec createModuleDependencySpec(final ModuleIdentifier identifier, final boolean export, final boolean optional) { return createModuleDependencySpec(PathFilters.getDefaultImportFilter(), export ? PathFilters.acceptAll() : PathFilters.rejectAll(), null, identifier, optional); }
/** * Create a dependency on the given local loader. * * @param localLoader the local loader * @param loaderPaths the set of paths that is exposed by the local loader * @param export {@code true} if this is a fully re-exported dependency, {@code false} if it should not be exported * @return the dependency spec */ public static DependencySpec createLocalDependencySpec(final LocalLoader localLoader, final Set<String> loaderPaths, boolean export) { return createLocalDependencySpec(PathFilters.acceptAll(), export ? PathFilters.getDefaultImportFilter() : PathFilters.rejectAll(), localLoader, loaderPaths); }
@Override protected void configure(ModuleLoader loader, Builder builder) { builder.addDependency(DependencySpec.createSystemDependencySpec( PathFilters.acceptAll(), PathFilters.any(Arrays.asList( PathFilters.isChildOf("javax"), PathFilters.is("org/jboss/weld"), PathFilters.isChildOf("org/jboss/weld"))), systemPaths)); }
void addModuleDependencies(final ModuleSpec.Builder builder, final ModuleLoader fatModuleLoader, final Attributes mainAttributes) { for (String dependency : dependencies) { builder.addDependency(new ModuleDependencySpecBuilder() .setImportFilter(PathFilters.acceptAll()) .setModuleLoader(fatModuleLoader) .setName(dependency) .build()); } super.addModuleDependencies(builder, fatModuleLoader, mainAttributes); }