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