How to use

RepositorySystemSession

in

org.sonatype.aether

setOffline( session.isOffline() );
setTransferErrorCachingEnabled( session.isTransferErrorCachingEnabled() );
setNotFoundCachingEnabled( session.isNotFoundCachingEnabled() );
setIgnoreInvalidArtifactDescriptor( session.isIgnoreInvalidArtifactDescriptor() );
setIgnoreMissingArtifactDescriptor( session.isIgnoreMissingArtifactDescriptor() );
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() );
setDependencyGraphTransformer( session.getDependencyGraphTransformer() );
setData( session.getData() );
setCache( session.getCache() );

public LocalRepository getLocalRepository()
{
  return session.getLocalRepository();
}

public static ArtifactRepository getRepository( RepositorySystemSession session,
                        List<RemoteRepository> repositories, Class<?> repoClass,
                        String repoId )
{
  if ( repoClass != null )
  {
    if ( WorkspaceRepository.class.isAssignableFrom( repoClass ) )
    {
      return session.getWorkspaceReader().getRepository();
    }
    else if ( LocalRepository.class.isAssignableFrom( repoClass ) )
    {
      return session.getLocalRepository();
    }
    else
    {
      for ( RemoteRepository repository : repositories )
      {
        if ( repoId.equals( repository.getId() ) )
        {
          return repository;
        }
      }
    }
  }
  return null;
}

if ( session.getLocalRepositoryManager() == null )
if ( session.getSystemProperties() == null )
if ( session.getUserProperties() == null )
if ( session.getConfigProperties() == null )
if ( session.getMirrorSelector() == null )
if ( session.getProxySelector() == null )
if ( session.getAuthenticationSelector() == null )
if ( session.getArtifactTypeRegistry() == null )
if ( session.getDependencyTraverser() == null )
if ( session.getDependencyManager() == null )
if ( session.getDependencySelector() == null )
if ( session.getDependencyGraphTransformer() == null )
if ( session.getData() == null )

public Map<String, Object> getConfigProperties()
{
  return session.getConfigProperties();
}

public LocalRepositoryManager getLocalRepositoryManager()
{
  return session.getLocalRepositoryManager();
}

boolean failures = false;
LocalRepositoryManager lrm = session.getLocalRepositoryManager();
WorkspaceReader workspace = session.getWorkspaceReader();
  if ( session.isOffline() )
      remoteRepositoryManager.getPolicy( session, group.repository, !snapshot, snapshot );
    if ( session.isNotFoundCachingEnabled() || session.isTransferErrorCachingEnabled() )

  LocalRepository localRepo = session.getLocalRepositoryManager().getRepository();
LocalRepositoryManager lrm = session.getLocalRepositoryManager();
LocalMetadataRequest localRequest =
  new LocalMetadataRequest( metadata, repository, request.getRequestContext() );
if ( session.isOffline() )
         session.getLocalRepository().getBasedir(),
         session.getLocalRepositoryManager().getPathForRemoteMetadata( metadata, repository,
                                        request.getRequestContext() ) );
  check.setFile( checkFile );
         session.getLocalRepository().getBasedir(),
         session.getLocalRepositoryManager().getPathForRemoteMetadata( metadata,
                                        request.getRepository(),
                                        request.getRequestContext() ) );
  File metadataFile = session.getLocalRepositoryManager().find( session, localRequest ).getFile();
  if ( metadataFile != null )

MirrorSelector mirrorSelector = session.getMirrorSelector();
AuthenticationSelector authSelector = session.getAuthenticationSelector();
ProxySelector proxySelector = session.getProxySelector();

throws ArtifactDescriptorException
ProjectToolsSession pts = (ProjectToolsSession) session.getData().get( ProjectToolsSession.SESSION_KEY );
final RequestTrace trace = DefaultRequestTrace.newChild( request.getTrace(), request );
      new RepositoryException( "Artifact relocations form a cycle: " + visited );
    invalidDescriptor( session, trace, artifact, exception );
    if ( session.isIgnoreInvalidArtifactDescriptor() )
      if ( session.isIgnoreMissingArtifactDescriptor() )
    modelRequest.setProcessPlugins( pts == null ? false : pts.isProcessPomPlugins() );
    modelRequest.setTwoPhaseBuilding( false );
    modelRequest.setSystemProperties( toProperties( session.getUserProperties(),
                            session.getSystemProperties() ) );
    modelRequest.setModelCache( DefaultModelCache.newInstance( session ) );
    modelRequest.setModelResolver( new DefaultModelResolver( session, trace.newChild( modelRequest ),
    if ( session.isIgnoreInvalidArtifactDescriptor() )

public TransferListener getTransferListener()
{
  return session.getTransferListener();
}

  private RemoteRepository getRemoteRepository( RepositorySystemSession session, ArtifactRepository remoteRepository )
    throws ArtifactDeployerException
  {
    // CHECKSTYLE_OFF: LineLength
    RemoteRepository aetherRepo = (RemoteRepository) Invoker.invoke( RepositoryUtils.class, "toRepo",
                                     org.apache.maven.artifact.repository.ArtifactRepository.class,
                                     remoteRepository );
    // CHECKSTYLE_ON: LineLength

    if ( aetherRepo.getAuthentication() == null )
    {
      aetherRepo.setAuthentication( session.getAuthenticationSelector().getAuthentication( aetherRepo ) );
    }

    if ( aetherRepo.getProxy() == null )
    {
      aetherRepo.setProxy( session.getProxySelector().getProxy( aetherRepo ) );
    }

    return aetherRepo;
  }
}

if ( isAlreadyUpdated( session.getData(), updateKey ) )
    if ( session.isNotFoundCachingEnabled() )
    if ( session.isTransferErrorCachingEnabled() )

public RepositoryListener getRepositoryListener()
{
  return session.getRepositoryListener();
}

public SessionData getData()
{
  return session.getData();
}

if ( isAlreadyUpdated( session.getData(), updateKey ) )
    if ( session.isTransferErrorCachingEnabled() )

public RepositoryCache getCache()
{
  return session.getCache();
}

public ArtifactTypeRegistry getArtifactTypeRegistry()
{
  return session.getArtifactTypeRegistry();
}

public AuthenticationSelector getAuthenticationSelector()
{
  return session.getAuthenticationSelector();
}

public ProxySelector getProxySelector()
{
  return session.getProxySelector();
}