Repository System

public interface RepositorySystem {
    // Standard Repository Constants
    static final String DEFAULT_LOCAL_REPO_ID = "local";
    static final String DEFAULT_REMOTE_REPO_URL = "https://repo.maven.apache.org/maven2";
    
    /**
     * Resolve a single artifact.
     *
     * @param session repository system session
     * @param request artifact resolution request
     * @return artifact resolution result
     * @throws ArtifactResolutionException if resolution fails
     */
    ArtifactResult resolve(RepositorySystemSession session, ArtifactRequest request) 
        throws ArtifactResolutionException;
    
    /**
     * Resolve multiple artifacts.
     *
     * @param session repository system session
     * @param requests collection of artifact resolution requests
     * @return list of artifact resolution results
     * @throws ArtifactResolutionException if any resolution fails
     */
    List<ArtifactResult> resolveArtifacts(RepositorySystemSession session, 
        Collection<? extends ArtifactRequest> requests) throws ArtifactResolutionException;
    
    /**
     * Read artifact descriptor (POM information).
     *
     * @param session repository system session
     * @param request artifact descriptor request
     * @return artifact descriptor result with dependencies and metadata
     * @throws ArtifactDescriptorException if descriptor reading fails
     */
    ArtifactDescriptorResult readArtifactDescriptor(RepositorySystemSession session,
        ArtifactDescriptorRequest request) throws ArtifactDescriptorException;
    
    /**
     * Collect dependency information.
     *
     * @param session repository system session
     * @param request dependency collection request
     * @return dependency collection result with dependency tree
     * @throws DependencyCollectionException if collection fails
     */
    CollectResult collectDependencies(RepositorySystemSession session, CollectRequest request)
        throws DependencyCollectionException;
    
    /**
     * Resolve dependency tree.
     *
     * @param session repository system session
     * @param request dependency resolution request
     * @return dependency resolution result with resolved artifacts
     * @throws DependencyResolutionException if resolution fails
     */
    DependencyResult resolveDependencies(RepositorySystemSession session, DependencyRequest request)
        throws DependencyResolutionException;
    
    /**
     * Install artifacts to local repository.
     *
     * @param session repository system session
     * @param request installation request
     * @return installation result
     * @throws InstallationException if installation fails
     */
    InstallResult install(RepositorySystemSession session, InstallRequest request)
        throws InstallationException;
    
    /**
     * Deploy artifacts to remote repository.
     *
     * @param session repository system session
     * @param request deployment request
     * @return deployment result
     * @throws DeploymentException if deployment fails
     */
    DeployResult deploy(RepositorySystemSession session, DeployRequest request)
        throws DeploymentException;
    
    /**
     * Create local repository manager.
     *
     * @param session repository system session
     * @param localRepository local repository configuration
     * @return local repository manager instance
     */
    LocalRepositoryManager newLocalRepositoryManager(RepositorySystemSession session,
        LocalRepository localRepository);
    
    /**
     * Create synchronization context for thread-safe operations.
     *
     * @param session repository system session
     * @param shared whether context is shared across threads
     * @return synchronization context
     */
    SyncContext newSyncContext(RepositorySystemSession session, boolean shared);
}

import org.apache.maven.repository.RepositorySystem;
import org.eclipse.aether.artifact.DefaultArtifact;
import org.eclipse.aether.resolution.ArtifactRequest;
import org.eclipse.aether.resolution.ArtifactResult;

@Component
private RepositorySystem repositorySystem;

public void resolveArtifacts(RepositorySystemSession session, List<RemoteRepository> repositories) throws Exception {
    // Create artifact to resolve
    Artifact artifact = new DefaultArtifact("org.apache.commons", "commons-lang3", "jar", "3.12.0");
    
    // Create resolution request
    ArtifactRequest request = new ArtifactRequest();
    request.setArtifact(artifact);
    request.setRepositories(repositories);
    
    // Resolve artifact
    ArtifactResult result = repositorySystem.resolve(session, request);
    
    if (result.isResolved()) {
        File artifactFile = result.getArtifact().getFile();
        System.out.println("Resolved artifact: " + artifactFile.getAbsolutePath());
    } else {
        System.err.println("Failed to resolve artifact: " + artifact);
        for (Exception exception : result.getExceptions()) {
            exception.printStackTrace();
        }
    }
}

