Java ResolveOptions类代码示例

import org.apache.ivy.core.resolve.ResolveOptions; //导入依赖的package包/类
private void genreport(ResolutionCacheManager cache, String organisation, String module) {
    // first process the report with xslt
    XSLTProcess xslt = new XSLTProcess();
    xslt.setTaskName(getTaskName());
    xslt.setProject(getProject());
    xslt.init();

    String resolveId = ResolveOptions.getDefaultResolveId(new ModuleId(organisation, module));
    xslt.setIn(cache.getConfigurationResolveReportInCache(resolveId, "default"));
    xslt.setOut(new File(getTodir(), outputname + "." + xslext));

    xslt.setStyle(xslFile);

    XSLTProcess.Param xslExt = xslt.createParam();
    xslExt.setName("extension");
    xslExt.setExpression(xslext);

    // add the provided XSLT parameters
    for (XSLTProcess.Param param : params) {
        XSLTProcess.Param realParam = xslt.createParam();
        realParam.setName(param.getName());
        realParam.setExpression(param.getExpression());
    }

    xslt.execute();
}
 

import org.apache.ivy.core.resolve.ResolveOptions; //导入依赖的package包/类
public void doExecute() throws BuildException {
    prepareAndCheck();

    try {
        ResolutionCacheManager cacheMgr = getIvyInstance().getResolutionCacheManager();
        String resolveId = getResolveId();
        if (resolveId == null) {
            resolveId = ResolveOptions.getDefaultResolveId(getResolvedModuleId());
        }
        XmlReportParser parser = new XmlReportParser();
        for (String conf : splitToArray(getConf())) {
            File report = cacheMgr.getConfigurationResolveReportInCache(resolveId, conf);
            parser.parse(report);

            for (Artifact artifact : parser.getArtifacts()) {
                String name = IvyPatternHelper.substitute(getSettings().substitute(getName()),
                        artifact, conf);
                String value = IvyPatternHelper.substitute(
                        getSettings().substitute(getValue()), artifact, conf);
                setProperty(name, value);
            }
        }
    } catch (Exception ex) {
        throw new BuildException("impossible to add artifact properties: " + ex, ex);
    }
}
 

import org.apache.ivy.core.resolve.ResolveOptions; //导入依赖的package包/类
/**
 * Test case for IVY-1478.
 * {@link RetrieveEngine} must retrieve artifacts with the correct extension if the artifact
 * is unpacked.
 *
 * @throws Exception if something goes wrong
 * @see <a href="https://issues.apache.org/jira/browse/IVY-1478">IVY-1478</a>
 */
@Test
public void testUnpackExt() throws Exception {
    final ResolveOptions roptions = getResolveOptions(new String[] {"*"});

    final URL url = new File("test/repositories/1/packaging/module10/ivys/ivy-1.0.xml").toURI()
            .toURL();

    // normal resolve, the file goes in the cache
    final ResolveReport report = ivy.resolve(url, roptions);
    assertFalse("Resolution report has errors", report.hasError());
    final ModuleDescriptor md = report.getModuleDescriptor();
    assertNotNull("Module descriptor from report was null", md);

    final String pattern = "build/test/retrieve/[organization]/[module]/[conf]/[type]s/[artifact]-[revision](.[ext])";

    ivy.retrieve(md.getModuleRevisionId(),
        getRetrieveOptions().setDestArtifactPattern(pattern));

    final File dest = new File("build/test/retrieve/packaging/module9/default/jars/module9-1.0.jar");
    assertTrue("Retrieved artifact is missing at " + dest.getAbsolutePath(), dest.exists());
    assertTrue("Retrieved artifact at " + dest.getAbsolutePath() + " is not a file", dest.isFile());
}
 

import org.apache.ivy.core.resolve.ResolveOptions; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
    settings = new IvySettings();
    engine = new ResolveEngine(settings, new EventManager(), new SortEngine(settings));
    data = new ResolveData(engine, new ResolveOptions());
    TestHelper.createCache();
    settings.setDefaultCache(TestHelper.cache);
    settings.setVariable("test.mirroredurl.mirrorlist-solo.url",
        this.getClass().getResource("mirrorlist-solo.txt").toExternalForm());
    settings.setVariable("test.mirroredurl.mirrorlist-failover.url", this.getClass()
            .getResource("mirrorlist-failover.txt").toExternalForm());
    settings.setVariable("test.mirroredurl.mirrorlist-fail.url",
        this.getClass().getResource("mirrorlist-fail.txt").toExternalForm());
    new XmlSettingsParser(settings).parse(MirroredURLResolverTest.class
            .getResource("mirror-resolver-settings.xml"));
}
 

