throws ArtifactResolutionException
{
List<ArtifactResult> results = new ArrayList<ArtifactResult>( requests.size() );
boolean failures = false;
LocalRepositoryManager lrm = session.getLocalRepositoryManager();
WorkspaceReader workspace = session.getWorkspaceReader();
List<ResolutionGroup> groups = new ArrayList<ResolutionGroup>();
for ( ArtifactRequest request : requests )
{
RequestTrace trace = DefaultRequestTrace.newChild( request.getTrace(), request );
ArtifactResult result = new ArtifactResult( request );
results.add( result );
Artifact artifact = request.getArtifact();
List<RemoteRepository> repos = request.getRepositories();
artifactResolving( session, trace, artifact );
String localPath = artifact.getProperty( ArtifactProperties.LOCAL_PATH, null );
if ( localPath != null )
{
// unhosted artifact, just validate file
File file = new File( localPath );
if ( !file.isFile() )
{
failures = true;
result.addException( new ArtifactNotFoundException( artifact, null ) );
}
else
{
artifact = artifact.setFile( file );
result.setArtifact( artifact );
artifactResolved( session, trace, artifact, null, result.getExceptions() );
}
continue;
}
VersionResult versionResult;
try
{
VersionRequest versionRequest = new VersionRequest( artifact, repos, request.getRequestContext() );
versionRequest.setTrace( trace );
versionResult = versionResolver.resolveVersion( session, versionRequest );
}
catch ( VersionResolutionException e )
{
result.addException( e );
continue;
}
artifact = artifact.setVersion( versionResult.getVersion() );
if ( versionResult.getRepository() != null )
{
if ( versionResult.getRepository() instanceof RemoteRepository )
{
repos = Collections.singletonList( (RemoteRepository) versionResult.getRepository() );
}
else
{
repos = Collections.emptyList();
}
}
if ( workspace != null )
{
File file = workspace.findArtifact( artifact );
if ( file != null )
{
artifact = artifact.setFile( file );
result.setArtifact( artifact );
result.setRepository( workspace.getRepository() );
artifactResolved( session, trace, artifact, result.getRepository(), null );
continue;
}
}
LocalArtifactResult local =
lrm.find( session, new LocalArtifactRequest( artifact, repos, request.getRequestContext() ) );
if ( local.isAvailable()
|| ( local.getFile() != null && versionResult.getRepository() instanceof LocalRepository ) )
{
if ( local.getRepository() != null )
{
result.setRepository( local.getRepository() );
}
else
{
result.setRepository( lrm.getRepository() );
}
try
{
artifact = artifact.setFile( getFile( session, artifact, local.getFile() ) );
result.setArtifact( artifact );
artifactResolved( session, trace, artifact, result.getRepository(), null );
}
catch ( ArtifactTransferException e )
{
result.addException( e );
}
if ( !local.isAvailable() )
{
/*
* NOTE: Interop with Maven 2.x: An artifact installed by Maven 2.x will not show up in the
* repository tracking file of the local repository. If however the maven-metadata-local.xml tells
* us the artifact was installed, we sync the repository tracking file.
*/
lrm.add( session, new LocalArtifactRegistration( artifact ) );
}
continue;
}
else if ( local.getFile() != null )
{
logger.debug( "Verifying availability of " + local.getFile() + " from " + repos );
}
if ( session.isOffline() )
{
Exception exception =
new ArtifactNotFoundException( artifact, null, "The repository system is offline but the artifact "
+ artifact + " is not available in the local repository." );
result.addException( exception );
artifactResolved( session, trace, artifact, null, result.getExceptions() );
continue;
}
AtomicBoolean resolved = new AtomicBoolean( false );
Iterator<ResolutionGroup> groupIt = groups.iterator();
for ( RemoteRepository repo : repos )
{
if ( !repo.getPolicy( artifact.isSnapshot() ).isEnabled() )
{
continue;
}
ResolutionGroup group = null;
while ( groupIt.hasNext() )
{
ResolutionGroup t = groupIt.next();
if ( t.matches( repo ) )
{
group = t;
break;
}
}
if ( group == null )
{
group = new ResolutionGroup( repo );
groups.add( group );
groupIt = Collections.<ResolutionGroup> emptyList().iterator();
}
group.items.add( new ResolutionItem( trace, artifact, resolved, result, local, repo ) );
}
}
for ( ResolutionGroup group : groups )
{
List<ArtifactDownload> downloads = new ArrayList<ArtifactDownload>();
for ( ResolutionItem item : group.items )
{
Artifact artifact = item.artifact;
if ( item.resolved.get() )
{
// resolved in previous resolution group
continue;
}
ArtifactDownload download = new ArtifactDownload();
download.setArtifact( artifact );
download.setRequestContext( item.request.getRequestContext() );
download.setTrace( item.trace );
if ( item.local.getFile() != null )
{
download.setFile( item.local.getFile() );
download.setExistenceCheck( true );
}
else
{
String path =
lrm.getPathForRemoteArtifact( artifact, group.repository, item.request.getRequestContext() );
download.setFile( new File( lrm.getRepository().getBasedir(), path ) );
}
boolean snapshot = artifact.isSnapshot();
RepositoryPolicy policy =
remoteRepositoryManager.getPolicy( session, group.repository, !snapshot, snapshot );
if ( session.isNotFoundCachingEnabled() || session.isTransferErrorCachingEnabled() )
{
UpdateCheck<Artifact, ArtifactTransferException> check =
new UpdateCheck<Artifact, ArtifactTransferException>();
check.setItem( artifact );
check.setFile( download.getFile() );
check.setRepository( group.repository );
check.setPolicy( policy.getUpdatePolicy() );
item.updateCheck = check;
updateCheckManager.checkArtifact( session, check );
if ( !check.isRequired() && check.getException() != null )
{
item.result.addException( check.getException() );
continue;
}
}
download.setChecksumPolicy( policy.getChecksumPolicy() );
download.setRepositories( item.repository.getMirroredRepositories() );
downloads.add( download );
item.download = download;
}
if ( downloads.isEmpty() )
{
continue;
}
for ( ArtifactDownload download : downloads )
{
artifactDownloading( session, download.getTrace(), download.getArtifact(), group.repository );
}
try
{
RepositoryConnector connector =
remoteRepositoryManager.getRepositoryConnector( session, group.repository );
try
{
connector.get( downloads, null );
}
finally
{
connector.close();
}
}
catch ( NoRepositoryConnectorException e )
{
for ( ArtifactDownload download : downloads )
{
download.setException( new ArtifactTransferException( download.getArtifact(), group.repository, e ) );
}
}
for ( ResolutionItem item : group.items )
{
ArtifactDownload download = item.download;
if ( download == null )
{
continue;
}
if ( item.updateCheck != null )
{
item.updateCheck.setException( download.getException() );
updateCheckManager.touchArtifact( session, item.updateCheck );
}
if ( download.getException() == null )
{
item.resolved.set( true );
item.result.setRepository( group.repository );
Artifact artifact = download.getArtifact();
try
{
artifact = artifact.setFile( getFile( session, artifact, download.getFile() ) );
item.result.setArtifact( artifact );
}
catch ( ArtifactTransferException e )
{
item.result.addException( e );
continue;
}
lrm.add( session,
new LocalArtifactRegistration( artifact, group.repository, download.getSupportedContexts() ) );
artifactDownloaded( session, download.getTrace(), artifact, group.repository, null );
artifactResolved( session, download.getTrace(), artifact, group.repository, null );