// Batch artifact resolution
public Map<Artifact, File> resolveMultipleArtifacts(RepositorySystemSession session,
                                                   List<RemoteRepository> repositories,
                                                   List<Artifact> artifacts) throws Exception {
    // Create requests for all artifacts
    List<ArtifactRequest> requests = new ArrayList<>();
    for (Artifact artifact : artifacts) {
        ArtifactRequest request = new ArtifactRequest();
        request.setArtifact(artifact);
        request.setRepositories(repositories);
        requests.add(request);
    }
    
    // Resolve all artifacts
    List<ArtifactResult> results = repositorySystem.resolveArtifacts(session, requests);
    
    // Build result map
    Map<Artifact, File> resolvedArtifacts = new HashMap<>();
    for (ArtifactResult result : results) {
        if (result.isResolved()) {
            resolvedArtifacts.put(result.getRequest().getArtifact(), result.getArtifact().getFile());
        } else {
            System.err.println("Failed to resolve: " + result.getRequest().getArtifact());
        }
    }
    
    return resolvedArtifacts;
}

public interface RepositorySystem {
    /**
     * Collect dependencies for an artifact or project.
     *
     * @param session repository system session
     * @param request dependency collection request
     * @return collection result with dependency tree
     * @throws DependencyCollectionException if collection fails
     */
    CollectResult collectDependencies(RepositorySystemSession session, CollectRequest request)
        throws DependencyCollectionException;
    
    /**
     * Resolve collected dependencies to files.
     *
     * @param session repository system session  
     * @param request dependency resolution request
     * @return resolution result with artifact files
     * @throws DependencyResolutionException if resolution fails
     */
    DependencyResult resolveDependencies(RepositorySystemSession session, DependencyRequest request)
        throws DependencyResolutionException;
}

import org.eclipse.aether.collection.CollectRequest;
import org.eclipse.aether.collection.CollectResult;
import org.eclipse.aether.resolution.DependencyRequest;
import org.eclipse.aether.resolution.DependencyResult;
import org.eclipse.aether.graph.DependencyNode;

public void resolveDependencyTree(RepositorySystemSession session, List<RemoteRepository> repositories) throws Exception {
    // Create root dependency
    Dependency rootDependency = new Dependency(
        new DefaultArtifact("org.springframework", "spring-core", "jar", "5.3.21"), "compile");
    
    // Create collection request
    CollectRequest collectRequest = new CollectRequest();
    collectRequest.setRoot(rootDependency);
    collectRequest.setRepositories(repositories);
    
    // Collect dependency tree
    CollectResult collectResult = repositorySystem.collectDependencies(session, collectRequest);
    DependencyNode rootNode = collectResult.getRoot();
    
    System.out.println("Dependency tree for " + rootNode.getArtifact() + ":");
    printDependencyTree(rootNode, "");
    
    // Resolve dependencies to files
    DependencyRequest dependencyRequest = new DependencyRequest(rootNode, null);
    DependencyResult dependencyResult = repositorySystem.resolveDependencies(session, dependencyRequest);
    
    System.out.println("\nResolved dependencies:");
    for (ArtifactResult artifactResult : dependencyResult.getArtifactResults()) {
        if (artifactResult.isResolved()) {
            Artifact artifact = artifactResult.getArtifact();
            System.out.println("  " + artifact.getGroupId() + ":" + artifact.getArtifactId() + 
                              ":" + artifact.getVersion() + " -> " + artifact.getFile());
        }
    }
}

private void printDependencyTree(DependencyNode node, String indent) {
    Artifact artifact = node.getArtifact();
    if (artifact != null) {
        System.out.println(indent + artifact.getGroupId() + ":" + artifact.getArtifactId() + 
                          ":" + artifact.getVersion() + " (" + node.getDependency().getScope() + ")");
    }
    
    for (DependencyNode child : node.getChildren()) {
        printDependencyTree(child, indent + "  ");
    }
}

