From 93a38a4d1bb9cc1d4b33776ef11b6ff3a5dedbcf Mon Sep 17 00:00:00 2001 From: Sergey Evdokimov Date: Wed, 10 Oct 2012 18:16:51 +0400 Subject: [PATCH] Support Maven 3: resolving of module dependency --- .../lib/maven3/lib/maven-compat-3.0.3.jar | Bin 281507 -> 281591 bytes .../server/Maven3ServerEmbedderImpl.java | 16 +- .../CustomMaven3ArtifactResolver.java | 637 ++++++++++++++++-- 3 files changed, 607 insertions(+), 46 deletions(-) diff --git a/plugins/maven/maven3-server-impl/lib/maven3/lib/maven-compat-3.0.3.jar b/plugins/maven/maven3-server-impl/lib/maven3/lib/maven-compat-3.0.3.jar index e44987e765bfe2727712829b619159591d5dbd41..3fffcc8ceeed46bd37acbb167fa6b761a457c83e 100644 GIT binary patch delta 4967 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 IRP;Rl4}NjfLjV8( diff --git a/plugins/maven/maven3-server-impl/src/org/jetbrains/idea/maven/server/Maven3ServerEmbedderImpl.java b/plugins/maven/maven3-server-impl/src/org/jetbrains/idea/maven/server/Maven3ServerEmbedderImpl.java index ef973e590521..5137d3750eb9 100644 --- a/plugins/maven/maven3-server-impl/src/org/jetbrains/idea/maven/server/Maven3ServerEmbedderImpl.java +++ b/plugins/maven/maven3-server-impl/src/org/jetbrains/idea/maven/server/Maven3ServerEmbedderImpl.java @@ -70,6 +70,7 @@ import org.codehaus.plexus.personality.plexus.lifecycle.phase.InitializationExce import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.idea.maven.model.*; +import org.jetbrains.idea.maven.server.embedder.CustomMaven3ArtifactResolver; import org.jetbrains.idea.maven.server.embedder.CustomMaven3ModelInterpolator; import org.jetbrains.idea.maven.server.embedder.FieldAccessor; import org.jetbrains.idea.maven.server.embedder.MavenExecutionResult; @@ -247,7 +248,7 @@ public class Maven3ServerEmbedderImpl extends MavenRemoteObject implements Maven try { //((CustomArtifactFactory)getComponent(ArtifactFactory.class)).customize(); //((CustomArtifactFactory)getComponent(ProjectArtifactFactory.class)).customize(); - //((CustomArtifactResolver)getComponent(ArtifactResolver.class)).customize(workspaceMap, failOnUnresolvedDependency); + ((CustomMaven3ArtifactResolver)getComponent(ArtifactResolver.class)).customize(workspaceMap, failOnUnresolvedDependency); //((CustomRepositoryMetadataManager)getComponent(RepositoryMetadataManager.class)).customize(workspaceMap); //((CustomMaven3WagonManager)getComponent(WagonManager.class)).customize(failOnUnresolvedDependency); @@ -580,6 +581,19 @@ public class Maven3ServerEmbedderImpl extends MavenRemoteObject implements Maven @Override public void reset() throws RemoteException { + try { + setConsoleAndIndicator(null, null); + + //((CustomArtifactFactory)getComponent(ProjectArtifactFactory.class)).reset(); + //((CustomArtifactFactory)getComponent(ArtifactFactory.class)).reset(); + ((CustomMaven3ArtifactResolver)getComponent(ArtifactResolver.class)).reset(); + //((CustomRepositoryMetadataManager)getComponent(RepositoryMetadataManager.class)).reset(); + //((CustomWagonManager)getComponent(WagonManager.class)).reset(); + } + catch (Exception e) { + throw rethrowException(e); + } + } @Override diff --git a/plugins/maven/maven3-server-impl/src/org/jetbrains/idea/maven/server/embedder/CustomMaven3ArtifactResolver.java b/plugins/maven/maven3-server-impl/src/org/jetbrains/idea/maven/server/embedder/CustomMaven3ArtifactResolver.java index daa9dcbfb3a9..3b990a11f2d8 100644 --- a/plugins/maven/maven3-server-impl/src/org/jetbrains/idea/maven/server/embedder/CustomMaven3ArtifactResolver.java +++ b/plugins/maven/maven3-server-impl/src/org/jetbrains/idea/maven/server/embedder/CustomMaven3ArtifactResolver.java @@ -1,36 +1,524 @@ -/* - * Copyright 2000-2009 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ package org.jetbrains.idea.maven.server.embedder; +import org.apache.maven.RepositoryUtils; import org.apache.maven.artifact.Artifact; +import org.apache.maven.artifact.factory.ArtifactFactory; +import org.apache.maven.artifact.metadata.ArtifactMetadataRetrievalException; +import org.apache.maven.artifact.metadata.ArtifactMetadataSource; +import org.apache.maven.artifact.metadata.ResolutionGroup; import org.apache.maven.artifact.repository.ArtifactRepository; -import org.apache.maven.artifact.resolver.AbstractArtifactResolutionException; -import org.apache.maven.artifact.resolver.ArtifactNotFoundException; -import org.apache.maven.artifact.resolver.ArtifactResolutionException; -import org.apache.maven.artifact.resolver.DefaultArtifactResolver; +import org.apache.maven.artifact.repository.LegacyLocalRepositoryManager; +import org.apache.maven.artifact.repository.RepositoryRequest; +import org.apache.maven.artifact.repository.metadata.Snapshot; +import org.apache.maven.artifact.repository.metadata.SnapshotArtifactRepositoryMetadata; +import org.apache.maven.artifact.resolver.*; +import org.apache.maven.artifact.resolver.filter.ArtifactFilter; +import org.apache.maven.execution.MavenSession; +import org.apache.maven.plugin.LegacySupport; +import org.apache.maven.repository.legacy.metadata.DefaultMetadataResolutionRequest; +import org.apache.maven.repository.legacy.metadata.MetadataResolutionRequest; +import org.apache.maven.repository.legacy.resolver.conflict.ConflictResolver; +import org.apache.maven.wagon.events.TransferListener; +import org.codehaus.plexus.PlexusContainer; +import org.codehaus.plexus.component.annotations.Component; +import org.codehaus.plexus.component.annotations.Requirement; +import org.codehaus.plexus.component.repository.exception.ComponentLookupException; +import org.codehaus.plexus.logging.Logger; import org.jetbrains.idea.maven.model.MavenWorkspaceMap; import org.jetbrains.idea.maven.server.MavenModelConverter; import org.jetbrains.idea.maven.server.UnresolvedArtifactsCollector; +import org.sonatype.aether.RepositorySystem; +import org.sonatype.aether.RepositorySystemSession; +import org.sonatype.aether.repository.LocalRepositoryManager; +import org.sonatype.aether.resolution.ArtifactRequest; +import org.sonatype.aether.resolution.ArtifactResult; -import java.util.List; +import java.io.File; +import java.util.*; +import java.util.concurrent.*; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.regex.Matcher; + +/** + * Copy pasted from org.apache.maven.artifact.resolver.DefaultArtifactResolver, + * overriden method resolve( Artifact artifact, List remoteRepositories, RepositorySystemSession session ) + * @author Sergey Evdokimov + */ +@Component(role = ArtifactResolver.class) +public class CustomMaven3ArtifactResolver + implements ArtifactResolver +{ + @Requirement + private Logger logger; + + @Requirement + protected ArtifactFactory artifactFactory; + + @Requirement + private ArtifactCollector artifactCollector; + + @Requirement + private ResolutionErrorHandler resolutionErrorHandler; + + @Requirement + private ArtifactMetadataSource source; + + @Requirement + private PlexusContainer container; + + @Requirement + private LegacySupport legacySupport; + + @Requirement + private RepositorySystem repoSystem; + + private final Executor executor; -public class CustomMaven3ArtifactResolver extends DefaultArtifactResolver { private MavenWorkspaceMap myWorkspaceMap; private UnresolvedArtifactsCollector myUnresolvedCollector; + + public CustomMaven3ArtifactResolver() + { + int threads = Integer.getInteger( "maven.artifact.threads", 5 ).intValue(); + if ( threads <= 1 ) + { + executor = new Executor() + { + public void execute( Runnable command ) + { + command.run(); + } + }; + } + else + { + executor = + new ThreadPoolExecutor( threads, threads, 3, TimeUnit.SECONDS, new LinkedBlockingQueue(), new DaemonThreadCreator()); + } + } + + @Override + protected void finalize() + throws Throwable + { + if ( executor instanceof ExecutorService ) + { + ( (ExecutorService) executor ).shutdown(); + } + } + + private RepositorySystemSession getSession( ArtifactRepository localRepository ) + { + return LegacyLocalRepositoryManager.overlay( localRepository, legacySupport.getRepositorySession(), repoSystem ); + } + + private void injectSession1( RepositoryRequest request, MavenSession session ) + { + if ( session != null ) + { + request.setOffline( session.isOffline() ); + request.setForceUpdate( session.getRequest().isUpdateSnapshots() ); + } + } + + private void injectSession2( ArtifactResolutionRequest request, MavenSession session ) + { + injectSession1( request, session ); + + if ( session != null ) + { + request.setServers( session.getRequest().getServers() ); + request.setMirrors( session.getRequest().getMirrors() ); + request.setProxies( session.getRequest().getProxies() ); + } + } + + public void resolve( Artifact artifact, List remoteRepositories, ArtifactRepository localRepository, TransferListener resolutionListener ) + throws ArtifactResolutionException, ArtifactNotFoundException + { + resolve( artifact, remoteRepositories, getSession( localRepository ) ); + } + + public void resolveAlways( Artifact artifact, List remoteRepositories, ArtifactRepository localRepository ) + throws ArtifactResolutionException, ArtifactNotFoundException + { + resolve( artifact, remoteRepositories, getSession( localRepository ) ); + } + + private void resolve( Artifact artifact, List remoteRepositories, RepositorySystemSession session ) + throws ArtifactResolutionException, ArtifactNotFoundException { + if (resolveAsModule(artifact)) return; + try { + resolveOld(artifact, remoteRepositories, session); + } + catch (AbstractArtifactResolutionException e) { + myUnresolvedCollector.collectAndSetResolved(artifact); + } + } + + private void resolveOld( Artifact artifact, List remoteRepositories, RepositorySystemSession session ) + throws ArtifactResolutionException, ArtifactNotFoundException + { + if ( artifact == null ) + { + return; + } + + if ( Artifact.SCOPE_SYSTEM.equals( artifact.getScope() ) ) + { + File systemFile = artifact.getFile(); + + if ( systemFile == null ) + { + throw new ArtifactNotFoundException( "System artifact: " + artifact + " has no file attached", artifact ); + } + + if ( !systemFile.exists() ) + { + throw new ArtifactNotFoundException( "System artifact: " + artifact + " not found in path: " + systemFile, artifact ); + } + + if ( !systemFile.isFile() ) + { + throw new ArtifactNotFoundException( "System artifact: " + artifact + " is not a file: " + systemFile, artifact ); + } + + artifact.setResolved( true ); + + return; + } + + if ( !artifact.isResolved() ) + { + ArtifactResult result; + + try + { + ArtifactRequest artifactRequest = new ArtifactRequest(); + artifactRequest.setArtifact( RepositoryUtils.toArtifact( artifact ) ); + artifactRequest.setRepositories( RepositoryUtils.toRepos( remoteRepositories ) ); + + // Maven 2.x quirk: an artifact always points at the local repo, regardless whether resolved or not + LocalRepositoryManager lrm = session.getLocalRepositoryManager(); + String path = lrm.getPathForLocalArtifact( artifactRequest.getArtifact() ); + artifact.setFile( new File( lrm.getRepository().getBasedir(), path ) ); + + result = repoSystem.resolveArtifact( session, artifactRequest ); + } + catch ( org.sonatype.aether.resolution.ArtifactResolutionException e ) + { + if ( e.getCause() instanceof org.sonatype.aether.transfer.ArtifactNotFoundException ) + { + throw new ArtifactNotFoundException( e.getMessage(), artifact, remoteRepositories, e ) {}; + } + else + { + throw new ArtifactResolutionException( e.getMessage(), artifact, remoteRepositories, e ); + } + } + + artifact.selectVersion( result.getArtifact().getVersion() ); + artifact.setFile( result.getArtifact().getFile() ); + artifact.setResolved( true ); + + if ( artifact.isSnapshot() ) + { + Matcher matcher = Artifact.VERSION_FILE_PATTERN.matcher( artifact.getVersion() ); + if ( matcher.matches() ) + { + Snapshot snapshot = new Snapshot(); + snapshot.setTimestamp( matcher.group( 2 ) ); + try + { + snapshot.setBuildNumber( Integer.parseInt( matcher.group( 3 ) ) ); + artifact.addMetadata( new SnapshotArtifactRepositoryMetadata( artifact, snapshot ) ); + } + catch ( NumberFormatException e ) + { + logger.warn( "Invalid artifact version " + artifact.getVersion() + ": " + e.getMessage() ); + } + } + } + } + } + + public ArtifactResolutionResult resolveTransitively( Set artifacts, Artifact originatingArtifact, ArtifactRepository localRepository, List remoteRepositories, + ArtifactMetadataSource source, ArtifactFilter filter ) + throws ArtifactResolutionException, ArtifactNotFoundException + { + return resolveTransitively( artifacts, originatingArtifact, Collections.EMPTY_MAP, localRepository, remoteRepositories, source, filter ); + + } + + public ArtifactResolutionResult resolveTransitively( Set artifacts, Artifact originatingArtifact, Map managedVersions, ArtifactRepository localRepository, + List remoteRepositories, ArtifactMetadataSource source ) + throws ArtifactResolutionException, ArtifactNotFoundException + { + return resolveTransitively( artifacts, originatingArtifact, managedVersions, localRepository, remoteRepositories, source, null ); + } + + public ArtifactResolutionResult resolveTransitively( Set artifacts, Artifact originatingArtifact, Map managedVersions, ArtifactRepository localRepository, + List remoteRepositories, ArtifactMetadataSource source, ArtifactFilter filter ) + throws ArtifactResolutionException, ArtifactNotFoundException + { + return resolveTransitively( artifacts, originatingArtifact, managedVersions, localRepository, remoteRepositories, source, filter, null ); + } + + public ArtifactResolutionResult resolveTransitively( Set artifacts, Artifact originatingArtifact, List remoteRepositories, ArtifactRepository localRepository, + ArtifactMetadataSource source ) + throws ArtifactResolutionException, ArtifactNotFoundException + { + return resolveTransitively( artifacts, originatingArtifact, localRepository, remoteRepositories, source, null ); + } + + public ArtifactResolutionResult resolveTransitively( Set artifacts, Artifact originatingArtifact, List remoteRepositories, ArtifactRepository localRepository, + ArtifactMetadataSource source, List listeners ) + throws ArtifactResolutionException, ArtifactNotFoundException + { + return resolveTransitively( artifacts, originatingArtifact, Collections.EMPTY_MAP, localRepository, + remoteRepositories, source, null, listeners ); + } + + public ArtifactResolutionResult resolveTransitively( Set artifacts, Artifact originatingArtifact, Map managedVersions, ArtifactRepository localRepository, + List remoteRepositories, ArtifactMetadataSource source, ArtifactFilter filter, List listeners ) + throws ArtifactResolutionException, ArtifactNotFoundException + { + return resolveTransitively( artifacts, originatingArtifact, managedVersions, localRepository, remoteRepositories, source, filter, listeners, null ); + } + + public ArtifactResolutionResult resolveTransitively( Set artifacts, Artifact originatingArtifact, Map managedVersions, ArtifactRepository localRepository, + List remoteRepositories, ArtifactMetadataSource source, ArtifactFilter filter, List listeners, + List conflictResolvers ) + throws ArtifactResolutionException, ArtifactNotFoundException + { + ArtifactResolutionRequest request = new ArtifactResolutionRequest() + .setArtifact( originatingArtifact ) + .setResolveRoot( false ) + // This is required by the surefire plugin + .setArtifactDependencies( artifacts ) + .setManagedVersionMap( managedVersions ) + .setLocalRepository( localRepository ) + .setRemoteRepositories( remoteRepositories ) + .setCollectionFilter( filter ) + .setListeners( listeners ); + + injectSession2( request, legacySupport.getSession() ); + + return resolveWithExceptions( request ); + } + + public ArtifactResolutionResult resolveWithExceptions( ArtifactResolutionRequest request ) + throws ArtifactResolutionException, ArtifactNotFoundException + { + ArtifactResolutionResult result = resolve( request ); + + // We have collected all the problems so let's mimic the way the old code worked and just blow up right here. + // That's right lets just let it rip right here and send a big incomprehensible blob of text at unsuspecting + // users. Bad dog! + + resolutionErrorHandler.throwErrors( request, result ); + + return result; + } + + // ------------------------------------------------------------------------ + // + // ------------------------------------------------------------------------ + + public ArtifactResolutionResult resolve( ArtifactResolutionRequest request ) + { + Artifact rootArtifact = request.getArtifact(); + Set artifacts = request.getArtifactDependencies(); + Map managedVersions = request.getManagedVersionMap(); + List listeners = request.getListeners(); + ArtifactFilter collectionFilter = request.getCollectionFilter(); + ArtifactFilter resolutionFilter = request.getResolutionFilter(); + RepositorySystemSession session = getSession( request.getLocalRepository() ); + + //TODO: hack because metadata isn't generated in m2e correctly and i want to run the maven i have in the workspace + if ( source == null ) + { + try + { + source = container.lookup( ArtifactMetadataSource.class ); + } + catch ( ComponentLookupException e ) + { + // won't happen + } + } + + if ( listeners == null ) + { + listeners = new ArrayList(); + + if ( logger.isDebugEnabled() ) + { + listeners.add( new DebugResolutionListener( logger ) ); + } + + listeners.add( new WarningResolutionListener( logger ) ); + } + + ArtifactResolutionResult result = new ArtifactResolutionResult(); + + // The root artifact may, or may not be resolved so we need to check before we attempt to resolve. + // This is often an artifact like a POM that is taken from disk and we already have hold of the + // file reference. But this may be a Maven Plugin that we need to resolve from a remote repository + // as well as its dependencies. + + if ( request.isResolveRoot() /* && rootArtifact.getFile() == null */ ) + { + try + { + resolve( rootArtifact, request.getRemoteRepositories(), session ); + } + catch ( ArtifactResolutionException e ) + { + result.addErrorArtifactException( e ); + return result; + } + catch ( ArtifactNotFoundException e ) + { + result.addMissingArtifact( request.getArtifact() ); + return result; + } + } + + ArtifactResolutionRequest collectionRequest = request; + + if ( request.isResolveTransitively() ) + { + MetadataResolutionRequest metadataRequest = new DefaultMetadataResolutionRequest( request ); + + metadataRequest.setArtifact( rootArtifact ); + metadataRequest.setResolveManagedVersions( managedVersions == null ); + + try + { + ResolutionGroup resolutionGroup = source.retrieve( metadataRequest ); + + if ( managedVersions == null ) + { + managedVersions = resolutionGroup.getManagedVersions(); + } + + Set directArtifacts = resolutionGroup.getArtifacts(); + + if ( artifacts == null || artifacts.isEmpty() ) + { + artifacts = directArtifacts; + } + else + { + List allArtifacts = new ArrayList(); + allArtifacts.addAll( artifacts ); + allArtifacts.addAll( directArtifacts ); + + Map mergedArtifacts = new LinkedHashMap(); + for ( Artifact artifact : allArtifacts ) + { + String conflictId = artifact.getDependencyConflictId(); + if ( !mergedArtifacts.containsKey( conflictId ) ) + { + mergedArtifacts.put( conflictId, artifact ); + } + } + + artifacts = new LinkedHashSet( mergedArtifacts.values() ); + } + + collectionRequest = new ArtifactResolutionRequest( request ); + collectionRequest.setServers( request.getServers() ); + collectionRequest.setMirrors( request.getMirrors() ); + collectionRequest.setProxies( request.getProxies() ); + collectionRequest.setRemoteRepositories( resolutionGroup.getResolutionRepositories() ); + } + catch ( ArtifactMetadataRetrievalException e ) + { + ArtifactResolutionException are = + new ArtifactResolutionException( "Unable to get dependency information for " + rootArtifact.getId() + + ": " + e.getMessage(), rootArtifact, metadataRequest.getRemoteRepositories(), e ); + result.addMetadataResolutionException( are ); + return result; + } + } + + if ( artifacts == null || artifacts.isEmpty() ) + { + if ( request.isResolveRoot() ) + { + result.addArtifact( rootArtifact ); + } + return result; + } + + // After the collection we will have the artifact object in the result but they will not be resolved yet. + result = + artifactCollector.collect( artifacts, rootArtifact, managedVersions, collectionRequest, source, + collectionFilter, listeners, null ); + + // We have metadata retrieval problems, or there are cycles that have been detected + // so we give this back to the calling code and let them deal with this information + // appropriately. + + if ( result.hasMetadataResolutionExceptions() || result.hasVersionRangeViolations() || result.hasCircularDependencyExceptions() ) + { + return result; + } + + if ( result.getArtifactResolutionNodes() != null ) + { + ClassLoader classLoader = Thread.currentThread().getContextClassLoader(); + + CountDownLatch latch = new CountDownLatch( result.getArtifactResolutionNodes().size() ); + + for ( ResolutionNode node : result.getArtifactResolutionNodes() ) + { + Artifact artifact = node.getArtifact(); + + if ( resolutionFilter == null || resolutionFilter.include( artifact ) ) + { + executor.execute( new ResolveTask( classLoader, latch, artifact, session, + node.getRemoteRepositories(), result ) ); + } + else + { + latch.countDown(); + } + } + try + { + latch.await(); + } + catch ( InterruptedException e ) + { + result.addErrorArtifactException( new ArtifactResolutionException( "Resolution interrupted", + rootArtifact, e ) ); + } + } + + // We want to send the root artifact back in the result but we need to do this after the other dependencies + // have been resolved. + if ( request.isResolveRoot() ) + { + // Add the root artifact (as the first artifact to retain logical order of class path!) + Set allArtifacts = new LinkedHashSet(); + allArtifacts.add( rootArtifact ); + allArtifacts.addAll( result.getArtifacts() ); + result.setArtifacts( allArtifacts ); + } + + return result; + } + + public void resolve( Artifact artifact, List remoteRepositories, ArtifactRepository localRepository ) + throws ArtifactResolutionException, ArtifactNotFoundException + { + resolve( artifact, remoteRepositories, localRepository, null ); + } + public void customize(MavenWorkspaceMap workspaceMap, boolean failOnUnresolved) { myWorkspaceMap = workspaceMap; myUnresolvedCollector = new UnresolvedArtifactsCollector(failOnUnresolved); @@ -45,30 +533,6 @@ public class CustomMaven3ArtifactResolver extends DefaultArtifactResolver { return myUnresolvedCollector; } - @Override - public void resolve(Artifact artifact, List remoteRepositories, ArtifactRepository localRepository) - throws ArtifactResolutionException, ArtifactNotFoundException { - if (resolveAsModule(artifact)) return; - try { - super.resolve(artifact, remoteRepositories, localRepository); - } - catch (AbstractArtifactResolutionException e) { - myUnresolvedCollector.collectAndSetResolved(artifact); - } - } - - @Override - public void resolveAlways(Artifact artifact, List remoteRepositories, ArtifactRepository localRepository) - throws ArtifactResolutionException, ArtifactNotFoundException { - if (resolveAsModule(artifact)) return; - try { - super.resolveAlways(artifact, remoteRepositories, localRepository); - } - catch (AbstractArtifactResolutionException e) { - myUnresolvedCollector.collectAndSetResolved(artifact); - } - } - private boolean resolveAsModule(Artifact a) { // method is called from different threads, so we have to copy the reference so ensure there is no race conditions. MavenWorkspaceMap map = myWorkspaceMap; @@ -83,4 +547,87 @@ public class CustomMaven3ArtifactResolver extends DefaultArtifactResolver { return true; } + + /** + * ThreadCreator for creating daemon threads with fixed ThreadGroup-name. + */ + final static class DaemonThreadCreator + implements ThreadFactory + { + static final String THREADGROUP_NAME = "org.apache.maven.artifact.resolver.DefaultArtifactResolver"; + + final static ThreadGroup group = new ThreadGroup( THREADGROUP_NAME ); + + final static AtomicInteger threadNumber = new AtomicInteger( 1 ); + + public Thread newThread( Runnable r ) + { + Thread newThread = new Thread( group, r, "resolver-" + threadNumber.getAndIncrement() ); + newThread.setDaemon( true ); + return newThread; + } + } + + private class ResolveTask + implements Runnable + { + + private final ClassLoader classLoader; + + private final CountDownLatch latch; + + private final Artifact artifact; + + private final RepositorySystemSession session; + + private final List remoteRepositories; + + private final ArtifactResolutionResult result; + + public ResolveTask( ClassLoader classLoader, CountDownLatch latch, Artifact artifact, RepositorySystemSession session, + List remoteRepositories, ArtifactResolutionResult result ) + { + this.classLoader = classLoader; + this.latch = latch; + this.artifact = artifact; + this.session = session; + this.remoteRepositories = remoteRepositories; + this.result = result; + } + + public void run() + { + try + { + Thread.currentThread().setContextClassLoader( classLoader ); + resolve( artifact, remoteRepositories, session ); + } + catch ( ArtifactNotFoundException anfe ) + { + // These are cases where the artifact just isn't present in any of the remote repositories + // because it wasn't deployed, or it was deployed in the wrong place. + + synchronized ( result ) + { + result.addMissingArtifact( artifact ); + } + } + catch ( ArtifactResolutionException e ) + { + // This is really a wagon TransferFailedException so something went wrong after we successfully + // retrieved the metadata. + + synchronized ( result ) + { + result.addErrorArtifactException( e ); + } + } + finally + { + latch.countDown(); + } + } + + } + }