| package org.eclipse.aether.internal.impl; |
| |
| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.List; |
| |
| import javax.inject.Inject; |
| import javax.inject.Named; |
| |
| import org.eclipse.aether.RepositorySystem; |
| import org.eclipse.aether.RepositorySystemSession; |
| import org.eclipse.aether.RequestTrace; |
| import org.eclipse.aether.SyncContext; |
| import org.eclipse.aether.artifact.Artifact; |
| import org.eclipse.aether.collection.CollectRequest; |
| import org.eclipse.aether.collection.CollectResult; |
| import org.eclipse.aether.collection.DependencyCollectionException; |
| import org.eclipse.aether.deployment.DeployRequest; |
| import org.eclipse.aether.deployment.DeployResult; |
| import org.eclipse.aether.deployment.DeploymentException; |
| import org.eclipse.aether.graph.DependencyFilter; |
| import org.eclipse.aether.graph.DependencyVisitor; |
| import org.eclipse.aether.impl.ArtifactDescriptorReader; |
| import org.eclipse.aether.impl.ArtifactResolver; |
| import org.eclipse.aether.impl.DependencyCollector; |
| import org.eclipse.aether.impl.Deployer; |
| import org.eclipse.aether.impl.Installer; |
| import org.eclipse.aether.impl.LocalRepositoryProvider; |
| import org.eclipse.aether.impl.MetadataResolver; |
| import org.eclipse.aether.impl.RemoteRepositoryManager; |
| import org.eclipse.aether.impl.SyncContextFactory; |
| import org.eclipse.aether.impl.VersionRangeResolver; |
| import org.eclipse.aether.impl.VersionResolver; |
| import org.eclipse.aether.installation.InstallRequest; |
| import org.eclipse.aether.installation.InstallResult; |
| import org.eclipse.aether.installation.InstallationException; |
| import org.eclipse.aether.repository.Authentication; |
| import org.eclipse.aether.repository.LocalRepository; |
| import org.eclipse.aether.repository.LocalRepositoryManager; |
| import org.eclipse.aether.repository.NoLocalRepositoryManagerException; |
| import org.eclipse.aether.repository.Proxy; |
| import org.eclipse.aether.repository.RemoteRepository; |
| import org.eclipse.aether.resolution.ArtifactDescriptorException; |
| import org.eclipse.aether.resolution.ArtifactDescriptorRequest; |
| import org.eclipse.aether.resolution.ArtifactDescriptorResult; |
| import org.eclipse.aether.resolution.ArtifactRequest; |
| import org.eclipse.aether.resolution.ArtifactResolutionException; |
| import org.eclipse.aether.resolution.ArtifactResult; |
| import org.eclipse.aether.resolution.DependencyRequest; |
| import org.eclipse.aether.resolution.DependencyResolutionException; |
| import org.eclipse.aether.resolution.DependencyResult; |
| import org.eclipse.aether.resolution.MetadataRequest; |
| import org.eclipse.aether.resolution.MetadataResult; |
| import org.eclipse.aether.resolution.VersionRangeRequest; |
| import org.eclipse.aether.resolution.VersionRangeResolutionException; |
| import org.eclipse.aether.resolution.VersionRangeResult; |
| import org.eclipse.aether.resolution.VersionRequest; |
| import org.eclipse.aether.resolution.VersionResolutionException; |
| import org.eclipse.aether.resolution.VersionResult; |
| import org.eclipse.aether.spi.locator.Service; |
| import org.eclipse.aether.spi.locator.ServiceLocator; |
| import org.eclipse.aether.spi.log.Logger; |
| import org.eclipse.aether.spi.log.LoggerFactory; |
| import org.eclipse.aether.spi.log.NullLoggerFactory; |
| import org.eclipse.aether.util.graph.visitor.FilteringDependencyVisitor; |
| import org.eclipse.aether.util.graph.visitor.TreeDependencyVisitor; |
| |
| /** |
| */ |
| @Named |
| public class DefaultRepositorySystem |
| implements RepositorySystem, Service |
| { |
| |
| private Logger logger = NullLoggerFactory.LOGGER; |
| |
| private VersionResolver versionResolver; |
| |
| private VersionRangeResolver versionRangeResolver; |
| |
| private ArtifactResolver artifactResolver; |
| |
| private MetadataResolver metadataResolver; |
| |
| private ArtifactDescriptorReader artifactDescriptorReader; |
| |
| private DependencyCollector dependencyCollector; |
| |
| private Installer installer; |
| |
| private Deployer deployer; |
| |
| private LocalRepositoryProvider localRepositoryProvider; |
| |
| private SyncContextFactory syncContextFactory; |
| |
| private RemoteRepositoryManager remoteRepositoryManager; |
| |
| public DefaultRepositorySystem() |
| { |
| // enables default constructor |
| } |
| |
| @Inject |
| DefaultRepositorySystem( VersionResolver versionResolver, VersionRangeResolver versionRangeResolver, |
| ArtifactResolver artifactResolver, MetadataResolver metadataResolver, |
| ArtifactDescriptorReader artifactDescriptorReader, |
| DependencyCollector dependencyCollector, Installer installer, Deployer deployer, |
| LocalRepositoryProvider localRepositoryProvider, SyncContextFactory syncContextFactory, |
| RemoteRepositoryManager remoteRepositoryManager, LoggerFactory loggerFactory ) |
| { |
| setVersionResolver( versionResolver ); |
| setVersionRangeResolver( versionRangeResolver ); |
| setArtifactResolver( artifactResolver ); |
| setMetadataResolver( metadataResolver ); |
| setArtifactDescriptorReader( artifactDescriptorReader ); |
| setDependencyCollector( dependencyCollector ); |
| setInstaller( installer ); |
| setDeployer( deployer ); |
| setLocalRepositoryProvider( localRepositoryProvider ); |
| setSyncContextFactory( syncContextFactory ); |
| setRemoteRepositoryManager( remoteRepositoryManager ); |
| setLoggerFactory( loggerFactory ); |
| } |
| |
| public void initService( ServiceLocator locator ) |
| { |
| setLoggerFactory( locator.getService( LoggerFactory.class ) ); |
| setVersionResolver( locator.getService( VersionResolver.class ) ); |
| setVersionRangeResolver( locator.getService( VersionRangeResolver.class ) ); |
| setArtifactResolver( locator.getService( ArtifactResolver.class ) ); |
| setMetadataResolver( locator.getService( MetadataResolver.class ) ); |
| setArtifactDescriptorReader( locator.getService( ArtifactDescriptorReader.class ) ); |
| setDependencyCollector( locator.getService( DependencyCollector.class ) ); |
| setInstaller( locator.getService( Installer.class ) ); |
| setDeployer( locator.getService( Deployer.class ) ); |
| setLocalRepositoryProvider( locator.getService( LocalRepositoryProvider.class ) ); |
| setRemoteRepositoryManager( locator.getService( RemoteRepositoryManager.class ) ); |
| setSyncContextFactory( locator.getService( SyncContextFactory.class ) ); |
| } |
| |
| public DefaultRepositorySystem setLoggerFactory( LoggerFactory loggerFactory ) |
| { |
| this.logger = NullLoggerFactory.getSafeLogger( loggerFactory, getClass() ); |
| return this; |
| } |
| |
| public DefaultRepositorySystem setVersionResolver( VersionResolver versionResolver ) |
| { |
| if ( versionResolver == null ) |
| { |
| throw new IllegalArgumentException( "version resolver has not been specified" ); |
| } |
| this.versionResolver = versionResolver; |
| return this; |
| } |
| |
| public DefaultRepositorySystem setVersionRangeResolver( VersionRangeResolver versionRangeResolver ) |
| { |
| if ( versionRangeResolver == null ) |
| { |
| throw new IllegalArgumentException( "version range resolver has not been specified" ); |
| } |
| this.versionRangeResolver = versionRangeResolver; |
| return this; |
| } |
| |
| public DefaultRepositorySystem setArtifactResolver( ArtifactResolver artifactResolver ) |
| { |
| if ( artifactResolver == null ) |
| { |
| throw new IllegalArgumentException( "artifact resolver has not been specified" ); |
| } |
| this.artifactResolver = artifactResolver; |
| return this; |
| } |
| |
| public DefaultRepositorySystem setMetadataResolver( MetadataResolver metadataResolver ) |
| { |
| if ( metadataResolver == null ) |
| { |
| throw new IllegalArgumentException( "metadata resolver has not been specified" ); |
| } |
| this.metadataResolver = metadataResolver; |
| return this; |
| } |
| |
| public DefaultRepositorySystem setArtifactDescriptorReader( ArtifactDescriptorReader artifactDescriptorReader ) |
| { |
| if ( artifactDescriptorReader == null ) |
| { |
| throw new IllegalArgumentException( "artifact descriptor reader has not been specified" ); |
| } |
| this.artifactDescriptorReader = artifactDescriptorReader; |
| return this; |
| } |
| |
| public DefaultRepositorySystem setDependencyCollector( DependencyCollector dependencyCollector ) |
| { |
| if ( dependencyCollector == null ) |
| { |
| throw new IllegalArgumentException( "dependency collector has not been specified" ); |
| } |
| this.dependencyCollector = dependencyCollector; |
| return this; |
| } |
| |
| public DefaultRepositorySystem setInstaller( Installer installer ) |
| { |
| if ( installer == null ) |
| { |
| throw new IllegalArgumentException( "installer has not been specified" ); |
| } |
| this.installer = installer; |
| return this; |
| } |
| |
| public DefaultRepositorySystem setDeployer( Deployer deployer ) |
| { |
| if ( deployer == null ) |
| { |
| throw new IllegalArgumentException( "deployer has not been specified" ); |
| } |
| this.deployer = deployer; |
| return this; |
| } |
| |
| public DefaultRepositorySystem setLocalRepositoryProvider( LocalRepositoryProvider localRepositoryProvider ) |
| { |
| if ( localRepositoryProvider == null ) |
| { |
| throw new IllegalArgumentException( "local repository provider has not been specified" ); |
| } |
| this.localRepositoryProvider = localRepositoryProvider; |
| return this; |
| } |
| |
| public DefaultRepositorySystem setSyncContextFactory( SyncContextFactory syncContextFactory ) |
| { |
| if ( syncContextFactory == null ) |
| { |
| throw new IllegalArgumentException( "sync context factory has not been specified" ); |
| } |
| this.syncContextFactory = syncContextFactory; |
| return this; |
| } |
| |
| public DefaultRepositorySystem setRemoteRepositoryManager( RemoteRepositoryManager remoteRepositoryManager ) |
| { |
| if ( remoteRepositoryManager == null ) |
| { |
| throw new IllegalArgumentException( "remote repository manager has not been specified" ); |
| } |
| this.remoteRepositoryManager = remoteRepositoryManager; |
| return this; |
| } |
| |
| public VersionResult resolveVersion( RepositorySystemSession session, VersionRequest request ) |
| throws VersionResolutionException |
| { |
| validateSession( session ); |
| return versionResolver.resolveVersion( session, request ); |
| } |
| |
| public VersionRangeResult resolveVersionRange( RepositorySystemSession session, VersionRangeRequest request ) |
| throws VersionRangeResolutionException |
| { |
| validateSession( session ); |
| return versionRangeResolver.resolveVersionRange( session, request ); |
| } |
| |
| public ArtifactDescriptorResult readArtifactDescriptor( RepositorySystemSession session, |
| ArtifactDescriptorRequest request ) |
| throws ArtifactDescriptorException |
| { |
| validateSession( session ); |
| return artifactDescriptorReader.readArtifactDescriptor( session, request ); |
| } |
| |
| public ArtifactResult resolveArtifact( RepositorySystemSession session, ArtifactRequest request ) |
| throws ArtifactResolutionException |
| { |
| validateSession( session ); |
| return artifactResolver.resolveArtifact( session, request ); |
| } |
| |
| public List<ArtifactResult> resolveArtifacts( RepositorySystemSession session, |
| Collection<? extends ArtifactRequest> requests ) |
| throws ArtifactResolutionException |
| { |
| validateSession( session ); |
| return artifactResolver.resolveArtifacts( session, requests ); |
| } |
| |
| public List<MetadataResult> resolveMetadata( RepositorySystemSession session, |
| Collection<? extends MetadataRequest> requests ) |
| { |
| validateSession( session ); |
| return metadataResolver.resolveMetadata( session, requests ); |
| } |
| |
| public CollectResult collectDependencies( RepositorySystemSession session, CollectRequest request ) |
| throws DependencyCollectionException |
| { |
| validateSession( session ); |
| return dependencyCollector.collectDependencies( session, request ); |
| } |
| |
| public DependencyResult resolveDependencies( RepositorySystemSession session, DependencyRequest request ) |
| throws DependencyResolutionException |
| { |
| validateSession( session ); |
| |
| RequestTrace trace = RequestTrace.newChild( request.getTrace(), request ); |
| |
| DependencyResult result = new DependencyResult( request ); |
| |
| DependencyCollectionException dce = null; |
| ArtifactResolutionException are = null; |
| |
| if ( request.getRoot() != null ) |
| { |
| result.setRoot( request.getRoot() ); |
| } |
| else if ( request.getCollectRequest() != null ) |
| { |
| CollectResult collectResult; |
| try |
| { |
| request.getCollectRequest().setTrace( trace ); |
| collectResult = dependencyCollector.collectDependencies( session, request.getCollectRequest() ); |
| } |
| catch ( DependencyCollectionException e ) |
| { |
| dce = e; |
| collectResult = e.getResult(); |
| } |
| if ( collectResult != null ) |
| { |
| result.setRoot( collectResult.getRoot() ); |
| result.setCycles( collectResult.getCycles() ); |
| result.setCollectExceptions( collectResult.getExceptions() ); |
| } |
| } |
| else |
| { |
| throw new IllegalArgumentException( "dependency node or collect request missing" ); |
| } |
| |
| if ( result.getRoot() != null ) |
| { |
| ArtifactRequestBuilder builder = new ArtifactRequestBuilder( trace ); |
| DependencyFilter filter = request.getFilter(); |
| DependencyVisitor visitor = |
| ( filter != null ) ? new FilteringDependencyVisitor( builder, filter ) : builder; |
| visitor = new TreeDependencyVisitor( visitor ); |
| result.getRoot().accept( visitor ); |
| |
| List<ArtifactResult> results; |
| try |
| { |
| List<ArtifactRequest> requests = builder.getRequests(); |
| results = artifactResolver.resolveArtifacts( session, requests ); |
| } |
| catch ( ArtifactResolutionException e ) |
| { |
| are = e; |
| results = e.getResults(); |
| } |
| result.setArtifactResults( results ); |
| |
| updateNodesWithResolvedArtifacts( results ); |
| } |
| |
| if ( dce != null ) |
| { |
| throw new DependencyResolutionException( result, dce ); |
| } |
| else if ( are != null ) |
| { |
| throw new DependencyResolutionException( result, are ); |
| } |
| |
| return result; |
| } |
| |
| private void updateNodesWithResolvedArtifacts( List<ArtifactResult> results ) |
| { |
| for ( ArtifactResult result : results ) |
| { |
| Artifact artifact = result.getArtifact(); |
| if ( artifact != null ) |
| { |
| result.getRequest().getDependencyNode().setArtifact( artifact ); |
| } |
| } |
| } |
| |
| public InstallResult install( RepositorySystemSession session, InstallRequest request ) |
| throws InstallationException |
| { |
| validateSession( session ); |
| return installer.install( session, request ); |
| } |
| |
| public DeployResult deploy( RepositorySystemSession session, DeployRequest request ) |
| throws DeploymentException |
| { |
| validateSession( session ); |
| return deployer.deploy( session, request ); |
| } |
| |
| public LocalRepositoryManager newLocalRepositoryManager( RepositorySystemSession session, |
| LocalRepository localRepository ) |
| { |
| try |
| { |
| return localRepositoryProvider.newLocalRepositoryManager( session, localRepository ); |
| } |
| catch ( NoLocalRepositoryManagerException e ) |
| { |
| throw new IllegalArgumentException( e.getMessage(), e ); |
| } |
| } |
| |
| public SyncContext newSyncContext( RepositorySystemSession session, boolean shared ) |
| { |
| validateSession( session ); |
| return syncContextFactory.newInstance( session, shared ); |
| } |
| |
| public List<RemoteRepository> newResolutionRepositories( RepositorySystemSession session, |
| List<RemoteRepository> repositories ) |
| { |
| validateSession( session ); |
| repositories = |
| remoteRepositoryManager.aggregateRepositories( session, new ArrayList<RemoteRepository>(), repositories, |
| true ); |
| return repositories; |
| } |
| |
| public RemoteRepository newDeploymentRepository( RepositorySystemSession session, RemoteRepository repository ) |
| { |
| validateSession( session ); |
| RemoteRepository.Builder builder = new RemoteRepository.Builder( repository ); |
| Authentication auth = session.getAuthenticationSelector().getAuthentication( repository ); |
| builder.setAuthentication( auth ); |
| Proxy proxy = session.getProxySelector().getProxy( repository ); |
| builder.setProxy( proxy ); |
| return builder.build(); |
| } |
| |
| private void validateSession( RepositorySystemSession session ) |
| { |
| if ( session == null ) |
| { |
| throw new IllegalArgumentException( "Invalid repository system session: the session may not be null." ); |
| } |
| if ( session.getLocalRepositoryManager() == null ) |
| { |
| invalidSession( "LocalRepositoryManager" ); |
| } |
| if ( session.getSystemProperties() == null ) |
| { |
| invalidSession( "SystemProperties" ); |
| } |
| if ( session.getUserProperties() == null ) |
| { |
| invalidSession( "UserProperties" ); |
| } |
| if ( session.getConfigProperties() == null ) |
| { |
| invalidSession( "ConfigProperties" ); |
| } |
| if ( session.getMirrorSelector() == null ) |
| { |
| invalidSession( "MirrorSelector" ); |
| } |
| if ( session.getProxySelector() == null ) |
| { |
| invalidSession( "ProxySelector" ); |
| } |
| if ( session.getAuthenticationSelector() == null ) |
| { |
| invalidSession( "AuthenticationSelector" ); |
| } |
| if ( session.getArtifactTypeRegistry() == null ) |
| { |
| invalidSession( "ArtifactTypeRegistry" ); |
| } |
| if ( session.getData() == null ) |
| { |
| invalidSession( "Data" ); |
| } |
| } |
| |
| private void invalidSession( String name ) |
| { |
| throw new IllegalArgumentException( "Invalid repository system session: " + name + " is not set." ); |
| } |
| |
| } |