import org.apache.ivy.core.resolve.ResolveOptions; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
    Message.setDefaultLogger(new DefaultMessageLogger(99));

    settings = new IvySettings();
    ResolveEngine engine = new ResolveEngine(settings, new EventManager(), new SortEngine(
            settings));
    cache = new File("build/cache");
    data = new ResolveData(engine, new ResolveOptions());
    cache.mkdirs();
    settings.setDefaultCache(cache);

    // Create work space with build and resource cache directories
    workdir = new File("build/test/PackagerResolverTest");
    builddir = new File(workdir, "build");
    cachedir = new File(workdir, "resources");
    cleanupTempDirs();
    if (!builddir.mkdirs() || !cachedir.mkdirs()) {
        throw new Exception("can't create directories under " + workdir);
    }
}
 

import org.apache.ivy.core.resolve.ResolveOptions; //导入依赖的package包/类
/**
 * Configures resolve options
 * 
 * @return configured resolveOptions
 */
protected ResolveOptions configureResolveOptions() {
    // Here we do not specify explicit configuration to resolve as
    // we want to check multiple configurations.
    // If we make specify explicitly configurations to resolve, the
    // resolution could through exceptions when configuration does
    // not exist in resolved modules.
    // resolveOptions.setConfs(new String[] { mainConf,providedConf });

    // By default we consider that main conf is default.
    // To verify core compliance we can have a dependency on
    // easyant-core in a specific configuration.
    // By default this configuration is provided.

    // An error can be thrown if module contains non-public configurations.
    ResolveOptions resolveOptions = new ResolveOptions();
    resolveOptions.setLog(getResolveLog());

    Boolean offline = Boolean.valueOf(getProject().getProperty(EasyAntMagicNames.EASYANT_OFFLINE));
    resolveOptions.setUseCacheOnly(offline);
    return resolveOptions;
}
 

import org.apache.ivy.core.resolve.ResolveOptions; //导入依赖的package包/类
/**
 * Try to load a resolve report. If not found, not available, out of date or contains resolve errors, it returns
 * <code>null</code>.
 */
private XmlReportParser getResolveReport(Ivy ivy, ModuleId mid, String conf, File ivyfile) {
    File report = ivy.getResolutionCacheManager().getConfigurationResolveReportInCache(
            ResolveOptions.getDefaultResolveId(mid), conf);
    if (!report.exists()) {
        return null;
    }
    if (ivyfile != null && ivyfile.lastModified() > report.lastModified()) {
        return null;
    }
    // found a report, try to parse it.
    try {
        log("Reading resolve report " + report, Project.MSG_DEBUG);
        XmlReportParser reportparser = new XmlReportParser();
        reportparser.parse(report);
        if (reportparser.hasError()) {
            return null;
        }
        log("Loading last resolve report for " + mid + "[" + conf + "]", Project.MSG_VERBOSE);
        return reportparser;
    } catch (ParseException e) {
        return null;
    }
}
 

import org.apache.ivy.core.resolve.ResolveOptions; //导入依赖的package包/类
/**
 * Populate the map of artifact. The map should be populated by metadata in cache as this is
 * called in the refresh process.
 *
 * @param ivy Ivy
 * @param parser XmlReportParser
 * @param result ResolveResult
 * @throws ParseException if parser fails
 */
private void findAllArtifactOnRefresh(Ivy ivy, XmlReportParser parser, ResolveResult result)
        throws ParseException {
    ModuleRevisionId[] dependencyMrids = parser.getDependencyRevisionIds();
    IvyDEMessage.verbose("Resolve report parsed. Fetching artifacts of "
            + dependencyMrids.length + " dependencie(s)");
    for (ModuleRevisionId dependencyMrid : dependencyMrids) {
        DependencyResolver depResolver = ivy.getSettings().getResolver(dependencyMrid);
        DefaultDependencyDescriptor depDescriptor = new DefaultDependencyDescriptor(
                dependencyMrid, false);
        ResolveOptions options = new ResolveOptions();
        options.setRefresh(true);
        options.setUseCacheOnly(true);
        IvyDEMessage.debug("Fetching dependency " + dependencyMrid);
        ResolvedModuleRevision dependency = depResolver.getDependency(depDescriptor,
            new ResolveData(ivy.getResolveEngine(), options));
        if (dependency != null) {
            Artifact[] artifacts = dependency.getDescriptor().getAllArtifacts();
            IvyDEMessage.debug("Dependency " + dependencyMrid + " found: "
                    + artifacts.length + " artifact(s) found");
            result.putArtifactsForDep(dependencyMrid, artifacts);
        } else {
            IvyDEMessage.debug("Dependency " + dependencyMrid + " not found");
        }
    }
}
 