// Resolve with filters
public void resolveDependenciesWithFilters(RepositorySystemSession session, 
                                         List<RemoteRepository> repositories) throws Exception {
    // Create collection request
    CollectRequest collectRequest = new CollectRequest();
    collectRequest.setRoot(new Dependency(
        new DefaultArtifact("org.apache.maven", "maven-core", "jar", "3.9.11"), "compile"));
    collectRequest.setRepositories(repositories);
    
    // Collect dependencies
    CollectResult collectResult = repositorySystem.collectDependencies(session, collectRequest);
    
    // Create dependency filter (exclude test scope)
    DependencyFilter filter = DependencyFilterUtils.classpathFilter(JavaScopes.TEST);
    
    // Resolve with filter
    DependencyRequest dependencyRequest = new DependencyRequest(collectResult.getRoot(), filter);
    DependencyResult result = repositorySystem.resolveDependencies(session, dependencyRequest);
    
    System.out.println("Resolved " + result.getArtifactResults().size() + 
                      " dependencies (excluding test scope)");
}

public interface ArtifactTransferListener {
    /**
     * Called when transfer is initiated.
     *
     * @param event transfer event information
     */
    void transferInitiated(ArtifactTransferEvent event);
    
    /**
     * Called when transfer starts.
     *
     * @param event transfer event information
     */
    void transferStarted(ArtifactTransferEvent event);
    
    /**
     * Called during transfer progress.
     *
     * @param event transfer event information with progress data
     */
    void transferProgress(ArtifactTransferEvent event);
    
    /**
     * Called when transfer completes successfully.
     *
     * @param event transfer event information
     */
    void transferCompleted(ArtifactTransferEvent event);
    
    /**
     * Called when transfer encounters an error.
     *
     * @param event transfer event information with error details
     */
    void transferError(ArtifactTransferEvent event);
}

public class ArtifactTransferEvent {
    // Event Type Constants
    public static final int TRANSFER_INITIATED = 1;
    public static final int TRANSFER_STARTED = 2;
    public static final int TRANSFER_COMPLETED = 3;
    public static final int TRANSFER_ERROR = 4;
    
    // Request Type Constants
    public static final int REQUEST_GET = 1;
    public static final int REQUEST_PUT = 2;
    
    /**
     * Get event type.
     *
     * @return event type constant
     */
    public int getEventType();
    
    /**
     * Get request type (GET or PUT).
     *
     * @return request type constant
     */
    public int getRequestType();
    
    /**
     * Get artifact being transferred.
     *
     * @return artifact instance
     */
    public Artifact getArtifact();
    
    /**
     * Get local file for the artifact.
     *
     * @return local file path
     */
    public File getLocalFile();
    
    /**
     * Get repository involved in transfer.
     *
     * @return artifact repository
     */
    public ArtifactRepository getRepository();
    
    /**
     * Get transfer exception (for error events).
     *
     * @return exception or null if no error
     */
    public Exception getException();
    
    /**
     * Get total length of transfer.
     *
     * @return total bytes to transfer
     */
    public long getDataLength();
    
    /**
     * Get bytes transferred so far.
     *
     * @return bytes transferred
     */
    public long getTransferredBytes();
    
    /**
     * Get data buffer for progress events.
     *
     * @return byte buffer with current data chunk
     */
    public byte[] getDataBuffer();
    
    /**
     * Get offset in data buffer.
     *
     * @return buffer offset
     */
    public int getDataOffset();
    
    /**
     * Get length of data in buffer.
     *
     * @return buffer data length
     */
    public int getDataLength();
}

import org.apache.maven.repository.ArtifactTransferListener;
import org.apache.maven.repository.ArtifactTransferEvent;

public class ProgressTrackingTransferListener implements ArtifactTransferListener {
    private final Map<Artifact, TransferProgress> progressMap = new ConcurrentHashMap<>();
    
    @Override
    public void transferInitiated(ArtifactTransferEvent event) {
        Artifact artifact = event.getArtifact();
        System.out.println("Transfer initiated: " + artifact.getGroupId() + ":" + 
                          artifact.getArtifactId() + ":" + artifact.getVersion());
    }
    
    @Override
    public void transferStarted(ArtifactTransferEvent event) {
        Artifact artifact = event.getArtifact();
        long totalBytes = event.getDataLength();
        
        TransferProgress progress = new TransferProgress(totalBytes, System.currentTimeMillis());
        progressMap.put(artifact, progress);
        
        String direction = (event.getRequestType() == ArtifactTransferEvent.REQUEST_GET) ? "Downloading" : "Uploading";
        System.out.println(direction + " " + artifact.getArtifactId() + 
                          " (" + formatBytes(totalBytes) + ")");
    }
    
