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.bf; 020 021import javax.inject.Inject; 022import javax.inject.Named; 023import javax.inject.Singleton; 024 025import java.io.Closeable; 026import java.util.ArrayDeque; 027import java.util.ArrayList; 028import java.util.Arrays; 029import java.util.Collections; 030import java.util.LinkedHashMap; 031import java.util.List; 032import java.util.Map; 033import java.util.Optional; 034import java.util.Queue; 035import java.util.Set; 036import java.util.concurrent.Callable; 037import java.util.concurrent.CompletableFuture; 038import java.util.concurrent.ConcurrentHashMap; 039import java.util.concurrent.Future; 040import java.util.concurrent.atomic.AtomicReference; 041import java.util.function.Supplier; 042import java.util.stream.Collectors; 043import java.util.stream.Stream; 044 045import org.eclipse.aether.RepositorySystemSession; 046import org.eclipse.aether.RequestTrace; 047import org.eclipse.aether.artifact.Artifact; 048import org.eclipse.aether.collection.CollectRequest; 049import org.eclipse.aether.collection.DependencyCollectionException; 050import org.eclipse.aether.collection.DependencyManager; 051import org.eclipse.aether.collection.DependencySelector; 052import org.eclipse.aether.collection.DependencyTraverser; 053import org.eclipse.aether.collection.VersionFilter; 054import org.eclipse.aether.graph.DefaultDependencyNode; 055import org.eclipse.aether.graph.Dependency; 056import org.eclipse.aether.graph.DependencyNode; 057import org.eclipse.aether.impl.ArtifactDescriptorReader; 058import org.eclipse.aether.impl.RemoteRepositoryManager; 059import org.eclipse.aether.impl.VersionRangeResolver; 060import org.eclipse.aether.internal.impl.collect.DataPool; 061import org.eclipse.aether.internal.impl.collect.DefaultDependencyCollectionContext; 062import org.eclipse.aether.internal.impl.collect.DefaultDependencyCollector; 063import org.eclipse.aether.internal.impl.collect.DefaultVersionFilterContext; 064import org.eclipse.aether.internal.impl.collect.DependencyCollectorDelegate; 065import org.eclipse.aether.internal.impl.collect.PremanagedDependency; 066import org.eclipse.aether.repository.RemoteRepository; 067import org.eclipse.aether.resolution.ArtifactDescriptorRequest; 068import org.eclipse.aether.resolution.ArtifactDescriptorResult; 069import org.eclipse.aether.resolution.VersionRangeRequest; 070import org.eclipse.aether.resolution.VersionRangeResult; 071import org.eclipse.aether.spi.artifact.decorator.ArtifactDecoratorFactory; 072import org.eclipse.aether.util.ConfigUtils; 073import org.eclipse.aether.util.artifact.ArtifactIdUtils; 074import org.eclipse.aether.util.concurrency.SmartExecutor; 075import org.eclipse.aether.util.concurrency.SmartExecutorUtils; 076import org.eclipse.aether.util.graph.manager.DependencyManagerUtils; 077import org.eclipse.aether.version.Version; 078 079import static org.eclipse.aether.internal.impl.collect.DefaultDependencyCycle.find; 080 081/** 082 * Breadth-first {@link org.eclipse.aether.impl.DependencyCollector} 083 * 084 * @since 1.8.0 085 */ 086@Singleton 087@Named(BfDependencyCollector.NAME) 088public class BfDependencyCollector extends DependencyCollectorDelegate { 089 public static final String NAME = "bf"; 090 091 private static final String CONFIG_PROPS_PREFIX = DefaultDependencyCollector.CONFIG_PROPS_PREFIX + NAME + "."; 092 093 /** 094 * The key in the repository session's {@link RepositorySystemSession#getConfigProperties() 095 * configuration properties} used to store a {@link String} flag controlling the resolver's skip mode. 096 * Supported modes are "versionless" (default), "versioned" and "false" to not use skipper. The first two modes 097 * are defining "function" how to map artifact coordinates to (String) key while deciding "skip" logic. 098 * The "versionless" uses {@code G:A:C:E} coordinate elements only (without version), while "versioned" uses 099 * all {@code G:A:C:E:V} artifact coordinates. 100 * 101 * @since 1.8.0 102 * @configurationSource {@link RepositorySystemSession#getConfigProperties()} 103 * @configurationType {@link java.lang.String} 104 * @configurationDefaultValue {@link #DEFAULT_SKIPPER} 105 */ 106 public static final String CONFIG_PROP_SKIPPER = CONFIG_PROPS_PREFIX + "skipper"; 107 108 public static final String NONE_SKIPPER = "false"; 109 public static final String VERSIONLESS_SKIPPER = "versionless"; 110 public static final String VERSIONED_SKIPPER = "versioned"; 111 112 /** 113 * The default value for {@link #CONFIG_PROP_SKIPPER}, {@code true}. 114 * 115 * @since 1.8.0 116 */ 117 public static final String DEFAULT_SKIPPER = VERSIONLESS_SKIPPER; 118 119 /** 120 * The count of threads to be used when collecting POMs in parallel. 121 * 122 * @since 1.9.0 123 * @configurationSource {@link RepositorySystemSession#getConfigProperties()} 124 * @configurationType {@link java.lang.Integer} 125 * @configurationDefaultValue {@link #DEFAULT_THREADS} 126 */ 127 public static final String CONFIG_PROP_THREADS = CONFIG_PROPS_PREFIX + "threads"; 128 129 /** 130 * The default value for {@link #CONFIG_PROP_THREADS}, default value 5. 131 * 132 * @since 1.9.0 133 */ 134 public static final int DEFAULT_THREADS = 5; 135 136 @Inject 137 public BfDependencyCollector( 138 RemoteRepositoryManager remoteRepositoryManager, 139 ArtifactDescriptorReader artifactDescriptorReader, 140 VersionRangeResolver versionRangeResolver, 141 Map<String, ArtifactDecoratorFactory> artifactDecoratorFactories) { 142 super(remoteRepositoryManager, artifactDescriptorReader, versionRangeResolver, artifactDecoratorFactories); 143 } 144 145 @SuppressWarnings("checkstyle:parameternumber") 146 @Override 147 protected void doCollectDependencies( 148 RepositorySystemSession session, 149 RequestTrace trace, 150 DataPool pool, 151 DefaultDependencyCollectionContext context, 152 DefaultVersionFilterContext versionContext, 153 CollectRequest request, 154 DependencyNode node, 155 List<RemoteRepository> repositories, 156 List<Dependency> dependencies, 157 List<Dependency> managedDependencies, 158 Results results) 159 throws DependencyCollectionException { 160 String skipperMode = ConfigUtils.getString(session, DEFAULT_SKIPPER, CONFIG_PROP_SKIPPER); 161 Supplier<DependencyResolutionSkipper> skipperSupplier; 162 if (NONE_SKIPPER.equals(skipperMode)) { 163 logger.debug("Collector skip mode disabled"); 164 skipperSupplier = DependencyResolutionSkipper::neverSkipper; 165 } else if (VERSIONLESS_SKIPPER.equals(skipperMode)) { 166 logger.debug("Collector skip mode enabled: {} (key function GACE)", skipperMode); 167 skipperSupplier = DependencyResolutionSkipper::defaultGACESkipper; 168 } else if (VERSIONED_SKIPPER.equals(skipperMode)) { 169 logger.debug("Collector skip mode enabled: {} (key function GACEV)", skipperMode); 170 skipperSupplier = DependencyResolutionSkipper::defaultGACEVSkipper; 171 } else { 172 throw new IllegalArgumentException("Unknown skipper mode: " + skipperMode + "; known are " 173 + Arrays.asList(VERSIONLESS_SKIPPER, VERSIONED_SKIPPER, NONE_SKIPPER)); 174 } 175 176 try (DependencyResolutionSkipper skipper = skipperSupplier.get(); 177 ParallelDescriptorResolver parallelDescriptorResolver = 178 new ParallelDescriptorResolver(SmartExecutorUtils.smartExecutor( 179 session, 180 null, // we don't know ahead of time; we want global executor 181 ConfigUtils.getInteger(session, DEFAULT_THREADS, CONFIG_PROP_THREADS), 182 getClass().getSimpleName() + "-"))) { 183 Args args = new Args(session, pool, context, versionContext, request, skipper, parallelDescriptorResolver); 184 185 DependencySelector rootDepSelector = session.getDependencySelector() != null 186 ? session.getDependencySelector().deriveChildSelector(context) 187 : null; 188 DependencyManager rootDepManager = session.getDependencyManager() != null 189 ? session.getDependencyManager().deriveChildManager(context) 190 : null; 191 DependencyTraverser rootDepTraverser = session.getDependencyTraverser() != null 192 ? session.getDependencyTraverser().deriveChildTraverser(context) 193 : null; 194 VersionFilter rootVerFilter = session.getVersionFilter() != null 195 ? session.getVersionFilter().deriveChildFilter(context) 196 : null; 197 198 List<DependencyNode> parents = Collections.singletonList(node); 199 for (Dependency dependency : dependencies) { 200 if (rootDepSelector != null && !rootDepSelector.selectDependency(dependency)) { 201 continue; 202 } 203 RequestTrace childTrace = 204 collectStepTrace(trace, args.request.getRequestContext(), parents, dependency); 205 DependencyProcessingContext processingContext = new DependencyProcessingContext( 206 rootDepSelector, 207 rootDepManager, 208 rootDepTraverser, 209 rootVerFilter, 210 childTrace, 211 repositories, 212 managedDependencies, 213 parents, 214 dependency, 215 PremanagedDependency.create(rootDepManager, dependency, false, args.premanagedState)); 216 processingContext.withDependency(processingContext.premanagedDependency.getManagedDependency()); 217 resolveArtifactDescriptorAsync(args, processingContext, results); 218 args.dependencyProcessingQueue.add(processingContext); 219 } 220 221 while (!args.dependencyProcessingQueue.isEmpty()) { 222 processDependency( 223 args, results, args.dependencyProcessingQueue.remove(), Collections.emptyList(), false); 224 } 225 226 if (args.interruptedException.get() != null) { 227 // Thread.interrupted() cleared the flag when the interrupt was detected; restore it for the caller 228 Thread.currentThread().interrupt(); 229 throw new DependencyCollectionException( 230 results.getResult(), "Collection interrupted", args.interruptedException.get()); 231 } 232 } 233 } 234 235 @SuppressWarnings("checkstyle:parameternumber") 236 private void processDependency( 237 Args args, 238 Results results, 239 DependencyProcessingContext context, 240 List<Artifact> relocations, 241 boolean disableVersionManagement) { 242 if (Thread.interrupted()) { 243 args.interruptedException.set(new InterruptedException()); 244 } 245 if (args.interruptedException.get() != null) { 246 return; 247 } 248 Dependency dependency = context.dependency; 249 PremanagedDependency preManaged = context.premanagedDependency; 250 251 boolean noDescriptor = isLackingDescriptor(args.session, dependency.getArtifact()); 252 boolean traverse = 253 !noDescriptor && (context.depTraverser == null || context.depTraverser.traverseDependency(dependency)); 254 255 Future<DescriptorResolutionResult> resolutionResultFuture = args.resolver.find(dependency.getArtifact()); 256 DescriptorResolutionResult resolutionResult; 257 VersionRangeResult rangeResult; 258 try { 259 resolutionResult = resolutionResultFuture.get(); 260 rangeResult = resolutionResult.rangeResult; 261 } catch (Exception e) { 262 results.addException(dependency, e, context.parents); 263 return; 264 } 265 266 Set<Version> versions = resolutionResult.descriptors.keySet(); 267 for (Version version : versions) { 268 Artifact originalArtifact = dependency.getArtifact().setVersion(version.toString()); 269 Dependency d = dependency.setArtifact(originalArtifact); 270 271 final ArtifactDescriptorResult descriptorResult = resolutionResult.descriptors.get(version); 272 if (descriptorResult != null) { 273 d = d.setArtifact(descriptorResult.getArtifact()); 274 275 int cycleEntry = find(context.parents, d.getArtifact()); 276 if (cycleEntry >= 0) { 277 results.addCycle(context.parents, cycleEntry, d); 278 DependencyNode cycleNode = context.parents.get(cycleEntry); 279 if (cycleNode.getDependency() != null) { 280 DefaultDependencyNode child = createDependencyNode( 281 relocations, preManaged, rangeResult, version, d, descriptorResult, cycleNode); 282 context.getParent().getChildren().add(child); 283 continue; 284 } 285 } 286 287 if (!descriptorResult.getRelocations().isEmpty()) { 288 if (context.depSelector == null || context.depSelector.selectDependency(d)) { 289 boolean disableVersionManagementSubsequently = originalArtifact 290 .getGroupId() 291 .equals(d.getArtifact().getGroupId()) 292 && originalArtifact 293 .getArtifactId() 294 .equals(d.getArtifact().getArtifactId()); 295 296 PremanagedDependency premanagedDependency = PremanagedDependency.create( 297 context.depManager, d, disableVersionManagementSubsequently, args.premanagedState); 298 DependencyProcessingContext relocatedContext = new DependencyProcessingContext( 299 context.depSelector, 300 context.depManager, 301 context.depTraverser, 302 context.verFilter, 303 context.trace, 304 context.repositories, 305 descriptorResult.getManagedDependencies(), 306 context.parents, 307 d, 308 premanagedDependency); 309 310 relocatedContext.withDependency(premanagedDependency.getManagedDependency()); 311 resolveArtifactDescriptorAsync(args, relocatedContext, results); 312 processDependency( 313 args, 314 results, 315 relocatedContext, 316 descriptorResult.getRelocations(), 317 disableVersionManagementSubsequently); 318 } 319 continue; 320 } else { 321 d = args.pool.intern(d.setArtifact(args.pool.intern(d.getArtifact()))); 322 323 List<RemoteRepository> repos = 324 getRemoteRepositories(rangeResult.getRepository(version), context.repositories); 325 326 DefaultDependencyNode child = createDependencyNode( 327 relocations, 328 preManaged, 329 rangeResult, 330 version, 331 d, 332 descriptorResult.getAliases(), 333 repos, 334 args.request.getRequestContext()); 335 336 context.getParent().getChildren().add(child); 337 338 boolean recurse = 339 traverse && !descriptorResult.getDependencies().isEmpty(); 340 DependencyProcessingContext parentContext = context.withDependency(d); 341 if (recurse) { 342 doRecurse(args, parentContext, descriptorResult, child, results, disableVersionManagement); 343 } else if (!args.skipper.skipResolution(child, parentContext.parents)) { 344 List<DependencyNode> parents = new ArrayList<>(parentContext.parents.size() + 1); 345 parents.addAll(parentContext.parents); 346 parents.add(child); 347 args.skipper.cache(child, parents); 348 } 349 } 350 } else { 351 List<RemoteRepository> repos = 352 getRemoteRepositories(rangeResult.getRepository(version), context.repositories); 353 DefaultDependencyNode child = createDependencyNode( 354 relocations, 355 preManaged, 356 rangeResult, 357 version, 358 d, 359 null, 360 repos, 361 args.request.getRequestContext()); 362 context.getParent().getChildren().add(child); 363 } 364 } 365 } 366 367 @SuppressWarnings("checkstyle:parameternumber") 368 private void doRecurse( 369 Args args, 370 DependencyProcessingContext parentContext, 371 ArtifactDescriptorResult descriptorResult, 372 DefaultDependencyNode child, 373 Results results, 374 boolean disableVersionManagement) { 375 DefaultDependencyCollectionContext context = args.collectionContext.get(); 376 args.collectionContext.compareAndSet( 377 context, context.set(parentContext.dependency, descriptorResult.getManagedDependencies())); 378 context = args.collectionContext.get(); 379 380 DependencySelector childSelector = 381 parentContext.depSelector != null ? parentContext.depSelector.deriveChildSelector(context) : null; 382 DependencyTraverser childTraverser = 383 parentContext.depTraverser != null ? parentContext.depTraverser.deriveChildTraverser(context) : null; 384 VersionFilter childFilter = 385 parentContext.verFilter != null ? parentContext.verFilter.deriveChildFilter(context) : null; 386 387 final List<RemoteRepository> childRepos = args.ignoreRepos 388 ? parentContext.repositories 389 : remoteRepositoryManager.aggregateRepositories( 390 args.session, parentContext.repositories, descriptorResult.getRepositories(), true, true); 391 392 // Optimization: try pool cache with the parent manager as a speculative key BEFORE 393 // calling deriveChildManager. When deriveChildManager returns `this` (the common case — 394 // no new management data at this depth), the parent manager IS the child manager, so 395 // this speculative key matches any previously stored entry. On pool hit, we skip 396 // deriveChildManager entirely, saving even the memoization cache lookup. 397 Object speculativeKey = args.pool.toKey( 398 parentContext.dependency.getArtifact(), 399 childRepos, 400 childSelector, 401 parentContext.depManager, 402 childTraverser, 403 childFilter); 404 List<DependencyNode> children = args.pool.getChildren(speculativeKey); 405 if (children != null) { 406 child.setChildren(children); 407 return; 408 } 409 410 // Speculative miss — compute the actual derived manager 411 DependencyManager childManager = 412 parentContext.depManager != null ? parentContext.depManager.deriveChildManager(context) : null; 413 414 Object key; 415 if (childManager == parentContext.depManager) { 416 // Manager unchanged — speculative key was correct, already checked and missed 417 key = speculativeKey; 418 } else { 419 // Manager changed — recompute key and check pool again with the correct manager 420 key = args.pool.toKey( 421 parentContext.dependency.getArtifact(), 422 childRepos, 423 childSelector, 424 childManager, 425 childTraverser, 426 childFilter); 427 children = args.pool.getChildren(key); 428 if (children != null) { 429 child.setChildren(children); 430 return; 431 } 432 } 433 434 // True cache miss — do full resolution 435 boolean skipResolution = args.skipper.skipResolution(child, parentContext.parents); 436 if (!skipResolution) { 437 List<DependencyNode> parents = new ArrayList<>(parentContext.parents.size() + 1); 438 parents.addAll(parentContext.parents); 439 parents.add(child); 440 for (Dependency dependency : descriptorResult.getDependencies()) { 441 if (childSelector != null && !childSelector.selectDependency(dependency)) { 442 continue; 443 } 444 RequestTrace childTrace = 445 collectStepTrace(parentContext.trace, args.request.getRequestContext(), parents, dependency); 446 PremanagedDependency premanagedDependency = PremanagedDependency.create( 447 childManager, dependency, disableVersionManagement, args.premanagedState); 448 DependencyProcessingContext processingContext = new DependencyProcessingContext( 449 childSelector, 450 childManager, 451 childTraverser, 452 childFilter, 453 childTrace, 454 childRepos, 455 descriptorResult.getManagedDependencies(), 456 parents, 457 dependency, 458 premanagedDependency); 459 // resolve descriptors ahead for managed dependency 460 processingContext.withDependency(processingContext.premanagedDependency.getManagedDependency()); 461 resolveArtifactDescriptorAsync(args, processingContext, results); 462 args.dependencyProcessingQueue.add(processingContext); 463 } 464 args.pool.putChildren(key, child.getChildren()); 465 args.skipper.cache(child, parents); 466 } 467 } 468 469 private void resolveArtifactDescriptorAsync(Args args, DependencyProcessingContext context, Results results) { 470 Dependency dependency = context.dependency; 471 args.resolver.resolveDescriptors(dependency.getArtifact(), () -> { 472 VersionRangeRequest rangeRequest = createVersionRangeRequest( 473 args.request.getRequestContext(), context.trace, context.repositories, dependency); 474 VersionRangeResult rangeResult = cachedResolveRangeResult(rangeRequest, args.pool, args.session); 475 List<? extends Version> versions = 476 filterVersions(dependency, rangeResult, context.verFilter, args.versionContext); 477 478 // resolve newer version first to maximize benefits of skipper 479 Collections.reverse(versions); 480 481 Map<Version, ArtifactDescriptorResult> descriptors = new ConcurrentHashMap<>(versions.size()); 482 Stream<? extends Version> stream = versions.size() > 1 ? versions.parallelStream() : versions.stream(); 483 stream.forEach(version -> Optional.ofNullable( 484 resolveDescriptorForVersion(args, context, results, dependency, version)) 485 .ifPresent(r -> descriptors.put(version, r))); 486 487 DescriptorResolutionResult resolutionResult = 488 new DescriptorResolutionResult(dependency.getArtifact(), rangeResult); 489 // keep original sequence 490 versions.forEach(version -> resolutionResult.descriptors.put(version, descriptors.get(version))); 491 // populate for versions in version range 492 resolutionResult.flatten().forEach(dr -> args.resolver.cacheVersionRangeDescriptor(dr.artifact, dr)); 493 494 return resolutionResult; 495 }); 496 } 497 498 private ArtifactDescriptorResult resolveDescriptorForVersion( 499 Args args, DependencyProcessingContext context, Results results, Dependency dependency, Version version) { 500 Artifact original = dependency.getArtifact(); 501 Artifact newArtifact = original.setVersion(version.toString()); 502 Dependency newDependency = 503 new Dependency(newArtifact, dependency.getScope(), dependency.isOptional(), dependency.getExclusions()); 504 DependencyProcessingContext newContext = context.copy(); 505 506 ArtifactDescriptorRequest descriptorRequest = createArtifactDescriptorRequest( 507 args.request.getRequestContext(), context.trace, newContext.repositories, newDependency); 508 return isLackingDescriptor(args.session, newArtifact) 509 ? new ArtifactDescriptorResult(descriptorRequest) 510 : resolveCachedArtifactDescriptor( 511 args.pool, 512 descriptorRequest, 513 args.session, 514 newContext.withDependency(newDependency).dependency, 515 results, 516 context.parents); 517 } 518 519 static class ParallelDescriptorResolver implements Closeable { 520 private final SmartExecutor smartExecutor; 521 522 /** 523 * Artifact ID -> Future of DescriptorResolutionResult 524 */ 525 private final Map<String, Future<DescriptorResolutionResult>> results = new ConcurrentHashMap<>(256); 526 527 ParallelDescriptorResolver(SmartExecutor smartExecutor) { 528 this.smartExecutor = smartExecutor; 529 } 530 531 void resolveDescriptors(Artifact artifact, Callable<DescriptorResolutionResult> callable) { 532 results.computeIfAbsent(ArtifactIdUtils.toId(artifact), key -> smartExecutor.submit(callable)); 533 } 534 535 void cacheVersionRangeDescriptor(Artifact artifact, DescriptorResolutionResult resolutionResult) { 536 results.computeIfAbsent( 537 ArtifactIdUtils.toId(artifact), key -> CompletableFuture.completedFuture(resolutionResult)); 538 } 539 540 Future<DescriptorResolutionResult> find(Artifact artifact) { 541 return results.get(ArtifactIdUtils.toId(artifact)); 542 } 543 544 @Override 545 public void close() { 546 smartExecutor.close(); 547 } 548 } 549 550 static class DescriptorResolutionResult { 551 Artifact artifact; 552 553 VersionRangeResult rangeResult; 554 555 Map<Version, ArtifactDescriptorResult> descriptors; 556 557 DescriptorResolutionResult(Artifact artifact, VersionRangeResult rangeResult) { 558 this.artifact = artifact; 559 this.rangeResult = rangeResult; 560 this.descriptors = new LinkedHashMap<>(rangeResult.getVersions().size()); 561 } 562 563 DescriptorResolutionResult( 564 VersionRangeResult rangeResult, Version version, ArtifactDescriptorResult descriptor) { 565 // NOTE: In case of A1 -> A2 relocation this happens: 566 // ArtifactDescriptorResult read by ArtifactDescriptorResultReader for A1 567 // will return instance that will have artifact = A2 (as RelocatedArtifact). 568 // So to properly "key" this instance, we need to use "originally requested" A1 instead! 569 // In short: 570 // ArtifactDescriptorRequest.artifact != ArtifactDescriptorResult.artifact WHEN relocation in play 571 // otherwise (no relocation), they are EQUAL. 572 this(descriptor.getRequest().getArtifact(), rangeResult); 573 this.descriptors.put(version, descriptor); 574 } 575 576 List<DescriptorResolutionResult> flatten() { 577 if (descriptors.size() > 1) { 578 return descriptors.entrySet().stream() 579 .map(e -> new DescriptorResolutionResult(rangeResult, e.getKey(), e.getValue())) 580 .collect(Collectors.toList()); 581 } else { 582 return Collections.emptyList(); 583 } 584 } 585 } 586 587 static class Args { 588 589 final RepositorySystemSession session; 590 591 final boolean ignoreRepos; 592 593 final boolean premanagedState; 594 595 final DataPool pool; 596 597 final Queue<DependencyProcessingContext> dependencyProcessingQueue = new ArrayDeque<>(128); 598 599 final AtomicReference<DefaultDependencyCollectionContext> collectionContext; 600 601 final DefaultVersionFilterContext versionContext; 602 603 final CollectRequest request; 604 605 final DependencyResolutionSkipper skipper; 606 607 final ParallelDescriptorResolver resolver; 608 609 final AtomicReference<InterruptedException> interruptedException; 610 611 Args( 612 RepositorySystemSession session, 613 DataPool pool, 614 DefaultDependencyCollectionContext collectionContext, 615 DefaultVersionFilterContext versionContext, 616 CollectRequest request, 617 DependencyResolutionSkipper skipper, 618 ParallelDescriptorResolver resolver) { 619 this.session = session; 620 this.request = request; 621 this.ignoreRepos = session.isIgnoreArtifactDescriptorRepositories(); 622 this.premanagedState = ConfigUtils.getBoolean(session, false, DependencyManagerUtils.CONFIG_PROP_VERBOSE); 623 this.pool = pool; 624 this.collectionContext = new AtomicReference<>(collectionContext); 625 this.versionContext = versionContext; 626 this.skipper = skipper; 627 this.resolver = resolver; 628 this.interruptedException = new AtomicReference<>(null); 629 } 630 } 631}