View Javadoc
1   package org.eclipse.aether.internal.impl;
2   
3   /*
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   * 
12   *  http://www.apache.org/licenses/LICENSE-2.0
13   * 
14   * Unless required by applicable law or agreed to in writing,
15   * software distributed under the License is distributed on an
16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17   * KIND, either express or implied.  See the License for the
18   * specific language governing permissions and limitations
19   * under the License.
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         // 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 }