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.util.ArrayList; 023import java.util.Collection; 024import java.util.List; 025import static java.util.Objects.requireNonNull; 026 027import javax.inject.Inject; 028import javax.inject.Named; 029 030import org.eclipse.aether.RepositorySystem; 031import org.eclipse.aether.RepositorySystemSession; 032import org.eclipse.aether.RequestTrace; 033import org.eclipse.aether.SyncContext; 034import org.eclipse.aether.artifact.Artifact; 035import org.eclipse.aether.collection.CollectRequest; 036import org.eclipse.aether.collection.CollectResult; 037import org.eclipse.aether.collection.DependencyCollectionException; 038import org.eclipse.aether.deployment.DeployRequest; 039import org.eclipse.aether.deployment.DeployResult; 040import org.eclipse.aether.deployment.DeploymentException; 041import org.eclipse.aether.graph.DependencyFilter; 042import org.eclipse.aether.graph.DependencyVisitor; 043import org.eclipse.aether.impl.ArtifactDescriptorReader; 044import org.eclipse.aether.impl.ArtifactResolver; 045import org.eclipse.aether.impl.DependencyCollector; 046import org.eclipse.aether.impl.Deployer; 047import org.eclipse.aether.impl.Installer; 048import org.eclipse.aether.impl.LocalRepositoryProvider; 049import org.eclipse.aether.impl.MetadataResolver; 050import org.eclipse.aether.impl.RemoteRepositoryManager; 051import org.eclipse.aether.impl.SyncContextFactory; 052import org.eclipse.aether.impl.VersionRangeResolver; 053import org.eclipse.aether.impl.VersionResolver; 054import org.eclipse.aether.installation.InstallRequest; 055import org.eclipse.aether.installation.InstallResult; 056import org.eclipse.aether.installation.InstallationException; 057import org.eclipse.aether.repository.Authentication; 058import org.eclipse.aether.repository.LocalRepository; 059import org.eclipse.aether.repository.LocalRepositoryManager; 060import org.eclipse.aether.repository.NoLocalRepositoryManagerException; 061import org.eclipse.aether.repository.Proxy; 062import org.eclipse.aether.repository.RemoteRepository; 063import org.eclipse.aether.resolution.ArtifactDescriptorException; 064import org.eclipse.aether.resolution.ArtifactDescriptorRequest; 065import org.eclipse.aether.resolution.ArtifactDescriptorResult; 066import org.eclipse.aether.resolution.ArtifactRequest; 067import org.eclipse.aether.resolution.ArtifactResolutionException; 068import org.eclipse.aether.resolution.ArtifactResult; 069import org.eclipse.aether.resolution.DependencyRequest; 070import org.eclipse.aether.resolution.DependencyResolutionException; 071import org.eclipse.aether.resolution.DependencyResult; 072import org.eclipse.aether.resolution.MetadataRequest; 073import org.eclipse.aether.resolution.MetadataResult; 074import org.eclipse.aether.resolution.VersionRangeRequest; 075import org.eclipse.aether.resolution.VersionRangeResolutionException; 076import org.eclipse.aether.resolution.VersionRangeResult; 077import org.eclipse.aether.resolution.VersionRequest; 078import org.eclipse.aether.resolution.VersionResolutionException; 079import org.eclipse.aether.resolution.VersionResult; 080import org.eclipse.aether.spi.locator.Service; 081import org.eclipse.aether.spi.locator.ServiceLocator; 082import org.eclipse.aether.util.graph.visitor.FilteringDependencyVisitor; 083import org.eclipse.aether.util.graph.visitor.TreeDependencyVisitor; 084 085/** 086 */ 087@Named 088public class DefaultRepositorySystem 089 implements RepositorySystem, Service 090{ 091 092 private VersionResolver versionResolver; 093 094 private VersionRangeResolver versionRangeResolver; 095 096 private ArtifactResolver artifactResolver; 097 098 private MetadataResolver metadataResolver; 099 100 private ArtifactDescriptorReader artifactDescriptorReader; 101 102 private DependencyCollector dependencyCollector; 103 104 private Installer installer; 105 106 private Deployer deployer; 107 108 private LocalRepositoryProvider localRepositoryProvider; 109 110 private SyncContextFactory syncContextFactory; 111 112 private RemoteRepositoryManager remoteRepositoryManager; 113 114 public DefaultRepositorySystem() 115 { 116 // enables default constructor 117 } 118 119 @SuppressWarnings( "checkstyle:parameternumber" ) 120 @Inject 121 DefaultRepositorySystem( VersionResolver versionResolver, VersionRangeResolver versionRangeResolver, 122 ArtifactResolver artifactResolver, MetadataResolver metadataResolver, 123 ArtifactDescriptorReader artifactDescriptorReader, 124 DependencyCollector dependencyCollector, Installer installer, Deployer deployer, 125 LocalRepositoryProvider localRepositoryProvider, SyncContextFactory syncContextFactory, 126 RemoteRepositoryManager remoteRepositoryManager ) 127 { 128 setVersionResolver( versionResolver ); 129 setVersionRangeResolver( versionRangeResolver ); 130 setArtifactResolver( artifactResolver ); 131 setMetadataResolver( metadataResolver ); 132 setArtifactDescriptorReader( artifactDescriptorReader ); 133 setDependencyCollector( dependencyCollector ); 134 setInstaller( installer ); 135 setDeployer( deployer ); 136 setLocalRepositoryProvider( localRepositoryProvider ); 137 setSyncContextFactory( syncContextFactory ); 138 setRemoteRepositoryManager( remoteRepositoryManager ); 139 } 140 141 public void initService( ServiceLocator locator ) 142 { 143 setVersionResolver( locator.getService( VersionResolver.class ) ); 144 setVersionRangeResolver( locator.getService( VersionRangeResolver.class ) ); 145 setArtifactResolver( locator.getService( ArtifactResolver.class ) ); 146 setMetadataResolver( locator.getService( MetadataResolver.class ) ); 147 setArtifactDescriptorReader( locator.getService( ArtifactDescriptorReader.class ) ); 148 setDependencyCollector( locator.getService( DependencyCollector.class ) ); 149 setInstaller( locator.getService( Installer.class ) ); 150 setDeployer( locator.getService( Deployer.class ) ); 151 setLocalRepositoryProvider( locator.getService( LocalRepositoryProvider.class ) ); 152 setRemoteRepositoryManager( locator.getService( RemoteRepositoryManager.class ) ); 153 setSyncContextFactory( locator.getService( SyncContextFactory.class ) ); 154 } 155 156 /** 157 * @deprecated not used any more since MRESOLVER-36 move to slf4j, added back in MRESOLVER-64 for compatibility 158 */ 159 @Deprecated 160 public DefaultRepositorySystem setLoggerFactory( org.eclipse.aether.spi.log.LoggerFactory loggerFactory ) 161 { 162 // this.logger = NullLoggerFactory.getSafeLogger( loggerFactory, getClass() ); 163 return this; 164 } 165 166 public DefaultRepositorySystem setVersionResolver( VersionResolver versionResolver ) 167 { 168 this.versionResolver = requireNonNull( versionResolver, "version resolver cannot be null" ); 169 return this; 170 } 171 172 public DefaultRepositorySystem setVersionRangeResolver( VersionRangeResolver versionRangeResolver ) 173 { 174 this.versionRangeResolver = requireNonNull( 175 versionRangeResolver, "version range resolver cannot be null" ); 176 return this; 177 } 178 179 public DefaultRepositorySystem setArtifactResolver( ArtifactResolver artifactResolver ) 180 { 181 this.artifactResolver = requireNonNull( artifactResolver, "artifact resolver cannot be null" ); 182 return this; 183 } 184 185 public DefaultRepositorySystem setMetadataResolver( MetadataResolver metadataResolver ) 186 { 187 this.metadataResolver = requireNonNull( metadataResolver, "metadata resolver cannot be null" ); 188 return this; 189 } 190 191 public DefaultRepositorySystem setArtifactDescriptorReader( ArtifactDescriptorReader artifactDescriptorReader ) 192 { 193 this.artifactDescriptorReader = requireNonNull( 194 artifactDescriptorReader, "artifact descriptor reader cannot be null" ); 195 return this; 196 } 197 198 public DefaultRepositorySystem setDependencyCollector( DependencyCollector dependencyCollector ) 199 { 200 this.dependencyCollector = requireNonNull( dependencyCollector, "dependency collector cannot be null" ); 201 return this; 202 } 203 204 public DefaultRepositorySystem setInstaller( Installer installer ) 205 { 206 this.installer = requireNonNull( installer, "installer cannot be null" ); 207 return this; 208 } 209 210 public DefaultRepositorySystem setDeployer( Deployer deployer ) 211 { 212 this.deployer = requireNonNull( deployer, "deployer cannot be null" ); 213 return this; 214 } 215 216 public DefaultRepositorySystem setLocalRepositoryProvider( LocalRepositoryProvider localRepositoryProvider ) 217 { 218 this.localRepositoryProvider = requireNonNull( 219 localRepositoryProvider, "local repository provider cannot be null" ); 220 return this; 221 } 222 223 public DefaultRepositorySystem setSyncContextFactory( SyncContextFactory syncContextFactory ) 224 { 225 this.syncContextFactory = requireNonNull( syncContextFactory, "sync context factory cannot be null" ); 226 return this; 227 } 228 229 public DefaultRepositorySystem setRemoteRepositoryManager( RemoteRepositoryManager remoteRepositoryManager ) 230 { 231 this.remoteRepositoryManager = requireNonNull( 232 remoteRepositoryManager, "remote repository provider cannot be null" ); 233 return this; 234 } 235 236 public VersionResult resolveVersion( RepositorySystemSession session, VersionRequest request ) 237 throws VersionResolutionException 238 { 239 validateSession( session ); 240 return versionResolver.resolveVersion( session, request ); 241 } 242 243 public VersionRangeResult resolveVersionRange( RepositorySystemSession session, VersionRangeRequest request ) 244 throws VersionRangeResolutionException 245 { 246 validateSession( session ); 247 return versionRangeResolver.resolveVersionRange( session, request ); 248 } 249 250 public ArtifactDescriptorResult readArtifactDescriptor( RepositorySystemSession session, 251 ArtifactDescriptorRequest request ) 252 throws ArtifactDescriptorException 253 { 254 validateSession( session ); 255 return artifactDescriptorReader.readArtifactDescriptor( session, request ); 256 } 257 258 public ArtifactResult resolveArtifact( RepositorySystemSession session, ArtifactRequest request ) 259 throws ArtifactResolutionException 260 { 261 validateSession( session ); 262 return artifactResolver.resolveArtifact( session, request ); 263 } 264 265 public List<ArtifactResult> resolveArtifacts( RepositorySystemSession session, 266 Collection<? extends ArtifactRequest> requests ) 267 throws ArtifactResolutionException 268 { 269 validateSession( session ); 270 return artifactResolver.resolveArtifacts( session, requests ); 271 } 272 273 public List<MetadataResult> resolveMetadata( RepositorySystemSession session, 274 Collection<? extends MetadataRequest> requests ) 275 { 276 validateSession( session ); 277 return metadataResolver.resolveMetadata( session, requests ); 278 } 279 280 public CollectResult collectDependencies( RepositorySystemSession session, CollectRequest request ) 281 throws DependencyCollectionException 282 { 283 validateSession( session ); 284 return dependencyCollector.collectDependencies( session, request ); 285 } 286 287 public DependencyResult resolveDependencies( RepositorySystemSession session, DependencyRequest request ) 288 throws DependencyResolutionException 289 { 290 validateSession( session ); 291 292 RequestTrace trace = RequestTrace.newChild( request.getTrace(), request ); 293 294 DependencyResult result = new DependencyResult( request ); 295 296 DependencyCollectionException dce = null; 297 ArtifactResolutionException are = null; 298 299 if ( request.getRoot() != null ) 300 { 301 result.setRoot( request.getRoot() ); 302 } 303 else if ( request.getCollectRequest() != null ) 304 { 305 CollectResult collectResult; 306 try 307 { 308 request.getCollectRequest().setTrace( trace ); 309 collectResult = dependencyCollector.collectDependencies( session, request.getCollectRequest() ); 310 } 311 catch ( DependencyCollectionException e ) 312 { 313 dce = e; 314 collectResult = e.getResult(); 315 } 316 result.setRoot( collectResult.getRoot() ); 317 result.setCycles( collectResult.getCycles() ); 318 result.setCollectExceptions( collectResult.getExceptions() ); 319 } 320 else 321 { 322 throw new NullPointerException( "dependency node and collect request cannot be null" ); 323 } 324 325 ArtifactRequestBuilder builder = new ArtifactRequestBuilder( trace ); 326 DependencyFilter filter = request.getFilter(); 327 DependencyVisitor visitor = ( filter != null ) ? new FilteringDependencyVisitor( builder, filter ) : builder; 328 visitor = new TreeDependencyVisitor( visitor ); 329 330 if ( result.getRoot() != null ) 331 { 332 result.getRoot().accept( visitor ); 333 } 334 335 List<ArtifactRequest> requests = builder.getRequests(); 336 337 List<ArtifactResult> results; 338 try 339 { 340 results = artifactResolver.resolveArtifacts( session, requests ); 341 } 342 catch ( ArtifactResolutionException e ) 343 { 344 are = e; 345 results = e.getResults(); 346 } 347 result.setArtifactResults( results ); 348 349 updateNodesWithResolvedArtifacts( results ); 350 351 if ( dce != null ) 352 { 353 throw new DependencyResolutionException( result, dce ); 354 } 355 else if ( are != null ) 356 { 357 throw new DependencyResolutionException( result, are ); 358 } 359 360 return result; 361 } 362 363 private void updateNodesWithResolvedArtifacts( List<ArtifactResult> results ) 364 { 365 for ( ArtifactResult result : results ) 366 { 367 Artifact artifact = result.getArtifact(); 368 if ( artifact != null ) 369 { 370 result.getRequest().getDependencyNode().setArtifact( artifact ); 371 } 372 } 373 } 374 375 public InstallResult install( RepositorySystemSession session, InstallRequest request ) 376 throws InstallationException 377 { 378 validateSession( session ); 379 return installer.install( session, request ); 380 } 381 382 public DeployResult deploy( RepositorySystemSession session, DeployRequest request ) 383 throws DeploymentException 384 { 385 validateSession( session ); 386 return deployer.deploy( session, request ); 387 } 388 389 public LocalRepositoryManager newLocalRepositoryManager( RepositorySystemSession session, 390 LocalRepository localRepository ) 391 { 392 try 393 { 394 return localRepositoryProvider.newLocalRepositoryManager( session, localRepository ); 395 } 396 catch ( NoLocalRepositoryManagerException e ) 397 { 398 throw new IllegalArgumentException( e.getMessage(), e ); 399 } 400 } 401 402 public SyncContext newSyncContext( RepositorySystemSession session, boolean shared ) 403 { 404 validateSession( session ); 405 return syncContextFactory.newInstance( session, shared ); 406 } 407 408 public List<RemoteRepository> newResolutionRepositories( RepositorySystemSession session, 409 List<RemoteRepository> repositories ) 410 { 411 validateSession( session ); 412 repositories = 413 remoteRepositoryManager.aggregateRepositories( session, new ArrayList<RemoteRepository>(), repositories, 414 true ); 415 return repositories; 416 } 417 418 public RemoteRepository newDeploymentRepository( RepositorySystemSession session, RemoteRepository repository ) 419 { 420 validateSession( session ); 421 RemoteRepository.Builder builder = new RemoteRepository.Builder( repository ); 422 Authentication auth = session.getAuthenticationSelector().getAuthentication( repository ); 423 builder.setAuthentication( auth ); 424 Proxy proxy = session.getProxySelector().getProxy( repository ); 425 builder.setProxy( proxy ); 426 return builder.build(); 427 } 428 429 private void validateSession( RepositorySystemSession session ) 430 { 431 requireNonNull( session, "repository system session cannot be null" ); 432 invalidSession( session.getLocalRepositoryManager(), "local repository manager" ); 433 invalidSession( session.getSystemProperties(), "system properties" ); 434 invalidSession( session.getUserProperties(), "user properties" ); 435 invalidSession( session.getConfigProperties(), "config properties" ); 436 invalidSession( session.getMirrorSelector(), "mirror selector" ); 437 invalidSession( session.getProxySelector(), "proxy selector" ); 438 invalidSession( session.getAuthenticationSelector(), "authentication selector" ); 439 invalidSession( session.getArtifactTypeRegistry(), "artifact type registry" ); 440 invalidSession( session.getData(), "data" ); 441 } 442 443 private void invalidSession( Object obj, String name ) 444 { 445 requireNonNull( obj, "repository system session's " + name + " cannot be null" ); 446 } 447 448}