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; 020 021import javax.inject.Inject; 022import javax.inject.Named; 023import javax.inject.Singleton; 024 025import java.io.File; 026import java.io.IOException; 027import java.util.ArrayList; 028import java.util.Collection; 029import java.util.Collections; 030import java.util.Iterator; 031import java.util.List; 032import java.util.Map; 033import java.util.concurrent.atomic.AtomicBoolean; 034 035import org.eclipse.aether.RepositoryEvent; 036import org.eclipse.aether.RepositoryEvent.EventType; 037import org.eclipse.aether.RepositorySystemSession; 038import org.eclipse.aether.RequestTrace; 039import org.eclipse.aether.SyncContext; 040import org.eclipse.aether.artifact.Artifact; 041import org.eclipse.aether.artifact.ArtifactProperties; 042import org.eclipse.aether.impl.ArtifactResolver; 043import org.eclipse.aether.impl.OfflineController; 044import org.eclipse.aether.impl.RemoteRepositoryFilterManager; 045import org.eclipse.aether.impl.RemoteRepositoryManager; 046import org.eclipse.aether.impl.RepositoryConnectorProvider; 047import org.eclipse.aether.impl.RepositoryEventDispatcher; 048import org.eclipse.aether.impl.UpdateCheck; 049import org.eclipse.aether.impl.UpdateCheckManager; 050import org.eclipse.aether.impl.VersionResolver; 051import org.eclipse.aether.repository.ArtifactRepository; 052import org.eclipse.aether.repository.LocalArtifactRegistration; 053import org.eclipse.aether.repository.LocalArtifactRequest; 054import org.eclipse.aether.repository.LocalArtifactResult; 055import org.eclipse.aether.repository.LocalRepository; 056import org.eclipse.aether.repository.LocalRepositoryManager; 057import org.eclipse.aether.repository.RemoteRepository; 058import org.eclipse.aether.repository.RepositoryPolicy; 059import org.eclipse.aether.repository.WorkspaceReader; 060import org.eclipse.aether.resolution.ArtifactRequest; 061import org.eclipse.aether.resolution.ArtifactResolutionException; 062import org.eclipse.aether.resolution.ArtifactResult; 063import org.eclipse.aether.resolution.ResolutionErrorPolicy; 064import org.eclipse.aether.resolution.VersionRequest; 065import org.eclipse.aether.resolution.VersionResolutionException; 066import org.eclipse.aether.resolution.VersionResult; 067import org.eclipse.aether.spi.connector.ArtifactDownload; 068import org.eclipse.aether.spi.connector.RepositoryConnector; 069import org.eclipse.aether.spi.connector.filter.RemoteRepositoryFilter; 070import org.eclipse.aether.spi.io.FileProcessor; 071import org.eclipse.aether.spi.locator.Service; 072import org.eclipse.aether.spi.locator.ServiceLocator; 073import org.eclipse.aether.spi.resolution.ArtifactResolverPostProcessor; 074import org.eclipse.aether.spi.synccontext.SyncContextFactory; 075import org.eclipse.aether.transfer.ArtifactFilteredOutException; 076import org.eclipse.aether.transfer.ArtifactNotFoundException; 077import org.eclipse.aether.transfer.ArtifactTransferException; 078import org.eclipse.aether.transfer.NoRepositoryConnectorException; 079import org.eclipse.aether.transfer.RepositoryOfflineException; 080import org.eclipse.aether.util.ConfigUtils; 081import org.slf4j.Logger; 082import org.slf4j.LoggerFactory; 083 084import static java.util.Objects.requireNonNull; 085 086/** 087 * 088 */ 089@Singleton 090@Named 091public class DefaultArtifactResolver implements ArtifactResolver, Service { 092 093 /** 094 * Configuration to enable "snapshot normalization", downloaded snapshots from remote with timestamped file names 095 * will have file names converted back to baseVersion. Default: {@code true}. 096 */ 097 private static final String CONFIG_PROP_SNAPSHOT_NORMALIZATION = "aether.artifactResolver.snapshotNormalization"; 098 099 /** 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}