@Override public void deploy(final DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException { final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit(); final ModuleSpecification moduleSpecification = deploymentUnit.getAttachment(Attachments.MODULE_SPECIFICATION); final ModuleLoader moduleLoader = Module.getBootModuleLoader(); moduleSpecification.addSystemDependency(new ModuleDependency(moduleLoader, batchModule, false, false, false, false)); moduleSpecification.addSystemDependency(new ModuleDependency(moduleLoader, jberetModule, false, false, true, false)); }
/** * 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)); } }
final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit(); final ModuleSpecification moduleSpecification = deploymentUnit.getAttachment(Attachments.MODULE_SPECIFICATION); final ServiceModuleLoader loader = deploymentUnit.getAttachment(Attachments.SERVICE_MODULE_LOADER); if (!DeploymentTypeMarker.isType(DeploymentType.WAR, deploymentUnit)) { return; // Skip non web deployments WarMetaData warMetaData = deploymentUnit.getAttachment(WarMetaData.ATTACHMENT_KEY); assert warMetaData != null; final Module module = deploymentUnit.getAttachment(Attachments.MODULE); throw UndertowLogger.ROOT_LOGGER.failedToResolveModule(deploymentUnit); final ClassLoader classLoader = module.getClassLoader(); ScisMetaData scisMetaData = deploymentUnit.getAttachment(ScisMetaData.ATTACHMENT_KEY); if (scisMetaData == null) { for (ModuleDependency dependency : moduleSpecification.getAllDependencies()) { if (!dependency.isImportServices()) { continue; Module depModule = loader.loadModule(dependency.getIdentifier()); ServiceLoader<ServletContainerInitializer> serviceLoader = depModule.loadService(ServletContainerInitializer.class); for (ServletContainerInitializer service : serviceLoader) { if(sciClasses.add(service.getClass())) { if (!dependency.isOptional()) { throw UndertowLogger.ROOT_LOGGER.errorLoadingSCIFromModule(dependency.getIdentifier().toString(), e);
private void addJSFImpl(String jsfVersion, ModuleSpecification moduleSpecification, ModuleLoader moduleLoader) { if (jsfVersion.equals(JsfVersionMarker.WAR_BUNDLES_JSF_IMPL)) return; ModuleIdentifier jsfModule = moduleIdFactory.getImplModId(jsfVersion); ModuleDependency jsfImpl = new ModuleDependency(moduleLoader, jsfModule, false, false, true, false); jsfImpl.addImportFilter(PathFilters.getMetaInfFilter(), true); moduleSpecification.addSystemDependency(jsfImpl); }
/** * Add POJO module if we have any bean factories. * * @param phaseContext the deployment unit context * @throws org.jboss.as.server.deployment.DeploymentUnitProcessingException */ @Override public void deploy(DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException { final DeploymentUnit unit = phaseContext.getDeploymentUnit(); final List<KernelDeploymentXmlDescriptor> kdXmlDescriptors = unit.getAttachment(KernelDeploymentXmlDescriptor.ATTACHMENT_KEY); if (kdXmlDescriptors == null || kdXmlDescriptors.isEmpty()) return; for (KernelDeploymentXmlDescriptor kdxd : kdXmlDescriptors) { if (kdxd.getBeanFactoriesCount() > 0) { final ModuleSpecification moduleSpecification = unit.getAttachment(Attachments.MODULE_SPECIFICATION); final ModuleLoader moduleLoader = Module.getBootModuleLoader(); ModuleDependency dependency = new ModuleDependency(moduleLoader, POJO_MODULE, false, false, false, false); PathFilter filter = PathFilters.isChildOf(BaseBeanFactory.class.getPackage().getName()); dependency.addImportFilter(filter, true); dependency.addImportFilter(PathFilters.rejectAll(), false); moduleSpecification.addSystemDependency(dependency); return; } } }
final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit(); final ServiceModuleLoader deploymentModuleLoader = deploymentUnit.getAttachment(Attachments.SERVICE_MODULE_LOADER); final List<ResourceRoot> allResourceRoots = DeploymentUtils.allResourceRoots(deploymentUnit); continue; if(deploymentUnit.getParent() == null && SubDeploymentMarker.isSubDeployment(resourceRoot)) { final ModuleIdentifier dependencyId = ModuleIdentifier.fromString(dependencyParts[0]); final boolean export = containsParam(dependencyParts, EXPORT_PARAM); final boolean optional = containsParam(dependencyParts, OPTIONAL_PARAM); final boolean metaInf = containsParam(dependencyParts, META_INF); final ModuleLoader dependencyLoader; if (dependencyId.getName().startsWith("deployment.")) { dependencyLoader = deploymentModuleLoader; } else { dependencyLoader = Module.getBootModuleLoader(); deploymentUnit.addToAttachmentList(Attachments.ADDITIONAL_ANNOTATION_INDEXES, dependencyId); final ModuleDependency dependency = new ModuleDependency(dependencyLoader, dependencyId, optional, export, services, true); if(metaInf) { dependency.addImportFilter(PathFilters.getMetaInfSubdirectoriesFilter(), true); dependency.addImportFilter(PathFilters.getMetaInfFilter(), true); deploymentUnit.addToAttachmentList(Attachments.MANIFEST_DEPENDENCIES, dependency);
@Override public void deploy(final DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException { final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit(); final ModuleSpecification moduleSpecification = deploymentUnit.getAttachment(Attachments.MODULE_SPECIFICATION); final List<GlobalModule> globalMods = this.globalModules; for (final GlobalModule module : globalMods) { final ModuleDependency dependency = new ModuleDependency(Module.getBootModuleLoader(), module.getModuleIdentifier(), false, false, module.isServices(), false); if (module.isMetaInf()) { dependency.addImportFilter(PathFilters.getMetaInfSubdirectoriesFilter(), true); dependency.addImportFilter(PathFilters.getMetaInfFilter(), true); } if(module.isAnnotations()) { deploymentUnit.addToAttachmentList(Attachments.ADDITIONAL_ANNOTATION_INDEXES, module.getModuleIdentifier()); } moduleSpecification.addSystemDependency(dependency); } }
@Override public void deploy(DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException { final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit(); ModuleSpecification moduleSpecification = deploymentUnit.getAttachment(Attachments.MODULE_SPECIFICATION); if (!SwitchYardDeploymentMarker.isSwitchYardDeployment(deploymentUnit)) { return; } ModuleLoader moduleLoader = Module.getBootModuleLoader(); ModuleDependency dep = new ModuleDependency(moduleLoader, ModuleIdentifier.fromString(_moduleId), false, false, true, false); dep.addImportFilter(META_INF_FILTER, true); moduleSpecification.addSystemDependency(dep); if (WeldDeploymentMarker.isPartOfWeldDeployment(deploymentUnit) && (deploymentUnit.getParent() != null)) { final EarMetaData earConfig = deploymentUnit.getParent().getAttachment(org.jboss.as.ee.structure.Attachments.EAR_METADATA); if (earConfig != null) { final ModuleIdentifier beanComponent = deploymentUnit.getParent().getAttachment(SwitchYardMetaData.BEAN_COMPONENT_ATTACHMENT_KEY); if (beanComponent == null) { moduleLoader = Module.getBootModuleLoader(); moduleSpecification = deploymentUnit.getParent().getAttachment(Attachments.MODULE_SPECIFICATION); dep = new ModuleDependency(moduleLoader, SWITCHYARD_BEAN_ID, false, false, true, false); dep.addImportFilter(META_INF_FILTER, true); moduleSpecification.addSystemDependency(dep); deploymentUnit.getParent().putAttachment(SwitchYardMetaData.BEAN_COMPONENT_ATTACHMENT_KEY, SWITCHYARD_BEAN_ID); } } } }
@Override public void deploy(DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException { final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit(); final DeploymentUnit parent = deploymentUnit.getParent() == null ? deploymentUnit : deploymentUnit.getParent(); final ModuleSpecification parentModuleSpec = parent.getAttachment(Attachments.MODULE_SPECIFICATION); final ModuleSpecification moduleSpec = deploymentUnit.getAttachment(Attachments.MODULE_SPECIFICATION); if (parentModule != null) { ModuleDependency moduleDependency = new ModuleDependency(moduleLoader, parentModule, false, false, true, false); moduleDependency.addImportFilter(PathFilters.acceptAll(), true); moduleSpec.addLocalDependency(moduleDependency); for (AdditionalModuleSpecification module : deploymentUnit.getAttachmentList(Attachments.ADDITIONAL_MODULES)) { module.addLocalDependency(new ModuleDependency(moduleLoader, moduleIdentifier, false, false, true, false)); for (DeploymentUnit subDeployment : subDeployments) { final ModuleSpecification subModule = subDeployment.getAttachment(Attachments.MODULE_SPECIFICATION); if (!subModule.isPrivateModule() && (!parentModuleSpec.isSubDeploymentModulesIsolated() || subModule.isPublicModule())) { ModuleIdentifier identifier = subDeployment.getAttachment(Attachments.MODULE_IDENTIFIER); ModuleDependency dependency = new ModuleDependency(moduleLoader, identifier, false, false, true, false); dependency.addImportFilter(PathFilters.acceptAll(), true); accessibleModules.add(dependency); if (!dependency.getIdentifier().equals(moduleIdentifier)) { moduleSpec.addLocalDependency(dependency);
@Override public void deploy(DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException { final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit(); final DeploymentUnit parent = Utils.getRootDeploymentUnit(deploymentUnit); final ServiceTarget serviceTarget = phaseContext.getServiceTarget(); final ResourceRoot deploymentRoot = deploymentUnit.getAttachment(Attachments.DEPLOYMENT_ROOT); if (!WeldDeploymentMarker.isPartOfWeldDeployment(deploymentUnit)) { if (deploymentUnit.getParent() == null && CdiAnnotationMarker.cdiAnnotationsPresent(deploymentUnit)) { WeldLogger.DEPLOYMENT_LOGGER.cdiAnnotationsButNotBeanArchive(deploymentUnit.getName()); WeldLogger.DEPLOYMENT_LOGGER.startingServicesForCDIDeployment(phaseContext.getDeploymentUnit().getName()); final Module module = deploymentUnit.getAttachment(Attachments.MODULE); final BeanDeploymentModule rootBeanDeploymentModule = deploymentUnit.getAttachment(WeldAttachments.BEAN_DEPLOYMENT_MODULE); putIfValueNotNull(eeModuleDescriptors, module.getIdentifier(), rootBeanDeploymentModule.getModuleDescriptor()); bdmsByIdentifier.put(module.getIdentifier(), rootBeanDeploymentModule); moduleSpecByIdentifier.put(module.getIdentifier(), moduleSpecification); continue; // the root module only has access to itself for (ModuleDependency dependency : bdmSpec.getSystemDependencies()) { BeanDeploymentModule other = bdmsByIdentifier.get(dependency.getIdentifier()); if (other != null && other != bdm) { bdm.addBeanDeploymentModule(other);
/** * 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); }
@Override public void deploy(final DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException { final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit(); final ModuleSpecification moduleSpec = deploymentUnit.getAttachment(org.jboss.as.server.deployment.Attachments.MODULE_SPECIFICATION); final Map<ModuleIdentifier, DeploymentUnit> deployments = new HashMap<ModuleIdentifier, DeploymentUnit>(); //local classes are always first deploymentUnit.addToAttachmentList(Attachments.ACCESSIBLE_SUB_DEPLOYMENTS, deploymentUnit); buildModuleMap(deploymentUnit, deployments); for (final ModuleDependency dependency : moduleSpec.getAllDependencies()) { final DeploymentUnit sub = deployments.get(dependency.getIdentifier()); if (sub != null) { deploymentUnit.addToAttachmentList(Attachments.ACCESSIBLE_SUB_DEPLOYMENTS, sub); } } }
@Override public void deploy(final DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException { final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit(); final ModuleSpecification moduleSpecification = deploymentUnit.getAttachment(Attachments.MODULE_SPECIFICATION); final ModuleLoader loader = deploymentUnit.getAttachment(Attachments.SERVICE_MODULE_LOADER); moduleSpecification.addSystemDependency(new ModuleDependency(loader, CORBA_ID, false, true, true, false)); moduleSpecification.addSystemDependency(new ModuleDependency(loader, XNIO, false, true, true, false)); final Set<ModuleIdentifier> moduleIdentifiers = new HashSet<ModuleIdentifier>(); final DeploymentUnit top = deploymentUnit.getParent() == null ? deploymentUnit : deploymentUnit.getParent(); moduleIdentifiers.add(top.getAttachment(Attachments.MODULE_IDENTIFIER)); for(final DeploymentUnit module : top.getAttachmentList(Attachments.SUB_DEPLOYMENTS)) { moduleIdentifiers.add(module.getAttachment(Attachments.MODULE_IDENTIFIER)); } final ListIterator<ModuleDependency> iterator = moduleSpecification.getMutableUserDependencies().listIterator(); while (iterator.hasNext()) { final ModuleDependency dep = iterator.next(); final ModuleIdentifier identifier = dep.getIdentifier(); if(identifier.getName().startsWith(ServiceModuleLoader.MODULE_PREFIX) && !identifier.getName().startsWith(ExtensionIndexService.MODULE_PREFIX)) { if(!moduleIdentifiers.contains(identifier)) { iterator.remove(); } } } }
private void addDeploymentDependencies(DeploymentUnit depUnit, CamelDeploymentSettings depSettings) { ModuleLoader moduleLoader = depUnit.getAttachment(Attachments.SERVICE_MODULE_LOADER); ModuleSpecification moduleSpec = depUnit.getAttachment(Attachments.MODULE_SPECIFICATION); moduleSpec.addUserDependency(new ModuleDependency(moduleLoader, ModuleIdentifier.create(WILDFLY_CAMEL_MODULE), false, false, false, false)); // Add camel aggregator dependency ModuleDependency moddep = new ModuleDependency(moduleLoader, ModuleIdentifier.create(APACHE_CAMEL_MODULE), false, false, true, false); moddep.addImportFilter(PathFilters.getMetaInfFilter(), true); moduleSpec.addUserDependency(moddep); List<String> deploymentDefinedModules = depSettings.getModuleDependencies(); if (!deploymentDefinedModules.isEmpty()) { for (String modid : deploymentDefinedModules) { moduleSpec.addUserDependency(new ModuleDependency(moduleLoader, modid, false, false, true, false)); } } else { moddep = new ModuleDependency(moduleLoader, ModuleIdentifier.create(APACHE_CAMEL_COMPONENT_MODULE), false, false, true, false); moddep.addImportFilter(PathFilters.getMetaInfFilter(), true); moddep.addImportFilter(PathFilters.isOrIsChildOf("META-INF/cxf"), true); moduleSpec.addUserDependency(moddep); moddep = new ModuleDependency(moduleLoader, ModuleIdentifier.create(APACHE_CAMEL_COMPONENT_CDI_MODULE), true, false, false, false); moddep.addImportFilter(PathFilters.getMetaInfSubdirectoriesFilter(), true); moddep.addImportFilter(PathFilters.getMetaInfFilter(), true); moduleSpec.addUserDependency(moddep); } }
private void addJSFInjection(String jsfVersion, ModuleSpecification moduleSpecification, ModuleLoader moduleLoader) throws DeploymentUnitProcessingException { if (jsfVersion.equals(JsfVersionMarker.WAR_BUNDLES_JSF_IMPL)) return; ModuleIdentifier jsfInjectionModule = moduleIdFactory.getInjectionModId(jsfVersion); ModuleDependency jsfInjectionDependency = new ModuleDependency(moduleLoader, jsfInjectionModule, false, true, true, false); try { if (isJSF12(jsfInjectionDependency, jsfInjectionModule.toString())) { JSFLogger.ROOT_LOGGER.loadingJsf12(); jsfInjectionDependency.addImportFilter(PathFilters.is("META-INF/faces-config.xml"), false); jsfInjectionDependency.addImportFilter(PathFilters.is("META-INF/1.2/faces-config.xml"), true); } else { JSFLogger.ROOT_LOGGER.loadingJsf2x(); jsfInjectionDependency.addImportFilter(PathFilters.getMetaInfFilter(), true); // Exclude JSF 1.2 faces-config.xml to make extra sure it won't interfere with JSF 2.0 deployments jsfInjectionDependency.addImportFilter(PathFilters.is("META-INF/1.2/faces-config.xml"), false); } } catch (ModuleLoadException e) { throw JSFLogger.ROOT_LOGGER.jsfInjectionFailed(jsfVersion); } moduleSpecification.addSystemDependency(jsfInjectionDependency); }
private void addDependency(ModuleSpecification moduleSpecification, ModuleLoader moduleLoader, ModuleIdentifier moduleIdentifier, boolean optional) { moduleSpecification.addSystemDependency(new ModuleDependency(moduleLoader, moduleIdentifier, optional, false, true, false)); }
private void addDependency(ModuleSpecification moduleSpecification, ModuleLoader moduleLoader, ModuleIdentifier moduleIdentifier, boolean optional, boolean deploymentBundelesClientBuilder) { ModuleDependency dependency = new ModuleDependency(moduleLoader, moduleIdentifier, optional, false, true, false); if(deploymentBundelesClientBuilder) { dependency.addImportFilter(PathFilters.is(CLIENT_BUILDER), false); } moduleSpecification.addSystemDependency(dependency); }
@Override public ServiceName createModuleService(XBundleRevision brev, List<BundleWire> wires) { Deployment deployment = brev.getBundle().adapt(Deployment.class); DeploymentUnit depUnit = deployment.getAttachment(DeploymentUnit.class); // Add a dependency on the parent module if we have one List<ModuleDependency> dependencies = new ArrayList<ModuleDependency>(); if (depUnit != null && depUnit.getParent() != null) { String parentName = depUnit.getParent().getName(); ModuleIdentifier depId = ModuleIdentifier.create(MODULE_PREFIX + parentName); dependencies.add(new ModuleDependency(null, depId, false, false, false, false)); } // Add dependencies on all modules this brev has a wire to for (BundleWire wire : wires) { XBundleRevision provider = (XBundleRevision) wire.getProvider(); ModuleIdentifier providerid = provider.getModuleIdentifier(); dependencies.add(new ModuleDependency(null, providerid, false, false, false, false)); } ModuleIdentifier identifier = brev.getModuleIdentifier(); return ModuleLoadService.install(serviceTarget, identifier, dependencies); }
private void createDependencies(final ModuleSpec.Builder specBuilder, final List<ModuleDependency> apiDependencies, final boolean requireTransitive) { if (apiDependencies != null) { for (final ModuleDependency dependency : apiDependencies) { final boolean export = requireTransitive ? true : dependency.isExport(); final List<FilterSpecification> importFilters = dependency.getImportFilters(); final List<FilterSpecification> exportFilters = dependency.getExportFilters(); final PathFilter importFilter; final PathFilter exportFilter; final MultiplePathFilterBuilder importBuilder = PathFilters.multiplePathFilterBuilder(true); for (final FilterSpecification filter : importFilters) { importBuilder.addFilter(filter.getPathFilter(), filter.isInclude()); if (dependency.isImportServices()) { importBuilder.addFilter(PathFilters.getMetaInfServicesFilter(), true); importBuilder.addFilter(PathFilters.getMetaInfSubdirectoriesFilter(), false); importBuilder.addFilter(PathFilters.getMetaInfFilter(), false); importFilter = importBuilder.create(); .getModuleLoader(), dependency.getIdentifier(), dependency.isOptional()); specBuilder.addDependency(depSpec); logger.debugf("Adding dependency %s to module %s", dependency, specBuilder.getIdentifier());
private static boolean hasCxfModuleDependency(DeploymentUnit unit) { final ModuleSpecification moduleSpec = unit.getAttachment(Attachments.MODULE_SPECIFICATION); for (ModuleDependency dep : moduleSpec.getUserDependencies()) { final String id = dep.getIdentifier().getName(); if (cxfExportingModules.contains(id)) { return true; } } return false; }