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