ArtifactResolutionResult (ArtifactResolutionRequest request ) { Artifact rootArtifact = request.getArtifact(); Set<Artifact> artifacts = request.getArtifactDependencies(); Map<String, Artifact> managedVersions = request.getManagedVersionMap(); List<ResolutionListener> 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<ResolutionListener>(); 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<Artifact> directArtifacts = resolutionGroup.getArtifacts(); if ( artifacts == null || artifacts.isEmpty() ) { artifacts = directArtifacts; } else { List<Artifact> allArtifacts = new ArrayList<Artifact>(); allArtifacts.addAll( artifacts ); allArtifacts.addAll( directArtifacts ); Map<String, Artifact> mergedArtifacts = new LinkedHashMap<String, Artifact>(); for ( Artifact artifact : allArtifacts ) { String conflictId = artifact.getDependencyConflictId(); if ( !mergedArtifacts.containsKey( conflictId ) ) { mergedArtifacts.put( conflictId, artifact ); } } artifacts = new LinkedHashSet<Artifact>( 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<Artifact> allArtifacts = new LinkedHashSet<Artifact>(); allArtifacts.add( rootArtifact ); allArtifacts.addAll( result.getArtifacts() ); result.setArtifacts( allArtifacts ); } return result; }