Java ModuleDescriptor类代码示例

import org.apache.ivy.core.module.descriptor.ModuleDescriptor; //导入依赖的package包/类
private void mergeWithOtherModuleDescriptor(List<String> extendTypes, ModuleDescriptor parent) {

            if (extendTypes.contains("all")) {
                mergeAll(parent);
            } else {
                if (extendTypes.contains("info")) {
                    mergeInfo(parent);
                }

                if (extendTypes.contains("configurations")) {
                    mergeConfigurations(parent.getModuleRevisionId(), parent.getConfigurations());
                }

                if (extendTypes.contains("dependencies")) {
                    mergeDependencies(parent.getDependencies());
                }

                if (extendTypes.contains("description")) {
                    mergeDescription(parent.getDescription());
                }
            }
        }
 

import org.apache.ivy.core.module.descriptor.ModuleDescriptor; //导入依赖的package包/类
private void mergeInfo(ModuleDescriptor parent) {
    ModuleRevisionId parentMrid = parent.getModuleRevisionId();

    DefaultModuleDescriptor descriptor = getMd();
    ModuleRevisionId currentMrid = descriptor.getModuleRevisionId();

    ModuleRevisionId mergedMrid = createModuleRevisionId(
            mergeValue(parentMrid.getOrganisation(), currentMrid.getOrganisation()),
            currentMrid.getName(),
            mergeValue(parentMrid.getBranch(), currentMrid.getBranch()),
            mergeValue(parentMrid.getRevision(), currentMrid.getRevision()),
            mergeValues(parentMrid.getQualifiedExtraAttributes(), currentMrid.getQualifiedExtraAttributes())
    );

    descriptor.setModuleRevisionId(mergedMrid);
    descriptor.setResolvedModuleRevisionId(mergedMrid);

    descriptor.setStatus(mergeValue(parent.getStatus(), descriptor.getStatus()));
    if (descriptor.getNamespace() == null && parent instanceof DefaultModuleDescriptor) {
        Namespace parentNamespace = ((DefaultModuleDescriptor) parent).getNamespace();
        descriptor.setNamespace(parentNamespace);
    }
}
 

import org.apache.ivy.core.module.descriptor.ModuleDescriptor; //导入依赖的package包/类
public static ModuleDescriptorState forIvyModuleDescriptor(ModuleDescriptor ivyDescriptor) {
    ModuleRevisionId moduleRevisionId = ivyDescriptor.getModuleRevisionId();
    ModuleComponentIdentifier componentIdentifier = DefaultModuleComponentIdentifier.newId(moduleRevisionId.getOrganisation(), moduleRevisionId.getName(), moduleRevisionId.getRevision());
    MutableModuleDescriptorState state = new MutableModuleDescriptorState(componentIdentifier, ivyDescriptor.getStatus(), ivyDescriptor.isDefault());

    state.setBranch(moduleRevisionId.getBranch());
    state.setDescription(ivyDescriptor.getDescription());
    state.setPublicationDate(ivyDescriptor.getPublicationDate());
    Map<NamespaceId, String> extraInfo = Cast.uncheckedCast(ivyDescriptor.getExtraInfo());
    state.getExtraInfo().putAll(extraInfo);

    for (ExcludeRule excludeRule : ivyDescriptor.getAllExcludeRules()) {
        addExcludeRule(state, excludeRule);
    }

    return state;
}
 

import org.apache.ivy.core.module.descriptor.ModuleDescriptor; //导入依赖的package包/类
private void deployEffectivePom( ModuleRevisionId moduleRevisionId, Path artifactPath )
    throws IOException
{
    try
    {
        File pomFile = artifactPath.resolveSibling( artifactPath.getName( artifactPath.getNameCount() - 1 )
            + "-xmvn.pom" ).toFile();
        ModuleDescriptorParser parser = XmlModuleDescriptorParser.getInstance();
        ModuleDescriptor module =
            parser.parseDescriptor( getSettings(), artifactPath.toFile().toURI().toURL(), false );
        PomModuleDescriptorWriter.write( module, pomFile, new PomWriterOptions() );

        org.fedoraproject.xmvn.artifact.Artifact artifact = ivy2aether( moduleRevisionId, "pom" );
        deploy( artifact, null, artifactPath );
    }
    catch ( ParseException e )
    {
        throw new IOException( e );
    }
}
 

