Examples of org.apache.ivy.core.module.descriptor.DependencyDescriptor

Package org.apache.ivy.core.module.descriptor

Examples of org.apache.ivy.core.module.descriptor.DependencyDescriptor

org.apache.ivy.core.module.descriptor.DependencyDescriptor
Describes a dependency from a depender to a dependee.
The main information this descriptor contains is the constraint on the dependency. There is actually two kind of dependency constraints: the default dependency constraint, which can be obtained with {@link #getDependencyRevisionId()}, and corresponds to the rev attribute in Ivy files. This is the constraint as it should be honored by Ivy in default resolve mode.

Then there is the dynamic constraint, which can either be the same as the default constraint, or the original dependency constraint when an Ivy file is delivered an published to a repository. This dynamic constraint is returned by {@link #getDynamicConstraintDependencyRevisionId()}, and corresponds to the revconstraint attribute in the Ivy file. In some resolve mode, this constraint can be used instead of the default dependency constraint when performing dependency resolution.

        DependencyDescriptor[] dependencies = md.getDependencies();
        assertNotNull(dependencies);
        assertEquals(2, dependencies.length);


        // no conf def => defaults to defaultConf defined in imported file: *->@
        DependencyDescriptor dd = getDependency(dependencies, "mymodule1");
        assertEquals(Arrays.asList(new String[] {"*"}), Arrays.asList(dd.getModuleConfigurations()));
        assertEquals(Arrays.asList(new String[] {"conf1"}), Arrays.asList(dd
                .getDependencyConfigurations("conf1")));
        assertEquals(Arrays.asList(new String[] {"conf2"}), Arrays.asList(dd
                .getDependencyConfigurations("conf2")));


        // confs def: conf1->*
        dd = getDependency(dependencies, "mymodule2");
        assertEquals(Arrays.asList(new String[] {"conf1"}), Arrays.asList(dd
                .getModuleConfigurations()));
        assertEquals(Arrays.asList(new String[] {"*"}), Arrays.asList(dd
                .getDependencyConfigurations("conf1")));
    }

View Full Code Here

        DependencyDescriptor[] dependencies = md.getDependencies();
        assertNotNull(dependencies);
        assertEquals(2, dependencies.length);


        // no conf def => defaults to defaultConf: *->*
        DependencyDescriptor dd = getDependency(dependencies, "mymodule1");
        assertEquals(Arrays.asList(new String[] {"*"}), Arrays.asList(dd.getModuleConfigurations()));
        assertEquals(Arrays.asList(new String[] {"*"}), Arrays.asList(dd
                .getDependencyConfigurations("conf1")));


        // confs def: conf1->*
        dd = getDependency(dependencies, "mymodule2");
        assertEquals(Arrays.asList(new String[] {"conf1"}), Arrays.asList(dd
                .getModuleConfigurations()));
        assertEquals(Arrays.asList(new String[] {"*"}), Arrays.asList(dd
                .getDependencyConfigurations("conf1")));
    }

View Full Code Here

        DependencyDescriptor[] dependencies = md.getDependencies();
        assertNotNull(dependencies);
        assertEquals(2, dependencies.length);


        // confs dep1: conf1->A;conf2->B (mappingoverride = true)
        DependencyDescriptor dd = getDependency(dependencies, "mymodule1");
        assertEquals(Arrays.asList(new String[] {"conf1", "conf2"}), Arrays.asList(dd
                .getModuleConfigurations()));
        assertEquals(Arrays.asList(new String[] {"A"}), Arrays.asList(dd
                .getDependencyConfigurations("conf1")));
        assertEquals(Arrays.asList(new String[] {"B"}), Arrays.asList(dd
                .getDependencyConfigurations("conf2")));


        // confs dep2: conf2->B
        dd = getDependency(dependencies, "mymodule2");
        assertEquals(Arrays.asList(new String[] {"conf2"}), Arrays.asList(dd
                .getModuleConfigurations()));
        assertEquals(Arrays.asList(new String[] {"B"}), Arrays.asList(dd
                .getDependencyConfigurations("conf2")));
    }

