View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements.  See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership.  The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License.  You may obtain a copy of the License at
9    *
10   *   http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing,
13   * software distributed under the License is distributed on an
14   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   * KIND, either express or implied.  See the License for the
16   * specific language governing permissions and limitations
17   * under the License.
18   */
19  package org.eclipse.aether.internal.impl;
20  
21  import javax.inject.Inject;
22  import javax.inject.Named;
23  import javax.inject.Singleton;
24  
25  import java.io.File;
26  import java.io.IOException;
27  import java.util.ArrayList;
28  import java.util.Collection;
29  import java.util.Collections;
30  import java.util.Iterator;
31  import java.util.List;
32  import java.util.Map;
33  import java.util.concurrent.atomic.AtomicBoolean;
34  
35  import org.eclipse.aether.RepositoryEvent;
36  import org.eclipse.aether.RepositoryEvent.EventType;
37  import org.eclipse.aether.RepositorySystemSession;
38  import org.eclipse.aether.RequestTrace;
39  import org.eclipse.aether.SyncContext;
40  import org.eclipse.aether.artifact.Artifact;
41  import org.eclipse.aether.artifact.ArtifactProperties;
42  import org.eclipse.aether.impl.ArtifactResolver;
43  import org.eclipse.aether.impl.OfflineController;
44  import org.eclipse.aether.impl.RemoteRepositoryFilterManager;
45  import org.eclipse.aether.impl.RemoteRepositoryManager;
46  import org.eclipse.aether.impl.RepositoryConnectorProvider;
47  import org.eclipse.aether.impl.RepositoryEventDispatcher;
48  import org.eclipse.aether.impl.UpdateCheck;
49  import org.eclipse.aether.impl.UpdateCheckManager;
50  import org.eclipse.aether.impl.VersionResolver;
51  import org.eclipse.aether.repository.ArtifactRepository;
52  import org.eclipse.aether.repository.LocalArtifactRegistration;
53  import org.eclipse.aether.repository.LocalArtifactRequest;
54  import org.eclipse.aether.repository.LocalArtifactResult;
55  import org.eclipse.aether.repository.LocalRepository;
56  import org.eclipse.aether.repository.LocalRepositoryManager;
57  import org.eclipse.aether.repository.RemoteRepository;
58  import org.eclipse.aether.repository.RepositoryPolicy;
59  import org.eclipse.aether.repository.WorkspaceReader;
60  import org.eclipse.aether.resolution.ArtifactRequest;
61  import org.eclipse.aether.resolution.ArtifactResolutionException;
62  import org.eclipse.aether.resolution.ArtifactResult;
63  import org.eclipse.aether.resolution.ResolutionErrorPolicy;
64  import org.eclipse.aether.resolution.VersionRequest;
65  import org.eclipse.aether.resolution.VersionResolutionException;
66  import org.eclipse.aether.resolution.VersionResult;
67  import org.eclipse.aether.spi.connector.ArtifactDownload;
68  import org.eclipse.aether.spi.connector.RepositoryConnector;
69  import org.eclipse.aether.spi.connector.filter.RemoteRepositoryFilter;
70  import org.eclipse.aether.spi.io.FileProcessor;
71  import org.eclipse.aether.spi.locator.Service;
72  import org.eclipse.aether.spi.locator.ServiceLocator;
73  import org.eclipse.aether.spi.resolution.ArtifactResolverPostProcessor;
74  import org.eclipse.aether.spi.synccontext.SyncContextFactory;
75  import org.eclipse.aether.transfer.ArtifactFilteredOutException;
76  import org.eclipse.aether.transfer.ArtifactNotFoundException;
77  import org.eclipse.aether.transfer.ArtifactTransferException;
78  import org.eclipse.aether.transfer.NoRepositoryConnectorException;
79  import org.eclipse.aether.transfer.RepositoryOfflineException;
80  import org.eclipse.aether.util.ConfigUtils;
81  import org.slf4j.Logger;
82  import org.slf4j.LoggerFactory;
83  
84  import static java.util.Objects.requireNonNull;
85  
86  /**
87   *
88   */
89  @Singleton
90  @Named
91  public class DefaultArtifactResolver implements ArtifactResolver, Service {
92  
93      /**
94       * Configuration to enable "snapshot normalization", downloaded snapshots from remote with timestamped file names
95       * will have file names converted back to baseVersion. Default: {@code true}.
96       */
97      private static final String CONFIG_PROP_SNAPSHOT_NORMALIZATION = "aether.artifactResolver.snapshotNormalization";
98  
99      /**
100      * Configuration to enable "interoperability" with Simple LRM, but this breaks RRF feature, hence this configuration
101      * is IGNORED when RRF is used, and is warmly recommended to leave it disabled even if no RRF is being used.
102      * Default: {@code false}.
103      */
104     private static final String CONFIG_PROP_SIMPLE_LRM_INTEROP = "aether.artifactResolver.simpleLrmInterop";
105 
106     private static final Logger LOGGER = LoggerFactory.getLogger(DefaultArtifactResolver.class);
107 
108     private FileProcessor fileProcessor;
109 
110     private RepositoryEventDispatcher repositoryEventDispatcher;
111 
112     private VersionResolver versionResolver;
113 
114     private UpdateCheckManager updateCheckManager;
115 
116     private RepositoryConnectorProvider repositoryConnectorProvider;
117 
118     private RemoteRepositoryManager remoteRepositoryManager;
119 
120     private SyncContextFactory syncContextFactory;
121 
122     private OfflineController offlineController;
123 
124     private Map<String, ArtifactResolverPostProcessor> artifactResolverPostProcessors;
125 
126     private RemoteRepositoryFilterManager remoteRepositoryFilterManager;
127 
128     public DefaultArtifactResolver() {
129         // enables default constructor
130     }
131 
132     @SuppressWarnings("checkstyle:parameternumber")
133     @Inject
134     DefaultArtifactResolver(
135             FileProcessor fileProcessor,
136             RepositoryEventDispatcher repositoryEventDispatcher,
137             VersionResolver versionResolver,
138             UpdateCheckManager updateCheckManager,
139             RepositoryConnectorProvider repositoryConnectorProvider,
140             RemoteRepositoryManager remoteRepositoryManager,
141             SyncContextFactory syncContextFactory,
142             OfflineController offlineController,
143             Map<String, ArtifactResolverPostProcessor> artifactResolverPostProcessors,
144             RemoteRepositoryFilterManager remoteRepositoryFilterManager) {
145         setFileProcessor(fileProcessor);
146         setRepositoryEventDispatcher(repositoryEventDispatcher);
147         setVersionResolver(versionResolver);
148         setUpdateCheckManager(updateCheckManager);
149         setRepositoryConnectorProvider(repositoryConnectorProvider);
150         setRemoteRepositoryManager(remoteRepositoryManager);
151         setSyncContextFactory(syncContextFactory);
152         setOfflineController(offlineController);
153         setArtifactResolverPostProcessors(artifactResolverPostProcessors);
154         setRemoteRepositoryFilterManager(remoteRepositoryFilterManager);
155     }
156 
157     public void initService(ServiceLocator locator) {
158         setFileProcessor(locator.getService(FileProcessor.class));
159         setRepositoryEventDispatcher(locator.getService(RepositoryEventDispatcher.class));
160         setVersionResolver(locator.getService(VersionResolver.class));
161         setUpdateCheckManager(locator.getService(UpdateCheckManager.class));
162         setRepositoryConnectorProvider(locator.getService(RepositoryConnectorProvider.class));
163         setRemoteRepositoryManager(locator.getService(RemoteRepositoryManager.class));
164         setSyncContextFactory(locator.getService(SyncContextFactory.class));
165         setOfflineController(locator.getService(OfflineController.class));
166         setArtifactResolverPostProcessors(Collections.emptyMap());
167         setRemoteRepositoryFilterManager(locator.getService(RemoteRepositoryFilterManager.class));
168     }
169 
170     /**
171      * @deprecated not used any more since MRESOLVER-36 move to slf4j, added back in MRESOLVER-64 for compatibility
172      */
173     @Deprecated
174     public DefaultArtifactResolver setLoggerFactory(org.eclipse.aether.spi.log.LoggerFactory loggerFactory) {
175         // this.logger = NullLoggerFactory.getSafeLogger( loggerFactory, getClass() );
176         return this;
177     }
178 
179     public DefaultArtifactResolver setFileProcessor(FileProcessor fileProcessor) {
180         this.fileProcessor = requireNonNull(fileProcessor, "file processor cannot be null");
181         return this;
182     }
183 
184     public DefaultArtifactResolver setRepositoryEventDispatcher(RepositoryEventDispatcher repositoryEventDispatcher) {
185         this.repositoryEventDispatcher =
186                 requireNonNull(repositoryEventDispatcher, "repository event dispatcher cannot be null");
187         return this;
188     }
189 
190     public DefaultArtifactResolver setVersionResolver(VersionResolver versionResolver) {
191         this.versionResolver = requireNonNull(versionResolver, "version resolver cannot be null");
192         return this;
193     }
194 
195     public DefaultArtifactResolver setUpdateCheckManager(UpdateCheckManager updateCheckManager) {
196         this.updateCheckManager = requireNonNull(updateCheckManager, "update check manager cannot be null");
197         return this;
198     }
199 
200     public DefaultArtifactResolver setRepositoryConnectorProvider(
201             RepositoryConnectorProvider repositoryConnectorProvider) {
202         this.repositoryConnectorProvider =
203                 requireNonNull(repositoryConnectorProvider, "repository connector provider cannot be null");
204         return this;
205     }
206 
207     public DefaultArtifactResolver setRemoteRepositoryManager(RemoteRepositoryManager remoteRepositoryManager) {
208         this.remoteRepositoryManager =
209                 requireNonNull(remoteRepositoryManager, "remote repository provider cannot be null");
210         return this;
211     }
212 
213     public DefaultArtifactResolver setSyncContextFactory(SyncContextFactory syncContextFactory) {
214         this.syncContextFactory = requireNonNull(syncContextFactory, "sync context factory cannot be null");
215         return this;
216     }
217 
218     public DefaultArtifactResolver setOfflineController(OfflineController offlineController) {
219         this.offlineController = requireNonNull(offlineController, "offline controller cannot be null");
220         return this;
221     }
222 
223     public DefaultArtifactResolver setArtifactResolverPostProcessors(
224             Map<String, ArtifactResolverPostProcessor> artifactResolverPostProcessors) {
225         this.artifactResolverPostProcessors =
226                 requireNonNull(artifactResolverPostProcessors, "artifact resolver post-processors cannot be null");
227         return this;
228     }
229 
230     public DefaultArtifactResolver setRemoteRepositoryFilterManager(
231             RemoteRepositoryFilterManager remoteRepositoryFilterManager) {
232         this.remoteRepositoryFilterManager =
233                 requireNonNull(remoteRepositoryFilterManager, "remote repository filter manager cannot be null");
234         return this;
235     }
236 
237     public ArtifactResult resolveArtifact(RepositorySystemSession session, ArtifactRequest request)
238             throws ArtifactResolutionException {
239         requireNonNull(session, "session cannot be null");
240         requireNonNull(request, "request cannot be null");
241 
242         return resolveArtifacts(session, Collections.singleton(request)).get(0);
243     }
244 
245     public List<ArtifactResult> resolveArtifacts(
246             RepositorySystemSession session, Collection<? extends ArtifactRequest> requests)
247             throws ArtifactResolutionException {
248         requireNonNull(session, "session cannot be null");
249         requireNonNull(requests, "requests cannot be null");
250         try (SyncContext exclusive = syncContextFactory.newInstance(session, false)) {
251             Collection<Artifact> artifacts = new ArrayList<>(requests.size());
252             for (ArtifactRequest request : requests) {
253                 if (request.getArtifact().getProperty(ArtifactProperties.LOCAL_PATH, null) != null) {
254                     continue;
255                 }
256                 artifacts.add(request.getArtifact());
257             }
258 
259             return resolve(exclusive, artifacts, session, requests);
260         }
261     }
262 
263     @SuppressWarnings("checkstyle:methodlength")
264     private List<ArtifactResult> resolve(
265             SyncContext syncContext,
266             Collection<Artifact> subjects,
267             RepositorySystemSession session,
268             Collection<? extends ArtifactRequest> requests)
269             throws ArtifactResolutionException {
270         try {
271             syncContext.acquire(subjects, null);
272 
273             boolean failures = false;
274             final List<ArtifactResult> results = new ArrayList<>(requests.size());
275             final boolean simpleLrmInterop = ConfigUtils.getBoolean(session, false, CONFIG_PROP_SIMPLE_LRM_INTEROP);
276             final LocalRepositoryManager lrm = session.getLocalRepositoryManager();
277             final WorkspaceReader workspace = session.getWorkspaceReader();
278             final List<ResolutionGroup> groups = new ArrayList<>();
279             // filter != null: means "filtering applied", if null no filtering applied (behave as before)
280             final RemoteRepositoryFilter filter = remoteRepositoryFilterManager.getRemoteRepositoryFilter(session);
281 
282             for (ArtifactRequest request : requests) {
283                 RequestTrace trace = RequestTrace.newChild(request.getTrace(), request);
284 
285                 ArtifactResult result = new ArtifactResult(request);
286                 results.add(result);
287 
288                 Artifact artifact = request.getArtifact();
289 
290                 artifactResolving(session, trace, artifact);
291 
292                 String localPath = artifact.getProperty(ArtifactProperties.LOCAL_PATH, null);
293                 if (localPath != null) {
294                     // unhosted artifact, just validate file
295                     File file = new File(localPath);
296                     if (!file.isFile()) {
297                         failures = true;
298                         result.addException(new ArtifactNotFoundException(artifact, null));
299                     } else {
300                         artifact = artifact.setFile(file);
301                         result.setArtifact(artifact);
302                         artifactResolved(session, trace, artifact, null, result.getExceptions());
303                     }
304                     continue;
305                 }
306 
307                 List<RemoteRepository> remoteRepositories = request.getRepositories();
308                 List<RemoteRepository> filteredRemoteRepositories = new ArrayList<>(remoteRepositories);
309                 if (filter != null) {
310                     for (RemoteRepository repository : remoteRepositories) {
311                         RemoteRepositoryFilter.Result filterResult = filter.acceptArtifact(repository, artifact);
312                         if (!filterResult.isAccepted()) {
313                             result.addException(
314                                     new ArtifactFilteredOutException(artifact, repository, filterResult.reasoning()));
315                             filteredRemoteRepositories.remove(repository);
316                         }
317                     }
318                 }
319 
320                 VersionResult versionResult;
321                 try {
322                     VersionRequest versionRequest =
323                             new VersionRequest(artifact, filteredRemoteRepositories, request.getRequestContext());
324                     versionRequest.setTrace(trace);
325                     versionResult = versionResolver.resolveVersion(session, versionRequest);
326                 } catch (VersionResolutionException e) {
327                     result.addException(e);
328                     continue;
329                 }
330 
331                 artifact = artifact.setVersion(versionResult.getVersion());
332 
333                 if (versionResult.getRepository() != null) {
334                     if (versionResult.getRepository() instanceof RemoteRepository) {
335                         filteredRemoteRepositories =
336                                 Collections.singletonList((RemoteRepository) versionResult.getRepository());
337                     } else {
338                         filteredRemoteRepositories = Collections.emptyList();
339                     }
340                 }
341 
342                 if (workspace != null) {
343                     File file = workspace.findArtifact(artifact);
344                     if (file != null) {
345                         artifact = artifact.setFile(file);
346                         result.setArtifact(artifact);
347                         result.setRepository(workspace.getRepository());
348                         artifactResolved(session, trace, artifact, result.getRepository(), null);
349                         continue;
350                     }
351                 }
352 
353                 LocalArtifactResult local = lrm.find(
354                         session,
355                         new LocalArtifactRequest(artifact, filteredRemoteRepositories, request.getRequestContext()));
356                 result.setLocalArtifactResult(local);
357                 boolean found = (filter != null && local.isAvailable()) || isLocallyInstalled(local, versionResult);
358                 // with filtering it is availability that drives logic
359                 // without filtering it is simply presence of file that drives the logic
360                 // "interop" logic with simple LRM leads to RRF breakage: hence is ignored when filtering in effect
361                 if (found) {
362                     if (local.getRepository() != null) {
363                         result.setRepository(local.getRepository());
364                     } else {
365                         result.setRepository(lrm.getRepository());
366                     }
367 
368                     try {
369                         artifact = artifact.setFile(getFile(session, artifact, local.getFile()));
370                         result.setArtifact(artifact);
371                         artifactResolved(session, trace, artifact, result.getRepository(), null);
372                     } catch (ArtifactTransferException e) {
373                         result.addException(e);
374                     }
375                     if (filter == null && simpleLrmInterop && !local.isAvailable()) {
376                         /*
377                          * NOTE: Interop with simple local repository: An artifact installed by a simple local repo
378                          * manager will not show up in the repository tracking file of the enhanced local repository.
379                          * If however the maven-metadata-local.xml tells us the artifact was installed locally, we
380                          * sync the repository tracking file.
381                          */
382                         lrm.add(session, new LocalArtifactRegistration(artifact));
383                     }
384 
385                     continue;
386                 }
387 
388                 if (local.getFile() != null) {
389                     LOGGER.info(
390                             "Artifact {} is present in the local repository, but cached from a remote repository ID that is unavailable in current build context, verifying that is downloadable from {}",
391                             artifact,
392                             remoteRepositories);
393                 }
394 
395                 LOGGER.debug("Resolving artifact {} from {}", artifact, remoteRepositories);
396                 AtomicBoolean resolved = new AtomicBoolean(false);
397                 Iterator<ResolutionGroup> groupIt = groups.iterator();
398                 for (RemoteRepository repo : filteredRemoteRepositories) {
399                     if (!repo.getPolicy(artifact.isSnapshot()).isEnabled()) {
400                         continue;
401                     }
402 
403                     try {
404                         Utils.checkOffline(session, offlineController, repo);
405                     } catch (RepositoryOfflineException e) {
406                         Exception exception = new ArtifactNotFoundException(
407                                 artifact,
408                                 repo,
409                                 "Cannot access " + repo.getId() + " ("
410                                         + repo.getUrl() + ") in offline mode and the artifact " + artifact
411                                         + " has not been downloaded from it before.",
412                                 e);
413                         result.addException(exception);
414                         continue;
415                     }
416 
417                     ResolutionGroup group = null;
418                     while (groupIt.hasNext()) {
419                         ResolutionGroup t = groupIt.next();
420                         if (t.matches(repo)) {
421                             group = t;
422                             break;
423                         }
424                     }
425                     if (group == null) {
426                         group = new ResolutionGroup(repo);
427                         groups.add(group);
428                         groupIt = Collections.emptyIterator();
429                     }
430                     group.items.add(new ResolutionItem(trace, artifact, resolved, result, local, repo));
431                 }
432             }
433 
434             for (ResolutionGroup group : groups) {
435                 performDownloads(session, group);
436             }
437 
438             for (ArtifactResolverPostProcessor artifactResolverPostProcessor :
439                     artifactResolverPostProcessors.values()) {
440                 artifactResolverPostProcessor.postProcess(session, results);
441             }
442 
443             for (ArtifactResult result : results) {
444                 ArtifactRequest request = result.getRequest();
445 
446                 Artifact artifact = result.getArtifact();
447                 if (artifact == null || artifact.getFile() == null) {
448                     failures = true;
449                     if (result.getExceptions().isEmpty()) {
450                         Exception exception = new ArtifactNotFoundException(request.getArtifact(), null);
451                         result.addException(exception);
452                     }
453                     RequestTrace trace = RequestTrace.newChild(request.getTrace(), request);
454                     artifactResolved(session, trace, request.getArtifact(), null, result.getExceptions());
455                 }
456             }
457 
458             if (failures) {
459                 throw new ArtifactResolutionException(results);
460             }
461 
462             return results;
463         } finally {
464             syncContext.close();
465         }
466     }
467 
468     private boolean isLocallyInstalled(LocalArtifactResult lar, VersionResult vr) {
469         if (lar.isAvailable()) {
470             return true;
471         }
472         if (lar.getFile() != null) {
473             if (vr.getRepository() instanceof LocalRepository) {
474                 // resolution of (snapshot) version found locally installed artifact
475                 return true;
476             } else if (vr.getRepository() == null
477                     && lar.getRequest().getRepositories().isEmpty()) {
478                 // resolution of version range found locally installed artifact
479                 return true;
480             }
481         }
482         return false;
483     }
484 
485     private File getFile(RepositorySystemSession session, Artifact artifact, File file)
486             throws ArtifactTransferException {
487         if (artifact.isSnapshot()
488                 && !artifact.getVersion().equals(artifact.getBaseVersion())
489                 && ConfigUtils.getBoolean(session, true, CONFIG_PROP_SNAPSHOT_NORMALIZATION)) {
490             String name = file.getName().replace(artifact.getVersion(), artifact.getBaseVersion());
491             File dst = new File(file.getParent(), name);
492 
493             boolean copy = dst.length() != file.length() || dst.lastModified() != file.lastModified();
494             if (copy) {
495                 try {
496                     fileProcessor.copy(file, dst);
497                     dst.setLastModified(file.lastModified());
498                 } catch (IOException e) {
499                     throw new ArtifactTransferException(artifact, null, e);
500                 }
501             }
502 
503             file = dst;
504         }
505 
506         return file;
507     }
508 
509     private void performDownloads(RepositorySystemSession session, ResolutionGroup group) {
510         List<ArtifactDownload> downloads = gatherDownloads(session, group);
511         if (downloads.isEmpty()) {
512             return;
513         }
514 
515         for (ArtifactDownload download : downloads) {
516             artifactDownloading(session, download.getTrace(), download.getArtifact(), group.repository);
517         }
518 
519         try {
520             try (RepositoryConnector connector =
521                     repositoryConnectorProvider.newRepositoryConnector(session, group.repository)) {
522                 connector.get(downloads, null);
523             }
524         } catch (NoRepositoryConnectorException e) {
525             for (ArtifactDownload download : downloads) {
526                 download.setException(new ArtifactTransferException(download.getArtifact(), group.repository, e));
527             }
528         }
529 
530         evaluateDownloads(session, group);
531     }
532 
533     private List<ArtifactDownload> gatherDownloads(RepositorySystemSession session, ResolutionGroup group) {
534         LocalRepositoryManager lrm = session.getLocalRepositoryManager();
535         List<ArtifactDownload> downloads = new ArrayList<>();
536 
537         for (ResolutionItem item : group.items) {
538             Artifact artifact = item.artifact;
539 
540             if (item.resolved.get()) {
541                 // resolved in previous resolution group
542                 continue;
543             }
544 
545             ArtifactDownload download = new ArtifactDownload();
546             download.setArtifact(artifact);
547             download.setRequestContext(item.request.getRequestContext());
548             download.setListener(SafeTransferListener.wrap(session));
549             download.setTrace(item.trace);
550             if (item.local.getFile() != null) {
551                 download.setFile(item.local.getFile());
552                 download.setExistenceCheck(true);
553             } else {
554                 String path =
555                         lrm.getPathForRemoteArtifact(artifact, group.repository, item.request.getRequestContext());
556                 download.setFile(new File(lrm.getRepository().getBasedir(), path));
557             }
558 
559             boolean snapshot = artifact.isSnapshot();
560             RepositoryPolicy policy = remoteRepositoryManager.getPolicy(session, group.repository, !snapshot, snapshot);
561 
562             int errorPolicy = Utils.getPolicy(session, artifact, group.repository);
563             if ((errorPolicy & ResolutionErrorPolicy.CACHE_ALL) != 0) {
564                 UpdateCheck<Artifact, ArtifactTransferException> check = new UpdateCheck<>();
565                 check.setItem(artifact);
566                 check.setFile(download.getFile());
567                 check.setFileValid(false);
568                 check.setRepository(group.repository);
569                 check.setPolicy(policy.getUpdatePolicy());
570                 item.updateCheck = check;
571                 updateCheckManager.checkArtifact(session, check);
572                 if (!check.isRequired()) {
573                     item.result.addException(check.getException());
574                     continue;
575                 }
576             }
577 
578             download.setChecksumPolicy(policy.getChecksumPolicy());
579             download.setRepositories(item.repository.getMirroredRepositories());
580             downloads.add(download);
581             item.download = download;
582         }
583 
584         return downloads;
585     }
586 
587     private void evaluateDownloads(RepositorySystemSession session, ResolutionGroup group) {
588         LocalRepositoryManager lrm = session.getLocalRepositoryManager();
589 
590         for (ResolutionItem item : group.items) {
591             ArtifactDownload download = item.download;
592             if (download == null) {
593                 continue;
594             }
595 
596             Artifact artifact = download.getArtifact();
597             if (download.getException() == null) {
598                 item.resolved.set(true);
599                 item.result.setRepository(group.repository);
600                 try {
601                     artifact = artifact.setFile(getFile(session, artifact, download.getFile()));
602                     item.result.setArtifact(artifact);
603 
604                     lrm.add(
605                             session,
606                             new LocalArtifactRegistration(artifact, group.repository, download.getSupportedContexts()));
607                 } catch (ArtifactTransferException e) {
608                     download.setException(e);
609                     item.result.addException(e);
610                 }
611             } else {
612                 item.result.addException(download.getException());
613             }
614 
615             /*
616              * NOTE: Touch after registration with local repo to ensure concurrent resolution is not rejected with
617              * "already updated" via session data when actual update to local repo is still pending.
618              */
619             if (item.updateCheck != null) {
620                 item.updateCheck.setException(download.getException());
621                 updateCheckManager.touchArtifact(session, item.updateCheck);
622             }
623 
624             artifactDownloaded(session, download.getTrace(), artifact, group.repository, download.getException());
625             if (download.getException() == null) {
626                 artifactResolved(session, download.getTrace(), artifact, group.repository, null);
627             }
628         }
629     }
630 
631     private void artifactResolving(RepositorySystemSession session, RequestTrace trace, Artifact artifact) {
632         RepositoryEvent.Builder event = new RepositoryEvent.Builder(session, EventType.ARTIFACT_RESOLVING);
633         event.setTrace(trace);
634         event.setArtifact(artifact);
635 
636         repositoryEventDispatcher.dispatch(event.build());
637     }
638 
639     private void artifactResolved(
640             RepositorySystemSession session,
641             RequestTrace trace,
642             Artifact artifact,
643             ArtifactRepository repository,
644             List<Exception> exceptions) {
645         RepositoryEvent.Builder event = new RepositoryEvent.Builder(session, EventType.ARTIFACT_RESOLVED);
646         event.setTrace(trace);
647         event.setArtifact(artifact);
648         event.setRepository(repository);
649         event.setExceptions(exceptions);
650         if (artifact != null) {
651             event.setFile(artifact.getFile());
652         }
653 
654         repositoryEventDispatcher.dispatch(event.build());
655     }
656 
657     private void artifactDownloading(
658             RepositorySystemSession session, RequestTrace trace, Artifact artifact, RemoteRepository repository) {
659         RepositoryEvent.Builder event = new RepositoryEvent.Builder(session, EventType.ARTIFACT_DOWNLOADING);
660         event.setTrace(trace);
661         event.setArtifact(artifact);
662         event.setRepository(repository);
663 
664         repositoryEventDispatcher.dispatch(event.build());
665     }
666 
667     private void artifactDownloaded(
668             RepositorySystemSession session,
669             RequestTrace trace,
670             Artifact artifact,
671             RemoteRepository repository,
672             Exception exception) {
673         RepositoryEvent.Builder event = new RepositoryEvent.Builder(session, EventType.ARTIFACT_DOWNLOADED);
674         event.setTrace(trace);
675         event.setArtifact(artifact);
676         event.setRepository(repository);
677         event.setException(exception);
678         if (artifact != null) {
679             event.setFile(artifact.getFile());
680         }
681 
682         repositoryEventDispatcher.dispatch(event.build());
683     }
684 
685     static class ResolutionGroup {
686 
687         final RemoteRepository repository;
688 
689         final List<ResolutionItem> items = new ArrayList<>();
690 
691         ResolutionGroup(RemoteRepository repository) {
692             this.repository = repository;
693         }
694 
695         boolean matches(RemoteRepository repo) {
696             return repository.getUrl().equals(repo.getUrl())
697                     && repository.getContentType().equals(repo.getContentType())
698                     && repository.isRepositoryManager() == repo.isRepositoryManager();
699         }
700     }
701 
702     static class ResolutionItem {
703 
704         final RequestTrace trace;
705 
706         final ArtifactRequest request;
707 
708         final ArtifactResult result;
709 
710         final LocalArtifactResult local;
711 
712         final RemoteRepository repository;
713 
714         final Artifact artifact;
715 
716         final AtomicBoolean resolved;
717 
718         ArtifactDownload download;
719 
720         UpdateCheck<Artifact, ArtifactTransferException> updateCheck;
721 
722         ResolutionItem(
723                 RequestTrace trace,
724                 Artifact artifact,
725                 AtomicBoolean resolved,
726                 ArtifactResult result,
727                 LocalArtifactResult local,
728                 RemoteRepository repository) {
729             this.trace = trace;
730             this.artifact = artifact;
731             this.resolved = resolved;
732             this.result = result;
733             this.request = result.getRequest();
734             this.local = local;
735             this.repository = repository;
736         }
737     }
738 }