import org.apache.ivy.core.module.descriptor.ModuleDescriptor; //导入依赖的package包/类
private int publishIvyArtifacts(JkIvyPublication publication, Instant date,
        ModuleDescriptor moduleDescriptor) {
    int count = 0;
    for (final DependencyResolver resolver : IvyTranslations.publishResolverOf(this.ivy
            .getSettings())) {
        final JkPublishRepo publishRepo = this.publishRepos.getRepoHavingUrl(IvyTranslations
                .publishResolverUrl(resolver));
        final JkVersionedModule jkModule = IvyTranslations
                .toJkVersionedModule(moduleDescriptor.getModuleRevisionId());
        if (!isMaven(resolver) && publishRepo.filter().accept(jkModule)) {
            JkLog.startln("Publishing for repository " + resolver);
            this.publishIvyArtifacts(resolver, publication, date, moduleDescriptor);
            JkLog.done();
            count++;
        }
    }
    return count;
}
 

import org.apache.ivy.core.module.descriptor.ModuleDescriptor; //导入依赖的package包/类
private Path createIvyFile(ModuleDescriptor moduleDescriptor) {
    try {
        final ModuleRevisionId mrId = moduleDescriptor.getModuleRevisionId();
        final Path file;
        if (this.descriptorOutputDir != null) {
            file = this.descriptorOutputDir.toPath().resolve("published-ivy-" + mrId.getOrganisation()
            + "-" + mrId.getName() + "-" + mrId.getRevision() + ".xml");
        } else {
            file = JkUtilsPath.createTempFile("published-ivy-", ".xml");
        }
        moduleDescriptor.toIvyFile(file.toFile());
        return file;
    } catch (final IOException | ParseException e) {
        throw new RuntimeException(e);
    }

}
 

import org.apache.ivy.core.module.descriptor.ModuleDescriptor; //导入依赖的package包/类
public Set<ConfigurationMetaData> resolveTargetConfigurations(DependencyMetaData dependencyMetaData, ConfigurationMetaData fromConfiguration, ComponentResolveMetaData targetComponent) {
    // TODO - resolve directly to config meta data
    ModuleDescriptor targetDescriptor = targetComponent.getDescriptor();
    DependencyDescriptor dependencyDescriptor = dependencyMetaData.getDescriptor();
    Set<String> targetConfigurationNames = new LinkedHashSet<String>();
    for (String config : dependencyDescriptor.getModuleConfigurations()) {
        if (config.equals("*") || config.equals("%")) {
            collectTargetConfiguration(dependencyDescriptor, fromConfiguration, fromConfiguration.getName(), targetDescriptor, targetConfigurationNames);
        } else if (fromConfiguration.getHierarchy().contains(config)) {
            collectTargetConfiguration(dependencyDescriptor, fromConfiguration, config, targetDescriptor, targetConfigurationNames);
        }
    }

    Set<ConfigurationMetaData> targets = new LinkedHashSet<ConfigurationMetaData>();
    for (String targetConfigurationName : targetConfigurationNames) {
        // TODO - move this down below
        if (targetDescriptor.getConfiguration(targetConfigurationName) == null) {
            throw new RuntimeException(String.format("Module version %s, configuration '%s' declares a dependency on configuration '%s' which is not declared in the module descriptor for %s",
                    fromConfiguration.getComponent().getId(), fromConfiguration.getName(),
                    targetConfigurationName, targetComponent.getId()));
        }
        ConfigurationMetaData targetConfiguration = targetComponent.getConfiguration(targetConfigurationName);
        targets.add(targetConfiguration);
    }
    return targets;
}
 

import org.apache.ivy.core.module.descriptor.ModuleDescriptor; //导入依赖的package包/类
private void collectTargetConfiguration(DependencyDescriptor dependencyDescriptor, ConfigurationMetaData fromConfiguration, String mappingRhs, ModuleDescriptor targetModule, Collection<String> targetConfigs) {
    String[] dependencyConfigurations = dependencyDescriptor.getDependencyConfigurations(mappingRhs, fromConfiguration.getName());
    for (String target : dependencyConfigurations) {
        String candidate = target;
        int startFallback = candidate.indexOf('(');
        if (startFallback >= 0) {
            if (candidate.charAt(candidate.length() - 1) == ')') {
                String preferred = candidate.substring(0, startFallback);
                if (targetModule.getConfiguration(preferred) != null) {
                    targetConfigs.add(preferred);
                    continue;
                }
                candidate = candidate.substring(startFallback + 1, candidate.length() - 1);
            }
        }
        if (candidate.equals("*")) {
            Collections.addAll(targetConfigs, targetModule.getPublicConfigurationsNames());
            continue;
        }
        targetConfigs.add(candidate);
    }
}
 

