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}