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
30 import org.eclipse.aether.RepositorySystem;
31 import org.eclipse.aether.RepositorySystemSession;
32 import org.eclipse.aether.RequestTrace;
33 import org.eclipse.aether.SyncContext;
34 import org.eclipse.aether.artifact.Artifact;
35 import org.eclipse.aether.collection.CollectRequest;
36 import org.eclipse.aether.collection.CollectResult;
37 import org.eclipse.aether.collection.DependencyCollectionException;
38 import org.eclipse.aether.deployment.DeployRequest;
39 import org.eclipse.aether.deployment.DeployResult;
40 import org.eclipse.aether.deployment.DeploymentException;
41 import org.eclipse.aether.graph.DependencyFilter;
42 import org.eclipse.aether.graph.DependencyVisitor;
43 import org.eclipse.aether.impl.ArtifactDescriptorReader;
44 import org.eclipse.aether.impl.ArtifactResolver;
45 import org.eclipse.aether.impl.DependencyCollector;
46 import org.eclipse.aether.impl.Deployer;
47 import org.eclipse.aether.impl.Installer;
48 import org.eclipse.aether.impl.LocalRepositoryProvider;
49 import org.eclipse.aether.impl.MetadataResolver;
50 import org.eclipse.aether.impl.RemoteRepositoryManager;
51 import org.eclipse.aether.impl.SyncContextFactory;
52 import org.eclipse.aether.impl.VersionRangeResolver;
53 import org.eclipse.aether.impl.VersionResolver;
54 import org.eclipse.aether.installation.InstallRequest;
55 import org.eclipse.aether.installation.InstallResult;
56 import org.eclipse.aether.installation.InstallationException;
57 import org.eclipse.aether.repository.Authentication;
58 import org.eclipse.aether.repository.LocalRepository;
59 import org.eclipse.aether.repository.LocalRepositoryManager;
60 import org.eclipse.aether.repository.NoLocalRepositoryManagerException;
61 import org.eclipse.aether.repository.Proxy;
62 import org.eclipse.aether.repository.RemoteRepository;
63 import org.eclipse.aether.resolution.ArtifactDescriptorException;
64 import org.eclipse.aether.resolution.ArtifactDescriptorRequest;
65 import org.eclipse.aether.resolution.ArtifactDescriptorResult;
66 import org.eclipse.aether.resolution.ArtifactRequest;
67 import org.eclipse.aether.resolution.ArtifactResolutionException;
68 import org.eclipse.aether.resolution.ArtifactResult;
69 import org.eclipse.aether.resolution.DependencyRequest;
70 import org.eclipse.aether.resolution.DependencyResolutionException;
71 import org.eclipse.aether.resolution.DependencyResult;
72 import org.eclipse.aether.resolution.MetadataRequest;
73 import org.eclipse.aether.resolution.MetadataResult;
74 import org.eclipse.aether.resolution.VersionRangeRequest;
75 import org.eclipse.aether.resolution.VersionRangeResolutionException;
76 import org.eclipse.aether.resolution.VersionRangeResult;
77 import org.eclipse.aether.resolution.VersionRequest;
78 import org.eclipse.aether.resolution.VersionResolutionException;
79 import org.eclipse.aether.resolution.VersionResult;
80 import org.eclipse.aether.spi.locator.Service;
81 import org.eclipse.aether.spi.locator.ServiceLocator;
82 import org.eclipse.aether.util.graph.visitor.FilteringDependencyVisitor;
83 import org.eclipse.aether.util.graph.visitor.TreeDependencyVisitor;
84
85
86
87 @Named
88 public class DefaultRepositorySystem
89 implements RepositorySystem, Service
90 {
91
92 private VersionResolver versionResolver;
93
94 private VersionRangeResolver versionRangeResolver;
95
96 private ArtifactResolver artifactResolver;
97
98 private MetadataResolver metadataResolver;
99
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
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
158
159 @Deprecated
160 public DefaultRepositorySystem setLoggerFactory( org.eclipse.aether.spi.log.LoggerFactory loggerFactory )
161 {
162
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 }