import org.apache.ivy.core.module.descriptor.ModuleDescriptor; //导入依赖的package包/类
public EnhancedDependencyDescriptor createDependencyDescriptor(String configuration, ModuleDependency dependency, ModuleDescriptor parent) {
    ModuleRevisionId moduleRevisionId = createModuleRevisionId(dependency);
    ClientModule clientModule = getClientModule(dependency);
    MutableModuleVersionMetaData moduleVersionMetaData = clientModuleMetaDataFactory.createModuleDescriptor(
            moduleRevisionId, clientModule.getDependencies());

    EnhancedDependencyDescriptor dependencyDescriptor = new ClientModuleDependencyDescriptor(
            clientModule,
            parent,
            moduleVersionMetaData,
            moduleRevisionId,
            clientModule.isForce(),
            false,
            clientModule.isTransitive());
    addExcludesArtifactsAndDependencies(configuration, clientModule, dependencyDescriptor);
    return dependencyDescriptor;
}
 

import org.apache.ivy.core.module.descriptor.ModuleDescriptor; //导入依赖的package包/类
public Set<ConfigurationMetaData> resolveTargetConfigurations(DependencyMetaData dependencyMetaData, ConfigurationMetaData fromConfiguration, ComponentMetaData targetComponent) {
    // TODO - resolve directly to config meta data
    ModuleDescriptor targetDescriptor = targetComponent.getDescriptor();
    DependencyDescriptor dependencyDescriptor = dependencyMetaData.getDescriptor();
    Set<String> targetConfigurationNames = new LinkedHashSet<String>();
    for (String config : dependencyDescriptor.getModuleConfigurations()) {
        if (config.equals("*") || config.equals("%")) {
            collectTargetConfiguration(dependencyDescriptor, fromConfiguration, fromConfiguration.getName(), targetDescriptor, targetConfigurationNames);
        } else if (fromConfiguration.getHierarchy().contains(config)) {
            collectTargetConfiguration(dependencyDescriptor, fromConfiguration, config, targetDescriptor, targetConfigurationNames);
        }
    }

    Set<ConfigurationMetaData> targets = new LinkedHashSet<ConfigurationMetaData>();
    for (String targetConfigurationName : targetConfigurationNames) {
        // TODO - move this down below
        if (targetDescriptor.getConfiguration(targetConfigurationName) == null) {
            throw new RuntimeException(String.format("Module version %s, configuration '%s' declares a dependency on configuration '%s' which is not declared in the module descriptor for %s",
                    fromConfiguration.getComponent().getId(), fromConfiguration.getName(),
                    targetConfigurationName, targetComponent.getId()));
        }
        ConfigurationMetaData targetConfiguration = targetComponent.getConfiguration(targetConfigurationName);
        targets.add(targetConfiguration);
    }
    return targets;
}
 

import org.apache.ivy.core.module.descriptor.ModuleDescriptor; //导入依赖的package包/类
private static MavenArtifactInfo gatherInfoFromIvyFile(File file) {
    MavenArtifactInfo result = null;
    try {
        IvyService ivyService = ContextHelper.get().beanForType(IvyService.class);
        ModuleDescriptor ivyDescriptor = ivyService.parseIvyFile(file);
        if (ivyDescriptor != null) {
            ModuleRevisionId ivyModule = ivyDescriptor.getModuleRevisionId();
            result = new MavenArtifactInfo();
            result.setGroupId(ivyModule.getOrganisation());
            result.setArtifactId(ivyModule.getName());
            result.setVersion(ivyModule.getRevision());
            result.setClassifier("ivy");
            result.setType(MavenArtifactInfo.XML);
        } else {
            log.debug("Failed to read ivy model from '{}'", file.getName());
        }
    } catch (Exception e) {
        log.debug("Failed to read ivy model from '{}'. Cause: {}.", file.getName(), e.getMessage());
    }
    return result;
}
 