View Full Code Here

        DependencyDescriptor[] dependencies = md.getDependencies();
        assertNotNull(dependencies);
        assertEquals(2, dependencies.length);


        // confs dep1: all-public->all-public (mappingoverride = true)
        DependencyDescriptor dd = getDependency(dependencies, "mymodule1");
        assertEquals(Arrays.asList(new String[] {"all-public"}), Arrays.asList(dd
                .getModuleConfigurations()));
        assertEquals(Arrays.asList(new String[] {"all-public"}), Arrays.asList(dd
                .getDependencyConfigurations("all-public")));


        // confs dep2: extra->extra;all-public->all-public (mappingoverride = true)
        dd = getDependency(dependencies, "mymodule2");
        assertEquals(Arrays.asList(new String[] {"extra", "all-public"}), Arrays.asList(dd
                .getModuleConfigurations()));
        assertEquals(Arrays.asList(new String[] {"extra"}), Arrays.asList(dd
                .getDependencyConfigurations("extra")));
        assertEquals(Arrays.asList(new String[] {"all-public"}), Arrays.asList(dd
                .getDependencyConfigurations("all-public")));
    }

View Full Code Here

        DependencyDescriptor[] dependencies = md.getDependencies();
        assertNotNull(dependencies);
        assertEquals(3, dependencies.length);


        // confs dep1: *->default1,default3
        DependencyDescriptor dd = getDependency(dependencies, "mymodule1");
        assertEquals(Arrays.asList(new String[] {"*"}), Arrays.asList(dd.getModuleConfigurations()));
        assertEquals(Arrays.asList(new String[] {"default1", "default3"}), Arrays.asList(dd
                .getDependencyConfigurations("default")));


        // confs dep2: test->default2,default3
        dd = getDependency(dependencies, "mymodule2");
        assertEquals(Arrays.asList(new String[] {"test"}), Arrays.asList(dd
                .getModuleConfigurations()));
        assertEquals(Arrays.asList(new String[] {"default2", "default3"}), Arrays.asList(dd
                .getDependencyConfigurations("test")));


        // confs dep3: *->default4
        dd = getDependency(dependencies, "mymodule3");
        assertEquals(Arrays.asList(new String[] {"*"}), Arrays.asList(dd.getModuleConfigurations()));
        assertEquals(Arrays.asList(new String[] {"default4"}), Arrays.asList(dd
                .getDependencyConfigurations("bla")));
    }