    @Override
    public void transferProgress(ArtifactTransferEvent event) {
        Artifact artifact = event.getArtifact();
        TransferProgress progress = progressMap.get(artifact);
        
        if (progress != null) {
            progress.addBytes(event.getDataLength());
            
            long elapsed = System.currentTimeMillis() - progress.getStartTime();
            if (elapsed > 1000) { // Update every second
                double percentage = (progress.getTransferredBytes() * 100.0) / progress.getTotalBytes();
                double speed = progress.getTransferredBytes() / (elapsed / 1000.0); // bytes per second
                
                System.out.printf("\r%s: %.1f%% (%s at %s/s)",
                    artifact.getArtifactId(),
                    percentage,
                    formatBytes(progress.getTransferredBytes()),
                    formatBytes((long) speed));
            }
        }
    }
    
    @Override
    public void transferCompleted(ArtifactTransferEvent event) {
        Artifact artifact = event.getArtifact();
        TransferProgress progress = progressMap.remove(artifact);
        
        if (progress != null) {
            long elapsed = System.currentTimeMillis() - progress.getStartTime();
            double speed = progress.getTotalBytes() / (elapsed / 1000.0);
            
            System.out.println("\nCompleted " + artifact.getArtifactId() + 
                              " (" + formatBytes(progress.getTotalBytes()) + 
                              " in " + (elapsed / 1000.0) + "s at " + formatBytes((long) speed) + "/s)");
        }
    }
    
    @Override
    public void transferError(ArtifactTransferEvent event) {
        Artifact artifact = event.getArtifact();
        Exception exception = event.getException();
        
        progressMap.remove(artifact);
        
        System.err.println("\nTransfer failed for " + artifact.getArtifactId() + 
                          ": " + exception.getMessage());
    }
    
    private String formatBytes(long bytes) {
        if (bytes < 1024) return bytes + " B";
        if (bytes < 1024 * 1024) return String.format("%.1f KB", bytes / 1024.0);
        return String.format("%.1f MB", bytes / (1024.0 * 1024.0));
    }
    
    private static class TransferProgress {
        private final long totalBytes;
        private final long startTime;
        private long transferredBytes;
        
        public TransferProgress(long totalBytes, long startTime) {
            this.totalBytes = totalBytes;
            this.startTime = startTime;
        }
        
        public void addBytes(long bytes) {
            this.transferredBytes += bytes;
        }
        
        public long getTotalBytes() { return totalBytes; }
        public long getStartTime() { return startTime; }
        public long getTransferredBytes() { return transferredBytes; }
    }
}

public interface ArtifactRepository {
    /**
     * Get repository identifier.
     *
     * @return repository ID
     */
    String getId();
    
    /**
     * Set repository identifier.
     *
     * @param id repository ID
     */
    void setId(String id);
    
    /**
     * Get repository URL.
     *
     * @return repository URL
     */
    String getUrl();
    
    /**
     * Set repository URL.
     *
     * @param url repository URL
     */
    void setUrl(String url);
    
    /**
     * Get repository layout.
     *
     * @return repository layout strategy
     */
    ArtifactRepositoryLayout getLayout();
    
    /**
     * Set repository layout.
     *
     * @param layout repository layout strategy
     */
    void setLayout(ArtifactRepositoryLayout layout);
    
    /**
     * Get snapshot policy.
     *
     * @return snapshot artifact policy
     */
    ArtifactRepositoryPolicy getSnapshots();
    
    /**
     * Set snapshot policy.
     *
     * @param policy snapshot artifact policy
     */
    void setSnapshots(ArtifactRepositoryPolicy policy);
    
    /**
     * Get releases policy.
     *
     * @return release artifact policy
     */
    ArtifactRepositoryPolicy getReleases();
    
    /**
     * Set releases policy.
     *
     * @param policy release artifact policy
     */
    void setReleases(ArtifactRepositoryPolicy policy);
    
    /**
     * Check if repository uses unique versions for snapshots.
     *
     * @return true if unique versions are used
     */
    boolean isUniqueVersion();
    
    /**
     * Check if repository is blacklisted.
     *
     * @return true if blacklisted
     */
    boolean isBlacklisted();
    
    /**
     * Set repository blacklist status.
     *
     * @param blacklisted true to blacklist repository
     */
    void setBlacklisted(boolean blacklisted);
}

