import org.apache.ivy.core.module.descriptor.DefaultArtifact; //导入依赖的package包/类
public void publish(IvyNormalizedPublication publication, PublicationAwareRepository repository) {
    ModuleVersionPublisher publisher = repository.createPublisher();
    IvyPublicationIdentity projectIdentity = publication.getProjectIdentity();
    ModuleRevisionId moduleRevisionId = IvyUtil.createModuleRevisionId(projectIdentity.getOrganisation(), projectIdentity.getModule(), projectIdentity.getRevision());
    ModuleVersionIdentifier moduleVersionIdentifier = DefaultModuleVersionIdentifier.newId(moduleRevisionId);
    DefaultIvyModulePublishMetaData publishMetaData = new DefaultIvyModulePublishMetaData(moduleVersionIdentifier);

    try {
        for (IvyArtifact publishArtifact : publication.getArtifacts()) {
            Artifact ivyArtifact = createIvyArtifact(publishArtifact, moduleRevisionId);
            publishMetaData.addArtifact(ivyArtifact, publishArtifact.getFile());
        }

        Artifact artifact = DefaultArtifact.newIvyArtifact(moduleRevisionId, null);
        publishMetaData.addArtifact(artifact, publication.getDescriptorFile());

        publisher.publish(publishMetaData);
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}
 

import org.apache.ivy.core.module.descriptor.DefaultArtifact; //导入依赖的package包/类
public Artifact createIvyArtifact(PublishArtifact publishArtifact, ModuleRevisionId moduleRevisionId) {
    Map<String, String> extraAttributes = new HashMap<String, String>();
    if (GUtil.isTrue(publishArtifact.getClassifier())) {
        extraAttributes.put(Dependency.CLASSIFIER, publishArtifact.getClassifier());
    }
    String name = publishArtifact.getName();
    if (!GUtil.isTrue(name)) {
        name = moduleRevisionId.getName();
    }
    return new DefaultArtifact(
            moduleRevisionId,
            publishArtifact.getDate(),
            name,
            publishArtifact.getType(),
            publishArtifact.getExtension(),
            extraAttributes);
}
 

import org.apache.ivy.core.module.descriptor.DefaultArtifact; //导入依赖的package包/类
public void publish(IvyNormalizedPublication publication, PublicationAwareRepository repository) {
    ModuleVersionPublisher publisher = repository.createPublisher();
    IvyPublicationIdentity projectIdentity = publication.getProjectIdentity();
    ModuleRevisionId moduleRevisionId = IvyUtil.createModuleRevisionId(projectIdentity.getOrganisation(), projectIdentity.getModule(), projectIdentity.getRevision());
    ModuleVersionIdentifier moduleVersionIdentifier = DefaultModuleVersionIdentifier.newId(moduleRevisionId);
    DefaultModuleVersionPublishMetaData publishMetaData = new DefaultModuleVersionPublishMetaData(moduleVersionIdentifier);

    try {
        for (IvyArtifact publishArtifact : publication.getArtifacts()) {
            Artifact ivyArtifact = createIvyArtifact(publishArtifact, moduleRevisionId);
            publishMetaData.addArtifact(ivyArtifact, publishArtifact.getFile());
        }

        Artifact artifact = DefaultArtifact.newIvyArtifact(moduleRevisionId, null);
        publishMetaData.addArtifact(artifact, publication.getDescriptorFile());

        publisher.publish(publishMetaData);
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}
 

import org.apache.ivy.core.module.descriptor.DefaultArtifact; //导入依赖的package包/类
public void analyse(String pattern, DependencyAnalyser depAnalyser) {
    JarModuleFinder finder = new JarModuleFinder(pattern);
    ModuleDescriptor[] mds = depAnalyser.analyze(finder.findJarModules());
    Message.info("found " + mds.length + " modules");
    for (ModuleDescriptor md : mds) {
        File ivyFile = new File(IvyPatternHelper.substitute(
                pattern,
                DefaultArtifact.newIvyArtifact(md.getModuleRevisionId(),
                        md.getPublicationDate())));
        try {
            Message.info("generating " + ivyFile);
            XmlModuleDescriptorWriter.write(md, ivyFile);
        } catch (IOException e) {
            Message.debug(e);
        }
    }
}
 

import org.apache.ivy.core.module.descriptor.DefaultArtifact; //导入依赖的package包/类
@Override
public ResolvedResource findIvyFileRef(DependencyDescriptor dd, ResolveData data) {
    if (!isM2compatible() || !isUsepoms()) {
        return null;
    }
    ModuleRevisionId mrid = dd.getDependencyRevisionId();
    mrid = convertM2IdForResourceSearch(mrid);
    final String revision = dd.getDependencyRevisionId().getRevision();
    final MavenTimedSnapshotVersionMatcher.MavenSnapshotRevision snapshotRevision = MavenTimedSnapshotVersionMatcher.computeIfSnapshot(revision);
    if (snapshotRevision != null) {
        final ResolvedResource rres = findSnapshotDescriptor(dd, data, mrid, snapshotRevision);
        if (rres != null) {
            return rres;
        }
    }
    return findResourceUsingPatterns(mrid, getIvyPatterns(),
            DefaultArtifact.newPomArtifact(mrid, data.getDate()), getRMDParser(dd, data),
            data.getDate());
}
 

import org.apache.ivy.core.module.descriptor.DefaultArtifact; //导入依赖的package包/类
protected void putSignature(Artifact artifact, File src, String dest, boolean overwrite)
        throws IOException {
    SignatureGenerator gen = getSettings().getSignatureGenerator(signerName);
    if (gen == null) {
        throw new IllegalArgumentException("Couldn't sign the artifacts! "
                + "Unknown signer name: '" + signerName + "'");
    }

    File tempFile = File.createTempFile("ivytemp", gen.getExtension());

    try {
        gen.sign(src, tempFile);
        repository.put(
            DefaultArtifact.cloneWithAnotherTypeAndExt(artifact, gen.getExtension(),
                artifact.getExt() + "." + gen.getExtension()), tempFile,
            dest + "." + gen.getExtension(), overwrite);
    } finally {
        tempFile.delete();
    }
}
 

import org.apache.ivy.core.module.descriptor.DefaultArtifact; //导入依赖的package包/类
@Test
public void testAbortTransaction() throws Exception {
    FileSystemResolver resolver = new FileSystemResolver();
    resolver.setName("test");
    resolver.setSettings(settings);

    resolver.addIvyPattern(settings.getBaseDir()
            + "/test/repositories/1/[organisation]/[module]/[revision]/[artifact].[ext]");
    resolver.addArtifactPattern(settings.getBaseDir()
            + "/test/repositories/1/[organisation]/[module]/[revision]/[artifact]-[revision].[ext]");

    ModuleRevisionId mrid = ModuleRevisionId.newInstance("myorg", "mymodule", "myrevision");
    Artifact ivyArtifact = new DefaultArtifact(mrid, new Date(), "ivy", "ivy", "xml");
    Artifact artifact = new DefaultArtifact(mrid, new Date(), "myartifact", "mytype",
            "myext");
    File src = new File("test/repositories/ivysettings.xml");
    resolver.beginPublishTransaction(mrid, false);
    resolver.publish(ivyArtifact, src, false);
    resolver.publish(artifact, src, false);
    resolver.abortPublishTransaction();

    assertFalse(new File("test/repositories/1/myorg/mymodule/myrevision/ivy.xml").exists());
    assertFalse(new File(
            "test/repositories/1/myorg/mymodule/myrevision/myartifact-myrevision.myext")
            .exists());
}
 

import org.apache.ivy.core.module.descriptor.DefaultArtifact; //导入依赖的package包/类
/**
 * Publishing with transaction=true and an unsupported pattern must fail.
 *
 * @throws Exception if something goes wrong
 */
@Test
public void testUnsupportedTransaction() throws Exception {
    expExc.expect(IllegalStateException.class);
    expExc.expectMessage("transactional");

    FileSystemResolver resolver = new FileSystemResolver();
    resolver.setName("test");
    resolver.setSettings(settings);
    resolver.setTransactional("true");

    resolver.addArtifactPattern(
            // this pattern is not supported for transaction publish
            settings.getBaseDir()
                    + "/test/repositories/1/[organisation]/[module]/[artifact]-[revision].[ext]");

    ModuleRevisionId mrid = ModuleRevisionId.newInstance("myorg", "mymodule", "myrevision");
    Artifact artifact = new DefaultArtifact(mrid, new Date(), "myartifact", "mytype",
            "myext");
    File src = new File("test/repositories/ivysettings.xml");

    resolver.beginPublishTransaction(mrid, false);
    resolver.publish(artifact, src, false);
}
 

import org.apache.ivy.core.module.descriptor.DefaultArtifact; //导入依赖的package包/类
/**
 * Publishing with transaction=true and overwrite mode must fail.
 *
 * @throws Exception if something goes wrong
 */
@Test
public void testUnsupportedTransaction3() throws Exception {
    expExc.expect(IllegalStateException.class);
    expExc.expectMessage("transactional");

    FileSystemResolver resolver = new FileSystemResolver();
    resolver.setName("test");
    resolver.setSettings(settings);
    resolver.setTransactional("true");

    resolver.addArtifactPattern(settings.getBaseDir()
            + "/test/repositories/1/[organisation]/[module]/[revision]/[artifact]-[revision].[ext]");

    ModuleRevisionId mrid = ModuleRevisionId.newInstance("myorg", "mymodule", "myrevision");
    Artifact artifact = new DefaultArtifact(mrid, new Date(), "myartifact", "mytype",
            "myext");
    File src = new File("test/repositories/ivysettings.xml");

    // overwrite transaction not supported
    resolver.beginPublishTransaction(mrid, true);
    resolver.publish(artifact, src, true);
}
 

import org.apache.ivy.core.module.descriptor.DefaultArtifact; //导入依赖的package包/类
public void publish(IvyModulePublishMetadata moduleVersion) {
    for (IvyModuleArtifactPublishMetadata artifactMetadata : moduleVersion.getArtifacts()) {
        IvyArtifactName artifact = artifactMetadata.getArtifactName();
        ModuleRevisionId moduleRevisionId = IvyUtil.createModuleRevisionId(artifactMetadata.getId().getComponentIdentifier());
        Map<String, String> attributes = Collections.singletonMap("classifier", artifact.getClassifier());
        Artifact ivyArtifact = new DefaultArtifact(moduleRevisionId, null, artifact.getName(), artifact.getType(), artifact.getExtension(), attributes);
        collectArtifact(ivyArtifact, artifactMetadata.getFile());
    }
    publish();
}
 

import org.apache.ivy.core.module.descriptor.DefaultArtifact; //导入依赖的package包/类
private static org.fedoraproject.xmvn.artifact.Artifact ivy2aether( ModuleRevisionId revision, String extension )
{
    String groupId = revision.getOrganisation();
    String artifactId = revision.getName();
    String classifier = revision.getExtraAttribute( "classifier" );
    String version = revision.getRevision();

    return new org.fedoraproject.xmvn.artifact.DefaultArtifact( groupId, artifactId, extension, classifier,
                                                                version );
}
 

import org.apache.ivy.core.module.descriptor.DefaultArtifact; //导入依赖的package包/类
@Override
public ResolvedResource findIvyFileRef( DependencyDescriptor depDescriptor, ResolveData data )
{
    Artifact artifact = DefaultArtifact.newIvyArtifact( depDescriptor.getDependencyRevisionId(), null );

    ResolutionRequest request = new ResolutionRequest();
    request.setArtifact( ivy2aether( artifact.getModuleRevisionId(), "pom" ) );
    ResolutionResult result = getResolver().resolve( request );
    Path pomPath = result.getArtifactPath();
    if ( pomPath == null )
        return null;

    Resource fileResource = new FileResource( new FileRepository(), pomPath.toFile() );
    return new ResolvedResource( fileResource, resolvedVersion( result ) );
}
 

import org.apache.ivy.core.module.descriptor.DefaultArtifact; //导入依赖的package包/类
static Artifact toPublishedArtifact(JkIvyPublication.Artifact artifact,
        ModuleRevisionId moduleId, Instant date) {
    final String artifactName = JkUtilsString.isBlank(artifact.name) ? moduleId.getName()
            : artifact.name;
    final String extension = JkUtilsObject.firstNonNull(artifact.extension, "");
    final String type = JkUtilsObject.firstNonNull(artifact.type, extension);
    return new DefaultArtifact(moduleId, new Date(date.toEpochMilli()), artifactName, type, extension);
}
 

import org.apache.ivy.core.module.descriptor.DefaultArtifact; //导入依赖的package包/类
private static Artifact toPublishedMavenArtifact(Path artifact, String artifactName,
                                                 String classifier, ModuleRevisionId moduleId, Instant date) {
    final String extension = JkUtilsString.substringAfterLast(artifact.getFileName().toString(), ".");
    final Map<String, String> extraMap;
    if (classifier == null) {
        extraMap = new HashMap<>();
    } else {
        extraMap = JkUtilsIterable.mapOf(EXTRA_PREFIX + ":classifier", classifier);
    }
    return new DefaultArtifact(moduleId, new Date(date.toEpochMilli()), artifactName, extension, extension, extraMap);
}
 

import org.apache.ivy.core.module.descriptor.DefaultArtifact; //导入依赖的package包/类
private Artifact createIvyArtifact(IvyArtifact ivyArtifact, ModuleRevisionId moduleRevisionId) {
    Map<String, String> extraAttributes = new HashMap<String, String>();
    if (GUtil.isTrue(ivyArtifact.getClassifier())) {
        extraAttributes.put(Dependency.CLASSIFIER, ivyArtifact.getClassifier());
    }
    return new DefaultArtifact(
            moduleRevisionId,
            null,
            GUtil.elvis(ivyArtifact.getName(), moduleRevisionId.getName()),
            ivyArtifact.getType(),
            ivyArtifact.getExtension(),
            extraAttributes);
}
 

import org.apache.ivy.core.module.descriptor.DefaultArtifact; //导入依赖的package包/类
public MutableModuleVersionMetaData createModuleDescriptor(ModuleRevisionId moduleRevisionId, Set<ModuleDependency> dependencies) {
    DefaultModuleDescriptor moduleDescriptor = new DefaultModuleDescriptor(moduleRevisionId,
            "release", null);
    moduleDescriptor.addConfiguration(new Configuration(Dependency.DEFAULT_CONFIGURATION));
    addDependencyDescriptors(moduleDescriptor, dependencies, dependencyDescriptorFactory);
    moduleDescriptor.addArtifact(Dependency.DEFAULT_CONFIGURATION,
            new DefaultArtifact(moduleRevisionId, null, moduleRevisionId.getName(), "jar", "jar"));
    return new ModuleDescriptorAdapter(moduleDescriptor);
}
 

import org.apache.ivy.core.module.descriptor.DefaultArtifact; //导入依赖的package包/类
@Override
protected List<Artifact> createWorkspaceArtifacts(ModuleDescriptor md) {
    List<Artifact> res = new ArrayList<>();

    for (WorkspaceArtifact wa : artifacts) {
        String name = wa.name;
        String type = wa.type;
        String ext = wa.ext;
        String path = wa.path;
        if (name == null) {
            name = md.getModuleRevisionId().getName();
        }
        if (type == null) {
            type = "jar";
        }
        if (ext == null) {
            ext = "jar";
        }
        if (path == null) {
            path = "target" + File.separator + "dist" + File.separator + type + "s"
                    + File.separator + name + "." + ext;
        }

        URL url;
        File ivyFile = md2IvyFile.get(md);
        File artifactFile = new File(ivyFile.getParentFile(), path);
        try {
            url = artifactFile.toURI().toURL();
        } catch (MalformedURLException e) {
            throw new RuntimeException("Unsupported file path : " + artifactFile, e);
        }

        res.add(new DefaultArtifact(md.getModuleRevisionId(), new Date(), name, type, ext,
                url, null));
    }

    return res;
}
 

import org.apache.ivy.core.module.descriptor.DefaultArtifact; //导入依赖的package包/类
private boolean isDependencyModuleExcluded(DependencyDescriptor dd, String rootModuleConf,
        ModuleRevisionId dependencyRevisionId, String conf) {
    Artifact a = DefaultArtifact.newIvyArtifact(dependencyRevisionId, null);
    if (isRoot()) {
        // no callers, but maybe some exclude
        Boolean exclude = doesExclude(md, rootModuleConf, new String[] {rootModuleConf}, dd, a,
            new Stack<ModuleRevisionId>());
        return exclude != null && exclude;
    }
    return callers.doesCallersExclude(rootModuleConf, a);
}
 

import org.apache.ivy.core.module.descriptor.DefaultArtifact; //导入依赖的package包/类
private ArtifactOrigin getDefaultMetadataArtifactOrigin(ModuleRevisionId mrid) {
    final String location;
    try {
        location = this.getIvyFileInCache(mrid).toURI().toURL().toExternalForm();
    } catch (MalformedURLException e) {
        throw new RuntimeException("Failed to determine artifact origin for " + mrid);
    }
    // it's important to say the origin is not local to make sure it won't ever be used for
    // anything else than original token
    return new ArtifactOrigin(DefaultArtifact.newIvyArtifact(mrid, null), false, location);
}
 

import org.apache.ivy.core.module.descriptor.DefaultArtifact; //导入依赖的package包/类
public String toString() {
    if (origin == null) {
        ModuleRevisionId revId = ModuleRevisionId.newInstance(org, moduleName, branch,
            revision, extraModuleAttributes);
        Artifact artifact = new DefaultArtifact(revId, null, artifactName, artifactType,
                artifactExt, extraArtifactAttributes);

        // TODO cache: see how we could know which actual cache manager to use, since this
        // will fail when using a resolver in a chain with a specific cache manager
        RepositoryCacheManager cacheManager = IvyContext.getContext().getSettings()
                .getResolver(revId).getRepositoryCacheManager();

        origin = cacheManager.getSavedArtifactOrigin(artifact);

        if (ArtifactOrigin.isUnknown(origin)) {
            Message.debug("no artifact origin found for " + artifact + " in "
                    + cacheManager);
            return null;
        }
    }

    if (ArtifactOrigin.isUnknown(origin)) {
        return null;
    }

    // we assume that the original filename is the last part of the original file location
    String location = origin.getLocation();
    int lastPathIndex = location.lastIndexOf('/');
    if (lastPathIndex == -1) {
        lastPathIndex = location.lastIndexOf('\\');
    }
    int lastColonIndex = location.lastIndexOf('.');

    return location.substring(lastPathIndex + 1, lastColonIndex);
}