1 package org.eclipse.aether.internal.impl;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import java.util.ArrayList;
23 import java.util.Collection;
24 import java.util.List;
25 import static java.util.Objects.requireNonNull;
26
27 import javax.inject.Inject;
28 import javax.inject.Named;
29 import javax.inject.Singleton;
30
31 import org.eclipse.aether.RepositorySystem;
32 import org.eclipse.aether.RepositorySystemSession;
33 import org.eclipse.aether.RequestTrace;
34 import org.eclipse.aether.SyncContext;
35 import org.eclipse.aether.artifact.Artifact;
36 import org.eclipse.aether.collection.CollectRequest;
37 import org.eclipse.aether.collection.CollectResult;
38 import org.eclipse.aether.collection.DependencyCollectionException;
39 import org.eclipse.aether.deployment.DeployRequest;
40 import org.eclipse.aether.deployment.DeployResult;
41 import org.eclipse.aether.deployment.DeploymentException;
42 import org.eclipse.aether.graph.DependencyFilter;
43 import org.eclipse.aether.graph.DependencyVisitor;
44 import org.eclipse.aether.impl.ArtifactDescriptorReader;
45 import org.eclipse.aether.impl.ArtifactResolver;
46 import org.eclipse.aether.impl.DependencyCollector;
47 import org.eclipse.aether.impl.Deployer;
48 import org.eclipse.aether.impl.Installer;
49 import org.eclipse.aether.impl.LocalRepositoryProvider;
50 import org.eclipse.aether.impl.MetadataResolver;
51 import org.eclipse.aether.impl.RemoteRepositoryManager;
52 import org.eclipse.aether.spi.synccontext.SyncContextFactory;
53 import org.eclipse.aether.impl.VersionRangeResolver;
54 import org.eclipse.aether.impl.VersionResolver;
55 import org.eclipse.aether.installation.InstallRequest;
56 import org.eclipse.aether.installation.InstallResult;
57 import org.eclipse.aether.installation.InstallationException;
58 import org.eclipse.aether.repository.Authentication;
59 import org.eclipse.aether.repository.LocalRepository;
60 import org.eclipse.aether.repository.LocalRepositoryManager;
61 import org.eclipse.aether.repository.NoLocalRepositoryManagerException;
62 import org.eclipse.aether.repository.Proxy;
63 import org.eclipse.aether.repository.RemoteRepository;
64 import org.eclipse.aether.resolution.ArtifactDescriptorException;
65 import org.eclipse.aether.resolution.ArtifactDescriptorRequest;
66 import org.eclipse.aether.resolution.ArtifactDescriptorResult;
67 import org.eclipse.aether.resolution.ArtifactRequest;
68 import org.eclipse.aether.resolution.ArtifactResolutionException;
69 import org.eclipse.aether.resolution.ArtifactResult;
70 import org.eclipse.aether.resolution.DependencyRequest;
71 import org.eclipse.aether.resolution.DependencyResolutionException;
72 import org.eclipse.aether.resolution.DependencyResult;
73 import org.eclipse.aether.resolution.MetadataRequest;
74 import org.eclipse.aether.resolution.MetadataResult;
75 import org.eclipse.aether.resolution.VersionRangeRequest;
76 import org.eclipse.aether.resolution.VersionRangeResolutionException;
77 import org.eclipse.aether.resolution.VersionRangeResult;
78 import org.eclipse.aether.resolution.VersionRequest;
79 import org.eclipse.aether.resolution.VersionResolutionException;
80 import org.eclipse.aether.resolution.VersionResult;
81 import org.eclipse.aether.spi.locator.Service;
82 import org.eclipse.aether.spi.locator.ServiceLocator;
83 import org.eclipse.aether.util.graph.visitor.FilteringDependencyVisitor;
84 import org.eclipse.aether.util.graph.visitor.TreeDependencyVisitor;
85
86
87
88 @Singleton
89 @Named
90 public class DefaultRepositorySystem
91 implements RepositorySystem, Service
92 {
93
94 private VersionResolver versionResolver;
95
96 private VersionRangeResolver versionRangeResolver;
97
98 private ArtifactResolver artifactResolver;
99
100 private MetadataResolver metadataResolver;
101
102 private ArtifactDescriptorReader artifactDescriptorReader;
103
104 private DependencyCollector dependencyCollector;
105
106 private Installer installer;
107
108 private Deployer deployer;
109
110 private LocalRepositoryProvider localRepositoryProvider;
111
112 private SyncContextFactory syncContextFactory;
113
114 private RemoteRepositoryManager remoteRepositoryManager;
115
116 public DefaultRepositorySystem()
117 {
118
119 }
120
121 @SuppressWarnings( "checkstyle:parameternumber" )
122 @Inject
123 DefaultRepositorySystem( VersionResolver versionResolver, VersionRangeResolver versionRangeResolver,
124 ArtifactResolver artifactResolver, MetadataResolver metadataResolver,
125 ArtifactDescriptorReader artifactDescriptorReader,
126 DependencyCollector dependencyCollector, Installer installer, Deployer deployer,
127 LocalRepositoryProvider localRepositoryProvider, SyncContextFactory syncContextFactory,
128 RemoteRepositoryManager remoteRepositoryManager )
129 {
130 setVersionResolver( versionResolver );
131 setVersionRangeResolver( versionRangeResolver );
132 setArtifactResolver( artifactResolver );
133 setMetadataResolver( metadataResolver );
134 setArtifactDescriptorReader( artifactDescriptorReader );
135 setDependencyCollector( dependencyCollector );
136 setInstaller( installer );
137 setDeployer( deployer );
138 setLocalRepositoryProvider( localRepositoryProvider );
139 setSyncContextFactory( syncContextFactory );
140 setRemoteRepositoryManager( remoteRepositoryManager );
141 }
142
143 public void initService( ServiceLocator locator )
144 {
145 setVersionResolver( locator.getService( VersionResolver.class ) );
146 setVersionRangeResolver( locator.getService( VersionRangeResolver.class ) );
147 setArtifactResolver( locator.getService( ArtifactResolver.class ) );
148 setMetadataResolver( locator.getService( MetadataResolver.class ) );
149 setArtifactDescriptorReader( locator.getService( ArtifactDescriptorReader.class ) );
150 setDependencyCollector( locator.getService( DependencyCollector.class ) );
151 setInstaller( locator.getService( Installer.class ) );
152 setDeployer( locator.getService( Deployer.class ) );
153 setLocalRepositoryProvider( locator.getService( LocalRepositoryProvider.class ) );
154 setRemoteRepositoryManager( locator.getService( RemoteRepositoryManager.class ) );
155 setSyncContextFactory( locator.getService( SyncContextFactory.class ) );
156 }
157
158
159
160
161 @Deprecated
162 public DefaultRepositorySystem setLoggerFactory( org.eclipse.aether.spi.log.LoggerFactory loggerFactory )
163 {
164
165 return this;
166 }
167
168 public DefaultRepositorySystem setVersionResolver( VersionResolver versionResolver )
169 {
170 this.versionResolver = requireNonNull( versionResolver, "version resolver cannot be null" );
171 return this;
172 }
173
174 public DefaultRepositorySystem setVersionRangeResolver( VersionRangeResolver versionRangeResolver )
175 {
176 this.versionRangeResolver = requireNonNull(
177 versionRangeResolver, "version range resolver cannot be null" );
178 return this;
179 }
180
181 public DefaultRepositorySystem setArtifactResolver( ArtifactResolver artifactResolver )
182 {
183 this.artifactResolver = requireNonNull( artifactResolver, "artifact resolver cannot be null" );
184 return this;
185 }
186
187 public DefaultRepositorySystem setMetadataResolver( MetadataResolver metadataResolver )
188 {
189 this.metadataResolver = requireNonNull( metadataResolver, "metadata resolver cannot be null" );
190 return this;
191 }
192
193 public DefaultRepositorySystem setArtifactDescriptorReader( ArtifactDescriptorReader artifactDescriptorReader )
194 {
195 this.artifactDescriptorReader = requireNonNull(
196 artifactDescriptorReader, "artifact descriptor reader cannot be null" );
197 return this;
198 }
199
200 public DefaultRepositorySystem setDependencyCollector( DependencyCollector dependencyCollector )
201 {
202 this.dependencyCollector = requireNonNull( dependencyCollector, "dependency collector cannot be null" );
203 return this;
204 }
205
206 public DefaultRepositorySystem setInstaller( Installer installer )
207 {
208 this.installer = requireNonNull( installer, "installer cannot be null" );
209 return this;
210 }
211
212 public DefaultRepositorySystem setDeployer( Deployer deployer )
213 {
214 this.deployer = requireNonNull( deployer, "deployer cannot be null" );
215 return this;
216 }
217
218 public DefaultRepositorySystem setLocalRepositoryProvider( LocalRepositoryProvider localRepositoryProvider )
219 {
220 this.localRepositoryProvider = requireNonNull(
221 localRepositoryProvider, "local repository provider cannot be null" );
222 return this;
223 }
224
225 public DefaultRepositorySystem setSyncContextFactory( SyncContextFactory syncContextFactory )
226 {
227 this.syncContextFactory = requireNonNull( syncContextFactory, "sync context factory cannot be null" );
228 return this;
229 }
230
231 public DefaultRepositorySystem setRemoteRepositoryManager( RemoteRepositoryManager remoteRepositoryManager )
232 {
233 this.remoteRepositoryManager = requireNonNull(
234 remoteRepositoryManager, "remote repository provider cannot be null" );
235 return this;
236 }
237
238 public VersionResult resolveVersion( RepositorySystemSession session, VersionRequest request )
239 throws VersionResolutionException
240 {
241 validateSession( session );
242 requireNonNull( request, "request cannot be null" );
243
244 return versionResolver.resolveVersion( session, request );
245 }
246
247 public VersionRangeResult resolveVersionRange( RepositorySystemSession session, VersionRangeRequest request )
248 throws VersionRangeResolutionException
249 {
250 validateSession( session );
251 requireNonNull( request, "request cannot be null" );
252
253 return versionRangeResolver.resolveVersionRange( session, request );
254 }
255
256 public ArtifactDescriptorResult readArtifactDescriptor( RepositorySystemSession session,
257 ArtifactDescriptorRequest request )
258 throws ArtifactDescriptorException
259 {
260 validateSession( session );
261 requireNonNull( request, "request cannot be null" );
262
263 return artifactDescriptorReader.readArtifactDescriptor( session, request );
264 }
265
266 public ArtifactResult resolveArtifact( RepositorySystemSession session, ArtifactRequest request )
267 throws ArtifactResolutionException
268 {
269 validateSession( session );
270 requireNonNull( session, "session cannot be null" );
271
272 return artifactResolver.resolveArtifact( session, request );
273 }
274
275 public List<ArtifactResult> resolveArtifacts( RepositorySystemSession session,
276 Collection<? extends ArtifactRequest> requests )
277 throws ArtifactResolutionException
278 {
279 validateSession( session );
280 requireNonNull( requests, "requests cannot be null" );
281
282 return artifactResolver.resolveArtifacts( session, requests );
283 }
284
285 public List<MetadataResult> resolveMetadata( RepositorySystemSession session,
286 Collection<? extends MetadataRequest> requests )
287 {
288 validateSession( session );
289 requireNonNull( requests, "requests cannot be null" );
290
291 return metadataResolver.resolveMetadata( session, requests );
292 }
293
294 public CollectResult collectDependencies( RepositorySystemSession session, CollectRequest request )
295 throws DependencyCollectionException
296 {
297 validateSession( session );
298 requireNonNull( request, "request cannot be null" );
299
300 return dependencyCollector.collectDependencies( session, request );
301 }
302
303 public DependencyResult resolveDependencies( RepositorySystemSession session, DependencyRequest request )
304 throws DependencyResolutionException
305 {
306 validateSession( session );
307 requireNonNull( request, "request cannot be null" );
308
309 RequestTrace trace = RequestTrace.newChild( request.getTrace(), request );
310
311 DependencyResult result = new DependencyResult( request );
312
313 DependencyCollectionException dce = null;
314 ArtifactResolutionException are = null;
315
316 if ( request.getRoot() != null )
317 {
318 result.setRoot( request.getRoot() );
319 }
320 else if ( request.getCollectRequest() != null )
321 {
322 CollectResult collectResult;
323 try
324 {
325 request.getCollectRequest().setTrace( trace );
326 collectResult = dependencyCollector.collectDependencies( session, request.getCollectRequest() );
327 }
328 catch ( DependencyCollectionException e )
329 {
330 dce = e;
331 collectResult = e.getResult();
332 }
333 result.setRoot( collectResult.getRoot() );
334 result.setCycles( collectResult.getCycles() );
335 result.setCollectExceptions( collectResult.getExceptions() );
336 }
337 else
338 {
339 throw new NullPointerException( "dependency node and collect request cannot be null" );
340 }
341
342 ArtifactRequestBuilder builder = new ArtifactRequestBuilder( trace );
343 DependencyFilter filter = request.getFilter();
344 DependencyVisitor visitor = ( filter != null ) ? new FilteringDependencyVisitor( builder, filter ) : builder;
345 visitor = new TreeDependencyVisitor( visitor );
346
347 if ( result.getRoot() != null )
348 {
349 result.getRoot().accept( visitor );
350 }
351
352 List<ArtifactRequest> requests = builder.getRequests();
353
354 List<ArtifactResult> results;
355 try
356 {
357 results = artifactResolver.resolveArtifacts( session, requests );
358 }
359 catch ( ArtifactResolutionException e )
360 {
361 are = e;
362 results = e.getResults();
363 }
364 result.setArtifactResults( results );
365
366 updateNodesWithResolvedArtifacts( results );
367
368 if ( dce != null )
369 {
370 throw new DependencyResolutionException( result, dce );
371 }
372 else if ( are != null )
373 {
374 throw new DependencyResolutionException( result, are );
375 }
376
377 return result;
378 }
379
380 private void updateNodesWithResolvedArtifacts( List<ArtifactResult> results )
381 {
382 for ( ArtifactResult result : results )
383 {
384 Artifact artifact = result.getArtifact();
385 if ( artifact != null )
386 {
387 result.getRequest().getDependencyNode().setArtifact( artifact );
388 }
389 }
390 }
391
392 public InstallResult install( RepositorySystemSession session, InstallRequest request )
393 throws InstallationException
394 {
395 validateSession( session );
396 requireNonNull( request, "request cannot be null" );
397
398 return installer.install( session, request );
399 }
400
401 public DeployResult deploy( RepositorySystemSession session, DeployRequest request )
402 throws DeploymentException
403 {
404 validateSession( session );
405 requireNonNull( request, "request cannot be null" );
406
407 return deployer.deploy( session, request );
408 }
409
410 public LocalRepositoryManager newLocalRepositoryManager( RepositorySystemSession session,
411 LocalRepository localRepository )
412 {
413 requireNonNull( session, "session cannot be null" );
414 requireNonNull( localRepository, "localRepository cannot be null" );
415
416 try
417 {
418 return localRepositoryProvider.newLocalRepositoryManager( session, localRepository );
419 }
420 catch ( NoLocalRepositoryManagerException e )
421 {
422 throw new IllegalArgumentException( e.getMessage(), e );
423 }
424 }
425
426 public SyncContext newSyncContext( RepositorySystemSession session, boolean shared )
427 {
428 validateSession( session );
429 return syncContextFactory.newInstance( session, shared );
430 }
431
432 public List<RemoteRepository> newResolutionRepositories( RepositorySystemSession session,
433 List<RemoteRepository> repositories )
434 {
435 validateSession( session );
436 validateRepositories( repositories );
437
438 repositories =
439 remoteRepositoryManager.aggregateRepositories( session, new ArrayList<RemoteRepository>(), repositories,
440 true );
441 return repositories;
442 }
443
444 public RemoteRepository newDeploymentRepository( RepositorySystemSession session, RemoteRepository repository )
445 {
446 validateSession( session );
447 requireNonNull( repository, "repository cannot be null" );
448
449 RemoteRepository.Builder builder = new RemoteRepository.Builder( repository );
450 Authentication auth = session.getAuthenticationSelector().getAuthentication( repository );
451 builder.setAuthentication( auth );
452 Proxy proxy = session.getProxySelector().getProxy( repository );
453 builder.setProxy( proxy );
454 return builder.build();
455 }
456
457 private void validateSession( RepositorySystemSession session )
458 {
459 requireNonNull( session, "repository system session cannot be null" );
460 invalidSession( session.getLocalRepositoryManager(), "local repository manager" );
461 invalidSession( session.getSystemProperties(), "system properties" );
462 invalidSession( session.getUserProperties(), "user properties" );
463 invalidSession( session.getConfigProperties(), "config properties" );
464 invalidSession( session.getMirrorSelector(), "mirror selector" );
465 invalidSession( session.getProxySelector(), "proxy selector" );
466 invalidSession( session.getAuthenticationSelector(), "authentication selector" );
467 invalidSession( session.getArtifactTypeRegistry(), "artifact type registry" );
468 invalidSession( session.getData(), "data" );
469 }
470
471 private void validateRepositories( List<RemoteRepository> repositories )
472 {
473 requireNonNull( repositories, "repositories cannot be null" );
474 for ( RemoteRepository repository: repositories )
475 {
476 requireNonNull( repository, "repository cannot be null" );
477 }
478 }
479
480 private void invalidSession( Object obj, String name )
481 {
482 requireNonNull( obj, "repository system session's " + name + " cannot be null" );
483 }
484
485 }