View Javadoc

1   package org.apache.maven.project.artifact;
2   
3   /*
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   *
12   *  http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing,
15   * software distributed under the License is distributed on an
16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17   * KIND, either express or implied.  See the License for the
18   * specific language governing permissions and limitations
19   * under the License.
20   */
21  
22  import java.io.File;
23  import java.util.ArrayList;
24  import java.util.Arrays;
25  import java.util.Collection;
26  import java.util.Collections;
27  import java.util.HashMap;
28  import java.util.LinkedHashMap;
29  import java.util.LinkedHashSet;
30  import java.util.List;
31  import java.util.Map;
32  import java.util.Properties;
33  import java.util.Set;
34  
35  import org.apache.maven.artifact.Artifact;
36  import org.apache.maven.artifact.factory.ArtifactFactory;
37  import org.apache.maven.artifact.metadata.ArtifactMetadataRetrievalException;
38  import org.apache.maven.artifact.metadata.ArtifactMetadataSource;
39  import org.apache.maven.artifact.metadata.ResolutionGroup;
40  import org.apache.maven.artifact.repository.ArtifactRepository;
41  import org.apache.maven.artifact.repository.metadata.ArtifactRepositoryMetadata;
42  import org.apache.maven.artifact.repository.metadata.Metadata;
43  import org.apache.maven.artifact.repository.metadata.RepositoryMetadata;
44  import org.apache.maven.artifact.repository.metadata.RepositoryMetadataManager;
45  import org.apache.maven.artifact.repository.metadata.RepositoryMetadataResolutionException;
46  import org.apache.maven.artifact.resolver.ArtifactResolutionException;
47  import org.apache.maven.artifact.resolver.MultipleArtifactsNotFoundException;
48  import org.apache.maven.artifact.resolver.filter.AndArtifactFilter;
49  import org.apache.maven.artifact.resolver.filter.ArtifactFilter;
50  import org.apache.maven.artifact.resolver.filter.ExcludesArtifactFilter;
51  import org.apache.maven.artifact.versioning.ArtifactVersion;
52  import org.apache.maven.artifact.versioning.DefaultArtifactVersion;
53  import org.apache.maven.artifact.versioning.InvalidVersionSpecificationException;
54  import org.apache.maven.artifact.versioning.VersionRange;
55  import org.apache.maven.execution.MavenSession;
56  import org.apache.maven.model.Dependency;
57  import org.apache.maven.model.DependencyManagement;
58  import org.apache.maven.model.DistributionManagement;
59  import org.apache.maven.model.Exclusion;
60  import org.apache.maven.model.Relocation;
61  import org.apache.maven.model.building.ModelBuildingException;
62  import org.apache.maven.model.building.ModelBuildingRequest;
63  import org.apache.maven.model.building.ModelProblem;
64  import org.apache.maven.model.resolution.UnresolvableModelException;
65  import org.apache.maven.plugin.LegacySupport;
66  import org.apache.maven.project.DefaultProjectBuildingRequest;
67  import org.apache.maven.project.MavenProject;
68  import org.apache.maven.project.ProjectBuilder;
69  import org.apache.maven.project.ProjectBuildingException;
70  import org.apache.maven.project.ProjectBuildingRequest;
71  import org.apache.maven.properties.internal.EnvironmentUtils;
72  import org.apache.maven.repository.legacy.metadata.DefaultMetadataResolutionRequest;
73  import org.apache.maven.repository.legacy.metadata.MetadataResolutionRequest;
74  import org.codehaus.plexus.PlexusContainer;
75  import org.codehaus.plexus.component.annotations.Component;
76  import org.codehaus.plexus.component.annotations.Requirement;
77  import org.codehaus.plexus.component.repository.exception.ComponentLookupException;
78  import org.codehaus.plexus.logging.Logger;
79  import org.sonatype.aether.RepositorySystemSession;
80  import org.sonatype.aether.repository.RepositoryPolicy;
81  import org.sonatype.aether.transfer.ArtifactNotFoundException;
82  
83  /**
84   * @author Jason van Zyl
85   */
86  @Component( role = ArtifactMetadataSource.class, hint = "maven" )
87  public class MavenMetadataSource
88      implements ArtifactMetadataSource
89  {
90      @Requirement
91      private RepositoryMetadataManager repositoryMetadataManager;
92  
93      @Requirement
94      private ArtifactFactory repositorySystem;
95  
96      //TODO: This prevents a cycle in the composition which shows us another problem we need to deal with.
97      //@Requirement
98      private ProjectBuilder projectBuilder;
99  
100     @Requirement
101     private PlexusContainer container;
102 
103     @Requirement
104     private Logger logger;
105 
106     @Requirement
107     private MavenMetadataCache cache;
108 
109     @Requirement
110     private LegacySupport legacySupport;
111 
112     private void injectSession( MetadataResolutionRequest request )
113     {
114         RepositorySystemSession session = legacySupport.getRepositorySession();
115 
116         if ( session != null )
117         {
118             request.setOffline( session.isOffline() );
119             request.setForceUpdate( RepositoryPolicy.UPDATE_POLICY_ALWAYS.equals( session.getUpdatePolicy() ) );
120         }
121     }
122 
123     public ResolutionGroup retrieve( Artifact artifact, ArtifactRepository localRepository,
124                                      List<ArtifactRepository> remoteRepositories )
125         throws ArtifactMetadataRetrievalException
126     {
127         return retrieve( artifact, localRepository, remoteRepositories, false );
128     }
129 
130     public ResolutionGroup retrieve( Artifact artifact, ArtifactRepository localRepository,
131                                      List<ArtifactRepository> remoteRepositories, boolean resolveManagedVersions )
132         throws ArtifactMetadataRetrievalException
133     {
134         MetadataResolutionRequest request = new DefaultMetadataResolutionRequest();
135         injectSession( request );
136         request.setArtifact( artifact );
137         request.setLocalRepository( localRepository );
138         request.setRemoteRepositories( remoteRepositories );
139         request.setResolveManagedVersions( resolveManagedVersions );
140         return retrieve( request );
141     }
142 
143     public ResolutionGroup retrieve( MetadataResolutionRequest request )
144         throws ArtifactMetadataRetrievalException
145     {
146         Artifact artifact = request.getArtifact();
147 
148         //
149         // If we have a system scoped artifact then we do not want any searching in local or remote repositories
150         // and we want artifact resolution to only return the system scoped artifact itself.
151         //
152         if ( artifact.getScope() != null && artifact.getScope().equals( Artifact.SCOPE_SYSTEM ) )
153         {
154             return new ResolutionGroup( null, null, null );
155         }
156 
157         ResolutionGroup cached =
158             cache.get( artifact, request.isResolveManagedVersions(), request.getLocalRepository(),
159                        request.getRemoteRepositories() );
160 
161         if ( cached != null )
162         {
163             // if the POM has no file, we cached a missing artifact, only return the cached data if no update forced
164             if ( !request.isForceUpdate() || hasFile( cached.getPomArtifact() ) )
165             {
166                 return cached;
167             }
168         }
169 
170         List<Dependency> dependencies;
171 
172         List<Dependency> managedDependencies = null;
173 
174         List<ArtifactRepository> pomRepositories = null;
175 
176         Artifact pomArtifact;
177 
178         Artifact relocatedArtifact = null;
179 
180         //TODO: Not even sure this is really required as the project will be cached in the builder, we'll see this
181         // is currently the biggest hotspot
182         if ( artifact instanceof ArtifactWithDependencies )
183         {
184             pomArtifact = artifact;
185 
186             dependencies = ( (ArtifactWithDependencies) artifact ).getDependencies();
187 
188             managedDependencies = ( (ArtifactWithDependencies) artifact ).getManagedDependencies();
189         }
190         else
191         {
192             ProjectRelocation rel = retrieveRelocatedProject( artifact, request );
193 
194             if ( rel == null )
195             {
196                 return null;
197             }
198 
199             pomArtifact = rel.pomArtifact;
200 
201             relocatedArtifact = rel.relocatedArtifact;
202 
203             if ( rel.project == null )
204             {
205                 // When this happens we have a Maven 1.x POM, or some invalid POM. 
206                 // It should have never found its way into Maven 2.x repository but it did.
207                 dependencies = Collections.emptyList();
208             }
209             else
210             {
211                 dependencies = rel.project.getDependencies();
212 
213                 DependencyManagement depMngt = rel.project.getDependencyManagement();
214                 managedDependencies = ( depMngt != null ) ? depMngt.getDependencies() : null;
215 
216                 pomRepositories = rel.project.getRemoteArtifactRepositories();
217             }
218         }
219 
220         Set<Artifact> artifacts = Collections.<Artifact>emptySet();
221 
222         if ( !artifact.getArtifactHandler().isIncludesDependencies() )
223         {
224             artifacts = new LinkedHashSet<Artifact>();
225 
226             for ( Dependency dependency : dependencies )
227             {
228                 Artifact dependencyArtifact = createDependencyArtifact( dependency, artifact, pomArtifact );
229 
230                 if ( dependencyArtifact != null )
231                 {
232                     artifacts.add( dependencyArtifact );
233                 }
234             }
235         }
236 
237         Map<String, Artifact> managedVersions = null;
238 
239         if ( managedDependencies != null && request.isResolveManagedVersions() )
240         {
241             managedVersions = new HashMap<String, Artifact>();
242 
243             for ( Dependency managedDependency : managedDependencies )
244             {
245                 Artifact managedArtifact = createDependencyArtifact( managedDependency, null, pomArtifact );
246 
247                 managedVersions.put( managedDependency.getManagementKey(), managedArtifact );
248             }
249         }
250 
251         List<ArtifactRepository> aggregatedRepositories =
252             aggregateRepositories( request.getRemoteRepositories(), pomRepositories );
253 
254         ResolutionGroup result =
255             new ResolutionGroup( pomArtifact, relocatedArtifact, artifacts, managedVersions, aggregatedRepositories );
256 
257         cache.put( artifact, request.isResolveManagedVersions(), request.getLocalRepository(),
258                    request.getRemoteRepositories(), result );
259 
260         return result;
261     }
262 
263     private boolean hasFile( Artifact artifact )
264     {
265         return artifact != null && artifact.getFile() != null && artifact.getFile().exists();
266     }
267 
268     private List<ArtifactRepository> aggregateRepositories( List<ArtifactRepository> requestRepositories,
269                                                             List<ArtifactRepository> pomRepositories )
270     {
271         List<ArtifactRepository> repositories = requestRepositories;
272 
273         if ( pomRepositories != null && !pomRepositories.isEmpty() )
274         {
275             Map<String, ArtifactRepository> repos = new LinkedHashMap<String, ArtifactRepository>();
276 
277             for ( ArtifactRepository repo : requestRepositories )
278             {
279                 if ( !repos.containsKey( repo.getId() ) )
280                 {
281                     repos.put( repo.getId(), repo );
282                 }
283             }
284 
285             for ( ArtifactRepository repo : pomRepositories )
286             {
287                 if ( !repos.containsKey( repo.getId() ) )
288                 {
289                     repos.put( repo.getId(), repo );
290                 }
291             }
292 
293             repositories = new ArrayList<ArtifactRepository>( repos.values() );
294         }
295 
296         return repositories;
297     }
298 
299     private Artifact createDependencyArtifact( Dependency dependency, Artifact owner, Artifact pom )
300         throws ArtifactMetadataRetrievalException
301     {
302         try
303         {
304             String inheritedScope = ( owner != null ) ? owner.getScope() : null;
305 
306             ArtifactFilter inheritedFilter = ( owner != null ) ? owner.getDependencyFilter() : null;
307 
308             return createDependencyArtifact( repositorySystem, dependency, inheritedScope, inheritedFilter );
309         }
310         catch ( InvalidVersionSpecificationException e )
311         {
312             throw new ArtifactMetadataRetrievalException( "Invalid version for dependency "
313                 + dependency.getManagementKey() + ": " + e.getMessage(), e, pom );
314         }
315     }
316 
317     private static Artifact createDependencyArtifact( ArtifactFactory factory, Dependency dependency,
318                                                       String inheritedScope, ArtifactFilter inheritedFilter )
319         throws InvalidVersionSpecificationException
320     {
321         String effectiveScope = getEffectiveScope( dependency.getScope(), inheritedScope );
322 
323         if ( effectiveScope == null )
324         {
325             return null;
326         }
327 
328         VersionRange versionRange = VersionRange.createFromVersionSpec( dependency.getVersion() );
329 
330         Artifact dependencyArtifact =
331             factory.createDependencyArtifact( dependency.getGroupId(), dependency.getArtifactId(), versionRange,
332                                               dependency.getType(), dependency.getClassifier(), effectiveScope,
333                                               dependency.isOptional() );
334 
335         ArtifactFilter dependencyFilter = inheritedFilter;
336 
337         if ( dependencyFilter != null && !dependencyFilter.include( dependencyArtifact ) )
338         {
339             return null;
340         }
341 
342         if ( Artifact.SCOPE_SYSTEM.equals( effectiveScope ) )
343         {
344             dependencyArtifact.setFile( new File( dependency.getSystemPath() ) );
345         }
346 
347         dependencyArtifact.setDependencyFilter( createDependencyFilter( dependency, dependencyFilter ) );
348 
349         return dependencyArtifact;
350     }
351 
352     private static String getEffectiveScope( String originalScope, String inheritedScope )
353     {
354         String effectiveScope = Artifact.SCOPE_RUNTIME;
355 
356         if ( originalScope == null )
357         {
358             originalScope = Artifact.SCOPE_COMPILE;
359         }
360 
361         if ( inheritedScope == null )
362         {
363             // direct dependency retains its scope
364             effectiveScope = originalScope;
365         }
366         else if ( Artifact.SCOPE_TEST.equals( originalScope ) || Artifact.SCOPE_PROVIDED.equals( originalScope ) )
367         {
368             // test and provided are not transitive, so exclude them
369             effectiveScope = null;
370         }
371         else if ( Artifact.SCOPE_SYSTEM.equals( originalScope ) )
372         {
373             // system scope come through unchanged...
374             effectiveScope = Artifact.SCOPE_SYSTEM;
375         }
376         else if ( Artifact.SCOPE_COMPILE.equals( originalScope ) && Artifact.SCOPE_COMPILE.equals( inheritedScope ) )
377         {
378             // added to retain compile scope. Remove if you want compile inherited as runtime
379             effectiveScope = Artifact.SCOPE_COMPILE;
380         }
381         else if ( Artifact.SCOPE_TEST.equals( inheritedScope ) )
382         {
383             effectiveScope = Artifact.SCOPE_TEST;
384         }
385         else if ( Artifact.SCOPE_PROVIDED.equals( inheritedScope ) )
386         {
387             effectiveScope = Artifact.SCOPE_PROVIDED;
388         }
389 
390         return effectiveScope;
391     }
392 
393     private static ArtifactFilter createDependencyFilter( Dependency dependency, ArtifactFilter inheritedFilter )
394     {
395         ArtifactFilter effectiveFilter = inheritedFilter;
396 
397         if ( !dependency.getExclusions().isEmpty() )
398         {
399             List<String> exclusions = new ArrayList<String>();
400 
401             for ( Exclusion e : dependency.getExclusions() )
402             {
403                 exclusions.add( e.getGroupId() + ':' + e.getArtifactId() );
404             }
405 
406             effectiveFilter = new ExcludesArtifactFilter( exclusions );
407 
408             if ( inheritedFilter != null )
409             {
410                 effectiveFilter = new AndArtifactFilter( Arrays.asList( inheritedFilter, effectiveFilter ) );
411             }
412         }
413 
414         return effectiveFilter;
415     }
416 
417     public List<ArtifactVersion> retrieveAvailableVersions( Artifact artifact, ArtifactRepository localRepository,
418                                                             List<ArtifactRepository> remoteRepositories )
419         throws ArtifactMetadataRetrievalException
420     {
421         MetadataResolutionRequest request = new DefaultMetadataResolutionRequest();
422         injectSession( request );
423         request.setArtifact( artifact );
424         request.setLocalRepository( localRepository );
425         request.setRemoteRepositories( remoteRepositories );
426         return retrieveAvailableVersions( request );
427     }
428 
429     public List<ArtifactVersion> retrieveAvailableVersions( MetadataResolutionRequest request )
430         throws ArtifactMetadataRetrievalException
431     {
432         RepositoryMetadata metadata = new ArtifactRepositoryMetadata( request.getArtifact() );
433 
434         try
435         {
436             repositoryMetadataManager.resolve( metadata, request );
437         }
438         catch ( RepositoryMetadataResolutionException e )
439         {
440             throw new ArtifactMetadataRetrievalException( e.getMessage(), e, request.getArtifact() );
441         }
442 
443         List<String> availableVersions = request.getLocalRepository().findVersions( request.getArtifact() );
444 
445         return retrieveAvailableVersionsFromMetadata( metadata.getMetadata(), availableVersions );
446     }
447 
448     public List<ArtifactVersion> retrieveAvailableVersionsFromDeploymentRepository( Artifact artifact,
449                                                                                     ArtifactRepository localRepository,
450                                                                                     ArtifactRepository deploymentRepository )
451         throws ArtifactMetadataRetrievalException
452     {
453         RepositoryMetadata metadata = new ArtifactRepositoryMetadata( artifact );
454 
455         try
456         {
457             repositoryMetadataManager.resolveAlways( metadata, localRepository, deploymentRepository );
458         }
459         catch ( RepositoryMetadataResolutionException e )
460         {
461             throw new ArtifactMetadataRetrievalException( e.getMessage(), e, artifact );
462         }
463 
464         List<String> availableVersions = localRepository.findVersions( artifact );
465 
466         return retrieveAvailableVersionsFromMetadata( metadata.getMetadata(), availableVersions );
467     }
468 
469     private List<ArtifactVersion> retrieveAvailableVersionsFromMetadata( Metadata repoMetadata,
470                                                                          List<String> availableVersions )
471     {
472         Collection<String> versions = new LinkedHashSet<String>();
473 
474         if ( ( repoMetadata != null ) && ( repoMetadata.getVersioning() != null ) )
475         {
476             versions.addAll( repoMetadata.getVersioning().getVersions() );
477         }
478 
479         versions.addAll( availableVersions );
480 
481         List<ArtifactVersion> artifactVersions = new ArrayList<ArtifactVersion>( versions.size() );
482 
483         for ( String version : versions )
484         {
485             artifactVersions.add( new DefaultArtifactVersion( version ) );
486         }
487 
488         return artifactVersions;
489     }
490 
491     // USED BY MAVEN ASSEMBLY PLUGIN
492     @Deprecated
493     public static Set<Artifact> createArtifacts( ArtifactFactory artifactFactory, List<Dependency> dependencies,
494                                                  String inheritedScope, ArtifactFilter dependencyFilter,
495                                                  MavenProject project )
496         throws InvalidDependencyVersionException
497     {
498         Set<Artifact> artifacts = new LinkedHashSet<Artifact>();
499 
500         for ( Dependency d : dependencies )
501         {
502             Artifact dependencyArtifact;
503             try
504             {
505                 dependencyArtifact = createDependencyArtifact( artifactFactory, d, inheritedScope, dependencyFilter );
506             }
507             catch ( InvalidVersionSpecificationException e )
508             {
509                 throw new InvalidDependencyVersionException( project.getId(), d, project.getFile(), e );
510             }
511 
512             if ( dependencyArtifact != null )
513             {
514                 artifacts.add( dependencyArtifact );
515             }
516         }
517 
518         return artifacts;
519     }
520 
521     private ProjectBuilder getProjectBuilder()
522     {
523         if ( projectBuilder != null )
524         {
525             return projectBuilder;
526         }
527 
528         try
529         {
530             projectBuilder = container.lookup( ProjectBuilder.class );
531         }
532         catch ( ComponentLookupException e )
533         {
534             // Won't happen
535         }
536 
537         return projectBuilder;
538     }
539 
540     private ProjectRelocation retrieveRelocatedProject( Artifact artifact, MetadataResolutionRequest repositoryRequest )
541         throws ArtifactMetadataRetrievalException
542     {
543         MavenProject project;
544 
545         Artifact pomArtifact;
546         Artifact relocatedArtifact = null;
547         boolean done = false;
548         do
549         {
550             project = null;
551 
552             pomArtifact =
553                 repositorySystem.createProjectArtifact( artifact.getGroupId(),
554                                                         artifact.getArtifactId(),
555                                                         artifact.getVersion(), artifact.getScope() );
556 
557             if ( "pom".equals( artifact.getType() ) )
558             {
559                 pomArtifact.setFile( artifact.getFile() );
560             }
561 
562             if ( Artifact.SCOPE_SYSTEM.equals( artifact.getScope() ) )
563             {
564                 done = true;
565             }
566             else
567             {
568                 try
569                 {
570                     ProjectBuildingRequest configuration = new DefaultProjectBuildingRequest();
571                     configuration.setLocalRepository( repositoryRequest.getLocalRepository() );
572                     configuration.setRemoteRepositories( repositoryRequest.getRemoteRepositories() );
573                     configuration.setValidationLevel( ModelBuildingRequest.VALIDATION_LEVEL_MINIMAL );
574                     configuration.setProcessPlugins( false );
575                     configuration.setRepositoryMerging( ProjectBuildingRequest.RepositoryMerging.REQUEST_DOMINANT );
576                     configuration.setSystemProperties( getSystemProperties() );
577                     configuration.setRepositorySession( legacySupport.getRepositorySession() );
578 
579                     project = getProjectBuilder().build( pomArtifact, configuration ).getProject();
580                 }
581                 catch ( ProjectBuildingException e )
582                 {
583                     ModelProblem missingParentPom = hasMissingParentPom( e );
584                     if ( missingParentPom != null )
585                     {
586                         throw new ArtifactMetadataRetrievalException( "Failed to process POM for "
587                             + artifact.getId() + ": " + missingParentPom.getMessage(),
588                                                                       missingParentPom.getException(),
589                                                                       artifact );
590                     }
591 
592                     String message;
593 
594                     if ( isMissingPom( e ) )
595                     {
596                         message = "Missing POM for " + artifact.getId();
597                     }
598                     else if ( isNonTransferrablePom( e ) )
599                     {
600                         throw new ArtifactMetadataRetrievalException( "Failed to retrieve POM for "
601                             + artifact.getId() + ": " + e.getCause().getMessage(), e.getCause(),
602                                                                       artifact );
603                     }
604                     else
605                     {
606                         message =
607                             "Invalid POM for " + artifact.getId()
608                                 + ", transitive dependencies (if any) will not be available"
609                                 + ", enable debug logging for more details";
610                     }
611 
612                     if ( logger.isDebugEnabled() )
613                     {
614                         message += ": " + e.getMessage();
615                     }
616 
617                     logger.warn( message );
618                 }
619 
620                 if ( project != null )
621                 {
622                     Relocation relocation = null;
623 
624                     DistributionManagement distMgmt = project.getDistributionManagement();
625                     if ( distMgmt != null )
626                     {
627                         relocation = distMgmt.getRelocation();
628 
629                         artifact.setDownloadUrl( distMgmt.getDownloadUrl() );
630                         pomArtifact.setDownloadUrl( distMgmt.getDownloadUrl() );
631                     }
632 
633                     if ( relocation != null )
634                     {
635                         if ( relocation.getGroupId() != null )
636                         {
637                             artifact.setGroupId( relocation.getGroupId() );
638                             relocatedArtifact = artifact;
639                             project.setGroupId( relocation.getGroupId() );
640                         }
641                         if ( relocation.getArtifactId() != null )
642                         {
643                             artifact.setArtifactId( relocation.getArtifactId() );
644                             relocatedArtifact = artifact;
645                             project.setArtifactId( relocation.getArtifactId() );
646                         }
647                         if ( relocation.getVersion() != null )
648                         {
649                             // note: see MNG-3454. This causes a problem, but fixing it may break more.
650                             artifact.setVersionRange( VersionRange.createFromVersion( relocation.getVersion() ) );
651                             relocatedArtifact = artifact;
652                             project.setVersion( relocation.getVersion() );
653                         }
654 
655                         if ( artifact.getDependencyFilter() != null
656                             && !artifact.getDependencyFilter().include( artifact ) )
657                         {
658                             return null;
659                         }
660 
661                         // MNG-2861: the artifact data has changed. If the available versions where previously
662                         // retrieved, we need to update it.
663                         // TODO: shouldn't the versions be merged across relocations?
664                         List<ArtifactVersion> available = artifact.getAvailableVersions();
665                         if ( available != null && !available.isEmpty() )
666                         {
667                             MetadataResolutionRequest metadataRequest =
668                                 new DefaultMetadataResolutionRequest( repositoryRequest );
669                             metadataRequest.setArtifact( artifact );
670                             available = retrieveAvailableVersions( metadataRequest );
671                             artifact.setAvailableVersions( available );
672                         }
673 
674                         String message =
675                             "\n  This artifact has been relocated to " + artifact.getGroupId() + ":"
676                                 + artifact.getArtifactId() + ":" + artifact.getVersion() + ".\n";
677 
678                         if ( relocation.getMessage() != null )
679                         {
680                             message += "  " + relocation.getMessage() + "\n";
681                         }
682 
683                         if ( artifact.getDependencyTrail() != null && artifact.getDependencyTrail().size() == 1 )
684                         {
685                             logger.warn( "While downloading " + pomArtifact.getGroupId() + ":"
686                                 + pomArtifact.getArtifactId() + ":" + pomArtifact.getVersion() + message + "\n" );
687                         }
688                         else
689                         {
690                             logger.debug( "While downloading " + pomArtifact.getGroupId() + ":"
691                                 + pomArtifact.getArtifactId() + ":" + pomArtifact.getVersion() + message + "\n" );
692                         }
693                     }
694                     else
695                     {
696                         done = true;
697                     }
698                 }
699                 else
700                 {
701                     done = true;
702                 }
703             }
704         }
705         while ( !done );
706 
707         ProjectRelocation rel = new ProjectRelocation();
708         rel.project = project;
709         rel.pomArtifact = pomArtifact;
710         rel.relocatedArtifact = relocatedArtifact;
711 
712         return rel;
713     }
714 
715     private ModelProblem hasMissingParentPom( ProjectBuildingException e )
716     {
717         if ( e.getCause() instanceof ModelBuildingException )
718         {
719             ModelBuildingException mbe = (ModelBuildingException) e.getCause();
720             for ( ModelProblem problem : mbe.getProblems() )
721             {
722                 if ( problem.getException() instanceof UnresolvableModelException )
723                 {
724                     return problem;
725                 }
726             }
727 
728         }
729         return null;
730     }
731 
732     private boolean isMissingPom( Exception e )
733     {
734         if ( e.getCause() instanceof MultipleArtifactsNotFoundException )
735         {
736             return true;
737         }
738         if ( e.getCause() instanceof org.sonatype.aether.resolution.ArtifactResolutionException
739             && e.getCause().getCause() instanceof ArtifactNotFoundException )
740         {
741             return true;
742         }
743         return false;
744     }
745 
746     private boolean isNonTransferrablePom( Exception e )
747     {
748         if ( e.getCause() instanceof ArtifactResolutionException )
749         {
750             return true;
751         }
752         if ( e.getCause() instanceof org.sonatype.aether.resolution.ArtifactResolutionException
753             && !( e.getCause().getCause() instanceof ArtifactNotFoundException ) )
754         {
755             return true;
756         }
757         return false;
758     }
759 
760     private Properties getSystemProperties()
761     {
762         Properties props = new Properties();
763 
764         EnvironmentUtils.addEnvVars( props );
765 
766         props.putAll( System.getProperties() );
767 
768         return props;
769     }
770 
771     private static final class ProjectRelocation
772     {
773         private MavenProject project;
774 
775         private Artifact pomArtifact;
776 
777         private Artifact relocatedArtifact;
778     }
779 
780 }