001package org.eclipse.aether.internal.impl.collect;
002
003/*
004 * Licensed to the Apache Software Foundation (ASF) under one
005 * or more contributor license agreements.  See the NOTICE file
006 * distributed with this work for additional information
007 * regarding copyright ownership.  The ASF licenses this file
008 * to you under the Apache License, Version 2.0 (the
009 * "License"); you may not use this file except in compliance
010 * with the License.  You may obtain a copy of the License at
011 * 
012 *  http://www.apache.org/licenses/LICENSE-2.0
013 * 
014 * Unless required by applicable law or agreed to in writing,
015 * software distributed under the License is distributed on an
016 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
017 * KIND, either express or implied.  See the License for the
018 * specific language governing permissions and limitations
019 * under the License.
020 */
021
022import java.util.Collection;
023import java.util.Collections;
024import java.util.List;
025
026import org.eclipse.aether.DefaultRepositorySystemSession;
027import org.eclipse.aether.RepositoryException;
028import org.eclipse.aether.RepositorySystemSession;
029import org.eclipse.aether.artifact.Artifact;
030import org.eclipse.aether.artifact.ArtifactProperties;
031import org.eclipse.aether.collection.VersionFilter;
032import org.eclipse.aether.graph.DefaultDependencyNode;
033import org.eclipse.aether.graph.Dependency;
034import org.eclipse.aether.graph.DependencyNode;
035import org.eclipse.aether.repository.ArtifactRepository;
036import org.eclipse.aether.repository.RemoteRepository;
037import org.eclipse.aether.resolution.ArtifactDescriptorRequest;
038import org.eclipse.aether.resolution.ArtifactDescriptorResult;
039import org.eclipse.aether.resolution.VersionRangeRequest;
040import org.eclipse.aether.resolution.VersionRangeResolutionException;
041import org.eclipse.aether.resolution.VersionRangeResult;
042import org.eclipse.aether.version.Version;
043
044/**
045 * Utility methods for dependency collection.
046 *
047 */
048public class DependencyCollectionUtils
049{
050
051    @SuppressWarnings( "checkstyle:parameternumber" )
052    static DefaultDependencyNode addDependencyNode( DependencyNode parent, List<Artifact> relocations,
053                                                    PremanagedDependency preManaged, VersionRangeResult rangeResult,
054                                                    Version version, Dependency d, Collection<Artifact> aliases,
055                                                    List<RemoteRepository> repos, String requestContext )
056    {
057        DefaultDependencyNode child = new DefaultDependencyNode( d );
058        preManaged.applyTo( child );
059        child.setRelocations( relocations );
060        child.setVersionConstraint( rangeResult.getVersionConstraint() );
061        child.setVersion( version );
062        child.setAliases( aliases );
063        child.setRepositories( repos );
064        child.setRequestContext( requestContext );
065        parent.getChildren().add( child );
066        return child;
067    }
068
069    @SuppressWarnings( "checkstyle:parameternumber" )
070    static DefaultDependencyNode createDependencyNode( DependencyNode parent, List<Artifact> relocations,
071                                                       PremanagedDependency preManaged, VersionRangeResult rangeResult,
072                                                       Version version, Dependency d,
073                                                       ArtifactDescriptorResult descriptorResult,
074                                                       DependencyNode cycleNode )
075    {
076        DefaultDependencyNode child =
077            addDependencyNode( parent, relocations, preManaged, rangeResult, version, d, descriptorResult.getAliases(),
078                               cycleNode.getRepositories(), cycleNode.getRequestContext() );
079        child.setChildren( cycleNode.getChildren() );
080        return child;
081    }
082
083    static ArtifactDescriptorRequest createArtifactDescriptorRequest( Args args, List<RemoteRepository> repositories,
084                                                                      Dependency d )
085    {
086        ArtifactDescriptorRequest descriptorRequest = new ArtifactDescriptorRequest();
087        descriptorRequest.setArtifact( d.getArtifact() );
088        descriptorRequest.setRepositories( repositories );
089        descriptorRequest.setRequestContext( args.request.getRequestContext() );
090        descriptorRequest.setTrace( args.trace );
091        return descriptorRequest;
092    }
093
094    static VersionRangeRequest createVersionRangeRequest( Args args, List<RemoteRepository> repositories,
095                                                          Dependency dependency )
096    {
097        VersionRangeRequest rangeRequest = new VersionRangeRequest();
098        rangeRequest.setArtifact( dependency.getArtifact() );
099        rangeRequest.setRepositories( repositories );
100        rangeRequest.setRequestContext( args.request.getRequestContext() );
101        rangeRequest.setTrace( args.trace );
102        return rangeRequest;
103    }
104
105    static boolean isLackingDescriptor( Artifact artifact )
106    {
107        return artifact.getProperty( ArtifactProperties.LOCAL_PATH, null ) != null;
108    }
109
110    static List<RemoteRepository> getRemoteRepositories( ArtifactRepository repository,
111                                                         List<RemoteRepository> repositories )
112    {
113        if ( repository instanceof RemoteRepository )
114        {
115            return Collections.singletonList( (RemoteRepository) repository );
116        }
117        if ( repository != null )
118        {
119            return Collections.emptyList();
120        }
121        return repositories;
122    }
123
124    static List<? extends Version> filterVersions( Dependency dependency, VersionRangeResult rangeResult,
125                                                   VersionFilter verFilter, DefaultVersionFilterContext verContext )
126        throws VersionRangeResolutionException
127    {
128        if ( rangeResult.getVersions().isEmpty() )
129        {
130            throw new VersionRangeResolutionException( rangeResult, "No versions available for "
131                + dependency.getArtifact() + " within specified range" );
132        }
133
134        List<? extends Version> versions;
135        if ( verFilter != null && rangeResult.getVersionConstraint().getRange() != null )
136        {
137            verContext.set( dependency, rangeResult );
138            try
139            {
140                verFilter.filterVersions( verContext );
141            }
142            catch ( RepositoryException e )
143            {
144                throw new VersionRangeResolutionException( rangeResult, "Failed to filter versions for "
145                    + dependency.getArtifact() + ": " + e.getMessage(), e );
146            }
147            versions = verContext.get();
148            if ( versions.isEmpty() )
149            {
150                throw new VersionRangeResolutionException( rangeResult, "No acceptable versions for "
151                    + dependency.getArtifact() + ": " + rangeResult.getVersions() );
152            }
153        }
154        else
155        {
156            versions = rangeResult.getVersions();
157        }
158        return versions;
159    }
160
161    static RepositorySystemSession optimizeSession( RepositorySystemSession session )
162    {
163        DefaultRepositorySystemSession optimized = new DefaultRepositorySystemSession( session );
164        optimized.setArtifactTypeRegistry( CachingArtifactTypeRegistry.newInstance( session ) );
165        return optimized;
166    }
167
168    static String getId( Dependency d )
169    {
170        Artifact a = d.getArtifact();
171        return a.getGroupId() + ':' + a.getArtifactId() + ':' + a.getClassifier() + ':' + a.getExtension();
172    }
173}