shaded.org.eclipse.aether.internal.impl.collect.df.DfDependencyCollector Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of spring-cloud-contract-shade Show documentation
Show all versions of spring-cloud-contract-shade Show documentation
Spring Cloud Contract Shaded Dependencies
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package shaded.shaded.org.eclipse.aether.internal.impl.collect.df;
import javax.inject.Inject;
import javax.inject.Named;
import javax.inject.Singleton;
import java.util.Collections;
import java.util.List;
import org.eclipse.aether.RepositorySystemSession;
import org.eclipse.aether.RequestTrace;
import org.eclipse.aether.artifact.Artifact;
import org.eclipse.aether.collection.CollectRequest;
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 shaded.shaded.org.eclipse.aether.impl.ArtifactDescriptorReader;
import shaded.shaded.org.eclipse.aether.impl.RemoteRepositoryManager;
import shaded.shaded.org.eclipse.aether.impl.VersionRangeResolver;
import shaded.shaded.org.eclipse.aether.internal.impl.collect.DataPool;
import shaded.shaded.org.eclipse.aether.internal.impl.collect.DefaultDependencyCollectionContext;
import shaded.shaded.org.eclipse.aether.internal.impl.collect.DefaultDependencyCycle;
import shaded.shaded.org.eclipse.aether.internal.impl.collect.DefaultVersionFilterContext;
import shaded.shaded.org.eclipse.aether.internal.impl.collect.DependencyCollectorDelegate;
import shaded.shaded.org.eclipse.aether.internal.impl.collect.PremanagedDependency;
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 shaded.shaded.org.eclipse.aether.spi.locator.Service;
import org.eclipse.aether.util.ConfigUtils;
import org.eclipse.aether.util.graph.manager.DependencyManagerUtils;
import org.eclipse.aether.version.Version;
/**
* Depth-first {@link shaded.shaded.org.eclipse.aether.impl.DependencyCollector} (the "original" default). Originally
* this class was located a package higher (as "default" implementation).
*
* @since 1.8.0
*/
@Singleton
@Named(DfDependencyCollector.NAME)
public class DfDependencyCollector extends DependencyCollectorDelegate implements Service {
public static final String NAME = "df";
/**
* Default ctor for SL.
*
* @deprecated Will be dropped once SL gone.
*/
@Deprecated
public DfDependencyCollector() {
// enables default constructor
}
@Inject
public DfDependencyCollector(
RemoteRepositoryManager remoteRepositoryManager,
ArtifactDescriptorReader artifactDescriptorReader,
VersionRangeResolver versionRangeResolver) {
super(remoteRepositoryManager, artifactDescriptorReader, versionRangeResolver);
}
@SuppressWarnings("checkstyle:parameternumber")
@Override
protected void doCollectDependencies(
RepositorySystemSession session,
RequestTrace trace,
DataPool pool,
DefaultDependencyCollectionContext context,
DefaultVersionFilterContext versionContext,
CollectRequest request,
DependencyNode node,
List repositories,
List dependencies,
List managedDependencies,
Results results) {
NodeStack nodes = new NodeStack();
nodes.push(node);
Args args = new Args(session, pool, nodes, context, versionContext, request);
process(
args,
trace,
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")
private void process(
final Args args,
RequestTrace trace,
Results results,
List dependencies,
List repositories,
DependencySelector depSelector,
DependencyManager depManager,
DependencyTraverser depTraverser,
VersionFilter verFilter) {
for (Dependency dependency : dependencies) {
processDependency(
args, trace, results, repositories, depSelector, depManager, depTraverser, verFilter, dependency);
}
}
@SuppressWarnings("checkstyle:parameternumber")
private void processDependency(
Args args,
RequestTrace trace,
Results results,
List repositories,
DependencySelector depSelector,
DependencyManager depManager,
DependencyTraverser depTraverser,
VersionFilter verFilter,
Dependency dependency) {
List relocations = Collections.emptyList();
processDependency(
args,
trace,
results,
repositories,
depSelector,
depManager,
depTraverser,
verFilter,
dependency,
relocations,
false);
}
@SuppressWarnings("checkstyle:parameternumber")
private void processDependency(
Args args,
RequestTrace parent,
Results results,
List repositories,
DependencySelector depSelector,
DependencyManager depManager,
DependencyTraverser depTraverser,
VersionFilter verFilter,
Dependency dependency,
List relocations,
boolean disableVersionManagement) {
if (depSelector != null && !depSelector.selectDependency(dependency)) {
return;
}
RequestTrace trace = collectStepTrace(parent, args.request.getRequestContext(), args.nodes.nodes, dependency);
PremanagedDependency preManaged =
PremanagedDependency.create(depManager, dependency, disableVersionManagement, args.premanagedState);
dependency = preManaged.getManagedDependency();
boolean noDescriptor = isLackingDescriptor(dependency.getArtifact());
boolean traverse = !noDescriptor && (depTraverser == null || depTraverser.traverseDependency(dependency));
List versions;
VersionRangeResult rangeResult;
try {
VersionRangeRequest rangeRequest =
createVersionRangeRequest(args.request.getRequestContext(), trace, repositories, dependency);
rangeResult = cachedResolveRangeResult(rangeRequest, args.pool, args.session);
versions = filterVersions(dependency, rangeResult, verFilter, args.versionContext);
} catch (VersionRangeResolutionException e) {
results.addException(dependency, e, args.nodes.nodes);
return;
}
for (Version version : versions) {
Artifact originalArtifact = dependency.getArtifact().setVersion(version.toString());
Dependency d = dependency.setArtifact(originalArtifact);
ArtifactDescriptorRequest descriptorRequest =
createArtifactDescriptorRequest(args.request.getRequestContext(), trace, repositories, d);
final ArtifactDescriptorResult descriptorResult =
getArtifactDescriptorResult(args, results, noDescriptor, d, descriptorRequest);
if (descriptorResult != null) {
d = d.setArtifact(descriptorResult.getArtifact());
DependencyNode node = args.nodes.top();
int cycleEntry = DefaultDependencyCycle.find(args.nodes.nodes, d.getArtifact());
if (cycleEntry >= 0) {
results.addCycle(args.nodes.nodes, cycleEntry, d);
DependencyNode cycleNode = args.nodes.get(cycleEntry);
if (cycleNode.getDependency() != null) {
DefaultDependencyNode child = createDependencyNode(
relocations, preManaged, rangeResult, version, d, descriptorResult, cycleNode);
node.getChildren().add(child);
continue;
}
}
if (!descriptorResult.getRelocations().isEmpty()) {
boolean disableVersionManagementSubsequently =
originalArtifact.getGroupId().equals(d.getArtifact().getGroupId())
&& originalArtifact
.getArtifactId()
.equals(d.getArtifact().getArtifactId());
processDependency(
args,
parent,
results,
repositories,
depSelector,
depManager,
depTraverser,
verFilter,
d,
descriptorResult.getRelocations(),
disableVersionManagementSubsequently);
return;
} else {
d = args.pool.intern(d.setArtifact(args.pool.intern(d.getArtifact())));
List repos =
getRemoteRepositories(rangeResult.getRepository(version), repositories);
DefaultDependencyNode child = createDependencyNode(
relocations,
preManaged,
rangeResult,
version,
d,
descriptorResult.getAliases(),
repos,
args.request.getRequestContext());
node.getChildren().add(child);
boolean recurse =
traverse && !descriptorResult.getDependencies().isEmpty();
if (recurse) {
doRecurse(
args,
parent,
results,
repositories,
depSelector,
depManager,
depTraverser,
verFilter,
d,
descriptorResult,
child);
}
}
} else {
DependencyNode node = args.nodes.top();
List repos = getRemoteRepositories(rangeResult.getRepository(version), repositories);
DefaultDependencyNode child = createDependencyNode(
relocations,
preManaged,
rangeResult,
version,
d,
null,
repos,
args.request.getRequestContext());
node.getChildren().add(child);
}
}
}
@SuppressWarnings("checkstyle:parameternumber")
private void doRecurse(
Args args,
RequestTrace trace,
Results results,
List repositories,
DependencySelector depSelector,
DependencyManager depManager,
DependencyTraverser depTraverser,
VersionFilter verFilter,
Dependency d,
ArtifactDescriptorResult descriptorResult,
DefaultDependencyNode child) {
DefaultDependencyCollectionContext context = args.collectionContext;
context.set(d, descriptorResult.getManagedDependencies());
DependencySelector childSelector = depSelector != null ? depSelector.deriveChildSelector(context) : null;
DependencyManager childManager = depManager != null ? depManager.deriveChildManager(context) : null;
DependencyTraverser childTraverser = depTraverser != null ? depTraverser.deriveChildTraverser(context) : null;
VersionFilter childFilter = verFilter != null ? verFilter.deriveChildFilter(context) : null;
final List childRepos = args.ignoreRepos
? repositories
: remoteRepositoryManager.aggregateRepositories(
args.session, repositories, descriptorResult.getRepositories(), true);
Object key =
args.pool.toKey(d.getArtifact(), childRepos, childSelector, childManager, childTraverser, childFilter);
List children = args.pool.getChildren(key);
if (children == null) {
args.pool.putChildren(key, child.getChildren());
args.nodes.push(child);
process(
args,
trace,
results,
descriptorResult.getDependencies(),
childRepos,
childSelector,
childManager,
childTraverser,
childFilter);
args.nodes.pop();
} else {
child.setChildren(children);
}
}
private ArtifactDescriptorResult getArtifactDescriptorResult(
Args args,
Results results,
boolean noDescriptor,
Dependency d,
ArtifactDescriptorRequest descriptorRequest) {
return noDescriptor
? new ArtifactDescriptorResult(descriptorRequest)
: resolveCachedArtifactDescriptor(args.pool, descriptorRequest, args.session, d, results, args);
}
private ArtifactDescriptorResult resolveCachedArtifactDescriptor(
DataPool pool,
ArtifactDescriptorRequest descriptorRequest,
RepositorySystemSession session,
Dependency d,
Results results,
Args args) {
Object key = pool.toKey(descriptorRequest);
ArtifactDescriptorResult descriptorResult = pool.getDescriptor(key, descriptorRequest);
if (descriptorResult == null) {
try {
descriptorResult = descriptorReader.readArtifactDescriptor(session, descriptorRequest);
pool.putDescriptor(key, descriptorResult);
} catch (ArtifactDescriptorException e) {
results.addException(d, e, args.nodes.nodes);
pool.putDescriptor(key, e);
return null;
}
} else if (descriptorResult == DataPool.NO_DESCRIPTOR) {
return null;
}
return descriptorResult;
}
static class Args {
final RepositorySystemSession session;
final boolean ignoreRepos;
final boolean premanagedState;
final DataPool pool;
final NodeStack nodes;
final DefaultDependencyCollectionContext collectionContext;
final DefaultVersionFilterContext versionContext;
final CollectRequest request;
Args(
RepositorySystemSession session,
DataPool pool,
NodeStack nodes,
DefaultDependencyCollectionContext collectionContext,
DefaultVersionFilterContext versionContext,
CollectRequest request) {
this.session = session;
this.request = request;
this.ignoreRepos = session.isIgnoreArtifactDescriptorRepositories();
this.premanagedState = ConfigUtils.getBoolean(session, false, DependencyManagerUtils.CONFIG_PROP_VERBOSE);
this.pool = pool;
this.nodes = nodes;
this.collectionContext = collectionContext;
this.versionContext = versionContext;
}
}
}