001 package org.apache.maven.project.artifact; 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 022 import java.io.File; 023 import java.util.ArrayList; 024 import java.util.Arrays; 025 import java.util.Collection; 026 import java.util.Collections; 027 import java.util.HashMap; 028 import java.util.LinkedHashMap; 029 import java.util.LinkedHashSet; 030 import java.util.List; 031 import java.util.Map; 032 import java.util.Properties; 033 import java.util.Set; 034 035 import org.apache.maven.artifact.Artifact; 036 import org.apache.maven.artifact.factory.ArtifactFactory; 037 import org.apache.maven.artifact.metadata.ArtifactMetadataRetrievalException; 038 import org.apache.maven.artifact.metadata.ArtifactMetadataSource; 039 import org.apache.maven.artifact.metadata.ResolutionGroup; 040 import org.apache.maven.artifact.repository.ArtifactRepository; 041 import org.apache.maven.artifact.repository.metadata.ArtifactRepositoryMetadata; 042 import org.apache.maven.artifact.repository.metadata.Metadata; 043 import org.apache.maven.artifact.repository.metadata.RepositoryMetadata; 044 import org.apache.maven.artifact.repository.metadata.RepositoryMetadataManager; 045 import org.apache.maven.artifact.repository.metadata.RepositoryMetadataResolutionException; 046 import org.apache.maven.artifact.resolver.ArtifactResolutionException; 047 import org.apache.maven.artifact.resolver.MultipleArtifactsNotFoundException; 048 import org.apache.maven.artifact.resolver.filter.AndArtifactFilter; 049 import org.apache.maven.artifact.resolver.filter.ArtifactFilter; 050 import org.apache.maven.artifact.resolver.filter.ExcludesArtifactFilter; 051 import org.apache.maven.artifact.versioning.ArtifactVersion; 052 import org.apache.maven.artifact.versioning.DefaultArtifactVersion; 053 import org.apache.maven.artifact.versioning.InvalidVersionSpecificationException; 054 import org.apache.maven.artifact.versioning.VersionRange; 055 import org.apache.maven.execution.MavenSession; 056 import org.apache.maven.model.Dependency; 057 import org.apache.maven.model.DependencyManagement; 058 import org.apache.maven.model.DistributionManagement; 059 import org.apache.maven.model.Exclusion; 060 import org.apache.maven.model.Relocation; 061 import org.apache.maven.model.building.ModelBuildingException; 062 import org.apache.maven.model.building.ModelBuildingRequest; 063 import org.apache.maven.model.building.ModelProblem; 064 import org.apache.maven.model.resolution.UnresolvableModelException; 065 import org.apache.maven.plugin.LegacySupport; 066 import org.apache.maven.project.DefaultProjectBuildingRequest; 067 import org.apache.maven.project.MavenProject; 068 import org.apache.maven.project.ProjectBuilder; 069 import org.apache.maven.project.ProjectBuildingException; 070 import org.apache.maven.project.ProjectBuildingRequest; 071 import org.apache.maven.properties.internal.EnvironmentUtils; 072 import org.apache.maven.repository.legacy.metadata.DefaultMetadataResolutionRequest; 073 import org.apache.maven.repository.legacy.metadata.MetadataResolutionRequest; 074 import org.codehaus.plexus.PlexusContainer; 075 import org.codehaus.plexus.component.annotations.Component; 076 import org.codehaus.plexus.component.annotations.Requirement; 077 import org.codehaus.plexus.component.repository.exception.ComponentLookupException; 078 import org.codehaus.plexus.logging.Logger; 079 import org.sonatype.aether.RepositorySystemSession; 080 import org.sonatype.aether.repository.RepositoryPolicy; 081 import org.sonatype.aether.transfer.ArtifactNotFoundException; 082 083 /** 084 * @author Jason van Zyl 085 */ 086 @Component( role = ArtifactMetadataSource.class, hint = "maven" ) 087 public class MavenMetadataSource 088 implements ArtifactMetadataSource 089 { 090 @Requirement 091 private RepositoryMetadataManager repositoryMetadataManager; 092 093 @Requirement 094 private ArtifactFactory repositorySystem; 095 096 //TODO: This prevents a cycle in the composition which shows us another problem we need to deal with. 097 //@Requirement 098 private ProjectBuilder projectBuilder; 099 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 }