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 @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
157
158 @Deprecated
159 public DefaultRepositorySystem setLoggerFactory( org.eclipse.aether.spi.log.LoggerFactory loggerFactory )
160 {
161
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 }