org.eclipse.aether.DefaultRepositorySystemSession Maven / Gradle / Ivy
Show all versions of spring-cloud-contract-shade Show documentation
/*******************************************************************************
* Copyright (c) 2010, 2014 Sonatype, Inc.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Sonatype, Inc. - initial API and implementation
*******************************************************************************/
package org.eclipse.aether;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import org.eclipse.aether.artifact.ArtifactType;
import org.eclipse.aether.artifact.ArtifactTypeRegistry;
import org.eclipse.aether.collection.DependencyGraphTransformer;
import org.eclipse.aether.collection.DependencyManager;
import org.eclipse.aether.collection.DependencySelector;
import org.eclipse.aether.collection.DependencyTraverser;
import org.eclipse.aether.collection.VersionFilter;
import org.eclipse.aether.repository.Authentication;
import org.eclipse.aether.repository.AuthenticationSelector;
import org.eclipse.aether.repository.LocalRepository;
import org.eclipse.aether.repository.LocalRepositoryManager;
import org.eclipse.aether.repository.MirrorSelector;
import org.eclipse.aether.repository.Proxy;
import org.eclipse.aether.repository.ProxySelector;
import org.eclipse.aether.repository.RemoteRepository;
import org.eclipse.aether.repository.RepositoryPolicy;
import org.eclipse.aether.repository.WorkspaceReader;
import org.eclipse.aether.resolution.ArtifactDescriptorPolicy;
import org.eclipse.aether.resolution.ResolutionErrorPolicy;
import org.eclipse.aether.transfer.TransferListener;
/**
* A simple repository system session.
*
* Note: This class is not thread-safe. It is assumed that the mutators get only called during an
* initialization phase and that the session itself is not changed once initialized and being used by the repository
* system. It is recommended to call {@link #setReadOnly()} once the session has been fully initialized to prevent
* accidental manipulation of it afterwards.
*/
public final class DefaultRepositorySystemSession
implements RepositorySystemSession
{
private boolean readOnly;
private boolean offline;
private boolean ignoreArtifactDescriptorRepositories;
private ResolutionErrorPolicy resolutionErrorPolicy;
private ArtifactDescriptorPolicy artifactDescriptorPolicy;
private String checksumPolicy;
private String updatePolicy;
private LocalRepositoryManager localRepositoryManager;
private WorkspaceReader workspaceReader;
private RepositoryListener repositoryListener;
private TransferListener transferListener;
private Map systemProperties;
private Map systemPropertiesView;
private Map userProperties;
private Map userPropertiesView;
private Map configProperties;
private Map configPropertiesView;
private MirrorSelector mirrorSelector;
private ProxySelector proxySelector;
private AuthenticationSelector authenticationSelector;
private ArtifactTypeRegistry artifactTypeRegistry;
private DependencyTraverser dependencyTraverser;
private DependencyManager dependencyManager;
private DependencySelector dependencySelector;
private VersionFilter versionFilter;
private DependencyGraphTransformer dependencyGraphTransformer;
private SessionData data;
private RepositoryCache cache;
/**
* Creates an uninitialized session. Note: The new session is not ready to use, as a bare minimum,
* {@link #setLocalRepositoryManager(LocalRepositoryManager)} needs to be called but usually other settings also
* need to be customized to achieve meaningful behavior.
*/
public DefaultRepositorySystemSession()
{
systemProperties = new HashMap();
systemPropertiesView = Collections.unmodifiableMap( systemProperties );
userProperties = new HashMap();
userPropertiesView = Collections.unmodifiableMap( userProperties );
configProperties = new HashMap();
configPropertiesView = Collections.unmodifiableMap( configProperties );
mirrorSelector = NullMirrorSelector.INSTANCE;
proxySelector = NullProxySelector.INSTANCE;
authenticationSelector = NullAuthenticationSelector.INSTANCE;
artifactTypeRegistry = NullArtifactTypeRegistry.INSTANCE;
data = new DefaultSessionData();
}
/**
* Creates a shallow copy of the specified session. Actually, the copy is not completely shallow, all maps holding
* system/user/config properties are copied as well. In other words, invoking any mutator on the new session itself
* has no effect on the original session. Other mutable objects like the session data and cache (if any) are not
* copied and will be shared with the original session unless reconfigured.
*
* @param session The session to copy, must not be {@code null}.
*/
public DefaultRepositorySystemSession( RepositorySystemSession session )
{
if ( session == null )
{
throw new IllegalArgumentException( "repository system session not specified" );
}
setOffline( session.isOffline() );
setIgnoreArtifactDescriptorRepositories( session.isIgnoreArtifactDescriptorRepositories() );
setResolutionErrorPolicy( session.getResolutionErrorPolicy() );
setArtifactDescriptorPolicy( session.getArtifactDescriptorPolicy() );
setChecksumPolicy( session.getChecksumPolicy() );
setUpdatePolicy( session.getUpdatePolicy() );
setLocalRepositoryManager( session.getLocalRepositoryManager() );
setWorkspaceReader( session.getWorkspaceReader() );
setRepositoryListener( session.getRepositoryListener() );
setTransferListener( session.getTransferListener() );
setSystemProperties( session.getSystemProperties() );
setUserProperties( session.getUserProperties() );
setConfigProperties( session.getConfigProperties() );
setMirrorSelector( session.getMirrorSelector() );
setProxySelector( session.getProxySelector() );
setAuthenticationSelector( session.getAuthenticationSelector() );
setArtifactTypeRegistry( session.getArtifactTypeRegistry() );
setDependencyTraverser( session.getDependencyTraverser() );
setDependencyManager( session.getDependencyManager() );
setDependencySelector( session.getDependencySelector() );
setVersionFilter( session.getVersionFilter() );
setDependencyGraphTransformer( session.getDependencyGraphTransformer() );
setData( session.getData() );
setCache( session.getCache() );
}
public boolean isOffline()
{
return offline;
}
/**
* Controls whether the repository system operates in offline mode and avoids/refuses any access to remote
* repositories.
*
* @param offline {@code true} if the repository system is in offline mode, {@code false} otherwise.
* @return This session for chaining, never {@code null}.
*/
public DefaultRepositorySystemSession setOffline( boolean offline )
{
failIfReadOnly();
this.offline = offline;
return this;
}
public boolean isIgnoreArtifactDescriptorRepositories()
{
return ignoreArtifactDescriptorRepositories;
}
/**
* Controls whether repositories declared in artifact descriptors should be ignored during transitive dependency
* collection. If enabled, only the repositories originally provided with the collect request will be considered.
*
* @param ignoreArtifactDescriptorRepositories {@code true} to ignore additional repositories from artifact
* descriptors, {@code false} to merge those with the originally specified repositories.
* @return This session for chaining, never {@code null}.
*/
public DefaultRepositorySystemSession setIgnoreArtifactDescriptorRepositories( boolean ignoreArtifactDescriptorRepositories )
{
failIfReadOnly();
this.ignoreArtifactDescriptorRepositories = ignoreArtifactDescriptorRepositories;
return this;
}
public ResolutionErrorPolicy getResolutionErrorPolicy()
{
return resolutionErrorPolicy;
}
/**
* Sets the policy which controls whether resolutions errors from remote repositories should be cached.
*
* @param resolutionErrorPolicy The resolution error policy for this session, may be {@code null} if resolution
* errors should generally not be cached.
* @return This session for chaining, never {@code null}.
*/
public DefaultRepositorySystemSession setResolutionErrorPolicy( ResolutionErrorPolicy resolutionErrorPolicy )
{
failIfReadOnly();
this.resolutionErrorPolicy = resolutionErrorPolicy;
return this;
}
public ArtifactDescriptorPolicy getArtifactDescriptorPolicy()
{
return artifactDescriptorPolicy;
}
/**
* Sets the policy which controls how errors related to reading artifact descriptors should be handled.
*
* @param artifactDescriptorPolicy The descriptor error policy for this session, may be {@code null} if descriptor
* errors should generally not be tolerated.
* @return This session for chaining, never {@code null}.
*/
public DefaultRepositorySystemSession setArtifactDescriptorPolicy( ArtifactDescriptorPolicy artifactDescriptorPolicy )
{
failIfReadOnly();
this.artifactDescriptorPolicy = artifactDescriptorPolicy;
return this;
}
public String getChecksumPolicy()
{
return checksumPolicy;
}
/**
* Sets the global checksum policy. If set, the global checksum policy overrides the checksum policies of the remote
* repositories being used for resolution.
*
* @param checksumPolicy The global checksum policy, may be {@code null}/empty to apply the per-repository policies.
* @return This session for chaining, never {@code null}.
* @see RepositoryPolicy#CHECKSUM_POLICY_FAIL
* @see RepositoryPolicy#CHECKSUM_POLICY_IGNORE
* @see RepositoryPolicy#CHECKSUM_POLICY_WARN
*/
public DefaultRepositorySystemSession setChecksumPolicy( String checksumPolicy )
{
failIfReadOnly();
this.checksumPolicy = checksumPolicy;
return this;
}
public String getUpdatePolicy()
{
return updatePolicy;
}
/**
* Sets the global update policy. If set, the global update policy overrides the update policies of the remote
* repositories being used for resolution.
*
* @param updatePolicy The global update policy, may be {@code null}/empty to apply the per-repository policies.
* @return This session for chaining, never {@code null}.
* @see RepositoryPolicy#UPDATE_POLICY_ALWAYS
* @see RepositoryPolicy#UPDATE_POLICY_DAILY
* @see RepositoryPolicy#UPDATE_POLICY_NEVER
*/
public DefaultRepositorySystemSession setUpdatePolicy( String updatePolicy )
{
failIfReadOnly();
this.updatePolicy = updatePolicy;
return this;
}
public LocalRepository getLocalRepository()
{
LocalRepositoryManager lrm = getLocalRepositoryManager();
return ( lrm != null ) ? lrm.getRepository() : null;
}
public LocalRepositoryManager getLocalRepositoryManager()
{
return localRepositoryManager;
}
/**
* Sets the local repository manager used during this session. Note: Eventually, a valid session must have
* a local repository manager set.
*
* @param localRepositoryManager The local repository manager used during this session, may be {@code null}.
* @return This session for chaining, never {@code null}.
*/
public DefaultRepositorySystemSession setLocalRepositoryManager( LocalRepositoryManager localRepositoryManager )
{
failIfReadOnly();
this.localRepositoryManager = localRepositoryManager;
return this;
}
public WorkspaceReader getWorkspaceReader()
{
return workspaceReader;
}
/**
* Sets the workspace reader used during this session. If set, the workspace reader will usually be consulted first
* to resolve artifacts.
*
* @param workspaceReader The workspace reader for this session, may be {@code null} if none.
* @return This session for chaining, never {@code null}.
*/
public DefaultRepositorySystemSession setWorkspaceReader( WorkspaceReader workspaceReader )
{
failIfReadOnly();
this.workspaceReader = workspaceReader;
return this;
}
public RepositoryListener getRepositoryListener()
{
return repositoryListener;
}
/**
* Sets the listener being notified of actions in the repository system.
*
* @param repositoryListener The repository listener, may be {@code null} if none.
* @return This session for chaining, never {@code null}.
*/
public DefaultRepositorySystemSession setRepositoryListener( RepositoryListener repositoryListener )
{
failIfReadOnly();
this.repositoryListener = repositoryListener;
return this;
}
public TransferListener getTransferListener()
{
return transferListener;
}
/**
* Sets the listener being notified of uploads/downloads by the repository system.
*
* @param transferListener The transfer listener, may be {@code null} if none.
* @return This session for chaining, never {@code null}.
*/
public DefaultRepositorySystemSession setTransferListener( TransferListener transferListener )
{
failIfReadOnly();
this.transferListener = transferListener;
return this;
}
private Map copySafe( Map table, Class valueType )
{
Map map;
if ( table == null || table.isEmpty() )
{
map = new HashMap();
}
else
{
map = new HashMap( (int) ( table.size() / 0.75f ) + 1 );
for ( Map.Entry entry : table.entrySet() )
{
Object key = entry.getKey();
if ( key instanceof String )
{
Object value = entry.getValue();
if ( valueType.isInstance( value ) )
{
map.put( key.toString(), valueType.cast( value ) );
}
}
}
}
return map;
}
public Map getSystemProperties()
{
return systemPropertiesView;
}
/**
* Sets the system properties to use, e.g. for processing of artifact descriptors. System properties are usually
* collected from the runtime environment like {@link System#getProperties()} and environment variables.
*
* Note: System properties are of type {@code Map} and any key-value pair in the input map
* that doesn't match this type will be silently ignored.
*
* @param systemProperties The system properties, may be {@code null} or empty if none.
* @return This session for chaining, never {@code null}.
*/
public DefaultRepositorySystemSession setSystemProperties( Map systemProperties )
{
failIfReadOnly();
this.systemProperties = copySafe( systemProperties, String.class );
systemPropertiesView = Collections.unmodifiableMap( this.systemProperties );
return this;
}
/**
* Sets the specified system property.
*
* @param key The property key, must not be {@code null}.
* @param value The property value, may be {@code null} to remove/unset the property.
* @return This session for chaining, never {@code null}.
*/
public DefaultRepositorySystemSession setSystemProperty( String key, String value )
{
failIfReadOnly();
if ( value != null )
{
systemProperties.put( key, value );
}
else
{
systemProperties.remove( key );
}
return this;
}
public Map getUserProperties()
{
return userPropertiesView;
}
/**
* Sets the user properties to use, e.g. for processing of artifact descriptors. User properties are similar to
* system properties but are set on the discretion of the user and hence are considered of higher priority than
* system properties in case of conflicts.
*
* Note: User properties are of type {@code Map} and any key-value pair in the input map
* that doesn't match this type will be silently ignored.
*
* @param userProperties The user properties, may be {@code null} or empty if none.
* @return This session for chaining, never {@code null}.
*/
public DefaultRepositorySystemSession setUserProperties( Map userProperties )
{
failIfReadOnly();
this.userProperties = copySafe( userProperties, String.class );
userPropertiesView = Collections.unmodifiableMap( this.userProperties );
return this;
}
/**
* Sets the specified user property.
*
* @param key The property key, must not be {@code null}.
* @param value The property value, may be {@code null} to remove/unset the property.
* @return This session for chaining, never {@code null}.
*/
public DefaultRepositorySystemSession setUserProperty( String key, String value )
{
failIfReadOnly();
if ( value != null )
{
userProperties.put( key, value );
}
else
{
userProperties.remove( key );
}
return this;
}
public Map getConfigProperties()
{
return configPropertiesView;
}
/**
* Sets the configuration properties used to tweak internal aspects of the repository system (e.g. thread pooling,
* connector-specific behavior, etc.).
*
* Note: Configuration properties are of type {@code Map} and any key-value pair in the
* input map that doesn't match this type will be silently ignored.
*
* @param configProperties The configuration properties, may be {@code null} or empty if none.
* @return This session for chaining, never {@code null}.
*/
public DefaultRepositorySystemSession setConfigProperties( Map configProperties )
{
failIfReadOnly();
this.configProperties = copySafe( configProperties, Object.class );
configPropertiesView = Collections.unmodifiableMap( this.configProperties );
return this;
}
/**
* Sets the specified configuration property.
*
* @param key The property key, must not be {@code null}.
* @param value The property value, may be {@code null} to remove/unset the property.
* @return This session for chaining, never {@code null}.
*/
public DefaultRepositorySystemSession setConfigProperty( String key, Object value )
{
failIfReadOnly();
if ( value != null )
{
configProperties.put( key, value );
}
else
{
configProperties.remove( key );
}
return this;
}
public MirrorSelector getMirrorSelector()
{
return mirrorSelector;
}
/**
* Sets the mirror selector to use for repositories discovered in artifact descriptors. Note that this selector is
* not used for remote repositories which are passed as request parameters to the repository system, those
* repositories are supposed to denote the effective repositories.
*
* @param mirrorSelector The mirror selector to use, may be {@code null}.
* @return This session for chaining, never {@code null}.
*/
public DefaultRepositorySystemSession setMirrorSelector( MirrorSelector mirrorSelector )
{
failIfReadOnly();
this.mirrorSelector = mirrorSelector;
if ( this.mirrorSelector == null )
{
this.mirrorSelector = NullMirrorSelector.INSTANCE;
}
return this;
}
public ProxySelector getProxySelector()
{
return proxySelector;
}
/**
* Sets the proxy selector to use for repositories discovered in artifact descriptors. Note that this selector is
* not used for remote repositories which are passed as request parameters to the repository system, those
* repositories are supposed to have their proxy (if any) already set.
*
* @param proxySelector The proxy selector to use, may be {@code null}.
* @return This session for chaining, never {@code null}.
* @see org.eclipse.aether.repository.RemoteRepository#getProxy()
*/
public DefaultRepositorySystemSession setProxySelector( ProxySelector proxySelector )
{
failIfReadOnly();
this.proxySelector = proxySelector;
if ( this.proxySelector == null )
{
this.proxySelector = NullProxySelector.INSTANCE;
}
return this;
}
public AuthenticationSelector getAuthenticationSelector()
{
return authenticationSelector;
}
/**
* Sets the authentication selector to use for repositories discovered in artifact descriptors. Note that this
* selector is not used for remote repositories which are passed as request parameters to the repository system,
* those repositories are supposed to have their authentication (if any) already set.
*
* @param authenticationSelector The authentication selector to use, may be {@code null}.
* @return This session for chaining, never {@code null}.
* @see org.eclipse.aether.repository.RemoteRepository#getAuthentication()
*/
public DefaultRepositorySystemSession setAuthenticationSelector( AuthenticationSelector authenticationSelector )
{
failIfReadOnly();
this.authenticationSelector = authenticationSelector;
if ( this.authenticationSelector == null )
{
this.authenticationSelector = NullAuthenticationSelector.INSTANCE;
}
return this;
}
public ArtifactTypeRegistry getArtifactTypeRegistry()
{
return artifactTypeRegistry;
}
/**
* Sets the registry of artifact types recognized by this session.
*
* @param artifactTypeRegistry The artifact type registry, may be {@code null}.
* @return This session for chaining, never {@code null}.
*/
public DefaultRepositorySystemSession setArtifactTypeRegistry( ArtifactTypeRegistry artifactTypeRegistry )
{
failIfReadOnly();
this.artifactTypeRegistry = artifactTypeRegistry;
if ( this.artifactTypeRegistry == null )
{
this.artifactTypeRegistry = NullArtifactTypeRegistry.INSTANCE;
}
return this;
}
public DependencyTraverser getDependencyTraverser()
{
return dependencyTraverser;
}
/**
* Sets the dependency traverser to use for building dependency graphs.
*
* @param dependencyTraverser The dependency traverser to use for building dependency graphs, may be {@code null}.
* @return This session for chaining, never {@code null}.
*/
public DefaultRepositorySystemSession setDependencyTraverser( DependencyTraverser dependencyTraverser )
{
failIfReadOnly();
this.dependencyTraverser = dependencyTraverser;
return this;
}
public DependencyManager getDependencyManager()
{
return dependencyManager;
}
/**
* Sets the dependency manager to use for building dependency graphs.
*
* @param dependencyManager The dependency manager to use for building dependency graphs, may be {@code null}.
* @return This session for chaining, never {@code null}.
*/
public DefaultRepositorySystemSession setDependencyManager( DependencyManager dependencyManager )
{
failIfReadOnly();
this.dependencyManager = dependencyManager;
return this;
}
public DependencySelector getDependencySelector()
{
return dependencySelector;
}
/**
* Sets the dependency selector to use for building dependency graphs.
*
* @param dependencySelector The dependency selector to use for building dependency graphs, may be {@code null}.
* @return This session for chaining, never {@code null}.
*/
public DefaultRepositorySystemSession setDependencySelector( DependencySelector dependencySelector )
{
failIfReadOnly();
this.dependencySelector = dependencySelector;
return this;
}
public VersionFilter getVersionFilter()
{
return versionFilter;
}
/**
* Sets the version filter to use for building dependency graphs.
*
* @param versionFilter The version filter to use for building dependency graphs, may be {@code null} to not filter
* versions.
* @return This session for chaining, never {@code null}.
*/
public DefaultRepositorySystemSession setVersionFilter( VersionFilter versionFilter )
{
failIfReadOnly();
this.versionFilter = versionFilter;
return this;
}
public DependencyGraphTransformer getDependencyGraphTransformer()
{
return dependencyGraphTransformer;
}
/**
* Sets the dependency graph transformer to use for building dependency graphs.
*
* @param dependencyGraphTransformer The dependency graph transformer to use for building dependency graphs, may be
* {@code null}.
* @return This session for chaining, never {@code null}.
*/
public DefaultRepositorySystemSession setDependencyGraphTransformer( DependencyGraphTransformer dependencyGraphTransformer )
{
failIfReadOnly();
this.dependencyGraphTransformer = dependencyGraphTransformer;
return this;
}
public SessionData getData()
{
return data;
}
/**
* Sets the custom data associated with this session.
*
* @param data The session data, may be {@code null}.
* @return This session for chaining, never {@code null}.
*/
public DefaultRepositorySystemSession setData( SessionData data )
{
failIfReadOnly();
this.data = data;
if ( this.data == null )
{
this.data = new DefaultSessionData();
}
return this;
}
public RepositoryCache getCache()
{
return cache;
}
/**
* Sets the cache the repository system may use to save data for future reuse during the session.
*
* @param cache The repository cache, may be {@code null} if none.
* @return This session for chaining, never {@code null}.
*/
public DefaultRepositorySystemSession setCache( RepositoryCache cache )
{
failIfReadOnly();
this.cache = cache;
return this;
}
/**
* Marks this session as read-only such that any future attempts to call its mutators will fail with an exception.
* Marking an already read-only session as read-only has no effect. The session's data and cache remain writable
* though.
*/
public void setReadOnly()
{
readOnly = true;
}
private void failIfReadOnly()
{
if ( readOnly )
{
throw new IllegalStateException( "repository system session is read-only" );
}
}
static class NullProxySelector
implements ProxySelector
{
public static final ProxySelector INSTANCE = new NullProxySelector();
public Proxy getProxy( RemoteRepository repository )
{
return repository.getProxy();
}
}
static class NullMirrorSelector
implements MirrorSelector
{
public static final MirrorSelector INSTANCE = new NullMirrorSelector();
public RemoteRepository getMirror( RemoteRepository repository )
{
return null;
}
}
static class NullAuthenticationSelector
implements AuthenticationSelector
{
public static final AuthenticationSelector INSTANCE = new NullAuthenticationSelector();
public Authentication getAuthentication( RemoteRepository repository )
{
return repository.getAuthentication();
}
}
static final class NullArtifactTypeRegistry
implements ArtifactTypeRegistry
{
public static final ArtifactTypeRegistry INSTANCE = new NullArtifactTypeRegistry();
public ArtifactType get( String typeId )
{
return null;
}
}
}