You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@maven.apache.org by cs...@apache.org on 2022/05/11 19:08:30 UTC
[maven-resolver] branch collapse-collectors created (now 34f47a55)
This is an automated email from the ASF dual-hosted git repository.
cstamas pushed a change to branch collapse-collectors
in repository https://gitbox.apache.org/repos/asf/maven-resolver.git
at 34f47a55 Collapse collectors
This branch includes the following new commits:
new 34f47a55 Collapse collectors
The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
[maven-resolver] 01/01: Collapse collectors
Posted by cs...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
cstamas pushed a commit to branch collapse-collectors
in repository https://gitbox.apache.org/repos/asf/maven-resolver.git
commit 34f47a554d326ff214eff8cb968d49e03aaa54b9
Author: Tamas Cservenak <ta...@cservenak.net>
AuthorDate: Wed May 11 21:07:23 2022 +0200
Collapse collectors
As DF (original) and BF (added in 1.8) started as copy-paste of each other, they
share a LOT. This PR tries to minimize redundancy, still, not loosing clarity,
so leaving inner Args class for each of them.
---
.../impl/collect/DependencyCollectorDelegate.java | 581 ++++++++++++++++++++-
.../impl/collect/bf/BfDependencyCollector.java | 581 ++-------------------
.../impl/collect/df/DfDependencyCollector.java | 571 ++------------------
3 files changed, 659 insertions(+), 1074 deletions(-)
diff --git a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/DependencyCollectorDelegate.java b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/DependencyCollectorDelegate.java
index c7c2c985..14ae43f3 100644
--- a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/DependencyCollectorDelegate.java
+++ b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/DependencyCollectorDelegate.java
@@ -19,11 +19,52 @@ package org.eclipse.aether.internal.impl.collect;
* under the License.
*/
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.eclipse.aether.DefaultRepositorySystemSession;
+import org.eclipse.aether.RepositoryException;
+import org.eclipse.aether.RepositorySystemSession;
+import org.eclipse.aether.RequestTrace;
+import org.eclipse.aether.artifact.Artifact;
+import org.eclipse.aether.artifact.ArtifactProperties;
+import org.eclipse.aether.collection.CollectRequest;
+import org.eclipse.aether.collection.CollectResult;
+import org.eclipse.aether.collection.DependencyCollectionException;
+import org.eclipse.aether.collection.DependencyGraphTransformer;
+import org.eclipse.aether.collection.DependencyManagement;
+import org.eclipse.aether.collection.DependencyManager;
+import org.eclipse.aether.collection.DependencySelector;
+import org.eclipse.aether.collection.DependencyTraverser;
+import org.eclipse.aether.collection.VersionFilter;
+import org.eclipse.aether.graph.DefaultDependencyNode;
+import org.eclipse.aether.graph.Dependency;
+import org.eclipse.aether.graph.DependencyNode;
+import org.eclipse.aether.graph.Exclusion;
import org.eclipse.aether.impl.ArtifactDescriptorReader;
import org.eclipse.aether.impl.DependencyCollector;
import org.eclipse.aether.impl.RemoteRepositoryManager;
import org.eclipse.aether.impl.VersionRangeResolver;
+import org.eclipse.aether.internal.impl.collect.bf.BfDependencyCollector;
+import org.eclipse.aether.repository.ArtifactRepository;
+import org.eclipse.aether.repository.RemoteRepository;
+import org.eclipse.aether.resolution.ArtifactDescriptorException;
+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.ServiceLocator;
+import org.eclipse.aether.util.ConfigUtils;
+import org.eclipse.aether.util.graph.manager.DependencyManagerUtils;
+import org.eclipse.aether.util.graph.transformer.TransformationContextKeys;
+import org.eclipse.aether.version.Version;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -52,7 +93,13 @@ public abstract class DependencyCollectorDelegate implements DependencyCollector
protected VersionRangeResolver versionRangeResolver;
- public DependencyCollectorDelegate()
+ /**
+ * Default ctor for SL.
+ *
+ * @deprecated Will be dropped once SL gone.
+ */
+ @Deprecated
+ protected DependencyCollectorDelegate()
{
// enables default constructor
}
@@ -93,4 +140,536 @@ public abstract class DependencyCollectorDelegate implements DependencyCollector
return this;
}
+ @SuppressWarnings( "checkstyle:methodlength" )
+ @Override
+ public final CollectResult collectDependencies( RepositorySystemSession session, CollectRequest request )
+ throws DependencyCollectionException
+ {
+ requireNonNull( session, "session cannot be null" );
+ requireNonNull( request, "request cannot be null" );
+ session = optimizeSession( session );
+
+ RequestTrace trace = RequestTrace.newChild( request.getTrace(), request );
+
+ CollectResult result = new CollectResult( request );
+
+ DependencySelector depSelector = session.getDependencySelector();
+ DependencyManager depManager = session.getDependencyManager();
+ DependencyTraverser depTraverser = session.getDependencyTraverser();
+ VersionFilter verFilter = session.getVersionFilter();
+
+ Dependency root = request.getRoot();
+ List<RemoteRepository> repositories = request.getRepositories();
+ List<Dependency> dependencies = request.getDependencies();
+ List<Dependency> managedDependencies = request.getManagedDependencies();
+
+ Map<String, Object> stats = new LinkedHashMap<>();
+ long time1 = System.nanoTime();
+
+ DefaultDependencyNode node;
+ if ( root != null )
+ {
+ List<? extends Version> versions;
+ VersionRangeResult rangeResult;
+ try
+ {
+ VersionRangeRequest rangeRequest =
+ new VersionRangeRequest( root.getArtifact(), request.getRepositories(),
+ request.getRequestContext() );
+ rangeRequest.setTrace( trace );
+ rangeResult = versionRangeResolver.resolveVersionRange( session, rangeRequest );
+ versions = filterVersions( root, rangeResult, verFilter, new DefaultVersionFilterContext( session ) );
+ }
+ catch ( VersionRangeResolutionException e )
+ {
+ result.addException( e );
+ throw new DependencyCollectionException( result, e.getMessage() );
+ }
+
+ Version version = versions.get( versions.size() - 1 );
+ root = root.setArtifact( root.getArtifact().setVersion( version.toString() ) );
+
+ ArtifactDescriptorResult descriptorResult;
+ try
+ {
+ ArtifactDescriptorRequest descriptorRequest = new ArtifactDescriptorRequest();
+ descriptorRequest.setArtifact( root.getArtifact() );
+ descriptorRequest.setRepositories( request.getRepositories() );
+ descriptorRequest.setRequestContext( request.getRequestContext() );
+ descriptorRequest.setTrace( trace );
+ if ( isLackingDescriptor( root.getArtifact() ) )
+ {
+ descriptorResult = new ArtifactDescriptorResult( descriptorRequest );
+ }
+ else
+ {
+ descriptorResult = descriptorReader.readArtifactDescriptor( session, descriptorRequest );
+ }
+ }
+ catch ( ArtifactDescriptorException e )
+ {
+ result.addException( e );
+ throw new DependencyCollectionException( result, e.getMessage() );
+ }
+
+ root = root.setArtifact( descriptorResult.getArtifact() );
+
+ if ( !session.isIgnoreArtifactDescriptorRepositories() )
+ {
+ repositories = remoteRepositoryManager.aggregateRepositories( session, repositories,
+ descriptorResult.getRepositories(),
+ true );
+ }
+ dependencies = mergeDeps( dependencies, descriptorResult.getDependencies() );
+ managedDependencies = mergeDeps( managedDependencies, descriptorResult.getManagedDependencies() );
+
+ node = new DefaultDependencyNode( root );
+ node.setRequestContext( request.getRequestContext() );
+ node.setRelocations( descriptorResult.getRelocations() );
+ node.setVersionConstraint( rangeResult.getVersionConstraint() );
+ node.setVersion( version );
+ node.setAliases( descriptorResult.getAliases() );
+ node.setRepositories( request.getRepositories() );
+ }
+ else
+ {
+ node = new DefaultDependencyNode( request.getRootArtifact() );
+ node.setRequestContext( request.getRequestContext() );
+ node.setRepositories( request.getRepositories() );
+ }
+
+ result.setRoot( node );
+
+ boolean traverse = root == null || depTraverser == null || depTraverser.traverseDependency( root );
+ String errorPath = null;
+ if ( traverse && !dependencies.isEmpty() )
+ {
+ DataPool pool = new DataPool( session );
+
+ DefaultDependencyCollectionContext context = new DefaultDependencyCollectionContext(
+ session, request.getRootArtifact(), root, managedDependencies );
+
+ DefaultVersionFilterContext versionContext = new DefaultVersionFilterContext( session );
+
+ Results results = new Results( result, session );
+
+ doCollectDependencies(
+ session, trace, pool, context, versionContext, request, node, repositories, dependencies,
+ managedDependencies, results
+ );
+
+ errorPath = results.getErrorPath();
+ }
+
+ long time2 = System.nanoTime();
+
+ DependencyGraphTransformer transformer = session.getDependencyGraphTransformer();
+ if ( transformer != null )
+ {
+ try
+ {
+ DefaultDependencyGraphTransformationContext context =
+ new DefaultDependencyGraphTransformationContext( session );
+ context.put( TransformationContextKeys.STATS, stats );
+ result.setRoot( transformer.transformGraph( node, context ) );
+ }
+ catch ( RepositoryException e )
+ {
+ result.addException( e );
+ }
+ }
+
+ long time3 = System.nanoTime();
+ if ( logger.isDebugEnabled() )
+ {
+ stats.put( getClass().getSimpleName() + ".collectTime", time2 - time1 );
+ stats.put( getClass().getSimpleName() + ".transformTime", time3 - time2 );
+ logger.debug( "Dependency collection stats {}", stats );
+ }
+
+ if ( errorPath != null )
+ {
+ throw new DependencyCollectionException( result, "Failed to collect dependencies at " + errorPath );
+ }
+ if ( !result.getExceptions().isEmpty() )
+ {
+ throw new DependencyCollectionException( result );
+ }
+
+ return result;
+ }
+
+ @SuppressWarnings( "checkstyle:parameternumber" )
+ protected abstract void doCollectDependencies( RepositorySystemSession session, RequestTrace trace, DataPool pool,
+ DefaultDependencyCollectionContext context,
+ DefaultVersionFilterContext versionContext,
+ CollectRequest request, DependencyNode node,
+ List<RemoteRepository> repositories, List<Dependency> dependencies,
+ List<Dependency> managedDependencies, Results results );
+
+ protected RepositorySystemSession optimizeSession( RepositorySystemSession session )
+ {
+ DefaultRepositorySystemSession optimized = new DefaultRepositorySystemSession( session );
+ optimized.setArtifactTypeRegistry( CachingArtifactTypeRegistry.newInstance( session ) );
+ return optimized;
+ }
+
+ protected List<Dependency> mergeDeps( List<Dependency> dominant, List<Dependency> recessive )
+ {
+ List<Dependency> result;
+ if ( dominant == null || dominant.isEmpty() )
+ {
+ result = recessive;
+ }
+ else if ( recessive == null || recessive.isEmpty() )
+ {
+ result = dominant;
+ }
+ else
+ {
+ int initialCapacity = dominant.size() + recessive.size();
+ result = new ArrayList<>( initialCapacity );
+ Collection<String> ids = new HashSet<>( initialCapacity, 1.0f );
+ for ( Dependency dependency : dominant )
+ {
+ ids.add( getId( dependency.getArtifact() ) );
+ result.add( dependency );
+ }
+ for ( Dependency dependency : recessive )
+ {
+ if ( !ids.contains( getId( dependency.getArtifact() ) ) )
+ {
+ result.add( dependency );
+ }
+ }
+ }
+ return result;
+ }
+
+ protected static String getId( Artifact a )
+ {
+ return a.getGroupId() + ':' + a.getArtifactId() + ':' + a.getClassifier() + ':' + a.getExtension();
+ }
+
+ @SuppressWarnings( "checkstyle:parameternumber" )
+ protected static DefaultDependencyNode createDependencyNode( List<Artifact> relocations,
+ PremanagedDependency preManaged,
+ VersionRangeResult rangeResult, Version version,
+ Dependency d, Collection<Artifact> aliases,
+ List<RemoteRepository> repos, String requestContext )
+ {
+ DefaultDependencyNode child = new DefaultDependencyNode( d );
+ preManaged.applyTo( child );
+ child.setRelocations( relocations );
+ child.setVersionConstraint( rangeResult.getVersionConstraint() );
+ child.setVersion( version );
+ child.setAliases( aliases );
+ child.setRepositories( repos );
+ child.setRequestContext( requestContext );
+ return child;
+ }
+
+ protected static DefaultDependencyNode createDependencyNode( List<Artifact> relocations,
+ BfDependencyCollector.PremanagedDependency preManaged,
+ VersionRangeResult rangeResult, Version version,
+ Dependency d,
+ ArtifactDescriptorResult descriptorResult,
+ DependencyNode cycleNode )
+ {
+ DefaultDependencyNode child =
+ createDependencyNode( relocations, preManaged, rangeResult, version, d, descriptorResult.getAliases(),
+ cycleNode.getRepositories(), cycleNode.getRequestContext() );
+ child.setChildren( cycleNode.getChildren() );
+ return child;
+ }
+
+ protected static ArtifactDescriptorRequest createArtifactDescriptorRequest( String requestContext,
+ RequestTrace requestTrace,
+ List<RemoteRepository> repositories,
+ Dependency d )
+ {
+ ArtifactDescriptorRequest descriptorRequest = new ArtifactDescriptorRequest();
+ descriptorRequest.setArtifact( d.getArtifact() );
+ descriptorRequest.setRepositories( repositories );
+ descriptorRequest.setRequestContext( requestContext );
+ descriptorRequest.setTrace( requestTrace );
+ return descriptorRequest;
+ }
+
+ protected static VersionRangeRequest createVersionRangeRequest( String requestContext,
+ RequestTrace requestTrace,
+ List<RemoteRepository> repositories,
+ Dependency dependency )
+ {
+ VersionRangeRequest rangeRequest = new VersionRangeRequest();
+ rangeRequest.setArtifact( dependency.getArtifact() );
+ rangeRequest.setRepositories( repositories );
+ rangeRequest.setRequestContext( requestContext );
+ rangeRequest.setTrace( requestTrace );
+ return rangeRequest;
+ }
+
+ protected VersionRangeResult cachedResolveRangeResult( VersionRangeRequest rangeRequest, DataPool pool,
+ RepositorySystemSession session )
+ throws VersionRangeResolutionException
+ {
+ Object key = pool.toKey( rangeRequest );
+ VersionRangeResult rangeResult = pool.getConstraint( key, rangeRequest );
+ if ( rangeResult == null )
+ {
+ rangeResult = versionRangeResolver.resolveVersionRange( session, rangeRequest );
+ pool.putConstraint( key, rangeResult );
+ }
+ return rangeResult;
+ }
+
+ protected static boolean isLackingDescriptor( Artifact artifact )
+ {
+ return artifact.getProperty( ArtifactProperties.LOCAL_PATH, null ) != null;
+ }
+
+ protected static List<RemoteRepository> getRemoteRepositories( ArtifactRepository repository,
+ List<RemoteRepository> repositories )
+ {
+ if ( repository instanceof RemoteRepository )
+ {
+ return Collections.singletonList( (RemoteRepository) repository );
+ }
+ if ( repository != null )
+ {
+ return Collections.emptyList();
+ }
+ return repositories;
+ }
+
+ protected static List<? extends Version> filterVersions( Dependency dependency, VersionRangeResult rangeResult,
+ VersionFilter verFilter,
+ DefaultVersionFilterContext verContext )
+ throws VersionRangeResolutionException
+ {
+ if ( rangeResult.getVersions().isEmpty() )
+ {
+ throw new VersionRangeResolutionException( rangeResult,
+ "No versions available for " + dependency.getArtifact()
+ + " within specified range" );
+ }
+
+ List<? extends Version> versions;
+ if ( verFilter != null && rangeResult.getVersionConstraint().getRange() != null )
+ {
+ verContext.set( dependency, rangeResult );
+ try
+ {
+ verFilter.filterVersions( verContext );
+ }
+ catch ( RepositoryException e )
+ {
+ throw new VersionRangeResolutionException( rangeResult,
+ "Failed to filter versions for " + dependency.getArtifact(), e );
+ }
+ versions = verContext.get();
+ if ( versions.isEmpty() )
+ {
+ throw new VersionRangeResolutionException( rangeResult,
+ "No acceptable versions for " + dependency.getArtifact() + ": " + rangeResult.getVersions() );
+ }
+ }
+ else
+ {
+ versions = rangeResult.getVersions();
+ }
+ return versions;
+ }
+
+ /**
+ * Helper class used during collection.
+ */
+ protected static class Results
+ {
+
+ private final CollectResult result;
+
+ final int maxExceptions;
+
+ final int maxCycles;
+
+ String errorPath;
+
+ public Results( CollectResult result, RepositorySystemSession session )
+ {
+ this.result = result;
+
+ maxExceptions =
+ ConfigUtils.getInteger( session, CONFIG_PROP_MAX_EXCEPTIONS_DEFAULT, CONFIG_PROP_MAX_EXCEPTIONS );
+
+ maxCycles = ConfigUtils.getInteger( session, CONFIG_PROP_MAX_CYCLES_DEFAULT, CONFIG_PROP_MAX_CYCLES );
+ }
+
+ public String getErrorPath()
+ {
+ return errorPath;
+ }
+
+ public void addException( Dependency dependency, Exception e, List<DependencyNode> nodes )
+ {
+ if ( maxExceptions < 0 || result.getExceptions().size() < maxExceptions )
+ {
+ result.addException( e );
+ if ( errorPath == null )
+ {
+ StringBuilder buffer = new StringBuilder( 256 );
+ for ( DependencyNode node : nodes )
+ {
+ if ( buffer.length() > 0 )
+ {
+ buffer.append( " -> " );
+ }
+ Dependency dep = node.getDependency();
+ if ( dep != null )
+ {
+ buffer.append( dep.getArtifact() );
+ }
+ }
+ if ( buffer.length() > 0 )
+ {
+ buffer.append( " -> " );
+ }
+ buffer.append( dependency.getArtifact() );
+ errorPath = buffer.toString();
+ }
+ }
+ }
+
+ public void addCycle( List<DependencyNode> nodes, int cycleEntry, Dependency dependency )
+ {
+ if ( maxCycles < 0 || result.getCycles().size() < maxCycles )
+ {
+ result.addCycle( new DefaultDependencyCycle( nodes, cycleEntry, dependency ) );
+ }
+ }
+ }
+
+ /**
+ * Helper class used during collection.
+ */
+ protected static class PremanagedDependency
+ {
+
+ final String premanagedVersion;
+
+ final String premanagedScope;
+
+ final Boolean premanagedOptional;
+
+ /**
+ * @since 1.1.0
+ */
+ final Collection<Exclusion> premanagedExclusions;
+
+ /**
+ * @since 1.1.0
+ */
+ final Map<String, String> premanagedProperties;
+
+ final int managedBits;
+
+ final Dependency managedDependency;
+
+ final boolean premanagedState;
+
+ @SuppressWarnings( "checkstyle:parameternumber" )
+ PremanagedDependency( String premanagedVersion, String premanagedScope, Boolean premanagedOptional,
+ Collection<Exclusion> premanagedExclusions, Map<String, String> premanagedProperties,
+ int managedBits, Dependency managedDependency, boolean premanagedState )
+ {
+ this.premanagedVersion = premanagedVersion;
+ this.premanagedScope = premanagedScope;
+ this.premanagedOptional = premanagedOptional;
+ this.premanagedExclusions =
+ premanagedExclusions != null
+ ? Collections.unmodifiableCollection( new ArrayList<>( premanagedExclusions ) )
+ : null;
+
+ this.premanagedProperties =
+ premanagedProperties != null
+ ? Collections.unmodifiableMap( new HashMap<>( premanagedProperties ) )
+ : null;
+
+ this.managedBits = managedBits;
+ this.managedDependency = managedDependency;
+ this.premanagedState = premanagedState;
+ }
+
+ public static PremanagedDependency create( DependencyManager depManager, Dependency dependency,
+ boolean disableVersionManagement, boolean premanagedState )
+ {
+ DependencyManagement depMngt = depManager != null ? depManager.manageDependency( dependency ) : null;
+
+ int managedBits = 0;
+ String premanagedVersion = null;
+ String premanagedScope = null;
+ Boolean premanagedOptional = null;
+ Collection<Exclusion> premanagedExclusions = null;
+ Map<String, String> premanagedProperties = null;
+
+ if ( depMngt != null )
+ {
+ if ( depMngt.getVersion() != null && !disableVersionManagement )
+ {
+ Artifact artifact = dependency.getArtifact();
+ premanagedVersion = artifact.getVersion();
+ dependency = dependency.setArtifact( artifact.setVersion( depMngt.getVersion() ) );
+ managedBits |= DependencyNode.MANAGED_VERSION;
+ }
+ if ( depMngt.getProperties() != null )
+ {
+ Artifact artifact = dependency.getArtifact();
+ premanagedProperties = artifact.getProperties();
+ dependency = dependency.setArtifact( artifact.setProperties( depMngt.getProperties() ) );
+ managedBits |= DependencyNode.MANAGED_PROPERTIES;
+ }
+ if ( depMngt.getScope() != null )
+ {
+ premanagedScope = dependency.getScope();
+ dependency = dependency.setScope( depMngt.getScope() );
+ managedBits |= DependencyNode.MANAGED_SCOPE;
+ }
+ if ( depMngt.getOptional() != null )
+ {
+ premanagedOptional = dependency.isOptional();
+ dependency = dependency.setOptional( depMngt.getOptional() );
+ managedBits |= DependencyNode.MANAGED_OPTIONAL;
+ }
+ if ( depMngt.getExclusions() != null )
+ {
+ premanagedExclusions = dependency.getExclusions();
+ dependency = dependency.setExclusions( depMngt.getExclusions() );
+ managedBits |= DependencyNode.MANAGED_EXCLUSIONS;
+ }
+ }
+ return new PremanagedDependency( premanagedVersion, premanagedScope, premanagedOptional,
+ premanagedExclusions, premanagedProperties, managedBits, dependency,
+ premanagedState );
+
+ }
+
+ public Dependency getManagedDependency()
+ {
+ return managedDependency;
+ }
+
+ public void applyTo( DefaultDependencyNode child )
+ {
+ child.setManagedBits( managedBits );
+ if ( premanagedState )
+ {
+ child.setData( DependencyManagerUtils.NODE_DATA_PREMANAGED_VERSION, premanagedVersion );
+ child.setData( DependencyManagerUtils.NODE_DATA_PREMANAGED_SCOPE, premanagedScope );
+ child.setData( DependencyManagerUtils.NODE_DATA_PREMANAGED_OPTIONAL, premanagedOptional );
+ child.setData( DependencyManagerUtils.NODE_DATA_PREMANAGED_EXCLUSIONS, premanagedExclusions );
+ child.setData( DependencyManagerUtils.NODE_DATA_PREMANAGED_PROPERTIES, premanagedProperties );
+ }
+ }
+
+ }
}
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 4c41d40c..cb6d28c2 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,26 +25,14 @@ import javax.inject.Singleton;
import java.util.ArrayDeque;
import java.util.ArrayList;
-import java.util.Collection;
import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.LinkedHashMap;
import java.util.List;
-import java.util.Map;
import java.util.Queue;
-import org.eclipse.aether.DefaultRepositorySystemSession;
-import org.eclipse.aether.RepositoryException;
import org.eclipse.aether.RepositorySystemSession;
import org.eclipse.aether.RequestTrace;
import org.eclipse.aether.artifact.Artifact;
-import org.eclipse.aether.artifact.ArtifactProperties;
import org.eclipse.aether.collection.CollectRequest;
-import org.eclipse.aether.collection.CollectResult;
-import org.eclipse.aether.collection.DependencyCollectionException;
-import org.eclipse.aether.collection.DependencyGraphTransformer;
-import org.eclipse.aether.collection.DependencyManagement;
import org.eclipse.aether.collection.DependencyManager;
import org.eclipse.aether.collection.DependencySelector;
import org.eclipse.aether.collection.DependencyTraverser;
@@ -52,18 +40,13 @@ import org.eclipse.aether.collection.VersionFilter;
import org.eclipse.aether.graph.DefaultDependencyNode;
import org.eclipse.aether.graph.Dependency;
import org.eclipse.aether.graph.DependencyNode;
-import org.eclipse.aether.graph.Exclusion;
import org.eclipse.aether.impl.ArtifactDescriptorReader;
import org.eclipse.aether.impl.RemoteRepositoryManager;
import org.eclipse.aether.impl.VersionRangeResolver;
-import org.eclipse.aether.internal.impl.collect.CachingArtifactTypeRegistry;
import org.eclipse.aether.internal.impl.collect.DataPool;
import org.eclipse.aether.internal.impl.collect.DefaultDependencyCollectionContext;
-import org.eclipse.aether.internal.impl.collect.DefaultDependencyCycle;
-import org.eclipse.aether.internal.impl.collect.DefaultDependencyGraphTransformationContext;
import org.eclipse.aether.internal.impl.collect.DefaultVersionFilterContext;
import org.eclipse.aether.internal.impl.collect.DependencyCollectorDelegate;
-import org.eclipse.aether.repository.ArtifactRepository;
import org.eclipse.aether.repository.RemoteRepository;
import org.eclipse.aether.resolution.ArtifactDescriptorException;
import org.eclipse.aether.resolution.ArtifactDescriptorRequest;
@@ -74,10 +57,8 @@ import org.eclipse.aether.resolution.VersionRangeResult;
import org.eclipse.aether.spi.locator.Service;
import org.eclipse.aether.util.ConfigUtils;
import org.eclipse.aether.util.graph.manager.DependencyManagerUtils;
-import org.eclipse.aether.util.graph.transformer.TransformationContextKeys;
import org.eclipse.aether.version.Version;
-import static java.util.Objects.requireNonNull;
import static org.eclipse.aether.internal.impl.collect.DefaultDependencyCycle.find;
/**
@@ -107,6 +88,12 @@ public class BfDependencyCollector
*/
public static final boolean CONFIG_PROP_SKIPPER_DEFAULT = true;
+ /**
+ * Default ctor for SL.
+ *
+ * @deprecated Will be dropped once SL gone.
+ */
+ @Deprecated
public BfDependencyCollector()
{
// enables default constructor
@@ -120,14 +107,15 @@ public class BfDependencyCollector
super( remoteRepositoryManager, artifactDescriptorReader, versionRangeResolver );
}
- @SuppressWarnings( "checkstyle:methodlength" )
- public CollectResult collectDependencies( RepositorySystemSession session, CollectRequest request )
- throws DependencyCollectionException
+ @SuppressWarnings( "checkstyle:parameternumber" )
+ @Override
+ protected void doCollectDependencies( RepositorySystemSession session, RequestTrace trace, DataPool pool,
+ DefaultDependencyCollectionContext context,
+ DefaultVersionFilterContext versionContext,
+ CollectRequest request, DependencyNode node,
+ List<RemoteRepository> repositories, List<Dependency> dependencies,
+ List<Dependency> managedDependencies, Results results )
{
- requireNonNull( session, "session cannot be null" );
- requireNonNull( request, "request cannot be null" );
- session = optimizeSession( session );
-
boolean useSkip = ConfigUtils.getBoolean(
session, CONFIG_PROP_SKIPPER_DEFAULT, CONFIG_PROP_SKIPPER
);
@@ -136,220 +124,36 @@ public class BfDependencyCollector
logger.debug( "Collector skip mode enabled" );
}
- RequestTrace trace = RequestTrace.newChild( request.getTrace(), request );
-
- CollectResult result = new CollectResult( request );
-
- DependencySelector depSelector = session.getDependencySelector();
- DependencyManager depManager = session.getDependencyManager();
- DependencyTraverser depTraverser = session.getDependencyTraverser();
- VersionFilter verFilter = session.getVersionFilter();
-
- Dependency root = request.getRoot();
- List<RemoteRepository> repositories = request.getRepositories();
- List<Dependency> dependencies = request.getDependencies();
- List<Dependency> managedDependencies = request.getManagedDependencies();
-
- Map<String, Object> stats = new LinkedHashMap<>();
- long time1 = System.nanoTime();
-
- DefaultDependencyNode node;
- if ( root != null )
- {
- List<? extends Version> versions;
- VersionRangeResult rangeResult;
- try
- {
- VersionRangeRequest rangeRequest =
- new VersionRangeRequest( root.getArtifact(), request.getRepositories(),
- request.getRequestContext() );
- rangeRequest.setTrace( trace );
- rangeResult = versionRangeResolver.resolveVersionRange( session, rangeRequest );
- versions = filterVersions( root, rangeResult, verFilter, new DefaultVersionFilterContext( session ) );
- }
- catch ( VersionRangeResolutionException e )
- {
- result.addException( e );
- throw new DependencyCollectionException( result, e.getMessage() );
- }
-
- Version version = versions.get( versions.size() - 1 );
- root = root.setArtifact( root.getArtifact().setVersion( version.toString() ) );
-
- ArtifactDescriptorResult descriptorResult;
- try
- {
- ArtifactDescriptorRequest descriptorRequest = new ArtifactDescriptorRequest();
- descriptorRequest.setArtifact( root.getArtifact() );
- descriptorRequest.setRepositories( request.getRepositories() );
- descriptorRequest.setRequestContext( request.getRequestContext() );
- descriptorRequest.setTrace( trace );
- if ( isLackingDescriptor( root.getArtifact() ) )
- {
- descriptorResult = new ArtifactDescriptorResult( descriptorRequest );
- }
- else
- {
- descriptorResult = descriptorReader.readArtifactDescriptor( session, descriptorRequest );
- }
- }
- catch ( ArtifactDescriptorException e )
- {
- result.addException( e );
- throw new DependencyCollectionException( result, e.getMessage() );
- }
-
- root = root.setArtifact( descriptorResult.getArtifact() );
-
- if ( !session.isIgnoreArtifactDescriptorRepositories() )
- {
- repositories = remoteRepositoryManager.aggregateRepositories( session, repositories,
- descriptorResult.getRepositories(),
- true );
- }
- dependencies = mergeDeps( dependencies, descriptorResult.getDependencies() );
- managedDependencies = mergeDeps( managedDependencies, descriptorResult.getManagedDependencies() );
-
- node = new DefaultDependencyNode( root );
- node.setRequestContext( request.getRequestContext() );
- node.setRelocations( descriptorResult.getRelocations() );
- node.setVersionConstraint( rangeResult.getVersionConstraint() );
- node.setVersion( version );
- node.setAliases( descriptorResult.getAliases() );
- node.setRepositories( request.getRepositories() );
- }
- else
- {
- node = new DefaultDependencyNode( request.getRootArtifact() );
- node.setRequestContext( request.getRequestContext() );
- node.setRepositories( request.getRepositories() );
- }
-
- result.setRoot( node );
-
- boolean traverse = root == null || depTraverser == null || depTraverser.traverseDependency( root );
- String errorPath = null;
- if ( traverse && !dependencies.isEmpty() )
- {
- DataPool pool = new DataPool( session );
-
- DefaultDependencyCollectionContext context =
- new DefaultDependencyCollectionContext( session, request.getRootArtifact(), root, managedDependencies );
-
- DefaultVersionFilterContext versionContext = new DefaultVersionFilterContext( session );
-
- Args args =
- new Args( session, trace, pool, context, versionContext, request,
- useSkip ? DependencyResolutionSkipper.defaultSkipper()
- : DependencyResolutionSkipper.neverSkipper() );
- Results results = new Results( result, session );
-
- DependencySelector rootDepSelector =
- depSelector != null ? depSelector.deriveChildSelector( context ) : null;
- DependencyManager rootDepManager = depManager != null ? depManager.deriveChildManager( context ) : null;
- DependencyTraverser rootDepTraverser =
- depTraverser != null ? depTraverser.deriveChildTraverser( context ) : null;
- VersionFilter rootVerFilter = verFilter != null ? verFilter.deriveChildFilter( context ) : null;
-
- List<DependencyNode> parents = Collections.singletonList( node );
- for ( Dependency dependency : dependencies )
- {
- args.dependencyProcessingQueue.add(
- new DependencyProcessingContext( rootDepSelector, rootDepManager, rootDepTraverser,
- rootVerFilter, repositories, managedDependencies, parents,
- dependency ) );
- }
-
- while ( !args.dependencyProcessingQueue.isEmpty() )
- {
- processDependency( args, results, args.dependencyProcessingQueue.remove(), Collections.emptyList(),
- false );
- }
-
- args.skipper.report();
- errorPath = results.errorPath;
- }
-
- long time2 = System.nanoTime();
+ Args args =
+ new Args( session, trace, pool, context, versionContext, request,
+ useSkip ? DependencyResolutionSkipper.defaultSkipper()
+ : DependencyResolutionSkipper.neverSkipper() );
- DependencyGraphTransformer transformer = session.getDependencyGraphTransformer();
- if ( transformer != null )
- {
- try
- {
- DefaultDependencyGraphTransformationContext context =
- new DefaultDependencyGraphTransformationContext( session );
- context.put( TransformationContextKeys.STATS, stats );
- result.setRoot( transformer.transformGraph( node, context ) );
- }
- catch ( RepositoryException e )
- {
- result.addException( e );
- }
- }
+ DependencySelector rootDepSelector = session.getDependencySelector() != null
+ ? session.getDependencySelector().deriveChildSelector( context ) : null;
+ DependencyManager rootDepManager = session.getDependencyManager() != null
+ ? session.getDependencyManager().deriveChildManager( context ) : null;
+ DependencyTraverser rootDepTraverser = session.getDependencyTraverser() != null
+ ? session.getDependencyTraverser().deriveChildTraverser( context ) : null;
+ VersionFilter rootVerFilter = session.getVersionFilter() != null
+ ? session.getVersionFilter().deriveChildFilter( context ) : null;
- long time3 = System.nanoTime();
- if ( logger.isDebugEnabled() )
+ List<DependencyNode> parents = Collections.singletonList( node );
+ for ( Dependency dependency : dependencies )
{
- stats.put( "BfDependencyCollector.collectTime", time2 - time1 );
- stats.put( "BfDependencyCollector.transformTime", time3 - time2 );
- logger.debug( "Dependency collection stats {}", stats );
+ args.dependencyProcessingQueue.add(
+ new DependencyProcessingContext( rootDepSelector, rootDepManager, rootDepTraverser,
+ rootVerFilter, repositories, managedDependencies, parents,
+ dependency ) );
}
- if ( errorPath != null )
- {
- throw new DependencyCollectionException( result, "Failed to collect dependencies at " + errorPath );
- }
- if ( !result.getExceptions().isEmpty() )
- {
- throw new DependencyCollectionException( result );
- }
-
- return result;
- }
-
- private static RepositorySystemSession optimizeSession( RepositorySystemSession session )
- {
- DefaultRepositorySystemSession optimized = new DefaultRepositorySystemSession( session );
- optimized.setArtifactTypeRegistry( CachingArtifactTypeRegistry.newInstance( session ) );
- return optimized;
- }
-
- private List<Dependency> mergeDeps( List<Dependency> dominant, List<Dependency> recessive )
- {
- List<Dependency> result;
- if ( dominant == null || dominant.isEmpty() )
- {
- result = recessive;
- }
- else if ( recessive == null || recessive.isEmpty() )
- {
- result = dominant;
- }
- else
+ while ( !args.dependencyProcessingQueue.isEmpty() )
{
- int initialCapacity = dominant.size() + recessive.size();
- result = new ArrayList<>( initialCapacity );
- Collection<String> ids = new HashSet<>( initialCapacity, 1.0f );
- for ( Dependency dependency : dominant )
- {
- ids.add( getId( dependency.getArtifact() ) );
- result.add( dependency );
- }
- for ( Dependency dependency : recessive )
- {
- if ( !ids.contains( getId( dependency.getArtifact() ) ) )
- {
- result.add( dependency );
- }
- }
+ processDependency( args, results, args.dependencyProcessingQueue.remove(), Collections.emptyList(),
+ false );
}
- return result;
- }
- private static String getId( Artifact a )
- {
- return a.getGroupId() + ':' + a.getArtifactId() + ':' + a.getClassifier() + ':' + a.getExtension();
+ args.skipper.report();
}
@SuppressWarnings( "checkstyle:parameternumber" )
@@ -365,7 +169,7 @@ public class BfDependencyCollector
PremanagedDependency preManaged =
PremanagedDependency.create( context.depManager, context.dependency, disableVersionManagement,
args.premanagedState );
- Dependency dependency = preManaged.managedDependency;
+ Dependency dependency = preManaged.getManagedDependency();
boolean noDescriptor = isLackingDescriptor( dependency.getArtifact() );
@@ -377,7 +181,8 @@ public class BfDependencyCollector
VersionRangeResult rangeResult;
try
{
- VersionRangeRequest rangeRequest = createVersionRangeRequest( args, context.repositories, dependency );
+ VersionRangeRequest rangeRequest = createVersionRangeRequest( args.request.getRequestContext(), args.trace,
+ context.repositories, dependency );
rangeResult = cachedResolveRangeResult( rangeRequest, args.pool, args.session );
@@ -396,8 +201,8 @@ public class BfDependencyCollector
Artifact originalArtifact = dependency.getArtifact().setVersion( version.toString() );
Dependency d = dependency.setArtifact( originalArtifact );
- ArtifactDescriptorRequest descriptorRequest =
- createArtifactDescriptorRequest( args, context.repositories, d );
+ ArtifactDescriptorRequest descriptorRequest = createArtifactDescriptorRequest(
+ args.request.getRequestContext(), args.trace, context.repositories, d );
final ArtifactDescriptorResult descriptorResult =
noDescriptor
@@ -514,6 +319,7 @@ public class BfDependencyCollector
args.dependencyProcessingQueue.add(
new DependencyProcessingContext( childSelector, childManager, childTraverser, childFilter,
childRepos, descriptorResult.getManagedDependencies(), parents, dependency ) );
+
}
args.pool.putChildren( key, child.getChildren() );
args.skipper.cache( child, parents );
@@ -556,132 +362,6 @@ public class BfDependencyCollector
return descriptorResult;
}
- @SuppressWarnings( "checkstyle:parameternumber" )
- private static DefaultDependencyNode createDependencyNode( List<Artifact> relocations,
- PremanagedDependency preManaged,
- VersionRangeResult rangeResult, Version version,
- Dependency d, Collection<Artifact> aliases,
- List<RemoteRepository> repos, String requestContext )
- {
- DefaultDependencyNode child = new DefaultDependencyNode( d );
- preManaged.applyTo( child );
- child.setRelocations( relocations );
- child.setVersionConstraint( rangeResult.getVersionConstraint() );
- child.setVersion( version );
- child.setAliases( aliases );
- child.setRepositories( repos );
- child.setRequestContext( requestContext );
- return child;
- }
-
- private static DefaultDependencyNode createDependencyNode( List<Artifact> relocations,
- PremanagedDependency preManaged,
- VersionRangeResult rangeResult, Version version,
- Dependency d, ArtifactDescriptorResult descriptorResult,
- DependencyNode cycleNode )
- {
- DefaultDependencyNode child =
- createDependencyNode( relocations, preManaged, rangeResult, version, d, descriptorResult.getAliases(),
- cycleNode.getRepositories(), cycleNode.getRequestContext() );
- child.setChildren( cycleNode.getChildren() );
- return child;
- }
-
- private static ArtifactDescriptorRequest createArtifactDescriptorRequest( Args args,
- List<RemoteRepository> repositories,
- Dependency d )
- {
- ArtifactDescriptorRequest descriptorRequest = new ArtifactDescriptorRequest();
- descriptorRequest.setArtifact( d.getArtifact() );
- descriptorRequest.setRepositories( repositories );
- descriptorRequest.setRequestContext( args.request.getRequestContext() );
- descriptorRequest.setTrace( args.trace );
- return descriptorRequest;
- }
-
- private static VersionRangeRequest createVersionRangeRequest( Args args, List<RemoteRepository> repositories,
- Dependency dependency )
- {
- VersionRangeRequest rangeRequest = new VersionRangeRequest();
- rangeRequest.setArtifact( dependency.getArtifact() );
- rangeRequest.setRepositories( repositories );
- rangeRequest.setRequestContext( args.request.getRequestContext() );
- rangeRequest.setTrace( args.trace );
- return rangeRequest;
- }
-
- private VersionRangeResult cachedResolveRangeResult( VersionRangeRequest rangeRequest, DataPool pool,
- RepositorySystemSession session )
- throws VersionRangeResolutionException
- {
- Object key = pool.toKey( rangeRequest );
- VersionRangeResult rangeResult = pool.getConstraint( key, rangeRequest );
- if ( rangeResult == null )
- {
- rangeResult = versionRangeResolver.resolveVersionRange( session, rangeRequest );
- pool.putConstraint( key, rangeResult );
- }
- return rangeResult;
- }
-
- private static boolean isLackingDescriptor( Artifact artifact )
- {
- return artifact.getProperty( ArtifactProperties.LOCAL_PATH, null ) != null;
- }
-
- private static List<RemoteRepository> getRemoteRepositories( ArtifactRepository repository,
- List<RemoteRepository> repositories )
- {
- if ( repository instanceof RemoteRepository )
- {
- return Collections.singletonList( (RemoteRepository) repository );
- }
- if ( repository != null )
- {
- return Collections.emptyList();
- }
- return repositories;
- }
-
- private static List<? extends Version> filterVersions( Dependency dependency, VersionRangeResult rangeResult,
- VersionFilter verFilter,
- DefaultVersionFilterContext verContext )
- throws VersionRangeResolutionException
- {
- if ( rangeResult.getVersions().isEmpty() )
- {
- throw new VersionRangeResolutionException( rangeResult,
- "No versions available for " + dependency.getArtifact()
- + " within specified range" );
- }
-
- List<? extends Version> versions;
- if ( verFilter != null && rangeResult.getVersionConstraint().getRange() != null )
- {
- verContext.set( dependency, rangeResult );
- try
- {
- verFilter.filterVersions( verContext );
- }
- catch ( RepositoryException e )
- {
- throw new VersionRangeResolutionException( rangeResult,
- "Failed to filter versions for " + dependency.getArtifact(), e );
- }
- versions = verContext.get();
- if ( versions.isEmpty() )
- {
- throw new VersionRangeResolutionException( rangeResult,
- "No acceptable versions for " + dependency.getArtifact() + ": " + rangeResult.getVersions() );
- }
- }
- else
- {
- versions = rangeResult.getVersions();
- }
- return versions;
- }
-
static class Args
{
@@ -722,181 +402,4 @@ public class BfDependencyCollector
}
- static class Results
- {
-
- private final CollectResult result;
-
- final int maxExceptions;
-
- final int maxCycles;
-
- String errorPath;
-
- Results( CollectResult result, RepositorySystemSession session )
- {
- this.result = result;
-
- maxExceptions =
- ConfigUtils.getInteger( session, CONFIG_PROP_MAX_EXCEPTIONS_DEFAULT, CONFIG_PROP_MAX_EXCEPTIONS );
-
- maxCycles = ConfigUtils.getInteger( session, CONFIG_PROP_MAX_CYCLES_DEFAULT, CONFIG_PROP_MAX_CYCLES );
- }
-
- public void addException( Dependency dependency, Exception e, List<DependencyNode> nodes )
- {
- if ( maxExceptions < 0 || result.getExceptions().size() < maxExceptions )
- {
- result.addException( e );
- if ( errorPath == null )
- {
- StringBuilder buffer = new StringBuilder( 256 );
- for ( DependencyNode node : nodes )
- {
- if ( buffer.length() > 0 )
- {
- buffer.append( " -> " );
- }
- Dependency dep = node.getDependency();
- if ( dep != null )
- {
- buffer.append( dep.getArtifact() );
- }
- }
- if ( buffer.length() > 0 )
- {
- buffer.append( " -> " );
- }
- buffer.append( dependency.getArtifact() );
- errorPath = buffer.toString();
- }
- }
- }
-
- public void addCycle( List<DependencyNode> nodes, int cycleEntry, Dependency dependency )
- {
- if ( maxCycles < 0 || result.getCycles().size() < maxCycles )
- {
- result.addCycle( new DefaultDependencyCycle( nodes, cycleEntry, dependency ) );
- }
- }
-
- }
-
- static class PremanagedDependency
- {
-
- final String premanagedVersion;
-
- final String premanagedScope;
-
- final Boolean premanagedOptional;
-
- /**
- * @since 1.1.0
- */
- final Collection<Exclusion> premanagedExclusions;
-
- /**
- * @since 1.1.0
- */
- final Map<String, String> premanagedProperties;
-
- final int managedBits;
-
- final Dependency managedDependency;
-
- final boolean premanagedState;
-
- @SuppressWarnings( "checkstyle:parameternumber" )
- PremanagedDependency( String premanagedVersion, String premanagedScope, Boolean premanagedOptional,
- Collection<Exclusion> premanagedExclusions, Map<String, String> premanagedProperties,
- int managedBits, Dependency managedDependency, boolean premanagedState )
- {
- this.premanagedVersion = premanagedVersion;
- this.premanagedScope = premanagedScope;
- this.premanagedOptional = premanagedOptional;
- this.premanagedExclusions =
- premanagedExclusions != null
- ? Collections.unmodifiableCollection( new ArrayList<>( premanagedExclusions ) )
- : null;
-
- this.premanagedProperties =
- premanagedProperties != null
- ? Collections.unmodifiableMap( new HashMap<>( premanagedProperties ) )
- : null;
-
- this.managedBits = managedBits;
- this.managedDependency = managedDependency;
- this.premanagedState = premanagedState;
- }
-
- static PremanagedDependency create( DependencyManager depManager, Dependency dependency,
- boolean disableVersionManagement, boolean premanagedState )
- {
- DependencyManagement depMngt = depManager != null ? depManager.manageDependency( dependency ) : null;
-
- int managedBits = 0;
- String premanagedVersion = null;
- String premanagedScope = null;
- Boolean premanagedOptional = null;
- Collection<Exclusion> premanagedExclusions = null;
- Map<String, String> premanagedProperties = null;
-
- if ( depMngt != null )
- {
- if ( depMngt.getVersion() != null && !disableVersionManagement )
- {
- Artifact artifact = dependency.getArtifact();
- premanagedVersion = artifact.getVersion();
- dependency = dependency.setArtifact( artifact.setVersion( depMngt.getVersion() ) );
- managedBits |= DependencyNode.MANAGED_VERSION;
- }
- if ( depMngt.getProperties() != null )
- {
- Artifact artifact = dependency.getArtifact();
- premanagedProperties = artifact.getProperties();
- dependency = dependency.setArtifact( artifact.setProperties( depMngt.getProperties() ) );
- managedBits |= DependencyNode.MANAGED_PROPERTIES;
- }
- if ( depMngt.getScope() != null )
- {
- premanagedScope = dependency.getScope();
- dependency = dependency.setScope( depMngt.getScope() );
- managedBits |= DependencyNode.MANAGED_SCOPE;
- }
- if ( depMngt.getOptional() != null )
- {
- premanagedOptional = dependency.isOptional();
- dependency = dependency.setOptional( depMngt.getOptional() );
- managedBits |= DependencyNode.MANAGED_OPTIONAL;
- }
- if ( depMngt.getExclusions() != null )
- {
- premanagedExclusions = dependency.getExclusions();
- dependency = dependency.setExclusions( depMngt.getExclusions() );
- managedBits |= DependencyNode.MANAGED_EXCLUSIONS;
- }
- }
- return new PremanagedDependency( premanagedVersion, premanagedScope, premanagedOptional,
- premanagedExclusions, premanagedProperties, managedBits, dependency,
- premanagedState );
-
- }
-
- public void applyTo( DefaultDependencyNode child )
- {
- child.setManagedBits( managedBits );
- if ( premanagedState )
- {
- child.setData( DependencyManagerUtils.NODE_DATA_PREMANAGED_VERSION, premanagedVersion );
- child.setData( DependencyManagerUtils.NODE_DATA_PREMANAGED_SCOPE, premanagedScope );
- child.setData( DependencyManagerUtils.NODE_DATA_PREMANAGED_OPTIONAL, premanagedOptional );
- child.setData( DependencyManagerUtils.NODE_DATA_PREMANAGED_EXCLUSIONS, premanagedExclusions );
- child.setData( DependencyManagerUtils.NODE_DATA_PREMANAGED_PROPERTIES, premanagedProperties );
- }
- }
-
- }
-
}
diff --git a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/df/DfDependencyCollector.java b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/df/DfDependencyCollector.java
index e803fe13..b2444f8c 100644
--- a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/df/DfDependencyCollector.java
+++ b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/df/DfDependencyCollector.java
@@ -19,31 +19,17 @@ package org.eclipse.aether.internal.impl.collect.df;
* under the License.
*/
-import java.util.ArrayList;
-import java.util.Collection;
import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.LinkedHashMap;
import java.util.List;
-import java.util.Map;
-import static java.util.Objects.requireNonNull;
import javax.inject.Inject;
import javax.inject.Named;
import javax.inject.Singleton;
-import org.eclipse.aether.DefaultRepositorySystemSession;
-import org.eclipse.aether.RepositoryException;
import org.eclipse.aether.RepositorySystemSession;
import org.eclipse.aether.RequestTrace;
import org.eclipse.aether.artifact.Artifact;
-import org.eclipse.aether.artifact.ArtifactProperties;
import org.eclipse.aether.collection.CollectRequest;
-import org.eclipse.aether.collection.CollectResult;
-import org.eclipse.aether.collection.DependencyCollectionException;
-import org.eclipse.aether.collection.DependencyGraphTransformer;
-import org.eclipse.aether.collection.DependencyManagement;
import org.eclipse.aether.collection.DependencyManager;
import org.eclipse.aether.collection.DependencySelector;
import org.eclipse.aether.collection.DependencyTraverser;
@@ -51,18 +37,14 @@ import org.eclipse.aether.collection.VersionFilter;
import org.eclipse.aether.graph.DefaultDependencyNode;
import org.eclipse.aether.graph.Dependency;
import org.eclipse.aether.graph.DependencyNode;
-import org.eclipse.aether.graph.Exclusion;
import org.eclipse.aether.impl.ArtifactDescriptorReader;
import org.eclipse.aether.impl.RemoteRepositoryManager;
import org.eclipse.aether.impl.VersionRangeResolver;
-import org.eclipse.aether.internal.impl.collect.CachingArtifactTypeRegistry;
import org.eclipse.aether.internal.impl.collect.DataPool;
import org.eclipse.aether.internal.impl.collect.DefaultDependencyCollectionContext;
import org.eclipse.aether.internal.impl.collect.DefaultDependencyCycle;
-import org.eclipse.aether.internal.impl.collect.DefaultDependencyGraphTransformationContext;
import org.eclipse.aether.internal.impl.collect.DefaultVersionFilterContext;
import org.eclipse.aether.internal.impl.collect.DependencyCollectorDelegate;
-import org.eclipse.aether.repository.ArtifactRepository;
import org.eclipse.aether.repository.RemoteRepository;
import org.eclipse.aether.resolution.ArtifactDescriptorException;
import org.eclipse.aether.resolution.ArtifactDescriptorRequest;
@@ -73,7 +55,6 @@ import org.eclipse.aether.resolution.VersionRangeResult;
import org.eclipse.aether.spi.locator.Service;
import org.eclipse.aether.util.ConfigUtils;
import org.eclipse.aether.util.graph.manager.DependencyManagerUtils;
-import org.eclipse.aether.util.graph.transformer.TransformationContextKeys;
import org.eclipse.aether.version.Version;
/**
@@ -89,6 +70,12 @@ public class DfDependencyCollector
{
public static final String NAME = "df";
+ /**
+ * Default ctor for SL.
+ *
+ * @deprecated Will be dropped once SL gone.
+ */
+ @Deprecated
public DfDependencyCollector()
{
// enables default constructor
@@ -102,214 +89,32 @@ public class DfDependencyCollector
super( remoteRepositoryManager, artifactDescriptorReader, versionRangeResolver );
}
- @SuppressWarnings( "checkstyle:methodlength" )
- public CollectResult collectDependencies( RepositorySystemSession session, CollectRequest request )
- throws DependencyCollectionException
- {
- requireNonNull( session, "session cannot be null" );
- requireNonNull( request, "request cannot be null" );
- session = optimizeSession( session );
-
- RequestTrace trace = RequestTrace.newChild( request.getTrace(), request );
-
- CollectResult result = new CollectResult( request );
-
- DependencySelector depSelector = session.getDependencySelector();
- DependencyManager depManager = session.getDependencyManager();
- DependencyTraverser depTraverser = session.getDependencyTraverser();
- VersionFilter verFilter = session.getVersionFilter();
-
- Dependency root = request.getRoot();
- List<RemoteRepository> repositories = request.getRepositories();
- List<Dependency> dependencies = request.getDependencies();
- List<Dependency> managedDependencies = request.getManagedDependencies();
-
- Map<String, Object> stats = new LinkedHashMap<>();
- long time1 = System.nanoTime();
-
- DefaultDependencyNode node;
- if ( root != null )
- {
- List<? extends Version> versions;
- VersionRangeResult rangeResult;
- try
- {
- VersionRangeRequest rangeRequest =
- new VersionRangeRequest( root.getArtifact(), request.getRepositories(),
- request.getRequestContext() );
- rangeRequest.setTrace( trace );
- rangeResult = versionRangeResolver.resolveVersionRange( session, rangeRequest );
- versions = filterVersions( root, rangeResult, verFilter, new DefaultVersionFilterContext( session ) );
- }
- catch ( VersionRangeResolutionException e )
- {
- result.addException( e );
- throw new DependencyCollectionException( result, e.getMessage() );
- }
-
- Version version = versions.get( versions.size() - 1 );
- root = root.setArtifact( root.getArtifact().setVersion( version.toString() ) );
-
- ArtifactDescriptorResult descriptorResult;
- try
- {
- ArtifactDescriptorRequest descriptorRequest = new ArtifactDescriptorRequest();
- descriptorRequest.setArtifact( root.getArtifact() );
- descriptorRequest.setRepositories( request.getRepositories() );
- descriptorRequest.setRequestContext( request.getRequestContext() );
- descriptorRequest.setTrace( trace );
- if ( isLackingDescriptor( root.getArtifact() ) )
- {
- descriptorResult = new ArtifactDescriptorResult( descriptorRequest );
- }
- else
- {
- descriptorResult = descriptorReader.readArtifactDescriptor( session, descriptorRequest );
- }
- }
- catch ( ArtifactDescriptorException e )
- {
- result.addException( e );
- throw new DependencyCollectionException( result, e.getMessage() );
- }
-
- root = root.setArtifact( descriptorResult.getArtifact() );
-
- if ( !session.isIgnoreArtifactDescriptorRepositories() )
- {
- repositories = remoteRepositoryManager.aggregateRepositories( session, repositories,
- descriptorResult.getRepositories(),
- true );
- }
- dependencies = mergeDeps( dependencies, descriptorResult.getDependencies() );
- managedDependencies = mergeDeps( managedDependencies, descriptorResult.getManagedDependencies() );
-
- node = new DefaultDependencyNode( root );
- node.setRequestContext( request.getRequestContext() );
- node.setRelocations( descriptorResult.getRelocations() );
- node.setVersionConstraint( rangeResult.getVersionConstraint() );
- node.setVersion( version );
- node.setAliases( descriptorResult.getAliases() );
- node.setRepositories( request.getRepositories() );
- }
- else
- {
- node = new DefaultDependencyNode( request.getRootArtifact() );
- node.setRequestContext( request.getRequestContext() );
- node.setRepositories( request.getRepositories() );
- }
-
- result.setRoot( node );
-
- boolean traverse = root == null || depTraverser == null || depTraverser.traverseDependency( root );
- String errorPath = null;
- if ( traverse && !dependencies.isEmpty() )
- {
- DataPool pool = new DataPool( session );
-
- NodeStack nodes = new NodeStack();
- nodes.push( node );
-
- DefaultDependencyCollectionContext context =
- new DefaultDependencyCollectionContext( session, request.getRootArtifact(), root, managedDependencies );
-
- DefaultVersionFilterContext versionContext = new DefaultVersionFilterContext( session );
-
- Args args = new Args( session, trace, pool, nodes, context, versionContext, request );
- Results results = new Results( result, session );
-
- process( args, results, dependencies, repositories,
- depSelector != null ? depSelector.deriveChildSelector( context ) : null,
- depManager != null ? depManager.deriveChildManager( context ) : null,
- depTraverser != null ? depTraverser.deriveChildTraverser( context ) : null,
- verFilter != null ? verFilter.deriveChildFilter( context ) : null );
-
- errorPath = results.errorPath;
- }
-
- long time2 = System.nanoTime();
-
- DependencyGraphTransformer transformer = session.getDependencyGraphTransformer();
- if ( transformer != null )
- {
- try
- {
- DefaultDependencyGraphTransformationContext context =
- new DefaultDependencyGraphTransformationContext( session );
- context.put( TransformationContextKeys.STATS, stats );
- result.setRoot( transformer.transformGraph( node, context ) );
- }
- catch ( RepositoryException e )
- {
- result.addException( e );
- }
- }
-
- long time3 = System.nanoTime();
- if ( logger.isDebugEnabled() )
- {
- stats.put( "DfDependencyCollector.collectTime", time2 - time1 );
- stats.put( "DfDependencyCollector.transformTime", time3 - time2 );
- logger.debug( "Dependency collection stats {}", stats );
- }
-
- if ( errorPath != null )
- {
- throw new DependencyCollectionException( result, "Failed to collect dependencies at " + errorPath );
- }
- if ( !result.getExceptions().isEmpty() )
- {
- throw new DependencyCollectionException( result );
- }
-
- return result;
- }
-
- private static RepositorySystemSession optimizeSession( RepositorySystemSession session )
- {
- DefaultRepositorySystemSession optimized = new DefaultRepositorySystemSession( session );
- optimized.setArtifactTypeRegistry( CachingArtifactTypeRegistry.newInstance( session ) );
- return optimized;
- }
-
- private List<Dependency> mergeDeps( List<Dependency> dominant, List<Dependency> recessive )
- {
- List<Dependency> result;
- if ( dominant == null || dominant.isEmpty() )
- {
- result = recessive;
- }
- else if ( recessive == null || recessive.isEmpty() )
- {
- result = dominant;
- }
- else
- {
- int initialCapacity = dominant.size() + recessive.size();
- result = new ArrayList<>( initialCapacity );
- Collection<String> ids = new HashSet<>( initialCapacity, 1.0f );
- for ( Dependency dependency : dominant )
- {
- ids.add( getId( dependency.getArtifact() ) );
- result.add( dependency );
- }
- for ( Dependency dependency : recessive )
- {
- if ( !ids.contains( getId( dependency.getArtifact() ) ) )
- {
- result.add( dependency );
- }
- }
- }
- return result;
- }
-
- private static String getId( Artifact a )
+ @SuppressWarnings( "checkstyle:parameternumber" )
+ @Override
+ protected void doCollectDependencies( RepositorySystemSession session, RequestTrace trace, DataPool pool,
+ DefaultDependencyCollectionContext context,
+ DefaultVersionFilterContext versionContext,
+ CollectRequest request, DependencyNode node,
+ List<RemoteRepository> repositories, List<Dependency> dependencies,
+ List<Dependency> managedDependencies, Results results )
{
- return a.getGroupId() + ':' + a.getArtifactId() + ':' + a.getClassifier() + ':' + a.getExtension();
+ NodeStack nodes = new NodeStack();
+ nodes.push( node );
+
+ Args args = new Args( session, trace, pool, nodes, context, versionContext, request );
+
+ process( args, results, dependencies, repositories,
+ session.getDependencySelector() != null
+ ? session.getDependencySelector().deriveChildSelector( context ) : null,
+ session.getDependencyManager() != null
+ ? session.getDependencyManager().deriveChildManager( context ) : null,
+ session.getDependencyTraverser() != null
+ ? session.getDependencyTraverser().deriveChildTraverser( context ) : null,
+ session.getVersionFilter() != null
+ ? session.getVersionFilter().deriveChildFilter( context ) : null );
}
- @SuppressWarnings( "checkstyle:parameternumber" )
+ @SuppressWarnings( "checkstyle:parameternumber" )
private void process( final Args args, Results results, List<Dependency> dependencies,
List<RemoteRepository> repositories, DependencySelector depSelector,
DependencyManager depManager, DependencyTraverser depTraverser, VersionFilter verFilter )
@@ -346,7 +151,7 @@ public class DfDependencyCollector
PremanagedDependency preManaged =
PremanagedDependency.create( depManager, dependency, disableVersionManagement, args.premanagedState );
- dependency = preManaged.managedDependency;
+ dependency = preManaged.getManagedDependency();
boolean noDescriptor = isLackingDescriptor( dependency.getArtifact() );
@@ -356,7 +161,8 @@ public class DfDependencyCollector
VersionRangeResult rangeResult;
try
{
- VersionRangeRequest rangeRequest = createVersionRangeRequest( args, repositories, dependency );
+ VersionRangeRequest rangeRequest = createVersionRangeRequest( args.request.getRequestContext(), args.trace,
+ repositories, dependency );
rangeResult = cachedResolveRangeResult( rangeRequest, args.pool, args.session );
@@ -364,7 +170,7 @@ public class DfDependencyCollector
}
catch ( VersionRangeResolutionException e )
{
- results.addException( dependency, e, args.nodes );
+ results.addException( dependency, e, args.nodes.nodes );
return;
}
@@ -373,7 +179,8 @@ public class DfDependencyCollector
Artifact originalArtifact = dependency.getArtifact().setVersion( version.toString() );
Dependency d = dependency.setArtifact( originalArtifact );
- ArtifactDescriptorRequest descriptorRequest = createArtifactDescriptorRequest( args, repositories, d );
+ ArtifactDescriptorRequest descriptorRequest = createArtifactDescriptorRequest(
+ args.request.getRequestContext(), args.trace, repositories, d );
final ArtifactDescriptorResult descriptorResult =
getArtifactDescriptorResult( args, results, noDescriptor, d, descriptorRequest );
@@ -386,7 +193,7 @@ public class DfDependencyCollector
int cycleEntry = DefaultDependencyCycle.find( args.nodes.nodes, d.getArtifact() );
if ( cycleEntry >= 0 )
{
- results.addCycle( args.nodes, cycleEntry, d );
+ results.addCycle( args.nodes.nodes, cycleEntry, d );
DependencyNode cycleNode = args.nodes.get( cycleEntry );
if ( cycleNode.getDependency() != null )
{
@@ -509,7 +316,7 @@ public class DfDependencyCollector
}
catch ( ArtifactDescriptorException e )
{
- results.addException( d, e, args.nodes );
+ results.addException( d, e, args.nodes.nodes );
pool.putDescriptor( key, e );
return null;
}
@@ -523,132 +330,6 @@ public class DfDependencyCollector
return descriptorResult;
}
- @SuppressWarnings( "checkstyle:parameternumber" )
- private static DefaultDependencyNode createDependencyNode( List<Artifact> relocations,
- PremanagedDependency preManaged,
- VersionRangeResult rangeResult, Version version,
- Dependency d, Collection<Artifact> aliases,
- List<RemoteRepository> repos, String requestContext )
- {
- DefaultDependencyNode child = new DefaultDependencyNode( d );
- preManaged.applyTo( child );
- child.setRelocations( relocations );
- child.setVersionConstraint( rangeResult.getVersionConstraint() );
- child.setVersion( version );
- child.setAliases( aliases );
- child.setRepositories( repos );
- child.setRequestContext( requestContext );
- return child;
- }
-
- private static DefaultDependencyNode createDependencyNode( List<Artifact> relocations,
- PremanagedDependency preManaged,
- VersionRangeResult rangeResult, Version version,
- Dependency d, ArtifactDescriptorResult descriptorResult,
- DependencyNode cycleNode )
- {
- DefaultDependencyNode child =
- createDependencyNode( relocations, preManaged, rangeResult, version, d, descriptorResult.getAliases(),
- cycleNode.getRepositories(), cycleNode.getRequestContext() );
- child.setChildren( cycleNode.getChildren() );
- return child;
- }
-
- private static ArtifactDescriptorRequest createArtifactDescriptorRequest( Args args,
- List<RemoteRepository> repositories,
- Dependency d )
- {
- ArtifactDescriptorRequest descriptorRequest = new ArtifactDescriptorRequest();
- descriptorRequest.setArtifact( d.getArtifact() );
- descriptorRequest.setRepositories( repositories );
- descriptorRequest.setRequestContext( args.request.getRequestContext() );
- descriptorRequest.setTrace( args.trace );
- return descriptorRequest;
- }
-
- private static VersionRangeRequest createVersionRangeRequest( Args args, List<RemoteRepository> repositories,
- Dependency dependency )
- {
- VersionRangeRequest rangeRequest = new VersionRangeRequest();
- rangeRequest.setArtifact( dependency.getArtifact() );
- rangeRequest.setRepositories( repositories );
- rangeRequest.setRequestContext( args.request.getRequestContext() );
- rangeRequest.setTrace( args.trace );
- return rangeRequest;
- }
-
- private VersionRangeResult cachedResolveRangeResult( VersionRangeRequest rangeRequest, DataPool pool,
- RepositorySystemSession session )
- throws VersionRangeResolutionException
- {
- Object key = pool.toKey( rangeRequest );
- VersionRangeResult rangeResult = pool.getConstraint( key, rangeRequest );
- if ( rangeResult == null )
- {
- rangeResult = versionRangeResolver.resolveVersionRange( session, rangeRequest );
- pool.putConstraint( key, rangeResult );
- }
- return rangeResult;
- }
-
- private static boolean isLackingDescriptor( Artifact artifact )
- {
- return artifact.getProperty( ArtifactProperties.LOCAL_PATH, null ) != null;
- }
-
- private static List<RemoteRepository> getRemoteRepositories( ArtifactRepository repository,
- List<RemoteRepository> repositories )
- {
- if ( repository instanceof RemoteRepository )
- {
- return Collections.singletonList( (RemoteRepository) repository );
- }
- if ( repository != null )
- {
- return Collections.emptyList();
- }
- return repositories;
- }
-
- private static List<? extends Version> filterVersions( Dependency dependency, VersionRangeResult rangeResult,
- VersionFilter verFilter,
- DefaultVersionFilterContext verContext )
- throws VersionRangeResolutionException
- {
- if ( rangeResult.getVersions().isEmpty() )
- {
- throw new VersionRangeResolutionException( rangeResult,
- "No versions available for " + dependency.getArtifact()
- + " within specified range" );
- }
-
- List<? extends Version> versions;
- if ( verFilter != null && rangeResult.getVersionConstraint().getRange() != null )
- {
- verContext.set( dependency, rangeResult );
- try
- {
- verFilter.filterVersions( verContext );
- }
- catch ( RepositoryException e )
- {
- throw new VersionRangeResolutionException( rangeResult,
- "Failed to filter versions for " + dependency.getArtifact(), e );
- }
- versions = verContext.get();
- if ( versions.isEmpty() )
- {
- throw new VersionRangeResolutionException( rangeResult,
- "No acceptable versions for " + dependency.getArtifact() + ": " + rangeResult.getVersions() );
- }
- }
- else
- {
- versions = rangeResult.getVersions();
- }
- return versions;
- }
-
static class Args
{
@@ -686,182 +367,4 @@ public class DfDependencyCollector
}
}
-
- static class Results
- {
-
- private final CollectResult result;
-
- final int maxExceptions;
-
- final int maxCycles;
-
- String errorPath;
-
- Results( CollectResult result, RepositorySystemSession session )
- {
- this.result = result;
-
- maxExceptions =
- ConfigUtils.getInteger( session, CONFIG_PROP_MAX_EXCEPTIONS_DEFAULT, CONFIG_PROP_MAX_EXCEPTIONS );
-
- maxCycles = ConfigUtils.getInteger( session, CONFIG_PROP_MAX_CYCLES_DEFAULT, CONFIG_PROP_MAX_CYCLES );
- }
-
- public void addException( Dependency dependency, Exception e, NodeStack nodes )
- {
- if ( maxExceptions < 0 || result.getExceptions().size() < maxExceptions )
- {
- result.addException( e );
- if ( errorPath == null )
- {
- StringBuilder buffer = new StringBuilder( 256 );
- for ( int i = 0; i < nodes.size(); i++ )
- {
- if ( buffer.length() > 0 )
- {
- buffer.append( " -> " );
- }
- Dependency dep = nodes.get( i ).getDependency();
- if ( dep != null )
- {
- buffer.append( dep.getArtifact() );
- }
- }
- if ( buffer.length() > 0 )
- {
- buffer.append( " -> " );
- }
- buffer.append( dependency.getArtifact() );
- errorPath = buffer.toString();
- }
- }
- }
-
- public void addCycle( NodeStack nodes, int cycleEntry, Dependency dependency )
- {
- if ( maxCycles < 0 || result.getCycles().size() < maxCycles )
- {
- result.addCycle( new DefaultDependencyCycle( nodes.nodes, cycleEntry, dependency ) );
- }
- }
-
- }
-
- static class PremanagedDependency
- {
-
- final String premanagedVersion;
-
- final String premanagedScope;
-
- final Boolean premanagedOptional;
-
- /**
- * @since 1.1.0
- */
- final Collection<Exclusion> premanagedExclusions;
-
- /**
- * @since 1.1.0
- */
- final Map<String, String> premanagedProperties;
-
- final int managedBits;
-
- final Dependency managedDependency;
-
- final boolean premanagedState;
-
- @SuppressWarnings( "checkstyle:parameternumber" )
- PremanagedDependency( String premanagedVersion, String premanagedScope, Boolean premanagedOptional,
- Collection<Exclusion> premanagedExclusions, Map<String, String> premanagedProperties,
- int managedBits, Dependency managedDependency, boolean premanagedState )
- {
- this.premanagedVersion = premanagedVersion;
- this.premanagedScope = premanagedScope;
- this.premanagedOptional = premanagedOptional;
- this.premanagedExclusions =
- premanagedExclusions != null
- ? Collections.unmodifiableCollection( new ArrayList<>( premanagedExclusions ) )
- : null;
-
- this.premanagedProperties =
- premanagedProperties != null
- ? Collections.unmodifiableMap( new HashMap<>( premanagedProperties ) )
- : null;
-
- this.managedBits = managedBits;
- this.managedDependency = managedDependency;
- this.premanagedState = premanagedState;
- }
-
- static PremanagedDependency create( DependencyManager depManager, Dependency dependency,
- boolean disableVersionManagement, boolean premanagedState )
- {
- DependencyManagement depMngt = depManager != null ? depManager.manageDependency( dependency ) : null;
-
- int managedBits = 0;
- String premanagedVersion = null;
- String premanagedScope = null;
- Boolean premanagedOptional = null;
- Collection<Exclusion> premanagedExclusions = null;
- Map<String, String> premanagedProperties = null;
-
- if ( depMngt != null )
- {
- if ( depMngt.getVersion() != null && !disableVersionManagement )
- {
- Artifact artifact = dependency.getArtifact();
- premanagedVersion = artifact.getVersion();
- dependency = dependency.setArtifact( artifact.setVersion( depMngt.getVersion() ) );
- managedBits |= DependencyNode.MANAGED_VERSION;
- }
- if ( depMngt.getProperties() != null )
- {
- Artifact artifact = dependency.getArtifact();
- premanagedProperties = artifact.getProperties();
- dependency = dependency.setArtifact( artifact.setProperties( depMngt.getProperties() ) );
- managedBits |= DependencyNode.MANAGED_PROPERTIES;
- }
- if ( depMngt.getScope() != null )
- {
- premanagedScope = dependency.getScope();
- dependency = dependency.setScope( depMngt.getScope() );
- managedBits |= DependencyNode.MANAGED_SCOPE;
- }
- if ( depMngt.getOptional() != null )
- {
- premanagedOptional = dependency.isOptional();
- dependency = dependency.setOptional( depMngt.getOptional() );
- managedBits |= DependencyNode.MANAGED_OPTIONAL;
- }
- if ( depMngt.getExclusions() != null )
- {
- premanagedExclusions = dependency.getExclusions();
- dependency = dependency.setExclusions( depMngt.getExclusions() );
- managedBits |= DependencyNode.MANAGED_EXCLUSIONS;
- }
- }
- return new PremanagedDependency( premanagedVersion, premanagedScope, premanagedOptional,
- premanagedExclusions, premanagedProperties, managedBits, dependency,
- premanagedState );
-
- }
-
- public void applyTo( DefaultDependencyNode child )
- {
- child.setManagedBits( managedBits );
- if ( premanagedState )
- {
- child.setData( DependencyManagerUtils.NODE_DATA_PREMANAGED_VERSION, premanagedVersion );
- child.setData( DependencyManagerUtils.NODE_DATA_PREMANAGED_SCOPE, premanagedScope );
- child.setData( DependencyManagerUtils.NODE_DATA_PREMANAGED_OPTIONAL, premanagedOptional );
- child.setData( DependencyManagerUtils.NODE_DATA_PREMANAGED_EXCLUSIONS, premanagedExclusions );
- child.setData( DependencyManagerUtils.NODE_DATA_PREMANAGED_PROPERTIES, premanagedProperties );
- }
- }
-
- }
-
}
\ No newline at end of file