View Full Code Here


    public ResolvedModuleRevision getDependency(DependencyDescriptor dd, ResolveData data)
            throws ParseException {
        IvyContext.getContext().pushResolver(this);
        try {
            DependencyDescriptor systemDd = dd;
            dd = fromSystem(dd);


            clearIvyAttempts();
            clearArtifactAttempts();
            boolean downloaded = false;
            boolean searched = false;
            ModuleRevisionId mrid = dd.getDependencyRevisionId();
            // check revision
            int index = mrid.getRevision().indexOf("@");
            if (index != -1 && !mrid.getRevision().substring(index + 1).equals(workspaceName)) {
                Message.verbose("\t" + getName() + ": unhandled revision => " + mrid.getRevision());
                return null;
            }


            boolean isDynamic = getSettings().getVersionMatcher().isDynamic(mrid);
            if (isDynamic && !acceptLatest()) {
                Message.error("dynamic revisions not handled by " + getClass().getName()
                        + ". impossible to resolve " + mrid);
                return null;
            }


            boolean isChangingRevision = getChangingMatcher().matches(mrid.getRevision());
            boolean isChangingDependency = isChangingRevision || dd.isChanging();


            // if we do not have to check modified and if the revision is exact and not changing,
            // we first search for it in cache
            ResolvedModuleRevision cachedRmr = null;
            boolean checkedCache = false;
            if (!isDynamic && !isCheckmodified() && !isChangingDependency) {
                cachedRmr = findModuleInCache(data, mrid);
                checkedCache = true;
                if (cachedRmr != null) {
                    if (cachedRmr.getDescriptor().isDefault() && cachedRmr.getResolver() != this) {
                        Message.verbose("\t" + getName() + ": found revision in cache: " + mrid
                                + " (resolved by " + cachedRmr.getResolver().getName()
                                + "): but it's a default one, maybe we can find a better one");
                    } else {
                        Message.verbose("\t" + getName() + ": revision in cache: " + mrid);
                        return toSystem(cachedRmr);
                    }
                }
            }
            checkInterrupted();
            URL cachedIvyURL = null;
            ResolvedResource ivyRef = findIvyFileRef(dd, data);
            checkInterrupted();
            searched = true;


            // get module descriptor
            ModuleDescriptorParser parser;
            ModuleDescriptor md;
            ModuleDescriptor systemMd = null;
            if (ivyRef == null) {
                if (!isAllownomd()) {
                    Message.verbose("\t" + getName() + ": no ivy file found for " + mrid);
                    return null;
                }
                parser = XmlModuleDescriptorParser.getInstance();
                md = DefaultModuleDescriptor.newDefaultInstance(mrid, dd
                        .getAllDependencyArtifacts());
                ResolvedResource artifactRef = findFirstArtifactRef(md, dd, data);
                checkInterrupted();
                if (artifactRef == null) {
                    Message.verbose("\t" + getName() + ": no ivy file nor artifact found for "
                            + mrid);
                    if (!checkedCache) {
                        cachedRmr = findModuleInCache(data, mrid);
                    }
                    if (cachedRmr != null) {
                        Message.verbose("\t" + getName() + ": revision in cache: " + mrid);
                        return toSystem(cachedRmr);
                    }
                    return null;
                } else {
                    long lastModified = artifactRef.getLastModified();
                    if (lastModified != 0 && md instanceof DefaultModuleDescriptor) {
                        ((DefaultModuleDescriptor) md).setLastModified(lastModified);
                    }
                    Message.verbose("\t" + getName() + ": no ivy file found for " + mrid
                            + ": using default data");
                    if (isDynamic) {
                        md.setResolvedModuleRevisionId(ModuleRevisionId.newInstance(mrid,
                            artifactRef.getRevision()));
                    }
                }
            } else {
                ResolvedModuleRevision rmr = null;
                if (ivyRef instanceof MDResolvedResource) {
                    rmr = ((MDResolvedResource) ivyRef).getResolvedModuleRevision();
                }
                if (rmr == null) {
                    rmr = parse(ivyRef, dd, data);
                    if (rmr == null) {
                        return null;
                    }
                }
                if (!rmr.isDownloaded()) {
                    return toSystem(rmr);
                } else {
                    md = rmr.getDescriptor();
                    parser = ModuleDescriptorParserRegistry.getInstance().getParser(
                        ivyRef.getResource());
                    cachedIvyURL = rmr.getLocalMDUrl();


                    // check descriptor data is in sync with resource revision and names
                    systemMd = toSystem(md);
                    if (checkconsistency) {
                        checkDescriptorConsistency(mrid, md, ivyRef);
                        checkDescriptorConsistency(systemDd.getDependencyRevisionId(), systemMd,
                            ivyRef);
                    } else {
                        if (md instanceof DefaultModuleDescriptor) {
                            String revision = getRevision(ivyRef, mrid, md);
                            ((DefaultModuleDescriptor) md).setModuleRevisionId(ModuleRevisionId
                                    .newInstance(mrid, revision));
                        } else {
                            Message.warn(
                              "consistency disabled with instance of non DefaultModuleDescriptor..."
                              + " module info can't be updated, so consistency check will be done");
                            checkDescriptorConsistency(mrid, md, ivyRef);
                            checkDescriptorConsistency(systemDd.getDependencyRevisionId(),
                                systemMd, ivyRef);
                        }
                    }
                }
            }

View Full Code Here

        if (conflicts.size() < 2) {
            return conflicts;
        }
        for (Iterator iter = conflicts.iterator(); iter.hasNext();) {
            IvyNode node = (IvyNode) iter.next();
            DependencyDescriptor dd = node.getDependencyDescriptor(parent);
            if (dd != null && dd.isForce()
                    && parent.getResolvedId().equals(dd.getParentRevisionId())) {
                return Collections.singleton(node);
            }
        }
        try {
            ArtifactInfo latest = getStrategy().findLatest(toArtifactInfo(conflicts), null);

View Full Code Here

                            + ": check your configuration");
                    return false;
                }
                try {
                    Message.debug("\tusing " + resolver + " to resolve " + getId());
                    DependencyDescriptor dependencyDescriptor = getDependencyDescriptor(parent);
                    data.getEventManager().fireIvyEvent(
                        new StartResolveDependencyEvent(resolver, dependencyDescriptor));
                    module = resolver.getDependency(dependencyDescriptor, data);
                    data.getEventManager().fireIvyEvent(
                        new EndResolveDependencyEvent(resolver, dependencyDescriptor, module));
                    if (module != null) {
                        data.getCacheManager().saveResolver(module.getDescriptor(),
                            module.getResolver().getName());
                        data.getCacheManager().saveArtResolver(module.getDescriptor(),
                            module.getArtifactResolver().getName());
                        if (settings.logModuleWhenFound()) {
                            Message.info("\tfound " + module.getId() + " in "
                                    + module.getResolver().getName());
                        } else {
                            Message.verbose("\tfound " + module.getId() + " in "
                                    + module.getResolver().getName());
                        }


                        if (data.getSettings().getVersionMatcher().isDynamic(getId())) {
                            // IVY-56: check if revision has actually been resolved
                            if (data.getSettings().getVersionMatcher().isDynamic(module.getId())) {
                                Message
                                        .error("impossible to resolve dynamic revision for "
                                                + getId()
                                                + ": check your configuration and make sure revision is part of your pattern");
                                problem = new RuntimeException(
                                        "impossible to resolve dynamic revision");
                                return false;
                            }
                            IvyNode resolved = data.getNode(module.getId());
                            if (resolved != null) {
                                // exact revision has already been resolved
                                // => update it and discard this node
                                md = module.getDescriptor(); // needed for handleConfiguration
                                if (!handleConfiguration(loaded, rootModuleConf, parent,
                                    parentConf, conf, shouldBePublic)) {
                                    return false;
                                }


                                if (resolved.md == null) {
                                    resolved.md = md;
                                }
                                if (resolved.module == null) {
                                    resolved.module = module;
                                }
                                resolved.downloaded |= module.isDownloaded();
                                resolved.searched |= module.isSearched();
                                resolved.dds.putAll(dds);
                                resolved.updateDataFrom(this, rootModuleConf);
                                resolved.loadData(rootModuleConf, parent, parentConf, conf,
                                    shouldBePublic);
                                DependencyDescriptor dd = dependencyDescriptor;
                                if (dd != null) {
                                    resolved.addDependencyArtifacts(rootModuleConf, dd
                                            .getDependencyArtifacts(parentConf));
                                    resolved.addDependencyIncludes(rootModuleConf, dd
                                            .getIncludeRules(parentConf));
                                }
                                data.replaceNode(getId(), resolved, rootModuleConf); // this
                                // actually
                                // discards
                                // the node


                                if (settings.logResolvedRevision()) {
                                    Message.info("\t[" + module.getId().getRevision() + "] "
                                            + getId());
                                } else {
                                    Message.verbose("\t[" + module.getId().getRevision() + "] "
                                            + getId());
                                }


                                return true;
                            }
                        }
                        downloaded = module.isDownloaded();
                        searched = module.isSearched();
                    } else {
                        Message.warn("\tmodule not found: " + getId());
                        resolver.reportFailure();
                        problem = new RuntimeException("not found");
                    }
                } catch (Exception e) {
                    problem = e;
                }


                // still not resolved, report error
                if (module == null) {
                    return false;
                } else {
                    loaded = true;
                    if (settings.getVersionMatcher().isDynamic(getId())) {
                        if (settings.logResolvedRevision()) {
                            Message.info("\t[" + module.getId().getRevision() + "] " + getId());
                        } else {
                            Message.verbose("\t[" + module.getId().getRevision() + "] " + getId());
                        }
                    }
                    md = module.getDescriptor();
                    confsToFetch.remove("*");
                    updateConfsToFetch(Arrays.asList(resolveSpecialConfigurations(
                        getRequiredConfigurations(parent, parentConf), this)));
                }
            } else {
                loaded = true;
            }
        }
        if (hasProblem()) {
            return handleConfiguration(loaded, rootModuleConf, parent, parentConf, conf,
                shouldBePublic)
                    && loaded;
        }
        if (!handleConfiguration(loaded, rootModuleConf, parent, parentConf, conf, shouldBePublic)) {
            return false;
        }
        DependencyDescriptor dd = getDependencyDescriptor(parent);
        if (dd != null) {
            addDependencyArtifacts(rootModuleConf, dd.getDependencyArtifacts(parentConf));
            addDependencyIncludes(rootModuleConf, dd.getIncludeRules(parentConf));
        }
        return loaded;


    }

