shaded.org.eclipse.aether.internal.impl.DefaultRepositorySystem Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of spring-cloud-contract-shade Show documentation
Show all versions of spring-cloud-contract-shade Show documentation
Spring Cloud Contract Shaded Dependencies
package shaded.shaded.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 static java.util.Objects.requireNonNull;
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 shaded.shaded.org.eclipse.aether.impl.ArtifactDescriptorReader;
import shaded.shaded.org.eclipse.aether.impl.ArtifactResolver;
import shaded.shaded.org.eclipse.aether.impl.DependencyCollector;
import shaded.shaded.org.eclipse.aether.impl.Deployer;
import shaded.shaded.org.eclipse.aether.impl.Installer;
import shaded.shaded.org.eclipse.aether.impl.LocalRepositoryProvider;
import shaded.shaded.org.eclipse.aether.impl.MetadataResolver;
import shaded.shaded.org.eclipse.aether.impl.RemoteRepositoryManager;
import shaded.shaded.org.eclipse.aether.impl.SyncContextFactory;
import shaded.shaded.org.eclipse.aether.impl.VersionRangeResolver;
import shaded.shaded.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 shaded.shaded.org.eclipse.aether.spi.locator.Service;
import shaded.shaded.org.eclipse.aether.spi.locator.ServiceLocator;
import org.eclipse.aether.util.graph.visitor.FilteringDependencyVisitor;
import org.eclipse.aether.util.graph.visitor.TreeDependencyVisitor;
/**
*/
@Named
public class DefaultRepositorySystem
implements RepositorySystem, Service
{
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 )
{
setVersionResolver( versionResolver );
setVersionRangeResolver( versionRangeResolver );
setArtifactResolver( artifactResolver );
setMetadataResolver( metadataResolver );
setArtifactDescriptorReader( artifactDescriptorReader );
setDependencyCollector( dependencyCollector );
setInstaller( installer );
setDeployer( deployer );
setLocalRepositoryProvider( localRepositoryProvider );
setSyncContextFactory( syncContextFactory );
setRemoteRepositoryManager( remoteRepositoryManager );
}
public void initService( ServiceLocator locator )
{
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 ) );
}
/**
* @deprecated not used any more since MRESOLVER-36 move to slf4j, added back in MRESOLVER-64 for compatibility
*/
@Deprecated
public DefaultRepositorySystem setLoggerFactory( shaded.shaded.org.eclipse.aether.spi.log.LoggerFactory loggerFactory )
{
// this.logger = NullLoggerFactory.getSafeLogger( loggerFactory, getClass() );
return this;
}
public DefaultRepositorySystem setVersionResolver( VersionResolver versionResolver )
{
this.versionResolver = requireNonNull( versionResolver, "version resolver cannot be null" );
return this;
}
public DefaultRepositorySystem setVersionRangeResolver( VersionRangeResolver versionRangeResolver )
{
this.versionRangeResolver = requireNonNull( versionRangeResolver, "version range resolver cannot be null" );
return this;
}
public DefaultRepositorySystem setArtifactResolver( ArtifactResolver artifactResolver )
{
this.artifactResolver = requireNonNull( artifactResolver, "artifact resolver cannot be null" );
return this;
}
public DefaultRepositorySystem setMetadataResolver( MetadataResolver metadataResolver )
{
this.metadataResolver = requireNonNull( metadataResolver, "metadata resolver cannot be null" );
return this;
}
public DefaultRepositorySystem setArtifactDescriptorReader( ArtifactDescriptorReader artifactDescriptorReader )
{
this.artifactDescriptorReader = requireNonNull( artifactDescriptorReader, "artifact descriptor reader cannot be null" );
return this;
}
public DefaultRepositorySystem setDependencyCollector( DependencyCollector dependencyCollector )
{
this.dependencyCollector = requireNonNull( dependencyCollector, "dependency collector cannot be null" );
return this;
}
public DefaultRepositorySystem setInstaller( Installer installer )
{
this.installer = requireNonNull( installer, "installer cannot be null" );
return this;
}
public DefaultRepositorySystem setDeployer( Deployer deployer )
{
this.deployer = requireNonNull( deployer, "deployer cannot be null" );
return this;
}
public DefaultRepositorySystem setLocalRepositoryProvider( LocalRepositoryProvider localRepositoryProvider )
{
this.localRepositoryProvider = requireNonNull( localRepositoryProvider, "local repository provider cannot be null" );
return this;
}
public DefaultRepositorySystem setSyncContextFactory( SyncContextFactory syncContextFactory )
{
this.syncContextFactory = requireNonNull( syncContextFactory, "sync context factory cannot be null" );
return this;
}
public DefaultRepositorySystem setRemoteRepositoryManager( RemoteRepositoryManager remoteRepositoryManager )
{
this.remoteRepositoryManager = requireNonNull( remoteRepositoryManager, "remote repository provider cannot be null" );
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 resolveArtifacts( RepositorySystemSession session,
Collection requests )
throws ArtifactResolutionException
{
validateSession( session );
return artifactResolver.resolveArtifacts( session, requests );
}
public List resolveMetadata( RepositorySystemSession session,
Collection 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();
}
result.setRoot( collectResult.getRoot() );
result.setCycles( collectResult.getCycles() );
result.setCollectExceptions( collectResult.getExceptions() );
}
else
{
throw new NullPointerException( "dependency node and collect request cannot be null" );
}
ArtifactRequestBuilder builder = new ArtifactRequestBuilder( trace );
DependencyFilter filter = request.getFilter();
DependencyVisitor visitor = ( filter != null ) ? new FilteringDependencyVisitor( builder, filter ) : builder;
visitor = new TreeDependencyVisitor( visitor );
if ( result.getRoot() != null )
{
result.getRoot().accept( visitor );
}
List requests = builder.getRequests();
List results;
try
{
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 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 newResolutionRepositories( RepositorySystemSession session,
List repositories )
{
validateSession( session );
repositories =
remoteRepositoryManager.aggregateRepositories( session, new ArrayList(), 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 )
{
requireNonNull( session, "repository system session cannot be null" );
invalidSession( session.getLocalRepositoryManager(), "local repository manager" );
invalidSession( session.getSystemProperties(), "system properties" );
invalidSession( session.getUserProperties(), "user properties" );
invalidSession( session.getConfigProperties(), "config properties" );
invalidSession( session.getMirrorSelector(), "mirror selector" );
invalidSession( session.getProxySelector(), "proxy selector" );
invalidSession( session.getAuthenticationSelector(), "authentication selector" );
invalidSession( session.getArtifactTypeRegistry(), "artifact type registry" );
invalidSession( session.getData(), "data" );
}
private void invalidSession( Object obj, String name )
{
requireNonNull( obj, "repository system session's " + name + " cannot be null" );
}
}