Examples of org.sonatype.aether.graph.DependencyNode

org.sonatype.aether.graph.DependencyNode
A node within a dependency graph. Note: When traversing a dirty graph, i.e. a graph which hasn't undergone conflict resolution, there can be multiple path leading to the same node instance. @author Benjamin Bentmann

        node.accept( nlg );


        HashMap<String,String> map = new HashMap<String,String>();


        for ( Iterator<DependencyNode> it = nlg.getNodes().iterator(); it.hasNext(); ) {
            DependencyNode node = it.next();
            if ( node.getDependency() != null ) {
                Artifact artifact = node.getDependency().getArtifact();
                // skip pom artifacts
                if ( artifact.getFile() != null && !"pom".equals(artifact.getExtension())) {
                    map.put(artifact.toString(), artifact.getFile().getAbsolutePath());
                }
            }

View Full Code Here

        DependencyFilter resolutionFilter =
            new ExclusionsDependencyFilter( artifactFilterManager.getCoreArtifactExcludes() );
        resolutionFilter = AndDependencyFilter.newInstance( resolutionFilter, dependencyFilter );
        resolutionFilter = new AndDependencyFilter( collectionFilter, resolutionFilter );


        DependencyNode node;


        try
        {
            DependencySelector selector =
                AndDependencySelector.newInstance( session.getDependencySelector(), new WagonExcluder() );


            DependencyGraphTransformer transformer =
                ChainedDependencyGraphTransformer.newInstance( session.getDependencyGraphTransformer(),
                                                               new PlexusUtilsInjector() );


            DefaultRepositorySystemSession pluginSession = new DefaultRepositorySystemSession( session );
            pluginSession.setDependencySelector( selector );
            pluginSession.setDependencyGraphTransformer( transformer );


            CollectRequest request = new CollectRequest();
            request.setRequestContext( REPOSITORY_CONTEXT );
            request.setRepositories( repositories );
            request.setRoot( new org.sonatype.aether.graph.Dependency( pluginArtifact, null ) );
            for ( Dependency dependency : plugin.getDependencies() )
            {
                org.sonatype.aether.graph.Dependency pluginDep =
                    RepositoryUtils.toDependency( dependency, session.getArtifactTypeRegistry() );
                if ( !JavaScopes.SYSTEM.equals( pluginDep.getScope() ) )
                {
                    pluginDep = pluginDep.setScope( JavaScopes.RUNTIME );
                }
                request.addDependency( pluginDep );
            }


            node = repoSystem.collectDependencies( pluginSession, request ).getRoot();


            if ( logger.isDebugEnabled() )
            {
                node.accept( new GraphLogger() );
            }


            repoSystem.resolveDependencies( session, node, resolutionFilter );
        }
        catch ( DependencyCollectionException e )

View Full Code Here

        MavenProject project = session.getCurrentProject();


        DependencyFilter dependencyFilter = project.getExtensionDependencyFilter();
        dependencyFilter = AndDependencyFilter.newInstance( dependencyFilter, filter );


        DependencyNode root =
            pluginDependenciesResolver.resolve( plugin, RepositoryUtils.toArtifact( pluginArtifact ), dependencyFilter,
                                                project.getRemotePluginRepositories(), session.getRepositorySession() );


        PreorderNodeListGenerator nlg = new PreorderNodeListGenerator();
        root.accept( nlg );


        List<Artifact> exposedPluginArtifacts = new ArrayList<Artifact>( nlg.getNodes().size() );
        RepositoryUtils.toArtifacts( exposedPluginArtifacts, Collections.singleton( root ),
                                     Collections.<String> emptyList(), null );
        for ( Iterator<Artifact> it = exposedPluginArtifacts.iterator(); it.hasNext(); )

View Full Code Here


    //artifact search code adapted from geronimo car plugin


    public void getDependencies(MavenProject project, boolean useTransitiveDependencies) throws MojoExecutionException {


        DependencyNode rootNode = getDependencyTree(RepositoryUtils.toArtifact(project.getArtifact()));


        Scanner scanner = new Scanner();
        scanner.scan(rootNode, useTransitiveDependencies);
        localDependencies = scanner.localDependencies;
        treeListing = scanner.getLog();

View Full Code Here

        urls.add(artifactToUrl(artifactResult.getArtifact()));


        CollectRequest collectRequest = new CollectRequest();
        collectRequest.setRoot(new Dependency(artifact, "compile" ));
        collectRequest.addRepository( central );
        DependencyNode node = REPOSITORY_SYSTEM.collectDependencies( session, collectRequest ).getRoot();
        DependencyRequest dependencyRequest = new DependencyRequest( node, null );


        REPOSITORY_SYSTEM.resolveDependencies( session, dependencyRequest  );


        PreorderNodeListGenerator nlg = new PreorderNodeListGenerator();
        node.accept( nlg );
        for (Artifact cur : nlg.getArtifacts(false)) {
            urls.add(artifactToUrl(cur));
        }


        System.out.println("--------------------");

View Full Code Here

     * @param version
     * @return
     */
    public AetherPomResult resolvePom(String groupId, String artifactId, String version) throws ArtifactResolutionException, DependencyCollectionException, DependencyResolutionException {
        AetherResult result = resolve(groupId, artifactId, version, "pom");
        DependencyNode root = result.root();
        File file = root.getDependency().getArtifact().getFile();
        Model model = loadPom(file);
        List<String> modules = model.getModules();
        List<AetherJarOrPom> children = new LinkedList<AetherJarOrPom>();
        for (String moduleName: modules) {
            System.out.println("Found module " + moduleName);

View Full Code Here

        collectRequest.setRoot(dependency);
        for (Repository repo: remoteRepos) {
            collectRequest.addRepository(repo.toRemoteRepository());
        }


        DependencyNode rootNode = repositorySystem.collectDependencies(session, collectRequest).getRoot();


        repositorySystem.resolveDependencies(session, new DependencyRequest(rootNode, null));


        PreorderNodeListGenerator nlg = new PreorderNodeListGenerator();
        rootNode.accept(nlg);


        return new AetherResult(rootNode, nlg.getFiles(), nlg.getClassPath());
    }

View Full Code Here

        return false;
    }


    private void updateNonSelectedVersions(ConflictGroup group, Map<?, ?> conflictIds) {
        for (Position pos : group.positions) {
            DependencyNode parent = pos.parent;
            List<DependencyNode> children = parent.getChildren();
            List<DependencyNode> toAdd = new ArrayList<DependencyNode>();


            for (Iterator<DependencyNode> it = children.iterator(); it.hasNext();) {
                DependencyNode child = it.next();


                Object key = conflictIds.get(child);


                if (group.key.equals(key)) {
                    if (!group.pruned && group.position != null && group.version != null
                            && group.position.depth == pos.depth
                            && group.version.equals(child.getVersion())) {
                        group.pruned = true;
                    } else {
                        it.remove();


                        // now lets add the common dependency

View Full Code Here


        final DefaultDependencyNode rootNode = new DefaultDependencyNode(rootDependency);
        GenericVersionScheme versionScheme = new GenericVersionScheme();
        rootNode.setVersion(versionScheme.parseVersion(pomVersion));
        rootNode.setVersionConstraint(versionScheme.parseVersionConstraint(pomVersion));
        DependencyNode pomNode = rootNode;


        //final Filter<Dependency> shouldExclude = Filters.or(DependencyFilters.testScopeFilter, excludeDependencyFilter, new NewerVersionExistsFilter(rootNode));
        final Filter<Dependency> shouldExclude = Filters.or(DependencyFilters.testScopeFilter, excludeDependencyFilter);
        DependencySelector dependencySelector = new AndDependencySelector(new ScopeDependencySelector("test"),
                new ExclusionDependencySelector(),
                new DependencySelector() {
                    @Override
                    public DependencySelector deriveChildSelector(DependencyCollectionContext context) {
                        return this;
                    }


                    @Override
                    public boolean selectDependency(Dependency dependency) {
                        try {
                            boolean answer = DependencyFilters.matches(dependency, shouldExclude);
                            return !answer;
                        } catch (Exception e) {
                            failedToMakeDependencyTree(dependency, e);
                            return false;
                        }
                    }
                });
        session.setDependencySelector(dependencySelector);


        // TODO no idea why we have to iterate through the dependencies; why can't we just
        // work on the root dependency directly?
        if (true) {
            for (Dependency dependency : dependencies) {
                DependencyNode node = resolveDepedencies(repositorySystem, session, repos, pomNode, dependency, shouldExclude);
                if (node != null) {
                    pomNode.getChildren().add(node);
                }
            }
        } else {
            DependencyNode node = resolveDepedencies(repositorySystem, session, repos, pomNode, rootDependency, shouldExclude);
            if (node != null) {
                pomNode = node;
            }
        }

View Full Code Here

    protected DependencyNode resolveDepedencies(RepositorySystem repositorySystem, MavenRepositorySystemSession session, List<RemoteRepository> repos, DependencyNode pomNode, Dependency dependency, final Filter<Dependency> shouldExclude) throws FailedToResolveDependency {
        if (!DependencyFilters.matches(dependency, shouldExclude)) {
            CollectRequest request = new CollectRequest(dependency, repos);
            //request.setRequestContext("runtime");
            try {
                DependencyNode node = repositorySystem.collectDependencies(session, request).getRoot();
                repositorySystem.resolveDependencies(session, node, new DependencyFilter() {
                    @Override
                    public boolean accept(DependencyNode node, List<DependencyNode> parents) {
                        boolean answer = !DependencyFilters.matches(node, shouldExclude);
                        return answer;

View Full Code Here

0 1 2 3 4

TOP

Related Classes of org.sonatype.aether.graph.DependencyNode

io.fabric8.fab.MavenResolverImpl

io.fabric8.fab.ReplaceConflictingVersionResolver

io.fabric8.insight.maven.aether.Aether

io.fabric8.process.manager.support.JarInstaller

io.hawt.aether.AetherFacade

org.apache.karaf.tooling.features.Dependency30Helper

org.apache.karaf.tooling.features.DependencyHelper

org.apache.marmotta.maven.plugins.refpack.RefPackMojo

org.apache.maven.plugin.internal.DefaultMavenPluginManager

org.apache.maven.plugin.internal.DefaultPluginDependenciesResolver

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.