001package org.eclipse.aether.internal.impl; 002 003/* 004 * Licensed to the Apache Software Foundation (ASF) under one 005 * or more contributor license agreements. See the NOTICE file 006 * distributed with this work for additional information 007 * regarding copyright ownership. The ASF licenses this file 008 * to you under the Apache License, Version 2.0 (the 009 * "License"); you may not use this file except in compliance 010 * with the License. You may obtain a copy of the License at 011 * 012 * http://www.apache.org/licenses/LICENSE-2.0 013 * 014 * Unless required by applicable law or agreed to in writing, 015 * software distributed under the License is distributed on an 016 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 017 * KIND, either express or implied. See the License for the 018 * specific language governing permissions and limitations 019 * under the License. 020 */ 021 022import java.io.File; 023import java.util.ArrayList; 024import java.util.Arrays; 025import java.util.Collection; 026import java.util.Collections; 027import java.util.HashMap; 028import java.util.List; 029import java.util.Map; 030import static java.util.Objects.requireNonNull; 031import java.util.concurrent.Executor; 032import java.util.concurrent.ExecutorService; 033import java.util.concurrent.LinkedBlockingQueue; 034import java.util.concurrent.ThreadPoolExecutor; 035import java.util.concurrent.TimeUnit; 036 037import javax.inject.Inject; 038import javax.inject.Named; 039 040import org.eclipse.aether.RepositoryEvent; 041import org.eclipse.aether.RepositoryEvent.EventType; 042import org.eclipse.aether.RepositorySystemSession; 043import org.eclipse.aether.RequestTrace; 044import org.eclipse.aether.SyncContext; 045import org.eclipse.aether.impl.MetadataResolver; 046import org.eclipse.aether.impl.OfflineController; 047import org.eclipse.aether.impl.RemoteRepositoryManager; 048import org.eclipse.aether.impl.RepositoryConnectorProvider; 049import org.eclipse.aether.impl.RepositoryEventDispatcher; 050import org.eclipse.aether.impl.SyncContextFactory; 051import org.eclipse.aether.impl.UpdateCheck; 052import org.eclipse.aether.impl.UpdateCheckManager; 053import org.eclipse.aether.metadata.Metadata; 054import org.eclipse.aether.repository.ArtifactRepository; 055import org.eclipse.aether.repository.LocalMetadataRegistration; 056import org.eclipse.aether.repository.LocalMetadataRequest; 057import org.eclipse.aether.repository.LocalMetadataResult; 058import org.eclipse.aether.repository.LocalRepository; 059import org.eclipse.aether.repository.LocalRepositoryManager; 060import org.eclipse.aether.repository.RemoteRepository; 061import org.eclipse.aether.repository.RepositoryPolicy; 062import org.eclipse.aether.resolution.MetadataRequest; 063import org.eclipse.aether.resolution.MetadataResult; 064import org.eclipse.aether.spi.connector.MetadataDownload; 065import org.eclipse.aether.spi.connector.RepositoryConnector; 066import org.eclipse.aether.spi.locator.Service; 067import org.eclipse.aether.spi.locator.ServiceLocator; 068import org.eclipse.aether.transfer.MetadataNotFoundException; 069import org.eclipse.aether.transfer.MetadataTransferException; 070import org.eclipse.aether.transfer.NoRepositoryConnectorException; 071import org.eclipse.aether.transfer.RepositoryOfflineException; 072import org.eclipse.aether.util.ConfigUtils; 073import org.eclipse.aether.util.concurrency.RunnableErrorForwarder; 074import org.eclipse.aether.util.concurrency.WorkerThreadFactory; 075 076/** 077 */ 078@Named 079public class DefaultMetadataResolver 080 implements MetadataResolver, Service 081{ 082 083 private static final String CONFIG_PROP_THREADS = "aether.metadataResolver.threads"; 084 085 private RepositoryEventDispatcher repositoryEventDispatcher; 086 087 private UpdateCheckManager updateCheckManager; 088 089 private RepositoryConnectorProvider repositoryConnectorProvider; 090 091 private RemoteRepositoryManager remoteRepositoryManager; 092 093 private SyncContextFactory syncContextFactory; 094 095 private OfflineController offlineController; 096 097 public DefaultMetadataResolver() 098 { 099 // enables default constructor 100 } 101 102 @Inject 103 DefaultMetadataResolver( RepositoryEventDispatcher repositoryEventDispatcher, 104 UpdateCheckManager updateCheckManager, 105 RepositoryConnectorProvider repositoryConnectorProvider, 106 RemoteRepositoryManager remoteRepositoryManager, SyncContextFactory syncContextFactory, 107 OfflineController offlineController ) 108 { 109 setRepositoryEventDispatcher( repositoryEventDispatcher ); 110 setUpdateCheckManager( updateCheckManager ); 111 setRepositoryConnectorProvider( repositoryConnectorProvider ); 112 setRemoteRepositoryManager( remoteRepositoryManager ); 113 setSyncContextFactory( syncContextFactory ); 114 setOfflineController( offlineController ); 115 } 116 117 public void initService( ServiceLocator locator ) 118 { 119 setRepositoryEventDispatcher( locator.getService( RepositoryEventDispatcher.class ) ); 120 setUpdateCheckManager( locator.getService( UpdateCheckManager.class ) ); 121 setRepositoryConnectorProvider( locator.getService( RepositoryConnectorProvider.class ) ); 122 setRemoteRepositoryManager( locator.getService( RemoteRepositoryManager.class ) ); 123 setSyncContextFactory( locator.getService( SyncContextFactory.class ) ); 124 setOfflineController( locator.getService( OfflineController.class ) ); 125 } 126 127 public DefaultMetadataResolver setRepositoryEventDispatcher( RepositoryEventDispatcher repositoryEventDispatcher ) 128 { 129 this.repositoryEventDispatcher = requireNonNull( 130 repositoryEventDispatcher, "repository event dispatcher cannot be null" ); 131 return this; 132 } 133 134 public DefaultMetadataResolver setUpdateCheckManager( UpdateCheckManager updateCheckManager ) 135 { 136 this.updateCheckManager = requireNonNull( updateCheckManager, "update check manager cannot be null" ); 137 return this; 138 } 139 140 public DefaultMetadataResolver setRepositoryConnectorProvider( 141 RepositoryConnectorProvider repositoryConnectorProvider ) 142 { 143 this.repositoryConnectorProvider = requireNonNull( 144 repositoryConnectorProvider, "repository connector provider cannot be null" ); 145 return this; 146 } 147 148 public DefaultMetadataResolver setRemoteRepositoryManager( RemoteRepositoryManager remoteRepositoryManager ) 149 { 150 this.remoteRepositoryManager = requireNonNull( 151 remoteRepositoryManager, "remote repository provider cannot be null" ); 152 return this; 153 } 154 155 public DefaultMetadataResolver setSyncContextFactory( SyncContextFactory syncContextFactory ) 156 { 157 this.syncContextFactory = requireNonNull( syncContextFactory, "sync context factory cannot be null" ); 158 return this; 159 } 160 161 public DefaultMetadataResolver setOfflineController( OfflineController offlineController ) 162 { 163 this.offlineController = requireNonNull( offlineController, "offline controller cannot be null" ); 164 return this; 165 } 166 167 public List<MetadataResult> resolveMetadata( RepositorySystemSession session, 168 Collection<? extends MetadataRequest> requests ) 169 { 170 171 try ( SyncContext syncContext = syncContextFactory.newInstance( session, false ) ) 172 { 173 Collection<Metadata> metadata = new ArrayList<>( requests.size() ); 174 for ( MetadataRequest request : requests ) 175 { 176 metadata.add( request.getMetadata() ); 177 } 178 179 syncContext.acquire( null, metadata ); 180 181 return resolve( session, requests ); 182 } 183 } 184 185 @SuppressWarnings( "checkstyle:methodlength" ) 186 private List<MetadataResult> resolve( RepositorySystemSession session, 187 Collection<? extends MetadataRequest> requests ) 188 { 189 List<MetadataResult> results = new ArrayList<>( requests.size() ); 190 191 List<ResolveTask> tasks = new ArrayList<>( requests.size() ); 192 193 Map<File, Long> localLastUpdates = new HashMap<>(); 194 195 for ( MetadataRequest request : requests ) 196 { 197 RequestTrace trace = RequestTrace.newChild( request.getTrace(), request ); 198 199 MetadataResult result = new MetadataResult( request ); 200 results.add( result ); 201 202 Metadata metadata = request.getMetadata(); 203 RemoteRepository repository = request.getRepository(); 204 205 if ( repository == null ) 206 { 207 LocalRepository localRepo = session.getLocalRepositoryManager().getRepository(); 208 209 metadataResolving( session, trace, metadata, localRepo ); 210 211 File localFile = getLocalFile( session, metadata ); 212 213 if ( localFile != null ) 214 { 215 metadata = metadata.setFile( localFile ); 216 result.setMetadata( metadata ); 217 } 218 else 219 { 220 result.setException( new MetadataNotFoundException( metadata, localRepo ) ); 221 } 222 223 metadataResolved( session, trace, metadata, localRepo, result.getException() ); 224 continue; 225 } 226 227 List<RemoteRepository> repositories = getEnabledSourceRepositories( repository, metadata.getNature() ); 228 229 if ( repositories.isEmpty() ) 230 { 231 continue; 232 } 233 234 metadataResolving( session, trace, metadata, repository ); 235 LocalRepositoryManager lrm = session.getLocalRepositoryManager(); 236 LocalMetadataRequest localRequest = 237 new LocalMetadataRequest( metadata, repository, request.getRequestContext() ); 238 LocalMetadataResult lrmResult = lrm.find( session, localRequest ); 239 240 File metadataFile = lrmResult.getFile(); 241 242 try 243 { 244 Utils.checkOffline( session, offlineController, repository ); 245 } 246 catch ( RepositoryOfflineException e ) 247 { 248 if ( metadataFile != null ) 249 { 250 metadata = metadata.setFile( metadataFile ); 251 result.setMetadata( metadata ); 252 } 253 else 254 { 255 String msg = 256 "Cannot access " + repository.getId() + " (" + repository.getUrl() 257 + ") in offline mode and the metadata " + metadata 258 + " has not been downloaded from it before"; 259 result.setException( new MetadataNotFoundException( metadata, repository, msg, e ) ); 260 } 261 262 metadataResolved( session, trace, metadata, repository, result.getException() ); 263 continue; 264 } 265 266 Long localLastUpdate = null; 267 if ( request.isFavorLocalRepository() ) 268 { 269 File localFile = getLocalFile( session, metadata ); 270 localLastUpdate = localLastUpdates.get( localFile ); 271 if ( localLastUpdate == null ) 272 { 273 localLastUpdate = localFile != null ? localFile.lastModified() : 0; 274 localLastUpdates.put( localFile, localLastUpdate ); 275 } 276 } 277 278 List<UpdateCheck<Metadata, MetadataTransferException>> checks = new ArrayList<>(); 279 Exception exception = null; 280 for ( RemoteRepository repo : repositories ) 281 { 282 UpdateCheck<Metadata, MetadataTransferException> check = new UpdateCheck<>(); 283 check.setLocalLastUpdated( ( localLastUpdate != null ) ? localLastUpdate : 0 ); 284 check.setItem( metadata ); 285 286 // use 'main' installation file for the check (-> use requested repository) 287 File checkFile = new File( 288 session.getLocalRepository().getBasedir(), 289 session.getLocalRepositoryManager() 290 .getPathForRemoteMetadata( metadata, repository, request.getRequestContext() ) ); 291 check.setFile( checkFile ); 292 check.setRepository( repository ); 293 check.setAuthoritativeRepository( repo ); 294 check.setPolicy( getPolicy( session, repo, metadata.getNature() ).getUpdatePolicy() ); 295 296 if ( lrmResult.isStale() ) 297 { 298 checks.add( check ); 299 } 300 else 301 { 302 updateCheckManager.checkMetadata( session, check ); 303 if ( check.isRequired() ) 304 { 305 checks.add( check ); 306 } 307 else if ( exception == null ) 308 { 309 exception = check.getException(); 310 } 311 } 312 } 313 314 if ( !checks.isEmpty() ) 315 { 316 RepositoryPolicy policy = getPolicy( session, repository, metadata.getNature() ); 317 318 // install path may be different from lookup path 319 File installFile = new File( 320 session.getLocalRepository().getBasedir(), 321 session.getLocalRepositoryManager().getPathForRemoteMetadata( 322 metadata, request.getRepository(), request.getRequestContext() ) ); 323 324 ResolveTask task = 325 new ResolveTask( session, trace, result, installFile, checks, policy.getChecksumPolicy() ); 326 tasks.add( task ); 327 } 328 else 329 { 330 result.setException( exception ); 331 if ( metadataFile != null ) 332 { 333 metadata = metadata.setFile( metadataFile ); 334 result.setMetadata( metadata ); 335 } 336 metadataResolved( session, trace, metadata, repository, result.getException() ); 337 } 338 } 339 340 if ( !tasks.isEmpty() ) 341 { 342 int threads = ConfigUtils.getInteger( session, 4, CONFIG_PROP_THREADS ); 343 Executor executor = getExecutor( Math.min( tasks.size(), threads ) ); 344 try 345 { 346 RunnableErrorForwarder errorForwarder = new RunnableErrorForwarder(); 347 348 for ( ResolveTask task : tasks ) 349 { 350 executor.execute( errorForwarder.wrap( task ) ); 351 } 352 353 errorForwarder.await(); 354 355 for ( ResolveTask task : tasks ) 356 { 357 task.result.setException( task.exception ); 358 } 359 } 360 finally 361 { 362 shutdown( executor ); 363 } 364 for ( ResolveTask task : tasks ) 365 { 366 Metadata metadata = task.request.getMetadata(); 367 // re-lookup metadata for resolve 368 LocalMetadataRequest localRequest = new LocalMetadataRequest( 369 metadata, task.request.getRepository(), task.request.getRequestContext() ); 370 File metadataFile = session.getLocalRepositoryManager().find( session, localRequest ).getFile(); 371 if ( metadataFile != null ) 372 { 373 metadata = metadata.setFile( metadataFile ); 374 task.result.setMetadata( metadata ); 375 } 376 if ( task.result.getException() == null ) 377 { 378 task.result.setUpdated( true ); 379 } 380 metadataResolved( session, task.trace, metadata, task.request.getRepository(), 381 task.result.getException() ); 382 } 383 } 384 385 return results; 386 } 387 388 private File getLocalFile( RepositorySystemSession session, Metadata metadata ) 389 { 390 LocalRepositoryManager lrm = session.getLocalRepositoryManager(); 391 LocalMetadataResult localResult = lrm.find( session, new LocalMetadataRequest( metadata, null, null ) ); 392 return localResult.getFile(); 393 } 394 395 private List<RemoteRepository> getEnabledSourceRepositories( RemoteRepository repository, Metadata.Nature nature ) 396 { 397 List<RemoteRepository> repositories = new ArrayList<>(); 398 399 if ( repository.isRepositoryManager() ) 400 { 401 for ( RemoteRepository repo : repository.getMirroredRepositories() ) 402 { 403 if ( isEnabled( repo, nature ) ) 404 { 405 repositories.add( repo ); 406 } 407 } 408 } 409 else if ( isEnabled( repository, nature ) ) 410 { 411 repositories.add( repository ); 412 } 413 414 return repositories; 415 } 416 417 private boolean isEnabled( RemoteRepository repository, Metadata.Nature nature ) 418 { 419 if ( !Metadata.Nature.SNAPSHOT.equals( nature ) && repository.getPolicy( false ).isEnabled() ) 420 { 421 return true; 422 } 423 if ( !Metadata.Nature.RELEASE.equals( nature ) && repository.getPolicy( true ).isEnabled() ) 424 { 425 return true; 426 } 427 return false; 428 } 429 430 private RepositoryPolicy getPolicy( RepositorySystemSession session, RemoteRepository repository, 431 Metadata.Nature nature ) 432 { 433 boolean releases = !Metadata.Nature.SNAPSHOT.equals( nature ); 434 boolean snapshots = !Metadata.Nature.RELEASE.equals( nature ); 435 return remoteRepositoryManager.getPolicy( session, repository, releases, snapshots ); 436 } 437 438 private void metadataResolving( RepositorySystemSession session, RequestTrace trace, Metadata metadata, 439 ArtifactRepository repository ) 440 { 441 RepositoryEvent.Builder event = new RepositoryEvent.Builder( session, EventType.METADATA_RESOLVING ); 442 event.setTrace( trace ); 443 event.setMetadata( metadata ); 444 event.setRepository( repository ); 445 446 repositoryEventDispatcher.dispatch( event.build() ); 447 } 448 449 private void metadataResolved( RepositorySystemSession session, RequestTrace trace, Metadata metadata, 450 ArtifactRepository repository, Exception exception ) 451 { 452 RepositoryEvent.Builder event = new RepositoryEvent.Builder( session, EventType.METADATA_RESOLVED ); 453 event.setTrace( trace ); 454 event.setMetadata( metadata ); 455 event.setRepository( repository ); 456 event.setException( exception ); 457 event.setFile( metadata.getFile() ); 458 459 repositoryEventDispatcher.dispatch( event.build() ); 460 } 461 462 private void metadataDownloading( RepositorySystemSession session, RequestTrace trace, Metadata metadata, 463 ArtifactRepository repository ) 464 { 465 RepositoryEvent.Builder event = new RepositoryEvent.Builder( session, EventType.METADATA_DOWNLOADING ); 466 event.setTrace( trace ); 467 event.setMetadata( metadata ); 468 event.setRepository( repository ); 469 470 repositoryEventDispatcher.dispatch( event.build() ); 471 } 472 473 private void metadataDownloaded( RepositorySystemSession session, RequestTrace trace, Metadata metadata, 474 ArtifactRepository repository, File file, Exception exception ) 475 { 476 RepositoryEvent.Builder event = new RepositoryEvent.Builder( session, EventType.METADATA_DOWNLOADED ); 477 event.setTrace( trace ); 478 event.setMetadata( metadata ); 479 event.setRepository( repository ); 480 event.setException( exception ); 481 event.setFile( file ); 482 483 repositoryEventDispatcher.dispatch( event.build() ); 484 } 485 486 private Executor getExecutor( int threads ) 487 { 488 if ( threads <= 1 ) 489 { 490 return new Executor() 491 { 492 public void execute( Runnable command ) 493 { 494 command.run(); 495 } 496 }; 497 } 498 else 499 { 500 return new ThreadPoolExecutor( threads, threads, 3, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(), 501 new WorkerThreadFactory( null ) ); 502 } 503 } 504 505 private void shutdown( Executor executor ) 506 { 507 if ( executor instanceof ExecutorService ) 508 { 509 ( (ExecutorService) executor ).shutdown(); 510 } 511 } 512 513 class ResolveTask 514 implements Runnable 515 { 516 517 final RepositorySystemSession session; 518 519 final RequestTrace trace; 520 521 final MetadataResult result; 522 523 final MetadataRequest request; 524 525 final File metadataFile; 526 527 final String policy; 528 529 final List<UpdateCheck<Metadata, MetadataTransferException>> checks; 530 531 volatile MetadataTransferException exception; 532 533 ResolveTask( RepositorySystemSession session, RequestTrace trace, MetadataResult result, 534 File metadataFile, List<UpdateCheck<Metadata, MetadataTransferException>> checks, 535 String policy ) 536 { 537 this.session = session; 538 this.trace = trace; 539 this.result = result; 540 this.request = result.getRequest(); 541 this.metadataFile = metadataFile; 542 this.policy = policy; 543 this.checks = checks; 544 } 545 546 public void run() 547 { 548 Metadata metadata = request.getMetadata(); 549 RemoteRepository requestRepository = request.getRepository(); 550 551 metadataDownloading( session, trace, metadata, requestRepository ); 552 553 try 554 { 555 List<RemoteRepository> repositories = new ArrayList<>(); 556 for ( UpdateCheck<Metadata, MetadataTransferException> check : checks ) 557 { 558 repositories.add( check.getAuthoritativeRepository() ); 559 } 560 561 MetadataDownload download = new MetadataDownload(); 562 download.setMetadata( metadata ); 563 download.setRequestContext( request.getRequestContext() ); 564 download.setFile( metadataFile ); 565 download.setChecksumPolicy( policy ); 566 download.setRepositories( repositories ); 567 download.setListener( SafeTransferListener.wrap( session ) ); 568 download.setTrace( trace ); 569 570 try ( RepositoryConnector connector = 571 repositoryConnectorProvider.newRepositoryConnector( session, requestRepository ) ) 572 { 573 connector.get( null, Arrays.asList( download ) ); 574 } 575 576 exception = download.getException(); 577 578 if ( exception == null ) 579 { 580 581 List<String> contexts = Collections.singletonList( request.getRequestContext() ); 582 LocalMetadataRegistration registration = 583 new LocalMetadataRegistration( metadata, requestRepository, contexts ); 584 585 session.getLocalRepositoryManager().add( session, registration ); 586 } 587 else if ( request.isDeleteLocalCopyIfMissing() && exception instanceof MetadataNotFoundException ) 588 { 589 download.getFile().delete(); 590 } 591 } 592 catch ( NoRepositoryConnectorException e ) 593 { 594 exception = new MetadataTransferException( metadata, requestRepository, e ); 595 } 596 597 /* 598 * NOTE: Touch after registration with local repo to ensure concurrent resolution is not rejected with 599 * "already updated" via session data when actual update to local repo is still pending. 600 */ 601 for ( UpdateCheck<Metadata, MetadataTransferException> check : checks ) 602 { 603 updateCheckManager.touchMetadata( session, check.setException( exception ) ); 604 } 605 606 metadataDownloaded( session, trace, metadata, requestRepository, metadataFile, exception ); 607 } 608 609 } 610 611}