View Full Code Here

        }
        DependencyDescriptor[] dds = md.getDependencies();
        Collection dependencies = new LinkedHashSet(); // it's important to respect dependencies
        // order
        for (int i = 0; i < dds.length; i++) {
            DependencyDescriptor dd = dds[i];
            String[] dependencyConfigurations = dd.getDependencyConfigurations(conf, requestedConf);
            if (dependencyConfigurations.length == 0) {
                // no configuration of the dependency is required for current confs :
                // it is exactly the same as if there was no dependency at all on it
                continue;
            }
            if (isDependencyModuleExcluded(rootModuleConf, dd.getDependencyRevisionId(), conf)) {
                // the whole module is excluded, it is considered as not being part of dependencies
                // at all
                Message.verbose("excluding " + dd.getDependencyRevisionId() + " in " + conf);
                continue;
            }
            IvyNode depNode = data.getNode(dd.getDependencyRevisionId());
            if (depNode == null) {
                depNode = new IvyNode(data, this, dd);
            } else {
                depNode.addDependencyDescriptor(this, dd);
                if (depNode.hasProblem()) {

View Full Code Here

         * @param dependencies array of dependencies to inherit
         */
        protected void mergeDependencies(DependencyDescriptor[] dependencies) {
            DefaultModuleDescriptor md = getMd();
            for (int i = 0; i < dependencies.length; i++) {
                DependencyDescriptor dependencyDescriptor = dependencies[i];
                Message.debug("Merging dependency with: "
                        + dependencyDescriptor.getDependencyRevisionId().toString());
                md.addDependency(dependencyDescriptor);
            }
        }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.apache.ivy.core.module.descriptor.DependencyDescriptor

org.apache.ivy.ant.EasyAntPluginBridge

org.apache.ivy.ant.IvyDeliverTest

org.apache.ivy.ant.IvyDependencyUpdateChecker

org.apache.ivy.ant.IvyResolve

org.apache.ivy.core.resolve.IvyNode

org.apache.ivy.core.resolve.ResolveData

org.apache.ivy.core.resolve.ResolveEngine

org.apache.ivy.core.resolve.VisitNode

org.apache.ivy.core.sort.SortTest

org.apache.ivy.plugins.conflict.LatestConflictManager

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.