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    @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     * @deprecated not used any more since MRESOLVER-36 move to slf4j, added back in MRESOLVER-64 for compatibility
158     */
159    @Deprecated
160    public DefaultRepositorySystem setLoggerFactory( org.eclipse.aether.spi.log.LoggerFactory loggerFactory )
161    {
162        // this.logger = NullLoggerFactory.getSafeLogger( loggerFactory, getClass() );
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}