001/* 002 * Licensed to the Apache Software Foundation (ASF) under one 003 * or more contributor license agreements. See the NOTICE file 004 * distributed with this work for additional information 005 * regarding copyright ownership. The ASF licenses this file 006 * to you under the Apache License, Version 2.0 (the 007 * "License"); you may not use this file except in compliance 008 * with the License. You may obtain a copy of the License at 009 * 010 * http://www.apache.org/licenses/LICENSE-2.0 011 * 012 * Unless required by applicable law or agreed to in writing, 013 * software distributed under the License is distributed on an 014 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 015 * KIND, either express or implied. See the License for the 016 * specific language governing permissions and limitations 017 * under the License. 018 */ 019package org.eclipse.aether.internal.impl.collect.df; 020 021import javax.inject.Inject; 022import javax.inject.Named; 023import javax.inject.Singleton; 024 025import java.util.Collections; 026import java.util.List; 027import java.util.Map; 028import java.util.concurrent.atomic.AtomicReference; 029 030import org.eclipse.aether.RepositorySystemSession; 031import org.eclipse.aether.RequestTrace; 032import org.eclipse.aether.artifact.Artifact; 033import org.eclipse.aether.collection.CollectRequest; 034import org.eclipse.aether.collection.DependencyCollectionException; 035import org.eclipse.aether.collection.DependencyManager; 036import org.eclipse.aether.collection.DependencySelector; 037import org.eclipse.aether.collection.DependencyTraverser; 038import org.eclipse.aether.collection.VersionFilter; 039import org.eclipse.aether.graph.DefaultDependencyNode; 040import org.eclipse.aether.graph.Dependency; 041import org.eclipse.aether.graph.DependencyNode; 042import org.eclipse.aether.impl.ArtifactDescriptorReader; 043import org.eclipse.aether.impl.RemoteRepositoryManager; 044import org.eclipse.aether.impl.VersionRangeResolver; 045import org.eclipse.aether.internal.impl.collect.DataPool; 046import org.eclipse.aether.internal.impl.collect.DefaultDependencyCollectionContext; 047import org.eclipse.aether.internal.impl.collect.DefaultDependencyCycle; 048import org.eclipse.aether.internal.impl.collect.DefaultVersionFilterContext; 049import org.eclipse.aether.internal.impl.collect.DependencyCollectorDelegate; 050import org.eclipse.aether.internal.impl.collect.PremanagedDependency; 051import org.eclipse.aether.repository.RemoteRepository; 052import org.eclipse.aether.resolution.ArtifactDescriptorRequest; 053import org.eclipse.aether.resolution.ArtifactDescriptorResult; 054import org.eclipse.aether.resolution.VersionRangeRequest; 055import org.eclipse.aether.resolution.VersionRangeResolutionException; 056import org.eclipse.aether.resolution.VersionRangeResult; 057import org.eclipse.aether.spi.artifact.decorator.ArtifactDecoratorFactory; 058import org.eclipse.aether.util.ConfigUtils; 059import org.eclipse.aether.util.graph.manager.DependencyManagerUtils; 060import org.eclipse.aether.version.Version; 061 062/** 063 * Depth-first {@link org.eclipse.aether.impl.DependencyCollector} (the "original" default). Originally 064 * this class was located a package higher (as "default" implementation). 065 * 066 * @since 1.8.0 067 */ 068@Singleton 069@Named(DfDependencyCollector.NAME) 070public class DfDependencyCollector extends DependencyCollectorDelegate { 071 public static final String NAME = "df"; 072 073 @Inject 074 public DfDependencyCollector( 075 RemoteRepositoryManager remoteRepositoryManager, 076 ArtifactDescriptorReader artifactDescriptorReader, 077 VersionRangeResolver versionRangeResolver, 078 Map<String, ArtifactDecoratorFactory> artifactDecoratorFactories) { 079 super(remoteRepositoryManager, artifactDescriptorReader, versionRangeResolver, artifactDecoratorFactories); 080 } 081 082 @SuppressWarnings("checkstyle:parameternumber") 083 @Override 084 protected void doCollectDependencies( 085 RepositorySystemSession session, 086 RequestTrace trace, 087 DataPool pool, 088 DefaultDependencyCollectionContext context, 089 DefaultVersionFilterContext versionContext, 090 CollectRequest request, 091 DependencyNode node, 092 List<RemoteRepository> repositories, 093 List<Dependency> dependencies, 094 List<Dependency> managedDependencies, 095 Results results) 096 throws DependencyCollectionException { 097 NodeStack nodes = new NodeStack(); 098 nodes.push(node); 099 100 Args args = new Args(session, pool, nodes, context, versionContext, request); 101 102 process( 103 args, 104 trace, 105 results, 106 dependencies, 107 repositories, 108 session.getDependencySelector() != null 109 ? session.getDependencySelector().deriveChildSelector(context) 110 : null, 111 session.getDependencyManager() != null 112 ? session.getDependencyManager().deriveChildManager(context) 113 : null, 114 session.getDependencyTraverser() != null 115 ? session.getDependencyTraverser().deriveChildTraverser(context) 116 : null, 117 session.getVersionFilter() != null ? session.getVersionFilter().deriveChildFilter(context) : null); 118 119 if (args.interruptedException.get() != null) { 120 // Thread.interrupted() cleared the flag when the interrupt was detected; restore it for the caller 121 Thread.currentThread().interrupt(); 122 throw new DependencyCollectionException( 123 results.getResult(), "Collection interrupted", args.interruptedException.get()); 124 } 125 } 126 127 @SuppressWarnings("checkstyle:parameternumber") 128 private void process( 129 final Args args, 130 RequestTrace trace, 131 Results results, 132 List<Dependency> dependencies, 133 List<RemoteRepository> repositories, 134 DependencySelector depSelector, 135 DependencyManager depManager, 136 DependencyTraverser depTraverser, 137 VersionFilter verFilter) { 138 if (Thread.interrupted()) { 139 args.interruptedException.set(new InterruptedException()); 140 } 141 if (args.interruptedException.get() != null) { 142 return; 143 } 144 for (Dependency dependency : dependencies) { 145 processDependency( 146 args, trace, results, repositories, depSelector, depManager, depTraverser, verFilter, dependency); 147 } 148 } 149 150 @SuppressWarnings("checkstyle:parameternumber") 151 private void processDependency( 152 Args args, 153 RequestTrace trace, 154 Results results, 155 List<RemoteRepository> repositories, 156 DependencySelector depSelector, 157 DependencyManager depManager, 158 DependencyTraverser depTraverser, 159 VersionFilter verFilter, 160 Dependency dependency) { 161 162 List<Artifact> relocations = Collections.emptyList(); 163 processDependency( 164 args, 165 trace, 166 results, 167 repositories, 168 depSelector, 169 depManager, 170 depTraverser, 171 verFilter, 172 dependency, 173 relocations, 174 false); 175 } 176 177 @SuppressWarnings("checkstyle:parameternumber") 178 private void processDependency( 179 Args args, 180 RequestTrace parent, 181 Results results, 182 List<RemoteRepository> repositories, 183 DependencySelector depSelector, 184 DependencyManager depManager, 185 DependencyTraverser depTraverser, 186 VersionFilter verFilter, 187 Dependency dependency, 188 List<Artifact> relocations, 189 boolean disableVersionManagement) { 190 if (depSelector != null && !depSelector.selectDependency(dependency)) { 191 return; 192 } 193 194 RequestTrace trace = collectStepTrace(parent, args.request.getRequestContext(), args.nodes.nodes, dependency); 195 PremanagedDependency preManaged = 196 PremanagedDependency.create(depManager, dependency, disableVersionManagement, args.premanagedState); 197 dependency = preManaged.getManagedDependency(); 198 199 boolean noDescriptor = isLackingDescriptor(args.session, dependency.getArtifact()); 200 201 boolean traverse = !noDescriptor && (depTraverser == null || depTraverser.traverseDependency(dependency)); 202 203 List<? extends Version> versions; 204 VersionRangeResult rangeResult; 205 try { 206 VersionRangeRequest rangeRequest = 207 createVersionRangeRequest(args.request.getRequestContext(), trace, repositories, dependency); 208 209 rangeResult = cachedResolveRangeResult(rangeRequest, args.pool, args.session); 210 211 versions = filterVersions(dependency, rangeResult, verFilter, args.versionContext); 212 } catch (VersionRangeResolutionException e) { 213 results.addException(dependency, e, args.nodes.nodes); 214 return; 215 } 216 217 for (Version version : versions) { 218 Artifact originalArtifact = dependency.getArtifact().setVersion(version.toString()); 219 Dependency d = dependency.setArtifact(originalArtifact); 220 221 ArtifactDescriptorRequest descriptorRequest = 222 createArtifactDescriptorRequest(args.request.getRequestContext(), trace, repositories, d); 223 224 final ArtifactDescriptorResult descriptorResult = 225 getArtifactDescriptorResult(args, results, noDescriptor, d, descriptorRequest); 226 if (descriptorResult != null) { 227 d = d.setArtifact(descriptorResult.getArtifact()); 228 229 DependencyNode node = args.nodes.top(); 230 231 int cycleEntry = DefaultDependencyCycle.find(args.nodes.nodes, d.getArtifact()); 232 if (cycleEntry >= 0) { 233 results.addCycle(args.nodes.nodes, cycleEntry, d); 234 DependencyNode cycleNode = args.nodes.get(cycleEntry); 235 if (cycleNode.getDependency() != null) { 236 DefaultDependencyNode child = createDependencyNode( 237 relocations, preManaged, rangeResult, version, d, descriptorResult, cycleNode); 238 node.getChildren().add(child); 239 continue; 240 } 241 } 242 243 if (!descriptorResult.getRelocations().isEmpty()) { 244 boolean disableVersionManagementSubsequently = 245 originalArtifact.getGroupId().equals(d.getArtifact().getGroupId()) 246 && originalArtifact 247 .getArtifactId() 248 .equals(d.getArtifact().getArtifactId()); 249 250 processDependency( 251 args, 252 parent, 253 results, 254 repositories, 255 depSelector, 256 depManager, 257 depTraverser, 258 verFilter, 259 d, 260 descriptorResult.getRelocations(), 261 disableVersionManagementSubsequently); 262 continue; 263 } else { 264 d = args.pool.intern(d.setArtifact(args.pool.intern(d.getArtifact()))); 265 266 List<RemoteRepository> repos = 267 getRemoteRepositories(rangeResult.getRepository(version), repositories); 268 269 DefaultDependencyNode child = createDependencyNode( 270 relocations, 271 preManaged, 272 rangeResult, 273 version, 274 d, 275 descriptorResult.getAliases(), 276 repos, 277 args.request.getRequestContext()); 278 279 node.getChildren().add(child); 280 281 boolean recurse = 282 traverse && !descriptorResult.getDependencies().isEmpty(); 283 if (recurse) { 284 doRecurse( 285 args, 286 parent, 287 results, 288 repositories, 289 depSelector, 290 depManager, 291 depTraverser, 292 verFilter, 293 d, 294 descriptorResult, 295 child); 296 } 297 } 298 } else { 299 DependencyNode node = args.nodes.top(); 300 List<RemoteRepository> repos = getRemoteRepositories(rangeResult.getRepository(version), repositories); 301 DefaultDependencyNode child = createDependencyNode( 302 relocations, 303 preManaged, 304 rangeResult, 305 version, 306 d, 307 null, 308 repos, 309 args.request.getRequestContext()); 310 node.getChildren().add(child); 311 } 312 } 313 } 314 315 @SuppressWarnings("checkstyle:parameternumber") 316 private void doRecurse( 317 Args args, 318 RequestTrace trace, 319 Results results, 320 List<RemoteRepository> repositories, 321 DependencySelector depSelector, 322 DependencyManager depManager, 323 DependencyTraverser depTraverser, 324 VersionFilter verFilter, 325 Dependency d, 326 ArtifactDescriptorResult descriptorResult, 327 DefaultDependencyNode child) { 328 DefaultDependencyCollectionContext context = args.collectionContext.get(); 329 args.collectionContext.compareAndSet(context, context.set(d, descriptorResult.getManagedDependencies())); 330 context = args.collectionContext.get(); 331 332 DependencySelector childSelector = depSelector != null ? depSelector.deriveChildSelector(context) : null; 333 DependencyManager childManager = depManager != null ? depManager.deriveChildManager(context) : null; 334 DependencyTraverser childTraverser = depTraverser != null ? depTraverser.deriveChildTraverser(context) : null; 335 VersionFilter childFilter = verFilter != null ? verFilter.deriveChildFilter(context) : null; 336 337 final List<RemoteRepository> childRepos = args.ignoreRepos 338 ? repositories 339 : remoteRepositoryManager.aggregateRepositories( 340 args.session, repositories, descriptorResult.getRepositories(), true, true); 341 342 Object key = 343 args.pool.toKey(d.getArtifact(), childRepos, childSelector, childManager, childTraverser, childFilter); 344 345 List<DependencyNode> children = args.pool.getChildren(key); 346 if (children == null) { 347 args.pool.putChildren(key, child.getChildren()); 348 349 args.nodes.push(child); 350 351 process( 352 args, 353 trace, 354 results, 355 descriptorResult.getDependencies(), 356 childRepos, 357 childSelector, 358 childManager, 359 childTraverser, 360 childFilter); 361 362 args.nodes.pop(); 363 } else { 364 child.setChildren(children); 365 } 366 } 367 368 private ArtifactDescriptorResult getArtifactDescriptorResult( 369 Args args, 370 Results results, 371 boolean noDescriptor, 372 Dependency d, 373 ArtifactDescriptorRequest descriptorRequest) { 374 return noDescriptor 375 ? new ArtifactDescriptorResult(descriptorRequest) 376 : resolveCachedArtifactDescriptor( 377 args.pool, descriptorRequest, args.session, d, results, args.nodes.nodes); 378 } 379 380 static class Args { 381 382 final RepositorySystemSession session; 383 384 final boolean ignoreRepos; 385 386 final boolean premanagedState; 387 388 final DataPool pool; 389 390 final NodeStack nodes; 391 392 final AtomicReference<DefaultDependencyCollectionContext> collectionContext; 393 394 final DefaultVersionFilterContext versionContext; 395 396 final CollectRequest request; 397 398 final AtomicReference<InterruptedException> interruptedException; 399 400 Args( 401 RepositorySystemSession session, 402 DataPool pool, 403 NodeStack nodes, 404 DefaultDependencyCollectionContext collectionContext, 405 DefaultVersionFilterContext versionContext, 406 CollectRequest request) { 407 this.session = session; 408 this.request = request; 409 this.ignoreRepos = session.isIgnoreArtifactDescriptorRepositories(); 410 this.premanagedState = ConfigUtils.getBoolean(session, false, DependencyManagerUtils.CONFIG_PROP_VERBOSE); 411 this.pool = pool; 412 this.nodes = nodes; 413 this.collectionContext = new AtomicReference<>(collectionContext); 414 this.versionContext = versionContext; 415 this.interruptedException = new AtomicReference<>(null); 416 } 417 } 418}