From 5d3227535832391d3fd7b91736405be1d0ea0f5c Mon Sep 17 00:00:00 2001 From: Cai Date: Tue, 14 Jun 2022 22:41:39 -0700 Subject: [PATCH 1/8] download pom in parallel --- .../collect/bf/BfDependencyCollector.java | 236 ++++++++++++++---- .../bf/DependencyProcessingContext.java | 13 +- 2 files changed, 204 insertions(+), 45 deletions(-) diff --git a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/BfDependencyCollector.java b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/BfDependencyCollector.java index c82eed941..f8152e877 100644 --- a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/BfDependencyCollector.java +++ b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/BfDependencyCollector.java @@ -26,12 +26,25 @@ import java.util.ArrayDeque; import java.util.ArrayList; import java.util.Collections; +import java.util.LinkedHashMap; import java.util.List; +import java.util.Map; import java.util.Queue; - +import java.util.Set; +import java.util.concurrent.Callable; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; +import java.util.function.Function; +import java.util.stream.Stream; + +import org.apache.commons.lang3.concurrent.ConcurrentUtils; import org.eclipse.aether.RepositorySystemSession; import org.eclipse.aether.RequestTrace; import org.eclipse.aether.artifact.Artifact; +import org.eclipse.aether.artifact.ArtifactType; +import org.eclipse.aether.artifact.DefaultArtifact; import org.eclipse.aether.collection.CollectRequest; import org.eclipse.aether.collection.DependencyManager; import org.eclipse.aether.collection.DependencySelector; @@ -53,12 +66,14 @@ import org.eclipse.aether.resolution.ArtifactDescriptorRequest; import org.eclipse.aether.resolution.ArtifactDescriptorResult; import org.eclipse.aether.resolution.VersionRangeRequest; -import org.eclipse.aether.resolution.VersionRangeResolutionException; import org.eclipse.aether.resolution.VersionRangeResult; import org.eclipse.aether.spi.locator.Service; import org.eclipse.aether.util.ConfigUtils; +import org.eclipse.aether.util.artifact.ArtifactIdUtils; import org.eclipse.aether.util.graph.manager.DependencyManagerUtils; import org.eclipse.aether.version.Version; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; import static org.eclipse.aether.internal.impl.collect.DefaultDependencyCycle.find; @@ -128,7 +143,8 @@ protected void doCollectDependencies( RepositorySystemSession session, RequestTr Args args = new Args( session, pool, context, versionContext, request, useSkip ? DependencyResolutionSkipper.defaultSkipper() - : DependencyResolutionSkipper.neverSkipper() ); + : DependencyResolutionSkipper.neverSkipper(), + new ParallelDescriptorResolver( session ) ); DependencySelector rootDepSelector = session.getDependencySelector() != null ? session.getDependencySelector().deriveChildSelector( context ) : null; @@ -142,10 +158,12 @@ protected void doCollectDependencies( RepositorySystemSession session, RequestTr List parents = Collections.singletonList( node ); for ( Dependency dependency : dependencies ) { - args.dependencyProcessingQueue.add( + DependencyProcessingContext processingContext = new DependencyProcessingContext( rootDepSelector, rootDepManager, rootDepTraverser, - rootVerFilter, repositories, managedDependencies, parents, - dependency ) ); + rootVerFilter, repositories, managedDependencies, parents, dependency, + PremanagedDependency.create( rootDepManager, dependency, + false, args.premanagedState ) ); + putToQueue( args, trace, processingContext, results ); } while ( !args.dependencyProcessingQueue.isEmpty() ) @@ -154,6 +172,7 @@ protected void doCollectDependencies( RepositorySystemSession session, RequestTr false ); } + args.resolver.shutdown(); args.skipper.report(); } @@ -162,57 +181,37 @@ private void processDependency( Args args, RequestTrace parent, Results results, DependencyProcessingContext context, List relocations, boolean disableVersionManagement ) { - if ( context.depSelector != null && !context.depSelector.selectDependency( context.dependency ) ) - { - return; - } - RequestTrace trace = collectStepTrace( parent, args.request.getRequestContext(), context.parents, context.dependency ); - PremanagedDependency preManaged = - PremanagedDependency.create( context.depManager, context.dependency, disableVersionManagement, - args.premanagedState ); - Dependency dependency = preManaged.getManagedDependency(); + PremanagedDependency preManaged = context.premanagedDependency; + Dependency dependency = context.dependency; boolean noDescriptor = isLackingDescriptor( dependency.getArtifact() ); - boolean traverse = !noDescriptor && ( context.depTraverser == null || context.depTraverser.traverseDependency( dependency ) ); - List versions; + Future resolutionResultFuture = args.resolver.find( dependency ); + DescriptorResolutionResult resolutionResult; VersionRangeResult rangeResult; try { - VersionRangeRequest rangeRequest = createVersionRangeRequest( args.request.getRequestContext(), trace, - context.repositories, dependency ); - - rangeResult = cachedResolveRangeResult( rangeRequest, args.pool, args.session ); - - versions = filterVersions( dependency, rangeResult, context.verFilter, args.versionContext ); + resolutionResult = resolutionResultFuture.get(); + rangeResult = resolutionResult.rangeResult; } - catch ( VersionRangeResolutionException e ) + catch ( Exception e ) { results.addException( dependency, e, context.parents ); return; } - //Resolve newer version first to maximize benefits of skipper - Collections.reverse( versions ); + Set versions = resolutionResult.descriptors.keySet(); for ( Version version : versions ) { Artifact originalArtifact = dependency.getArtifact().setVersion( version.toString() ); Dependency d = dependency.setArtifact( originalArtifact ); - ArtifactDescriptorRequest descriptorRequest = createArtifactDescriptorRequest( - args.request.getRequestContext(), trace, context.repositories, d ); - - final ArtifactDescriptorResult descriptorResult = - noDescriptor - ? new ArtifactDescriptorResult( descriptorRequest ) - : resolveCachedArtifactDescriptor( args.pool, descriptorRequest, args.session, - context.withDependency( d ), results ); - + final ArtifactDescriptorResult descriptorResult = resolutionResult.descriptors.get( version ); if ( descriptorResult != null ) { d = d.setArtifact( descriptorResult.getArtifact() ); @@ -238,8 +237,10 @@ private void processDependency( Args args, RequestTrace parent, Results results, originalArtifact.getGroupId().equals( d.getArtifact().getGroupId() ) && originalArtifact.getArtifactId().equals( d.getArtifact().getArtifactId() ); - processDependency( args, parent, results, context.withDependency( d ), - descriptorResult.getRelocations(), disableVersionManagementSubsequently ); + context.withDependency( d ); + resolveArtifactDescriptorAsync( args, trace, context, results ); + processDependency( args, trace, results, context, descriptorResult.getRelocations(), + disableVersionManagementSubsequently ); return; } else @@ -256,10 +257,12 @@ private void processDependency( Args args, RequestTrace parent, Results results, context.getParent().getChildren().add( child ); boolean recurse = traverse && !descriptorResult.getDependencies().isEmpty(); + resolveArtifactDescriptorAsync( args, trace, context, results ); DependencyProcessingContext parentContext = context.withDependency( d ); if ( recurse ) { - doRecurse( args, parentContext, descriptorResult, child ); + doRecurse( args, trace, parentContext, descriptorResult, child, results, + disableVersionManagement ); } else if ( !args.skipper.skipResolution( child, parentContext.parents ) ) { @@ -283,8 +286,9 @@ else if ( !args.skipper.skipResolution( child, parentContext.parents ) ) } @SuppressWarnings( "checkstyle:parameternumber" ) - private void doRecurse( Args args, DependencyProcessingContext parentContext, - ArtifactDescriptorResult descriptorResult, DefaultDependencyNode child ) + private void doRecurse( Args args, RequestTrace trace, DependencyProcessingContext parentContext, + ArtifactDescriptorResult descriptorResult, DefaultDependencyNode child, Results results, + boolean disableVersionManagement ) { DefaultDependencyCollectionContext context = args.collectionContext; context.set( parentContext.dependency, descriptorResult.getManagedDependencies() ); @@ -319,9 +323,12 @@ private void doRecurse( Args args, DependencyProcessingContext parentContext, parents.add( child ); for ( Dependency dependency : descriptorResult.getDependencies() ) { - args.dependencyProcessingQueue.add( + DependencyProcessingContext processingContext = new DependencyProcessingContext( childSelector, childManager, childTraverser, childFilter, - childRepos, descriptorResult.getManagedDependencies(), parents, dependency ) ); + childRepos, descriptorResult.getManagedDependencies(), parents, dependency, + PremanagedDependency.create( childManager, dependency, disableVersionManagement, + args.premanagedState ) ); + putToQueue( args, trace, processingContext, results ); } args.pool.putChildren( key, child.getChildren() ); @@ -334,6 +341,85 @@ private void doRecurse( Args args, DependencyProcessingContext parentContext, } } + private void putToQueue( Args args, RequestTrace trace, DependencyProcessingContext context, + Results results ) + { + //filter with original dependency + if ( context.depSelector != null && !context.depSelector.selectDependency( context.dependency ) ) + { + return; + } + + //resolve descriptors for managed dependency + context.withDependency( context.premanagedDependency.getManagedDependency() ); + args.dependencyProcessingQueue.add( context ); + resolveArtifactDescriptorAsync( args, trace, context, results ); + } + + private void resolveArtifactDescriptorAsync( Args args, RequestTrace trace, DependencyProcessingContext context, + Results results ) + { + final Dependency dependency = context.dependency; + args.resolver.resolveDescriptors( dependency, () -> + { + VersionRangeRequest rangeRequest = + createVersionRangeRequest( args.request.getRequestContext(), trace, context.repositories, + dependency ); + VersionRangeResult rangeResult = cachedResolveRangeResult( rangeRequest, args.pool, args.session ); + DescriptorResolutionResult resolutionResult = new DescriptorResolutionResult( rangeResult ); + + List versions = filterVersions( dependency, rangeResult, context.verFilter, + args.versionContext ); + + Function resolveVersion = ( version ) -> + { + Artifact original = dependency.getArtifact(); + Artifact newArtifact = new DefaultArtifact( original.getGroupId(), + original.getArtifactId(), original.getClassifier(), original.getExtension(), + version.toString(), original.getProperties(), (ArtifactType) null ); + Dependency newDependency = new Dependency( newArtifact, dependency.getScope(), dependency.isOptional(), + dependency.getExclusions() ); + DependencyProcessingContext newContext = context.copy(); + + ArtifactDescriptorRequest descriptorRequest = + createArtifactDescriptorRequest( args.request.getRequestContext(), trace, + newContext.repositories, newDependency ); + return isLackingDescriptor( newArtifact ) + ? new ArtifactDescriptorResult( descriptorRequest ) + : resolveCachedArtifactDescriptor( args.pool, descriptorRequest, args.session, + newContext.withDependency( newDependency ), results ); + }; + + Map descriptors = new ConcurrentHashMap<>( versions.size() ); + Stream stream = versions.size() > 1 ? versions.parallelStream() : versions.stream(); + stream.forEach( version -> + { + ArtifactDescriptorResult descriptorResult = resolveVersion.apply( version ); + if ( descriptorResult != null ) + { + descriptors.put( version, descriptorResult ); + } + } ); + + //Resolve newer version first to maximize benefits of skipper + Collections.reverse( versions ); + versions.forEach( version -> resolutionResult.descriptors.put( version, descriptors.get( version ) ) ); + if ( versions.size() > 1 ) + { + //dependency with version range + versions.forEach( version -> + { + ArtifactDescriptorResult descriptorResult = descriptors.get( version ); + DescriptorResolutionResult result = new DescriptorResolutionResult( rangeResult ); + result.descriptors.put( version, descriptorResult ); + args.resolver.cacheVersionRangeDescriptor( descriptorResult.getArtifact(), + ConcurrentUtils.constantFuture( result ) ); + } ); + } + return resolutionResult; + } ); + } + private ArtifactDescriptorResult resolveCachedArtifactDescriptor( DataPool pool, ArtifactDescriptorRequest descriptorRequest, RepositorySystemSession session, @@ -365,6 +451,64 @@ else if ( descriptorResult == DataPool.NO_DESCRIPTOR ) return descriptorResult; } + static class ParallelDescriptorResolver + { + final ExecutorService executorService; + + /** + * Artifact ID -> Future of DescriptorResolutionResult + */ + final Map> results = new ConcurrentHashMap<>( 256 ); + final Logger logger = LoggerFactory.getLogger( getClass() ); + + ParallelDescriptorResolver( RepositorySystemSession session ) + { + this.executorService = getExecutorService( session ); + } + + Future resolveDescriptors( Dependency dependency, + Callable callable ) + { + return results.computeIfAbsent( ArtifactIdUtils.toId( dependency.getArtifact() ), + key -> this.executorService.submit( callable ) ); + } + + void cacheVersionRangeDescriptor( Artifact artifact, Future constantFuture ) + { + results.computeIfAbsent( ArtifactIdUtils.toId( artifact ), key -> constantFuture ); + } + + Future find( Dependency dependency ) + { + return results.get( ArtifactIdUtils.toId( dependency.getArtifact() ) ); + } + + void shutdown() + { + executorService.shutdown(); + } + + private ExecutorService getExecutorService( RepositorySystemSession session ) + { + int nThreads = ConfigUtils.getInteger( session, 5, "maven.descriptor.threads", "maven.artifact.threads" ); + logger.debug( "Created thread pool with {} threads to resolve descriptors.", nThreads ); + return Executors.newFixedThreadPool( nThreads ); + } + } + + static class DescriptorResolutionResult + { + VersionRangeResult rangeResult; + + Map descriptors; + + DescriptorResolutionResult( VersionRangeResult rangeResult ) + { + this.rangeResult = rangeResult; + this.descriptors = new LinkedHashMap<>( rangeResult.getVersions().size() ); + } + } + static class Args { @@ -386,9 +530,12 @@ static class Args final DependencyResolutionSkipper skipper; + final ParallelDescriptorResolver resolver; + Args( RepositorySystemSession session, DataPool pool, - DefaultDependencyCollectionContext collectionContext, DefaultVersionFilterContext versionContext, - CollectRequest request, DependencyResolutionSkipper skipper ) + DefaultDependencyCollectionContext collectionContext, DefaultVersionFilterContext versionContext, + CollectRequest request, DependencyResolutionSkipper skipper, + ParallelDescriptorResolver resolver ) { this.session = session; this.request = request; @@ -398,6 +545,7 @@ static class Args this.collectionContext = collectionContext; this.versionContext = versionContext; this.skipper = skipper; + this.resolver = resolver; } } diff --git a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/DependencyProcessingContext.java b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/DependencyProcessingContext.java index ee2e77204..ebf3a23da 100644 --- a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/DependencyProcessingContext.java +++ b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/DependencyProcessingContext.java @@ -27,6 +27,7 @@ import org.eclipse.aether.collection.VersionFilter; import org.eclipse.aether.graph.Dependency; import org.eclipse.aether.graph.DependencyNode; +import org.eclipse.aether.internal.impl.collect.PremanagedDependency; import org.eclipse.aether.repository.RemoteRepository; /** @@ -48,6 +49,7 @@ final class DependencyProcessingContext */ final List parents; Dependency dependency; + PremanagedDependency premanagedDependency; @SuppressWarnings( "checkstyle:parameternumber" ) DependencyProcessingContext( DependencySelector depSelector, @@ -57,7 +59,8 @@ final class DependencyProcessingContext List repositories, List managedDependencies, List parents, - Dependency dependency ) + Dependency dependency, + PremanagedDependency premanagedDependency ) { this.depSelector = depSelector; this.depManager = depManager; @@ -65,6 +68,7 @@ final class DependencyProcessingContext this.verFilter = verFilter; this.repositories = repositories; this.dependency = dependency; + this.premanagedDependency = premanagedDependency; this.managedDependencies = managedDependencies; this.parents = parents; } @@ -75,6 +79,13 @@ DependencyProcessingContext withDependency( Dependency dependency ) return this; } + DependencyProcessingContext copy() + { + return new DependencyProcessingContext( depSelector, depManager, depTraverser, + verFilter, repositories, managedDependencies, parents, dependency, + premanagedDependency ); + } + DependencyNode getParent() { return parents.get( parents.size() - 1 ); From 5cf45e811300e2512199515ef6045a47a4c14584 Mon Sep 17 00:00:00 2001 From: Cai Date: Wed, 15 Jun 2022 18:21:06 -0700 Subject: [PATCH 2/8] fix relocation IT MNG-3769 failure with the parallel download patch --- .../collect/bf/BfDependencyCollector.java | 147 +++++++++++------- .../bf/DependencyProcessingContext.java | 8 +- 2 files changed, 98 insertions(+), 57 deletions(-) diff --git a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/BfDependencyCollector.java b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/BfDependencyCollector.java index f8152e877..6ed16669b 100644 --- a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/BfDependencyCollector.java +++ b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/BfDependencyCollector.java @@ -66,6 +66,7 @@ import org.eclipse.aether.resolution.ArtifactDescriptorRequest; import org.eclipse.aether.resolution.ArtifactDescriptorResult; import org.eclipse.aether.resolution.VersionRangeRequest; +import org.eclipse.aether.resolution.VersionRangeResolutionException; import org.eclipse.aether.resolution.VersionRangeResult; import org.eclipse.aether.spi.locator.Service; import org.eclipse.aether.util.ConfigUtils; @@ -158,17 +159,24 @@ protected void doCollectDependencies( RepositorySystemSession session, RequestTr List parents = Collections.singletonList( node ); for ( Dependency dependency : dependencies ) { + RequestTrace childTrace = collectStepTrace( trace, args.request.getRequestContext(), parents, + dependency ); DependencyProcessingContext processingContext = new DependencyProcessingContext( rootDepSelector, rootDepManager, rootDepTraverser, - rootVerFilter, repositories, managedDependencies, parents, dependency, + rootVerFilter, childTrace, repositories, managedDependencies, parents, dependency, PremanagedDependency.create( rootDepManager, dependency, false, args.premanagedState ) ); - putToQueue( args, trace, processingContext, results ); + if ( !filter( processingContext ) ) + { + processingContext.withDependency( processingContext.premanagedDependency.getManagedDependency() ); + resolveArtifactDescriptorAsync( args, processingContext, results ); + args.dependencyProcessingQueue.add( processingContext ); + } } while ( !args.dependencyProcessingQueue.isEmpty() ) { - processDependency( args, trace, results, args.dependencyProcessingQueue.remove(), Collections.emptyList(), + processDependency( args, results, args.dependencyProcessingQueue.remove(), Collections.emptyList(), false ); } @@ -177,14 +185,12 @@ protected void doCollectDependencies( RepositorySystemSession session, RequestTr } @SuppressWarnings( "checkstyle:parameternumber" ) - private void processDependency( Args args, RequestTrace parent, Results results, + private void processDependency( Args args, Results results, DependencyProcessingContext context, List relocations, boolean disableVersionManagement ) { - RequestTrace trace = collectStepTrace( parent, args.request.getRequestContext(), context.parents, - context.dependency ); - PremanagedDependency preManaged = context.premanagedDependency; Dependency dependency = context.dependency; + PremanagedDependency preManaged = context.premanagedDependency; boolean noDescriptor = isLackingDescriptor( dependency.getArtifact() ); boolean traverse = @@ -237,10 +243,24 @@ private void processDependency( Args args, RequestTrace parent, Results results, originalArtifact.getGroupId().equals( d.getArtifact().getGroupId() ) && originalArtifact.getArtifactId().equals( d.getArtifact().getArtifactId() ); - context.withDependency( d ); - resolveArtifactDescriptorAsync( args, trace, context, results ); - processDependency( args, trace, results, context, descriptorResult.getRelocations(), - disableVersionManagementSubsequently ); + PremanagedDependency premanagedDependency = + PremanagedDependency.create( context.depManager, d, disableVersionManagementSubsequently, + args.premanagedState ); + DependencyProcessingContext relocatedContext = + new DependencyProcessingContext( context.depSelector, context.depManager, + context.depTraverser, context.verFilter, + context.trace, context.repositories, descriptorResult.getManagedDependencies(), + context.parents, + d, premanagedDependency ); + + if ( !filter( relocatedContext ) ) + { + relocatedContext.withDependency( premanagedDependency.getManagedDependency() ); + resolveArtifactDescriptorAsync( args, relocatedContext, results ); + processDependency( args, results, relocatedContext, descriptorResult.getRelocations(), + disableVersionManagementSubsequently ); + } + return; } else @@ -257,11 +277,10 @@ private void processDependency( Args args, RequestTrace parent, Results results, context.getParent().getChildren().add( child ); boolean recurse = traverse && !descriptorResult.getDependencies().isEmpty(); - resolveArtifactDescriptorAsync( args, trace, context, results ); DependencyProcessingContext parentContext = context.withDependency( d ); if ( recurse ) { - doRecurse( args, trace, parentContext, descriptorResult, child, results, + doRecurse( args, parentContext, descriptorResult, child, results, disableVersionManagement ); } else if ( !args.skipper.skipResolution( child, parentContext.parents ) ) @@ -286,7 +305,7 @@ else if ( !args.skipper.skipResolution( child, parentContext.parents ) ) } @SuppressWarnings( "checkstyle:parameternumber" ) - private void doRecurse( Args args, RequestTrace trace, DependencyProcessingContext parentContext, + private void doRecurse( Args args, DependencyProcessingContext parentContext, ArtifactDescriptorResult descriptorResult, DefaultDependencyNode child, Results results, boolean disableVersionManagement ) { @@ -323,13 +342,24 @@ private void doRecurse( Args args, RequestTrace trace, DependencyProcessingConte parents.add( child ); for ( Dependency dependency : descriptorResult.getDependencies() ) { + RequestTrace childTrace = + collectStepTrace( parentContext.trace, args.request.getRequestContext(), parents, + dependency ); + PremanagedDependency premanagedDependency = + PremanagedDependency.create( childManager, dependency, disableVersionManagement, + args.premanagedState ); DependencyProcessingContext processingContext = new DependencyProcessingContext( childSelector, childManager, childTraverser, childFilter, - childRepos, descriptorResult.getManagedDependencies(), parents, dependency, - PremanagedDependency.create( childManager, dependency, disableVersionManagement, - args.premanagedState ) ); - putToQueue( args, trace, processingContext, results ); - + childTrace, childRepos, descriptorResult.getManagedDependencies(), parents, + dependency, premanagedDependency ); + if ( !filter( processingContext ) ) + { + //resolve descriptors ahead for managed dependency + processingContext.withDependency( + processingContext.premanagedDependency.getManagedDependency() ); + resolveArtifactDescriptorAsync( args, processingContext, results ); + args.dependencyProcessingQueue.add( processingContext ); + } } args.pool.putChildren( key, child.getChildren() ); args.skipper.cache( child, parents ); @@ -341,55 +371,56 @@ private void doRecurse( Args args, RequestTrace trace, DependencyProcessingConte } } - private void putToQueue( Args args, RequestTrace trace, DependencyProcessingContext context, - Results results ) + private boolean filter( DependencyProcessingContext context ) { - //filter with original dependency if ( context.depSelector != null && !context.depSelector.selectDependency( context.dependency ) ) { - return; + return true; } - - //resolve descriptors for managed dependency - context.withDependency( context.premanagedDependency.getManagedDependency() ); - args.dependencyProcessingQueue.add( context ); - resolveArtifactDescriptorAsync( args, trace, context, results ); + return false; } - private void resolveArtifactDescriptorAsync( Args args, RequestTrace trace, DependencyProcessingContext context, + private void resolveArtifactDescriptorAsync( Args args, DependencyProcessingContext context, Results results ) { - final Dependency dependency = context.dependency; - args.resolver.resolveDescriptors( dependency, () -> + args.resolver.resolveDescriptors( context.dependency, () -> resolveDescriptor( args, context, results ) ); + } + + private DescriptorResolutionResult resolveDescriptor( Args args, DependencyProcessingContext context, + Results results ) + { + Dependency dependency = context.dependency; + + Function resolveVersion = ( version ) -> + { + Artifact original = dependency.getArtifact(); + Artifact newArtifact = new DefaultArtifact( original.getGroupId(), + original.getArtifactId(), original.getClassifier(), original.getExtension(), + version.toString(), original.getProperties(), (ArtifactType) null ); + Dependency newDependency = new Dependency( newArtifact, dependency.getScope(), dependency.isOptional(), + dependency.getExclusions() ); + DependencyProcessingContext newContext = context.copy(); + + ArtifactDescriptorRequest descriptorRequest = + createArtifactDescriptorRequest( args.request.getRequestContext(), context.trace, + newContext.repositories, newDependency ); + return isLackingDescriptor( newArtifact ) + ? new ArtifactDescriptorResult( descriptorRequest ) + : resolveCachedArtifactDescriptor( args.pool, descriptorRequest, args.session, + newContext.withDependency( newDependency ), results ); + }; + + try { VersionRangeRequest rangeRequest = - createVersionRangeRequest( args.request.getRequestContext(), trace, context.repositories, + createVersionRangeRequest( args.request.getRequestContext(), context.trace, context.repositories, dependency ); VersionRangeResult rangeResult = cachedResolveRangeResult( rangeRequest, args.pool, args.session ); DescriptorResolutionResult resolutionResult = new DescriptorResolutionResult( rangeResult ); - List versions = filterVersions( dependency, rangeResult, context.verFilter, args.versionContext ); - Function resolveVersion = ( version ) -> - { - Artifact original = dependency.getArtifact(); - Artifact newArtifact = new DefaultArtifact( original.getGroupId(), - original.getArtifactId(), original.getClassifier(), original.getExtension(), - version.toString(), original.getProperties(), (ArtifactType) null ); - Dependency newDependency = new Dependency( newArtifact, dependency.getScope(), dependency.isOptional(), - dependency.getExclusions() ); - DependencyProcessingContext newContext = context.copy(); - - ArtifactDescriptorRequest descriptorRequest = - createArtifactDescriptorRequest( args.request.getRequestContext(), trace, - newContext.repositories, newDependency ); - return isLackingDescriptor( newArtifact ) - ? new ArtifactDescriptorResult( descriptorRequest ) - : resolveCachedArtifactDescriptor( args.pool, descriptorRequest, args.session, - newContext.withDependency( newDependency ), results ); - }; - + //multiple versions (ex: version range) Map descriptors = new ConcurrentHashMap<>( versions.size() ); Stream stream = versions.size() > 1 ? versions.parallelStream() : versions.stream(); stream.forEach( version -> @@ -401,7 +432,7 @@ private void resolveArtifactDescriptorAsync( Args args, RequestTrace trace, Depe } } ); - //Resolve newer version first to maximize benefits of skipper + //resolve newer version first to maximize benefits of skipper Collections.reverse( versions ); versions.forEach( version -> resolutionResult.descriptors.put( version, descriptors.get( version ) ) ); if ( versions.size() > 1 ) @@ -416,8 +447,14 @@ private void resolveArtifactDescriptorAsync( Args args, RequestTrace trace, Depe ConcurrentUtils.constantFuture( result ) ); } ); } + return resolutionResult; - } ); + } + catch ( VersionRangeResolutionException e ) + { + results.addException( context.dependency, e, context.parents ); + return null; + } } private ArtifactDescriptorResult resolveCachedArtifactDescriptor( DataPool pool, @@ -467,7 +504,7 @@ static class ParallelDescriptorResolver } Future resolveDescriptors( Dependency dependency, - Callable callable ) + Callable callable ) { return results.computeIfAbsent( ArtifactIdUtils.toId( dependency.getArtifact() ), key -> this.executorService.submit( callable ) ); diff --git a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/DependencyProcessingContext.java b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/DependencyProcessingContext.java index ebf3a23da..508d2d04d 100644 --- a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/DependencyProcessingContext.java +++ b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/DependencyProcessingContext.java @@ -21,6 +21,7 @@ import java.util.List; +import org.eclipse.aether.RequestTrace; import org.eclipse.aether.collection.DependencyManager; import org.eclipse.aether.collection.DependencySelector; import org.eclipse.aether.collection.DependencyTraverser; @@ -48,14 +49,16 @@ final class DependencyProcessingContext * All parents of the dependency in the top > down order. */ final List parents; + final PremanagedDependency premanagedDependency; + final RequestTrace trace; Dependency dependency; - PremanagedDependency premanagedDependency; @SuppressWarnings( "checkstyle:parameternumber" ) DependencyProcessingContext( DependencySelector depSelector, DependencyManager depManager, DependencyTraverser depTraverser, VersionFilter verFilter, + RequestTrace trace, List repositories, List managedDependencies, List parents, @@ -66,6 +69,7 @@ final class DependencyProcessingContext this.depManager = depManager; this.depTraverser = depTraverser; this.verFilter = verFilter; + this.trace = trace; this.repositories = repositories; this.dependency = dependency; this.premanagedDependency = premanagedDependency; @@ -82,7 +86,7 @@ DependencyProcessingContext withDependency( Dependency dependency ) DependencyProcessingContext copy() { return new DependencyProcessingContext( depSelector, depManager, depTraverser, - verFilter, repositories, managedDependencies, parents, dependency, + verFilter, trace, repositories, managedDependencies, parents, dependency, premanagedDependency ); } From 2c805b5a7979b0d53ad22d9eb6947f6613a13357 Mon Sep 17 00:00:00 2001 From: Cai Date: Thu, 23 Jun 2022 02:00:01 -0700 Subject: [PATCH 3/8] no need to handle the exception here, handle in future.get --- .../impl/collect/bf/BfDependencyCollector.java | 17 +++-------------- 1 file changed, 3 insertions(+), 14 deletions(-) diff --git a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/BfDependencyCollector.java b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/BfDependencyCollector.java index 6ed16669b..f5ddef49b 100644 --- a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/BfDependencyCollector.java +++ b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/BfDependencyCollector.java @@ -66,7 +66,6 @@ import org.eclipse.aether.resolution.ArtifactDescriptorRequest; import org.eclipse.aether.resolution.ArtifactDescriptorResult; import org.eclipse.aether.resolution.VersionRangeRequest; -import org.eclipse.aether.resolution.VersionRangeResolutionException; import org.eclipse.aether.resolution.VersionRangeResult; import org.eclipse.aether.spi.locator.Service; import org.eclipse.aether.util.ConfigUtils; @@ -380,14 +379,9 @@ private boolean filter( DependencyProcessingContext context ) return false; } + private void resolveArtifactDescriptorAsync( Args args, DependencyProcessingContext context, Results results ) - { - args.resolver.resolveDescriptors( context.dependency, () -> resolveDescriptor( args, context, results ) ); - } - - private DescriptorResolutionResult resolveDescriptor( Args args, DependencyProcessingContext context, - Results results ) { Dependency dependency = context.dependency; @@ -410,7 +404,7 @@ private DescriptorResolutionResult resolveDescriptor( Args args, DependencyProce newContext.withDependency( newDependency ), results ); }; - try + args.resolver.resolveDescriptors( dependency, () -> { VersionRangeRequest rangeRequest = createVersionRangeRequest( args.request.getRequestContext(), context.trace, context.repositories, @@ -449,12 +443,7 @@ private DescriptorResolutionResult resolveDescriptor( Args args, DependencyProce } return resolutionResult; - } - catch ( VersionRangeResolutionException e ) - { - results.addException( context.dependency, e, context.parents ); - return null; - } + } ); } private ArtifactDescriptorResult resolveCachedArtifactDescriptor( DataPool pool, From 6c067c84b3e23cd255364436a913febe810063ec Mon Sep 17 00:00:00 2001 From: "eric.c" Date: Tue, 9 Aug 2022 22:49:45 +0800 Subject: [PATCH 4/8] refactor a bit --- .../collect/bf/BfDependencyCollector.java | 103 +++++++++--------- 1 file changed, 52 insertions(+), 51 deletions(-) diff --git a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/BfDependencyCollector.java b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/BfDependencyCollector.java index f5ddef49b..326028ffb 100644 --- a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/BfDependencyCollector.java +++ b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/BfDependencyCollector.java @@ -29,14 +29,16 @@ import java.util.LinkedHashMap; import java.util.List; import java.util.Map; +import java.util.Optional; import java.util.Queue; import java.util.Set; import java.util.concurrent.Callable; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ExecutorService; -import java.util.concurrent.Executors; import java.util.concurrent.Future; -import java.util.function.Function; +import java.util.concurrent.LinkedBlockingQueue; +import java.util.concurrent.ThreadPoolExecutor; +import java.util.concurrent.TimeUnit; import java.util.stream.Stream; import org.apache.commons.lang3.concurrent.ConcurrentUtils; @@ -70,6 +72,7 @@ import org.eclipse.aether.spi.locator.Service; import org.eclipse.aether.util.ConfigUtils; import org.eclipse.aether.util.artifact.ArtifactIdUtils; +import org.eclipse.aether.util.concurrency.WorkerThreadFactory; import org.eclipse.aether.util.graph.manager.DependencyManagerUtils; import org.eclipse.aether.version.Version; import org.slf4j.Logger; @@ -372,11 +375,7 @@ private void doRecurse( Args args, DependencyProcessingContext parentContext, private boolean filter( DependencyProcessingContext context ) { - if ( context.depSelector != null && !context.depSelector.selectDependency( context.dependency ) ) - { - return true; - } - return false; + return context.depSelector != null && !context.depSelector.selectDependency( context.dependency ); } @@ -384,26 +383,6 @@ private void resolveArtifactDescriptorAsync( Args args, DependencyProcessingCont Results results ) { Dependency dependency = context.dependency; - - Function resolveVersion = ( version ) -> - { - Artifact original = dependency.getArtifact(); - Artifact newArtifact = new DefaultArtifact( original.getGroupId(), - original.getArtifactId(), original.getClassifier(), original.getExtension(), - version.toString(), original.getProperties(), (ArtifactType) null ); - Dependency newDependency = new Dependency( newArtifact, dependency.getScope(), dependency.isOptional(), - dependency.getExclusions() ); - DependencyProcessingContext newContext = context.copy(); - - ArtifactDescriptorRequest descriptorRequest = - createArtifactDescriptorRequest( args.request.getRequestContext(), context.trace, - newContext.repositories, newDependency ); - return isLackingDescriptor( newArtifact ) - ? new ArtifactDescriptorResult( descriptorRequest ) - : resolveCachedArtifactDescriptor( args.pool, descriptorRequest, args.session, - newContext.withDependency( newDependency ), results ); - }; - args.resolver.resolveDescriptors( dependency, () -> { VersionRangeRequest rangeRequest = @@ -414,38 +393,53 @@ private void resolveArtifactDescriptorAsync( Args args, DependencyProcessingCont List versions = filterVersions( dependency, rangeResult, context.verFilter, args.versionContext ); - //multiple versions (ex: version range) + //resolve newer version first to maximize benefits of skipper + Collections.reverse( versions ); + Map descriptors = new ConcurrentHashMap<>( versions.size() ); Stream stream = versions.size() > 1 ? versions.parallelStream() : versions.stream(); - stream.forEach( version -> + stream.forEachOrdered( version -> { - ArtifactDescriptorResult descriptorResult = resolveVersion.apply( version ); - if ( descriptorResult != null ) + ArtifactDescriptorResult descriptorResult = + resolveDescriptorForVersion( args, context, results, dependency, version ); + resolutionResult.descriptors.put( version, descriptorResult ); + if ( versions.size() > 1 ) { - descriptors.put( version, descriptorResult ); + Optional.ofNullable( descriptorResult ).ifPresent( r -> + { + //cache for specific version in version range + descriptors.put( version, r ); + args.resolver.cacheVersionRangeDescriptor( r.getArtifact(), + ConcurrentUtils.constantFuture( + new DescriptorResolutionResult( rangeResult, descriptors ) ) ); + } ); } } ); - - //resolve newer version first to maximize benefits of skipper - Collections.reverse( versions ); - versions.forEach( version -> resolutionResult.descriptors.put( version, descriptors.get( version ) ) ); - if ( versions.size() > 1 ) - { - //dependency with version range - versions.forEach( version -> - { - ArtifactDescriptorResult descriptorResult = descriptors.get( version ); - DescriptorResolutionResult result = new DescriptorResolutionResult( rangeResult ); - result.descriptors.put( version, descriptorResult ); - args.resolver.cacheVersionRangeDescriptor( descriptorResult.getArtifact(), - ConcurrentUtils.constantFuture( result ) ); - } ); - } - return resolutionResult; } ); } + private ArtifactDescriptorResult resolveDescriptorForVersion( Args args, DependencyProcessingContext context, + Results results, Dependency dependency, + Version version ) + { + Artifact original = dependency.getArtifact(); + Artifact newArtifact = new DefaultArtifact( original.getGroupId(), + original.getArtifactId(), original.getClassifier(), original.getExtension(), + version.toString(), original.getProperties(), (ArtifactType) null ); + Dependency newDependency = new Dependency( newArtifact, dependency.getScope(), dependency.isOptional(), + dependency.getExclusions() ); + DependencyProcessingContext newContext = context.copy(); + + ArtifactDescriptorRequest descriptorRequest = + createArtifactDescriptorRequest( args.request.getRequestContext(), context.trace, + newContext.repositories, newDependency ); + return isLackingDescriptor( newArtifact ) + ? new ArtifactDescriptorResult( descriptorRequest ) + : resolveCachedArtifactDescriptor( args.pool, descriptorRequest, args.session, + newContext.withDependency( newDependency ), results ); + } + private ArtifactDescriptorResult resolveCachedArtifactDescriptor( DataPool pool, ArtifactDescriptorRequest descriptorRequest, RepositorySystemSession session, @@ -516,9 +510,10 @@ void shutdown() private ExecutorService getExecutorService( RepositorySystemSession session ) { - int nThreads = ConfigUtils.getInteger( session, 5, "maven.descriptor.threads", "maven.artifact.threads" ); + int nThreads = ConfigUtils.getInteger( session, 5, "maven.artifact.threads" ); logger.debug( "Created thread pool with {} threads to resolve descriptors.", nThreads ); - return Executors.newFixedThreadPool( nThreads ); + return new ThreadPoolExecutor( nThreads, nThreads, 3L, TimeUnit.SECONDS, new LinkedBlockingQueue(), + new WorkerThreadFactory( getClass().getSimpleName() ) ); } } @@ -533,6 +528,12 @@ static class DescriptorResolutionResult this.rangeResult = rangeResult; this.descriptors = new LinkedHashMap<>( rangeResult.getVersions().size() ); } + + DescriptorResolutionResult( VersionRangeResult rangeResult, Map descriptors ) + { + this( rangeResult ); + this.descriptors.putAll( descriptors ); + } } static class Args From c3ae229098df64d28fd11095d0c8cfa3cb35ee18 Mon Sep 17 00:00:00 2001 From: "eric.c" Date: Tue, 9 Aug 2022 23:21:37 +0800 Subject: [PATCH 5/8] fix using linkedHashMap in parallel stream --- .../collect/bf/BfDependencyCollector.java | 25 +++++++++---------- 1 file changed, 12 insertions(+), 13 deletions(-) diff --git a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/BfDependencyCollector.java b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/BfDependencyCollector.java index 326028ffb..c21871750 100644 --- a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/BfDependencyCollector.java +++ b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/BfDependencyCollector.java @@ -389,32 +389,31 @@ private void resolveArtifactDescriptorAsync( Args args, DependencyProcessingCont createVersionRangeRequest( args.request.getRequestContext(), context.trace, context.repositories, dependency ); VersionRangeResult rangeResult = cachedResolveRangeResult( rangeRequest, args.pool, args.session ); - DescriptorResolutionResult resolutionResult = new DescriptorResolutionResult( rangeResult ); List versions = filterVersions( dependency, rangeResult, context.verFilter, args.versionContext ); //resolve newer version first to maximize benefits of skipper Collections.reverse( versions ); + boolean isVersionRange = versions.size() > 1; Map descriptors = new ConcurrentHashMap<>( versions.size() ); - Stream stream = versions.size() > 1 ? versions.parallelStream() : versions.stream(); - stream.forEachOrdered( version -> + Stream stream = isVersionRange ? versions.parallelStream() : versions.stream(); + stream.forEach( version -> { ArtifactDescriptorResult descriptorResult = resolveDescriptorForVersion( args, context, results, dependency, version ); - resolutionResult.descriptors.put( version, descriptorResult ); - if ( versions.size() > 1 ) + Optional.ofNullable( descriptorResult ).ifPresent( r -> descriptors.put( version, r ) ); + if ( isVersionRange ) { - Optional.ofNullable( descriptorResult ).ifPresent( r -> - { - //cache for specific version in version range - descriptors.put( version, r ); - args.resolver.cacheVersionRangeDescriptor( r.getArtifact(), - ConcurrentUtils.constantFuture( - new DescriptorResolutionResult( rangeResult, descriptors ) ) ); - } ); + //cache for specific version in version range + args.resolver.cacheVersionRangeDescriptor( descriptorResult.getArtifact(), + ConcurrentUtils.constantFuture( + new DescriptorResolutionResult( rangeResult, descriptors ) ) ); } } ); + + DescriptorResolutionResult resolutionResult = new DescriptorResolutionResult( rangeResult ); + versions.forEach( version -> resolutionResult.descriptors.put( version, descriptors.get( version ) ) ); return resolutionResult; } ); } From 39da8e2221003ce1467bc72dbe258753fc64a8ea Mon Sep 17 00:00:00 2001 From: "eric.c" Date: Wed, 10 Aug 2022 13:40:32 +0800 Subject: [PATCH 6/8] refactor --- .../collect/bf/BfDependencyCollector.java | 72 +++++++++++-------- 1 file changed, 44 insertions(+), 28 deletions(-) diff --git a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/BfDependencyCollector.java b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/BfDependencyCollector.java index c21871750..1648ce1eb 100644 --- a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/BfDependencyCollector.java +++ b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/BfDependencyCollector.java @@ -25,6 +25,7 @@ import java.util.ArrayDeque; import java.util.ArrayList; +import java.util.Arrays; import java.util.Collections; import java.util.LinkedHashMap; import java.util.List; @@ -39,6 +40,7 @@ import java.util.concurrent.LinkedBlockingQueue; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; +import java.util.stream.Collectors; import java.util.stream.Stream; import org.apache.commons.lang3.concurrent.ConcurrentUtils; @@ -199,7 +201,7 @@ private void processDependency( Args args, Results results, !noDescriptor && ( context.depTraverser == null || context.depTraverser.traverseDependency( dependency ) ); - Future resolutionResultFuture = args.resolver.find( dependency ); + Future resolutionResultFuture = args.resolver.find( dependency.getArtifact() ); DescriptorResolutionResult resolutionResult; VersionRangeResult rangeResult; try @@ -383,7 +385,7 @@ private void resolveArtifactDescriptorAsync( Args args, DependencyProcessingCont Results results ) { Dependency dependency = context.dependency; - args.resolver.resolveDescriptors( dependency, () -> + args.resolver.resolveDescriptors( dependency.getArtifact(), () -> { VersionRangeRequest rangeRequest = createVersionRangeRequest( args.request.getRequestContext(), context.trace, context.repositories, @@ -395,25 +397,20 @@ private void resolveArtifactDescriptorAsync( Args args, DependencyProcessingCont //resolve newer version first to maximize benefits of skipper Collections.reverse( versions ); - boolean isVersionRange = versions.size() > 1; Map descriptors = new ConcurrentHashMap<>( versions.size() ); - Stream stream = isVersionRange ? versions.parallelStream() : versions.stream(); + Stream stream = versions.size() > 1 ? versions.parallelStream() : versions.stream(); stream.forEach( version -> - { - ArtifactDescriptorResult descriptorResult = - resolveDescriptorForVersion( args, context, results, dependency, version ); - Optional.ofNullable( descriptorResult ).ifPresent( r -> descriptors.put( version, r ) ); - if ( isVersionRange ) - { - //cache for specific version in version range - args.resolver.cacheVersionRangeDescriptor( descriptorResult.getArtifact(), - ConcurrentUtils.constantFuture( - new DescriptorResolutionResult( rangeResult, descriptors ) ) ); - } - } ); + Optional.ofNullable( resolveDescriptorForVersion( args, context, results, dependency, version ) ) + .ifPresent( r -> descriptors.put( version, r ) ) + ); - DescriptorResolutionResult resolutionResult = new DescriptorResolutionResult( rangeResult ); + DescriptorResolutionResult resolutionResult = + new DescriptorResolutionResult( dependency.getArtifact(), rangeResult ); + //keep original sequence versions.forEach( version -> resolutionResult.descriptors.put( version, descriptors.get( version ) ) ); + //populate for versions in version range + resolutionResult.flatten().forEach( dr -> args.resolver.cacheVersionRangeDescriptor( dr.artifact, dr ) ); + return resolutionResult; } ); } @@ -485,21 +482,22 @@ static class ParallelDescriptorResolver this.executorService = getExecutorService( session ); } - Future resolveDescriptors( Dependency dependency, - Callable callable ) + Future resolveDescriptors( Artifact artifact, + Callable callable ) { - return results.computeIfAbsent( ArtifactIdUtils.toId( dependency.getArtifact() ), + return results.computeIfAbsent( ArtifactIdUtils.toId( artifact ), key -> this.executorService.submit( callable ) ); } - void cacheVersionRangeDescriptor( Artifact artifact, Future constantFuture ) + void cacheVersionRangeDescriptor( Artifact artifact, DescriptorResolutionResult resolutionResult ) { - results.computeIfAbsent( ArtifactIdUtils.toId( artifact ), key -> constantFuture ); + results.computeIfAbsent( ArtifactIdUtils.toId( artifact ), + key -> ConcurrentUtils.constantFuture( resolutionResult ) ); } - Future find( Dependency dependency ) + Future find( Artifact artifact ) { - return results.get( ArtifactIdUtils.toId( dependency.getArtifact() ) ); + return results.get( ArtifactIdUtils.toId( artifact ) ); } void shutdown() @@ -518,20 +516,38 @@ private ExecutorService getExecutorService( RepositorySystemSession session ) static class DescriptorResolutionResult { + Artifact artifact; + VersionRangeResult rangeResult; Map descriptors; - DescriptorResolutionResult( VersionRangeResult rangeResult ) + DescriptorResolutionResult( Artifact artifact, VersionRangeResult rangeResult ) { + this.artifact = artifact; this.rangeResult = rangeResult; this.descriptors = new LinkedHashMap<>( rangeResult.getVersions().size() ); } - DescriptorResolutionResult( VersionRangeResult rangeResult, Map descriptors ) + DescriptorResolutionResult( VersionRangeResult rangeResult, + Version version, ArtifactDescriptorResult descriptor ) { - this( rangeResult ); - this.descriptors.putAll( descriptors ); + this( descriptor.getArtifact(), rangeResult ); + this.descriptors.put( version, descriptor ); + } + + List flatten() + { + if ( descriptors.size() > 1 ) + { + return descriptors.entrySet().stream() + .map( e -> new DescriptorResolutionResult( rangeResult, e.getKey(), e.getValue() ) ) + .collect( Collectors.toList() ); + } + else + { + return Collections.emptyList(); + } } } From 2f19ec25765fa69d341c6195e64d8ac33684ed40 Mon Sep 17 00:00:00 2001 From: "eric.c" Date: Wed, 10 Aug 2022 14:05:42 +0800 Subject: [PATCH 7/8] unused import --- .../aether/internal/impl/collect/bf/BfDependencyCollector.java | 1 - 1 file changed, 1 deletion(-) diff --git a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/BfDependencyCollector.java b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/BfDependencyCollector.java index 1648ce1eb..e1e5c2579 100644 --- a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/BfDependencyCollector.java +++ b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/BfDependencyCollector.java @@ -25,7 +25,6 @@ import java.util.ArrayDeque; import java.util.ArrayList; -import java.util.Arrays; import java.util.Collections; import java.util.LinkedHashMap; import java.util.List; From b5cf751a15e5c76d85fc86fa384cc1f1650ea9a5 Mon Sep 17 00:00:00 2001 From: Eric Cai Date: Mon, 3 Oct 2022 19:32:18 +0800 Subject: [PATCH 8/8] change method return value --- .../internal/impl/collect/bf/BfDependencyCollector.java | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/BfDependencyCollector.java b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/BfDependencyCollector.java index e1e5c2579..6145c595a 100644 --- a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/BfDependencyCollector.java +++ b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/bf/BfDependencyCollector.java @@ -481,10 +481,9 @@ static class ParallelDescriptorResolver this.executorService = getExecutorService( session ); } - Future resolveDescriptors( Artifact artifact, - Callable callable ) + void resolveDescriptors( Artifact artifact, Callable callable ) { - return results.computeIfAbsent( ArtifactIdUtils.toId( artifact ), + results.computeIfAbsent( ArtifactIdUtils.toId( artifact ), key -> this.executorService.submit( callable ) ); }