import org.apache.maven.artifact.repository.ArtifactRepository;
import org.apache.maven.artifact.repository.DefaultArtifactRepository;
import org.apache.maven.artifact.repository.ArtifactRepositoryPolicy;

public List<ArtifactRepository> createRepositoryList() {
    List<ArtifactRepository> repositories = new ArrayList<>();
    
    // Central repository
    ArtifactRepository central = new DefaultArtifactRepository(
        "central",
        "https://repo.maven.apache.org/maven2",
        new DefaultArtifactRepositoryLayout());
    
    // Enable releases, disable snapshots
    central.setReleases(new ArtifactRepositoryPolicy(true, "daily", "warn"));
    central.setSnapshots(new ArtifactRepositoryPolicy(false, "never", "ignore"));
    
    repositories.add(central);
    
    // Snapshot repository
    ArtifactRepository snapshots = new DefaultArtifactRepository(
        "snapshots", 
        "https://oss.sonatype.org/content/repositories/snapshots",
        new DefaultArtifactRepositoryLayout());
    
    // Enable snapshots with frequent updates
    snapshots.setReleases(new ArtifactRepositoryPolicy(false, "never", "ignore"));
    snapshots.setSnapshots(new ArtifactRepositoryPolicy(true, "always", "warn"));
    
    repositories.add(snapshots);
    
    return repositories;
}

// Create local repository
public ArtifactRepository createLocalRepository(String path) {
    ArtifactRepository localRepo = new DefaultArtifactRepository(
        RepositorySystem.DEFAULT_LOCAL_REPO_ID,
        "file://" + path,
        new DefaultArtifactRepositoryLayout());
    
    // Local repository accepts both releases and snapshots
    localRepo.setReleases(new ArtifactRepositoryPolicy(true, "never", "ignore"));
    localRepo.setSnapshots(new ArtifactRepositoryPolicy(true, "never", "ignore"));
    
    return localRepo;
}

public interface RepositorySystem {
    /**
     * Install artifacts to local repository.
     *
     * @param session repository system session
     * @param request installation request containing artifacts to install
     * @return installation result
     * @throws InstallationException if installation fails
     */
    InstallResult install(RepositorySystemSession session, InstallRequest request)
        throws InstallationException;
    
    /**
     * Deploy artifacts to remote repository.
     *
     * @param session repository system session
     * @param request deployment request containing artifacts and target repository
     * @return deployment result
     * @throws DeploymentException if deployment fails
     */
    DeployResult deploy(RepositorySystemSession session, DeployRequest request)
        throws DeploymentException;
}

import org.eclipse.aether.installation.InstallRequest;
import org.eclipse.aether.installation.InstallResult;
import org.eclipse.aether.deployment.DeployRequest;
import org.eclipse.aether.deployment.DeployResult;

public void installArtifact(RepositorySystemSession session, MavenProject project) throws Exception {
    // Create artifacts to install
    Artifact mainArtifact = new DefaultArtifact(
        project.getGroupId(),
        project.getArtifactId(), 
        project.getPackaging(),
        project.getVersion());
    mainArtifact = mainArtifact.setFile(project.getArtifact().getFile());
    
    // Create install request
    InstallRequest installRequest = new InstallRequest();
    installRequest.addArtifact(mainArtifact);
    
    // Install POM
    File pomFile = project.getFile();
    if (pomFile != null && pomFile.exists()) {
        Artifact pomArtifact = new SubArtifact(mainArtifact, "", "pom");
        pomArtifact = pomArtifact.setFile(pomFile);
        installRequest.addArtifact(pomArtifact);
    }
    
    // Install attached artifacts (sources, javadoc, etc.)
    for (Artifact attached : project.getAttachedArtifacts()) {
        installRequest.addArtifact(attached);
    }
    
    // Perform installation
    InstallResult result = repositorySystem.install(session, installRequest);
    
    System.out.println("Installed " + result.getArtifacts().size() + " artifacts to local repository:");
    for (Artifact artifact : result.getArtifacts()) {
        System.out.println("  " + artifact);
    }
}

