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/12 15:24:01 UTC
[maven-resolver] branch master updated: Collapse collectors (#177)
This is an automated email from the ASF dual-hosted git repository.
cstamas pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/maven-resolver.git
The following commit(s) were added to refs/heads/master by this push:
new a626750b Collapse collectors (#177)
a626750b is described below
commit a626750bf60a6f8209d3e2ccc0902d15f1d24140
Author: Tamas Cservenak <ta...@cservenak.net>
AuthorDate: Thu May 12 17:23:57 2022 +0200
Collapse collectors (#177)
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