import org.apache.ivy.core.resolve.ResolveOptions; //导入依赖的package包/类
/**
 * Build the resolve id used when reading and writing resolve reports.
 *
 * @param useExtendedResolveId
 *            boolean indicating if extended resolve id is being used.
 * @param md
 *            The ModuleDescriptor to be resolved.
 * @return The resolve id.
 */
public static String buildResolveId(boolean useExtendedResolveId, ModuleDescriptor md) {
    StringBuilder sb = new StringBuilder(ResolveOptions.getDefaultResolveId(md));
    if (useExtendedResolveId) {
        ModuleRevisionId mrid = md.getModuleRevisionId();
        String sts = md.getStatus();
        String bch = mrid.getBranch();
        String rev = mrid.getRevision();
        sb.append("-");
        if (sts != null) {
            sb.append(sts);
        }
        sb.append("-");
        if (bch != null) {
            sb.append(bch);
        }
        sb.append("-");
        if (rev != null) {
            sb.append(rev);
        }
    }
    return sb.toString();
}
 

import org.apache.ivy.core.resolve.ResolveOptions; //导入依赖的package包/类
private ResolveOptions newResolveOptions(String[] confs, String revision, File cache, Date date,
        boolean validate, boolean useCacheOnly, boolean transitive, boolean useOrigin,
        boolean download, boolean outputReport, Filter<Artifact> artifactFilter) {
    if (useOrigin) {
        ivy.getSettings().useDeprecatedUseOrigin();
    }
    return new ResolveOptions().setConfs(confs).setRevision(revision).setValidate(validate)
            .setUseCacheOnly(useCacheOnly).setTransitive(transitive).setDownload(download)
            .setOutputReport(outputReport).setArtifactFilter(artifactFilter);
}
 

import org.apache.ivy.core.resolve.ResolveOptions; //导入依赖的package包/类
public ResolveReport resolve(ModuleRevisionId mrid, ResolveOptions options, boolean changing)
        throws ParseException, IOException {
    pushContext();
    try {
        return resolveEngine.resolve(mrid, options, changing);
    } finally {
        popContext();
    }
}
 

import org.apache.ivy.core.resolve.ResolveOptions; //导入依赖的package包/类
public ResolvedModuleRevision findModule(ModuleRevisionId mrid) {
    pushContext();
    try {
        ResolveOptions options = new ResolveOptions();
        options.setValidate(false);
        return resolveEngine.findModule(mrid, options);
    } finally {
        popContext();
    }
}
 

import org.apache.ivy.core.resolve.ResolveOptions; //导入依赖的package包/类
private void gen(ResolutionCacheManager cache, String organisation, String module,
        String style, String ext) {
    XSLTProcess xslt = new XSLTProcess();
    xslt.setTaskName(getTaskName());
    xslt.setProject(getProject());
    xslt.init();

    String resolveId = ResolveOptions.getDefaultResolveId(new ModuleId(organisation, module));
    xslt.setIn(cache.getConfigurationResolveReportInCache(resolveId, "default"));
    xslt.setOut(new File(getTodir(), outputname + "." + ext));
    xslt.setBasedir(cache.getResolutionCacheRoot());
    xslt.setStyle(style);
    xslt.execute();
}
 

import org.apache.ivy.core.resolve.ResolveOptions; //导入依赖的package包/类
private ResolveOptions getResolveOptions(Ivy ivy, String[] confs, IvySettings settings) {
    if (useOrigin) {
        settings.useDeprecatedUseOrigin();
    }
    return ((ResolveOptions) new ResolveOptions().setLog(log)).setConfs(confs)
            .setValidate(doValidate(settings))
            .setArtifactFilter(FilterHelper.getArtifactTypeFilter(type)).setRevision(revision)
            .setDate(getPubDate(pubdate, null)).setUseCacheOnly(useCacheOnly)
            .setRefresh(refresh).setTransitive(transitive).setResolveMode(resolveMode)
            .setResolveId(resolveId).setCheckIfChanged(checkIfChanged);
}
 

import org.apache.ivy.core.resolve.ResolveOptions; //导入依赖的package包/类
public ResolverManifestIterator() {
    organisations = resolver.listOrganisations();
    IvySettings settings = new IvySettings();
    ResolveEngine engine = new ResolveEngine(settings, new EventManager(), new SortEngine(
            settings));
    data = new ResolveData(engine, new ResolveOptions());
}