public void deployArtifact(RepositorySystemSession session, MavenProject project, 
                          RemoteRepository deploymentRepository) throws Exception {
    // Create deployment request
    DeployRequest deployRequest = new DeployRequest();
    deployRequest.setRepository(deploymentRepository);
    
    // Add main artifact
    Artifact mainArtifact = new DefaultArtifact(
        project.getGroupId(),
        project.getArtifactId(),
        project.getPackaging(), 
        project.getVersion());
    mainArtifact = mainArtifact.setFile(project.getArtifact().getFile());
    deployRequest.addArtifact(mainArtifact);
    
    // Add POM
    File pomFile = project.getFile();
    if (pomFile != null && pomFile.exists()) {
        Artifact pomArtifact = new SubArtifact(mainArtifact, "", "pom");
        pomArtifact = pomArtifact.setFile(pomFile);
        deployRequest.addArtifact(pomArtifact);
    }
    
    // Add attached artifacts
    for (Artifact attached : project.getAttachedArtifacts()) {
        deployRequest.addArtifact(attached);
    }
    
    // Perform deployment
    DeployResult result = repositorySystem.deploy(session, deployRequest);
    
    System.out.println("Deployed " + result.getArtifacts().size() + 
                      " artifacts to " + deploymentRepository.getId() + ":");
    for (Artifact artifact : result.getArtifacts()) {
        System.out.println("  " + artifact + " -> " + deploymentRepository.getUrl());
    }
}

public interface ArtifactRepositoryPolicy {
    boolean isEnabled();
    void setEnabled(boolean enabled);
    
    String getUpdatePolicy();
    void setUpdatePolicy(String updatePolicy);
    
    String getChecksumPolicy();
    void setChecksumPolicy(String checksumPolicy);
    
    // Update Policy Constants
    String UPDATE_POLICY_NEVER = "never";
    String UPDATE_POLICY_ALWAYS = "always";
    String UPDATE_POLICY_DAILY = "daily";
    String UPDATE_POLICY_INTERVAL = "interval";
    
    // Checksum Policy Constants
    String CHECKSUM_POLICY_FAIL = "fail";
    String CHECKSUM_POLICY_WARN = "warn";
    String CHECKSUM_POLICY_IGNORE = "ignore";
}

public interface ArtifactRepositoryLayout {
    String pathOf(Artifact artifact);
    String pathOfLocalRepositoryMetadata(Metadata metadata, ArtifactRepository repository);
    String pathOfRemoteRepositoryMetadata(Metadata metadata);
}

public interface RepositorySystemSession {
    boolean isOffline();
    boolean isIgnoreArtifactDescriptorRepositories();
    ResolutionErrorPolicy getResolutionErrorPolicy();
    ArtifactTypeRegistry getArtifactTypeRegistry();
    DependencyTraverser getDependencyTraverser();
    DependencyManager getDependencyManager();
    DependencySelector getDependencySelector();
    VersionFilter getVersionFilter();
    VersionRangeResolver getVersionRangeResolver();
    VersionResolver getVersionResolver();
    ArtifactResolver getArtifactResolver();
    MetadataResolver getMetadataResolver();
    FileTransformerManager getFileTransformerManager();
    SessionData getData();
    RepositoryCache getCache();
    LocalRepository getLocalRepository();
    LocalRepositoryManager getLocalRepositoryManager();
    WorkspaceReader getWorkspaceReader();
    RepositoryListener getRepositoryListener();
    TransferListener getTransferListener();
    Map<String, String> getSystemProperties();
    Map<String, String> getUserProperties();
    Map<String, Object> getConfigProperties();
    MirrorSelector getMirrorSelector();
    ProxySelector getProxySelector();
    AuthenticationSelector getAuthenticationSelector();
    ArtifactDescriptorPolicy getArtifactDescriptorPolicy();
}

public interface LocalRepositoryManager {
    LocalRepository getRepository();
    String getPathForLocalArtifact(Artifact artifact);
    String getPathForRemoteArtifact(Artifact artifact, RemoteRepository repository, String context);
    String getPathForLocalMetadata(Metadata metadata);
    String getPathForRemoteMetadata(Metadata metadata, RemoteRepository repository, String context);
    LocalArtifactResult find(RepositorySystemSession session, LocalArtifactRequest request);
    void add(RepositorySystemSession session, LocalArtifactRegistration request);
    LocalMetadataResult find(RepositorySystemSession session, LocalMetadataRequest request);
    void add(RepositorySystemSession session, LocalMetadataRegistration request);
}

public interface SyncContext extends Closeable {
    void acquire(Collection<? extends Artifact> artifacts, Collection<? extends Metadata> metadatas);
    void close();
}