import org.apache.ivy.core.module.descriptor.ModuleDescriptor; //导入依赖的package包/类
@Test
public void testEjbType() throws Exception {
    ModuleDescriptor md = PomModuleDescriptorParser.getInstance().parseDescriptor(settings,
        getClass().getResource("test-ejb-type.pom"), false);
    assertNotNull(md);

    ModuleRevisionId mrid = ModuleRevisionId.newInstance("org.apache", "test-ejb-type", "1.0");
    assertEquals(mrid, md.getModuleRevisionId());

    DependencyDescriptor[] deps = md.getDependencies();
    assertNotNull(deps);
    assertEquals(1, deps.length);

    DependencyArtifactDescriptor[] artifacts = deps[0].getAllDependencyArtifacts();
    assertNotNull(artifacts);
    assertEquals(1, artifacts.length);
    assertEquals("test", artifacts[0].getName());
    assertEquals("jar", artifacts[0].getExt());
    assertEquals("ejb", artifacts[0].getType());
}
 

import org.apache.ivy.core.module.descriptor.ModuleDescriptor; //导入依赖的package包/类
@Test
public void testNoPublication() throws Exception {
    ModuleDescriptor md = XmlModuleDescriptorParser.getInstance().parseDescriptor(settings,
        getClass().getResource("test-nopublication.xml"), true);
    assertNotNull(md);
    assertEquals("myorg", md.getModuleRevisionId().getOrganisation());
    assertEquals("mymodule", md.getModuleRevisionId().getName());
    assertEquals("myrev", md.getModuleRevisionId().getRevision());
    assertEquals("integration", md.getStatus());
    Date pubdate = new GregorianCalendar(2004, 10, 1, 11, 0, 0).getTime();
    assertEquals(pubdate, md.getPublicationDate());

    assertNotNull(md.getConfigurations());
    assertEquals(Collections.singletonList(new Configuration("default")),
        Arrays.asList(md.getConfigurations()));

    assertNotNull(md.getArtifacts("default"));
    assertEquals(1, md.getArtifacts("default").length);

    assertNotNull(md.getDependencies());
    assertEquals(1, md.getDependencies().length);
}
 

import org.apache.ivy.core.module.descriptor.ModuleDescriptor; //导入依赖的package包/类
@Test
public void testResolveWithExcludesArtifacts3() throws Exception {
    // mod2.3 depends on mod2.1 and excludes artifacts with exact matcher
    ResolveReport report = ivy.resolve(new File(
            "test/repositories/1/org2/mod2.3/ivys/ivy-0.6.3.xml"),
        getResolveOptions(new String[] {"*"}));
    assertNotNull(report);
    ModuleDescriptor md = report.getModuleDescriptor();
    assertNotNull(md);
    ModuleRevisionId mrid = ModuleRevisionId.newInstance("org2", "mod2.3", "0.6.3");
    assertEquals(mrid, md.getModuleRevisionId());

    assertTrue(getResolvedIvyFileInCache(mrid).exists());

    assertTrue(getIvyFileInCache(ModuleRevisionId.newInstance("org2", "mod2.1", "0.3"))
            .exists());
    assertTrue(getArchiveFileInCache("org2", "mod2.1", "0.3", "art21A", "jar", "jar").exists());
    assertFalse(getArchiveFileInCache("org2", "mod2.1", "0.3", "art21B", "jar", "jar").exists());
    assertFalse(getArchiveFileInCache("org2", "mod2.1", "0.3", "mod2.1", "jar", "jar").exists());
}
 

import org.apache.ivy.core.module.descriptor.ModuleDescriptor; //导入依赖的package包/类
/**
 * Adds the current node to the toKeep collection and then processes the each of the direct
 * dependencies of this node that appear in the moduleIdMap (indicating that the dependency is
 * part of this BuildList)
 *
 * @param node
 *            the node to be processed
 * @param toKeep
 *            the set of ModuleDescriptors that should be kept
 * @param moduleIdMap
 *            reference mapping of moduleId to ModuleDescriptor that are part of the BuildList
 */
private void processFilterNodeFromRoot(ModuleDescriptor node, Set<ModuleDescriptor> toKeep,
        Map<ModuleId, ModuleDescriptor> moduleIdMap) {
    // toKeep.add(node);
    for (DependencyDescriptor dep : node.getDependencies()) {
        ModuleId id = dep.getDependencyId();
        ModuleDescriptor md = moduleIdMap.get(id);
        // we test if this module id has a module descriptor, and if it isn't already in the
        // toKeep Set, in which there's probably a circular dependency
        if (md != null && !toKeep.contains(md)) {
            toKeep.add(md);
            if (!getOnlydirectdep()) {
                processFilterNodeFromRoot(md, toKeep, moduleIdMap);
            }
        }
    }
}