[MNG-8107] Update Resolver 2.0.0-alpha-11 (#1488)
Update to Resolver 2.0.0-alpha-11 and restore renamed class.
---
https://issues.apache.org/jira/browse/MNG-8107
diff --git a/maven-api-impl/src/test/java/org/apache/maven/internal/impl/standalone/RepositorySystemSupplier.java b/maven-api-impl/src/test/java/org/apache/maven/internal/impl/standalone/RepositorySystemSupplier.java
index d64a617..e60bdbd 100644
--- a/maven-api-impl/src/test/java/org/apache/maven/internal/impl/standalone/RepositorySystemSupplier.java
+++ b/maven-api-impl/src/test/java/org/apache/maven/internal/impl/standalone/RepositorySystemSupplier.java
@@ -111,6 +111,7 @@
import org.eclipse.aether.named.providers.LocalSemaphoreNamedLockFactory;
import org.eclipse.aether.named.providers.NoopNamedLockFactory;
import org.eclipse.aether.spi.artifact.ArtifactPredicateFactory;
+import org.eclipse.aether.spi.artifact.decorator.ArtifactDecoratorFactory;
import org.eclipse.aether.spi.artifact.generator.ArtifactGeneratorFactory;
import org.eclipse.aether.spi.checksums.ProvidedChecksumsSource;
import org.eclipse.aether.spi.checksums.TrustedChecksumsSource;
@@ -155,8 +156,6 @@
* Important: Given the instance of supplier memorizes the supplier {@link RepositorySystem} instance it supplies,
* their lifecycle is shared as well: once supplied repository system is shut-down, this instance becomes closed as
* well. Any subsequent {@code getXXX} method invocation attempt will fail with {@link IllegalStateException}.
- *
- * @since 1.9.15
*/
public class RepositorySystemSupplier implements Supplier<RepositorySystem> {
private final AtomicBoolean closed = new AtomicBoolean(false);
@@ -640,7 +639,9 @@ public final Map<String, TransporterFactory> getTransporterFactories() {
protected Map<String, TransporterFactory> createTransporterFactories() {
HashMap<String, TransporterFactory> result = new HashMap<>();
result.put(FileTransporterFactory.NAME, new FileTransporterFactory());
- result.put(ApacheTransporterFactory.NAME, new ApacheTransporterFactory(getChecksumExtractor()));
+ result.put(
+ ApacheTransporterFactory.NAME,
+ new ApacheTransporterFactory(getChecksumExtractor(), getPathProcessor()));
return result;
}
@@ -767,10 +768,18 @@ protected Map<String, DependencyCollectorDelegate> createDependencyCollectorDele
HashMap<String, DependencyCollectorDelegate> result = new HashMap<>();
result.put(
DfDependencyCollector.NAME,
- new DfDependencyCollector(remoteRepositoryManager, artifactDescriptorReader, versionRangeResolver));
+ new DfDependencyCollector(
+ remoteRepositoryManager,
+ artifactDescriptorReader,
+ versionRangeResolver,
+ getArtifactDecoratorFactories()));
result.put(
BfDependencyCollector.NAME,
- new BfDependencyCollector(remoteRepositoryManager, artifactDescriptorReader, versionRangeResolver));
+ new BfDependencyCollector(
+ remoteRepositoryManager,
+ artifactDescriptorReader,
+ versionRangeResolver,
+ getArtifactDecoratorFactories()));
return result;
}
@@ -882,6 +891,21 @@ protected Map<String, ArtifactGeneratorFactory> createArtifactGeneratorFactories
return new HashMap<>();
}
+ private Map<String, ArtifactDecoratorFactory> artifactDecoratorFactories;
+
+ public final Map<String, ArtifactDecoratorFactory> getArtifactDecoratorFactories() {
+ checkClosed();
+ if (artifactDecoratorFactories == null) {
+ artifactDecoratorFactories = createArtifactDecoratorFactories();
+ }
+ return artifactDecoratorFactories;
+ }
+
+ protected Map<String, ArtifactDecoratorFactory> createArtifactDecoratorFactories() {
+ // by default none, this is extension point
+ return new HashMap<>();
+ }
+
// Maven provided
private Map<String, MetadataGeneratorFactory> metadataGeneratorFactories;
@@ -1036,7 +1060,8 @@ protected RepositorySystem createRepositorySystem() {
getLocalRepositoryProvider(),
getSyncContextFactory(),
getRemoteRepositoryManager(),
- getRepositorySystemLifecycle());
+ getRepositorySystemLifecycle(),
+ getArtifactDecoratorFactories());
}
@Override
diff --git a/maven-resolver-provider/src/main/java/org/apache/maven/repository/internal/MavenRepositorySystemSupplier.java b/maven-resolver-provider/src/main/java/org/apache/maven/repository/internal/MavenRepositorySystemSupplier.java
new file mode 100644
index 0000000..5348f9e
--- /dev/null
+++ b/maven-resolver-provider/src/main/java/org/apache/maven/repository/internal/MavenRepositorySystemSupplier.java
@@ -0,0 +1,1099 @@
+/*
+ * 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.
+ */
+package org.apache.maven.repository.internal;
+
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.Supplier;
+
+import org.apache.maven.api.services.ModelBuilder;
+import org.apache.maven.internal.impl.DefaultModelUrlNormalizer;
+import org.apache.maven.internal.impl.DefaultModelVersionParser;
+import org.apache.maven.internal.impl.DefaultModelXmlFactory;
+import org.apache.maven.internal.impl.DefaultPluginConfigurationExpander;
+import org.apache.maven.internal.impl.DefaultSuperPomProvider;
+import org.apache.maven.internal.impl.DefaultUrlNormalizer;
+import org.apache.maven.internal.impl.model.BuildModelTransformer;
+import org.apache.maven.internal.impl.model.DefaultDependencyManagementImporter;
+import org.apache.maven.internal.impl.model.DefaultDependencyManagementInjector;
+import org.apache.maven.internal.impl.model.DefaultInheritanceAssembler;
+import org.apache.maven.internal.impl.model.DefaultModelBuilder;
+import org.apache.maven.internal.impl.model.DefaultModelInterpolator;
+import org.apache.maven.internal.impl.model.DefaultModelNormalizer;
+import org.apache.maven.internal.impl.model.DefaultModelPathTranslator;
+import org.apache.maven.internal.impl.model.DefaultModelProcessor;
+import org.apache.maven.internal.impl.model.DefaultModelValidator;
+import org.apache.maven.internal.impl.model.DefaultModelVersionProcessor;
+import org.apache.maven.internal.impl.model.DefaultPathTranslator;
+import org.apache.maven.internal.impl.model.DefaultPluginManagementInjector;
+import org.apache.maven.internal.impl.model.DefaultProfileInjector;
+import org.apache.maven.internal.impl.model.DefaultProfileSelector;
+import org.apache.maven.internal.impl.model.DefaultRootLocator;
+import org.apache.maven.internal.impl.model.ProfileActivationFilePathInterpolator;
+import org.apache.maven.internal.impl.resolver.DefaultArtifactDescriptorReader;
+import org.apache.maven.internal.impl.resolver.DefaultVersionRangeResolver;
+import org.apache.maven.internal.impl.resolver.DefaultVersionResolver;
+import org.apache.maven.internal.impl.resolver.MavenArtifactRelocationSource;
+import org.apache.maven.internal.impl.resolver.PluginsMetadataGeneratorFactory;
+import org.apache.maven.internal.impl.resolver.SnapshotMetadataGeneratorFactory;
+import org.apache.maven.internal.impl.resolver.VersionsMetadataGeneratorFactory;
+import org.apache.maven.internal.impl.resolver.relocation.DistributionManagementArtifactRelocationSource;
+import org.apache.maven.internal.impl.resolver.relocation.UserPropertiesArtifactRelocationSource;
+import org.eclipse.aether.RepositoryListener;
+import org.eclipse.aether.RepositorySystem;
+import org.eclipse.aether.connector.basic.BasicRepositoryConnectorFactory;
+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.MetadataGeneratorFactory;
+import org.eclipse.aether.impl.MetadataResolver;
+import org.eclipse.aether.impl.OfflineController;
+import org.eclipse.aether.impl.RemoteRepositoryFilterManager;
+import org.eclipse.aether.impl.RemoteRepositoryManager;
+import org.eclipse.aether.impl.RepositoryConnectorProvider;
+import org.eclipse.aether.impl.RepositoryEventDispatcher;
+import org.eclipse.aether.impl.RepositorySystemLifecycle;
+import org.eclipse.aether.impl.UpdateCheckManager;
+import org.eclipse.aether.impl.UpdatePolicyAnalyzer;
+import org.eclipse.aether.impl.VersionRangeResolver;
+import org.eclipse.aether.impl.VersionResolver;
+import org.eclipse.aether.internal.impl.DefaultArtifactPredicateFactory;
+import org.eclipse.aether.internal.impl.DefaultArtifactResolver;
+import org.eclipse.aether.internal.impl.DefaultChecksumPolicyProvider;
+import org.eclipse.aether.internal.impl.DefaultChecksumProcessor;
+import org.eclipse.aether.internal.impl.DefaultDeployer;
+import org.eclipse.aether.internal.impl.DefaultInstaller;
+import org.eclipse.aether.internal.impl.DefaultLocalPathComposer;
+import org.eclipse.aether.internal.impl.DefaultLocalPathPrefixComposerFactory;
+import org.eclipse.aether.internal.impl.DefaultLocalRepositoryProvider;
+import org.eclipse.aether.internal.impl.DefaultMetadataResolver;
+import org.eclipse.aether.internal.impl.DefaultOfflineController;
+import org.eclipse.aether.internal.impl.DefaultPathProcessor;
+import org.eclipse.aether.internal.impl.DefaultRemoteRepositoryManager;
+import org.eclipse.aether.internal.impl.DefaultRepositoryConnectorProvider;
+import org.eclipse.aether.internal.impl.DefaultRepositoryEventDispatcher;
+import org.eclipse.aether.internal.impl.DefaultRepositoryLayoutProvider;
+import org.eclipse.aether.internal.impl.DefaultRepositorySystem;
+import org.eclipse.aether.internal.impl.DefaultRepositorySystemLifecycle;
+import org.eclipse.aether.internal.impl.DefaultTrackingFileManager;
+import org.eclipse.aether.internal.impl.DefaultTransporterProvider;
+import org.eclipse.aether.internal.impl.DefaultUpdateCheckManager;
+import org.eclipse.aether.internal.impl.DefaultUpdatePolicyAnalyzer;
+import org.eclipse.aether.internal.impl.EnhancedLocalRepositoryManagerFactory;
+import org.eclipse.aether.internal.impl.LocalPathComposer;
+import org.eclipse.aether.internal.impl.LocalPathPrefixComposerFactory;
+import org.eclipse.aether.internal.impl.Maven2RepositoryLayoutFactory;
+import org.eclipse.aether.internal.impl.SimpleLocalRepositoryManagerFactory;
+import org.eclipse.aether.internal.impl.TrackingFileManager;
+import org.eclipse.aether.internal.impl.checksum.DefaultChecksumAlgorithmFactorySelector;
+import org.eclipse.aether.internal.impl.checksum.Md5ChecksumAlgorithmFactory;
+import org.eclipse.aether.internal.impl.checksum.Sha1ChecksumAlgorithmFactory;
+import org.eclipse.aether.internal.impl.checksum.Sha256ChecksumAlgorithmFactory;
+import org.eclipse.aether.internal.impl.checksum.Sha512ChecksumAlgorithmFactory;
+import org.eclipse.aether.internal.impl.checksum.SparseDirectoryTrustedChecksumsSource;
+import org.eclipse.aether.internal.impl.checksum.SummaryFileTrustedChecksumsSource;
+import org.eclipse.aether.internal.impl.checksum.TrustedToProvidedChecksumsSourceAdapter;
+import org.eclipse.aether.internal.impl.collect.DefaultDependencyCollector;
+import org.eclipse.aether.internal.impl.collect.DependencyCollectorDelegate;
+import org.eclipse.aether.internal.impl.collect.bf.BfDependencyCollector;
+import org.eclipse.aether.internal.impl.collect.df.DfDependencyCollector;
+import org.eclipse.aether.internal.impl.filter.DefaultRemoteRepositoryFilterManager;
+import org.eclipse.aether.internal.impl.filter.GroupIdRemoteRepositoryFilterSource;
+import org.eclipse.aether.internal.impl.filter.PrefixesRemoteRepositoryFilterSource;
+import org.eclipse.aether.internal.impl.resolution.TrustedChecksumsArtifactResolverPostProcessor;
+import org.eclipse.aether.internal.impl.synccontext.DefaultSyncContextFactory;
+import org.eclipse.aether.internal.impl.synccontext.named.NameMapper;
+import org.eclipse.aether.internal.impl.synccontext.named.NameMappers;
+import org.eclipse.aether.internal.impl.synccontext.named.NamedLockFactoryAdapterFactory;
+import org.eclipse.aether.internal.impl.synccontext.named.NamedLockFactoryAdapterFactoryImpl;
+import org.eclipse.aether.internal.impl.transport.http.DefaultChecksumExtractor;
+import org.eclipse.aether.internal.impl.transport.http.Nx2ChecksumExtractor;
+import org.eclipse.aether.internal.impl.transport.http.XChecksumExtractor;
+import org.eclipse.aether.named.NamedLockFactory;
+import org.eclipse.aether.named.providers.FileLockNamedLockFactory;
+import org.eclipse.aether.named.providers.LocalReadWriteLockNamedLockFactory;
+import org.eclipse.aether.named.providers.LocalSemaphoreNamedLockFactory;
+import org.eclipse.aether.named.providers.NoopNamedLockFactory;
+import org.eclipse.aether.spi.artifact.ArtifactPredicateFactory;
+import org.eclipse.aether.spi.artifact.decorator.ArtifactDecoratorFactory;
+import org.eclipse.aether.spi.artifact.generator.ArtifactGeneratorFactory;
+import org.eclipse.aether.spi.checksums.ProvidedChecksumsSource;
+import org.eclipse.aether.spi.checksums.TrustedChecksumsSource;
+import org.eclipse.aether.spi.connector.RepositoryConnectorFactory;
+import org.eclipse.aether.spi.connector.checksum.ChecksumAlgorithmFactory;
+import org.eclipse.aether.spi.connector.checksum.ChecksumAlgorithmFactorySelector;
+import org.eclipse.aether.spi.connector.checksum.ChecksumPolicyProvider;
+import org.eclipse.aether.spi.connector.filter.RemoteRepositoryFilterSource;
+import org.eclipse.aether.spi.connector.layout.RepositoryLayoutFactory;
+import org.eclipse.aether.spi.connector.layout.RepositoryLayoutProvider;
+import org.eclipse.aether.spi.connector.transport.TransporterFactory;
+import org.eclipse.aether.spi.connector.transport.TransporterProvider;
+import org.eclipse.aether.spi.connector.transport.http.ChecksumExtractor;
+import org.eclipse.aether.spi.connector.transport.http.ChecksumExtractorStrategy;
+import org.eclipse.aether.spi.io.ChecksumProcessor;
+import org.eclipse.aether.spi.io.PathProcessor;
+import org.eclipse.aether.spi.localrepo.LocalRepositoryManagerFactory;
+import org.eclipse.aether.spi.resolution.ArtifactResolverPostProcessor;
+import org.eclipse.aether.spi.synccontext.SyncContextFactory;
+import org.eclipse.aether.transport.apache.ApacheTransporterFactory;
+import org.eclipse.aether.transport.file.FileTransporterFactory;
+import org.eclipse.aether.util.version.GenericVersionScheme;
+import org.eclipse.aether.version.VersionScheme;
+
+/**
+ * A simple memorizing {@link Supplier} of {@link RepositorySystem} instance, that on first call
+ * supplies lazily constructed instance, and on each subsequent call same instance. Hence, this instance should be
+ * thrown away immediately once repository system was created and there is no need for more instances. If new
+ * repository system instance needed, new instance of this class must be created. For proper shut down of returned
+ * repository system instance(s) use {@link RepositorySystem#shutdown()} method on supplied instance(s).
+ * <p>
+ * Since Resolver 2.0 this class offers access to various components via public getters, and allows even partial object
+ * graph construction.
+ * <p>
+ * Extend this class {@code createXXX()} methods and override to customize, if needed. The contract of this class makes
+ * sure that these (potentially overridden) methods are invoked only once, and instance created by those methods are
+ * memorized and kept as long as supplier instance is kept open.
+ * <p>
+ * This class is not thread safe and must be used from one thread only, while the constructed {@link RepositorySystem}
+ * is thread safe.
+ * <p>
+ * Important: Given the instance of supplier memorizes the supplier {@link RepositorySystem} instance it supplies,
+ * their lifecycle is shared as well: once supplied repository system is shut-down, this instance becomes closed as
+ * well. Any subsequent {@code getXXX} method invocation attempt will fail with {@link IllegalStateException}.
+ *
+ * @since 4.0.0
+ */
+public class MavenRepositorySystemSupplier implements Supplier<RepositorySystem> {
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ public MavenRepositorySystemSupplier() {}
+
+ private void checkClosed() {
+ if (closed.get()) {
+ throw new IllegalStateException("Supplier is closed");
+ }
+ }
+
+ private PathProcessor pathProcessor;
+
+ public final PathProcessor getPathProcessor() {
+ checkClosed();
+ if (pathProcessor == null) {
+ pathProcessor = createPathProcessor();
+ }
+ return pathProcessor;
+ }
+
+ protected PathProcessor createPathProcessor() {
+ return new DefaultPathProcessor();
+ }
+
+ private ChecksumProcessor checksumProcessor;
+
+ public final ChecksumProcessor getChecksumProcessor() {
+ checkClosed();
+ if (checksumProcessor == null) {
+ checksumProcessor = createChecksumProcessor();
+ }
+ return checksumProcessor;
+ }
+
+ protected ChecksumProcessor createChecksumProcessor() {
+ return new DefaultChecksumProcessor(getPathProcessor());
+ }
+
+ private TrackingFileManager trackingFileManager;
+
+ public final TrackingFileManager getTrackingFileManager() {
+ checkClosed();
+ if (trackingFileManager == null) {
+ trackingFileManager = createTrackingFileManager();
+ }
+ return trackingFileManager;
+ }
+
+ protected TrackingFileManager createTrackingFileManager() {
+ return new DefaultTrackingFileManager();
+ }
+
+ private LocalPathComposer localPathComposer;
+
+ public final LocalPathComposer getLocalPathComposer() {
+ checkClosed();
+ if (localPathComposer == null) {
+ localPathComposer = createLocalPathComposer();
+ }
+ return localPathComposer;
+ }
+
+ protected LocalPathComposer createLocalPathComposer() {
+ return new DefaultLocalPathComposer();
+ }
+
+ private LocalPathPrefixComposerFactory localPathPrefixComposerFactory;
+
+ public final LocalPathPrefixComposerFactory getLocalPathPrefixComposerFactory() {
+ checkClosed();
+ if (localPathPrefixComposerFactory == null) {
+ localPathPrefixComposerFactory = createLocalPathPrefixComposerFactory();
+ }
+ return localPathPrefixComposerFactory;
+ }
+
+ protected LocalPathPrefixComposerFactory createLocalPathPrefixComposerFactory() {
+ return new DefaultLocalPathPrefixComposerFactory();
+ }
+
+ private RepositorySystemLifecycle repositorySystemLifecycle;
+
+ public final RepositorySystemLifecycle getRepositorySystemLifecycle() {
+ checkClosed();
+ if (repositorySystemLifecycle == null) {
+ repositorySystemLifecycle = createRepositorySystemLifecycle();
+ repositorySystemLifecycle.addOnSystemEndedHandler(() -> closed.set(true));
+ }
+ return repositorySystemLifecycle;
+ }
+
+ protected RepositorySystemLifecycle createRepositorySystemLifecycle() {
+ return new DefaultRepositorySystemLifecycle();
+ }
+
+ private OfflineController offlineController;
+
+ public final OfflineController getOfflineController() {
+ checkClosed();
+ if (offlineController == null) {
+ offlineController = createOfflineController();
+ }
+ return offlineController;
+ }
+
+ protected OfflineController createOfflineController() {
+ return new DefaultOfflineController();
+ }
+
+ private UpdatePolicyAnalyzer updatePolicyAnalyzer;
+
+ public final UpdatePolicyAnalyzer getUpdatePolicyAnalyzer() {
+ checkClosed();
+ if (updatePolicyAnalyzer == null) {
+ updatePolicyAnalyzer = createUpdatePolicyAnalyzer();
+ }
+ return updatePolicyAnalyzer;
+ }
+
+ protected UpdatePolicyAnalyzer createUpdatePolicyAnalyzer() {
+ return new DefaultUpdatePolicyAnalyzer();
+ }
+
+ private ChecksumPolicyProvider checksumPolicyProvider;
+
+ public final ChecksumPolicyProvider getChecksumPolicyProvider() {
+ checkClosed();
+ if (checksumPolicyProvider == null) {
+ checksumPolicyProvider = createChecksumPolicyProvider();
+ }
+ return checksumPolicyProvider;
+ }
+
+ protected ChecksumPolicyProvider createChecksumPolicyProvider() {
+ return new DefaultChecksumPolicyProvider();
+ }
+
+ private UpdateCheckManager updateCheckManager;
+
+ public final UpdateCheckManager getUpdateCheckManager() {
+ checkClosed();
+ if (updateCheckManager == null) {
+ updateCheckManager = createUpdateCheckManager();
+ }
+ return updateCheckManager;
+ }
+
+ protected UpdateCheckManager createUpdateCheckManager() {
+ return new DefaultUpdateCheckManager(getTrackingFileManager(), getUpdatePolicyAnalyzer(), getPathProcessor());
+ }
+
+ private Map<String, NamedLockFactory> namedLockFactories;
+
+ public final Map<String, NamedLockFactory> getNamedLockFactories() {
+ checkClosed();
+ if (namedLockFactories == null) {
+ namedLockFactories = createNamedLockFactories();
+ }
+ return namedLockFactories;
+ }
+
+ protected Map<String, NamedLockFactory> createNamedLockFactories() {
+ HashMap<String, NamedLockFactory> result = new HashMap<>();
+ result.put(NoopNamedLockFactory.NAME, new NoopNamedLockFactory());
+ result.put(LocalReadWriteLockNamedLockFactory.NAME, new LocalReadWriteLockNamedLockFactory());
+ result.put(LocalSemaphoreNamedLockFactory.NAME, new LocalSemaphoreNamedLockFactory());
+ result.put(FileLockNamedLockFactory.NAME, new FileLockNamedLockFactory());
+ return result;
+ }
+
+ private Map<String, NameMapper> nameMappers;
+
+ public final Map<String, NameMapper> getNameMappers() {
+ checkClosed();
+ if (nameMappers == null) {
+ nameMappers = createNameMappers();
+ }
+ return nameMappers;
+ }
+
+ protected Map<String, NameMapper> createNameMappers() {
+ HashMap<String, NameMapper> result = new HashMap<>();
+ result.put(NameMappers.STATIC_NAME, NameMappers.staticNameMapper());
+ result.put(NameMappers.GAV_NAME, NameMappers.gavNameMapper());
+ result.put(NameMappers.DISCRIMINATING_NAME, NameMappers.discriminatingNameMapper());
+ result.put(NameMappers.FILE_GAV_NAME, NameMappers.fileGavNameMapper());
+ result.put(NameMappers.FILE_HGAV_NAME, NameMappers.fileHashingGavNameMapper());
+ return result;
+ }
+
+ private NamedLockFactoryAdapterFactory namedLockFactoryAdapterFactory;
+
+ public final NamedLockFactoryAdapterFactory getNamedLockFactoryAdapterFactory() {
+ checkClosed();
+ if (namedLockFactoryAdapterFactory == null) {
+ namedLockFactoryAdapterFactory = createNamedLockFactoryAdapterFactory();
+ }
+ return namedLockFactoryAdapterFactory;
+ }
+
+ protected NamedLockFactoryAdapterFactory createNamedLockFactoryAdapterFactory() {
+ return new NamedLockFactoryAdapterFactoryImpl(
+ getNamedLockFactories(), getNameMappers(), getRepositorySystemLifecycle());
+ }
+
+ private SyncContextFactory syncContextFactory;
+
+ public final SyncContextFactory getSyncContextFactory() {
+ checkClosed();
+ if (syncContextFactory == null) {
+ syncContextFactory = createSyncContextFactory();
+ }
+ return syncContextFactory;
+ }
+
+ protected SyncContextFactory createSyncContextFactory() {
+ return new DefaultSyncContextFactory(getNamedLockFactoryAdapterFactory());
+ }
+
+ private Map<String, ChecksumAlgorithmFactory> checksumAlgorithmFactories;
+
+ public final Map<String, ChecksumAlgorithmFactory> getChecksumAlgorithmFactories() {
+ checkClosed();
+ if (checksumAlgorithmFactories == null) {
+ checksumAlgorithmFactories = createChecksumAlgorithmFactories();
+ }
+ return checksumAlgorithmFactories;
+ }
+
+ protected Map<String, ChecksumAlgorithmFactory> createChecksumAlgorithmFactories() {
+ HashMap<String, ChecksumAlgorithmFactory> result = new HashMap<>();
+ result.put(Sha512ChecksumAlgorithmFactory.NAME, new Sha512ChecksumAlgorithmFactory());
+ result.put(Sha256ChecksumAlgorithmFactory.NAME, new Sha256ChecksumAlgorithmFactory());
+ result.put(Sha1ChecksumAlgorithmFactory.NAME, new Sha1ChecksumAlgorithmFactory());
+ result.put(Md5ChecksumAlgorithmFactory.NAME, new Md5ChecksumAlgorithmFactory());
+ return result;
+ }
+
+ private ChecksumAlgorithmFactorySelector checksumAlgorithmFactorySelector;
+
+ public final ChecksumAlgorithmFactorySelector getChecksumAlgorithmFactorySelector() {
+ checkClosed();
+ if (checksumAlgorithmFactorySelector == null) {
+ checksumAlgorithmFactorySelector = createChecksumAlgorithmFactorySelector();
+ }
+ return checksumAlgorithmFactorySelector;
+ }
+
+ protected ChecksumAlgorithmFactorySelector createChecksumAlgorithmFactorySelector() {
+ return new DefaultChecksumAlgorithmFactorySelector(getChecksumAlgorithmFactories());
+ }
+
+ private ArtifactPredicateFactory artifactPredicateFactory;
+
+ public final ArtifactPredicateFactory getArtifactPredicateFactory() {
+ checkClosed();
+ if (artifactPredicateFactory == null) {
+ artifactPredicateFactory = createArtifactPredicateFactory();
+ }
+ return artifactPredicateFactory;
+ }
+
+ protected ArtifactPredicateFactory createArtifactPredicateFactory() {
+ return new DefaultArtifactPredicateFactory(getChecksumAlgorithmFactorySelector());
+ }
+
+ private Map<String, RepositoryLayoutFactory> repositoryLayoutFactories;
+
+ public final Map<String, RepositoryLayoutFactory> getRepositoryLayoutFactories() {
+ checkClosed();
+ if (repositoryLayoutFactories == null) {
+ repositoryLayoutFactories = createRepositoryLayoutFactories();
+ }
+ return repositoryLayoutFactories;
+ }
+
+ protected Map<String, RepositoryLayoutFactory> createRepositoryLayoutFactories() {
+ HashMap<String, RepositoryLayoutFactory> result = new HashMap<>();
+ result.put(
+ Maven2RepositoryLayoutFactory.NAME,
+ new Maven2RepositoryLayoutFactory(
+ getChecksumAlgorithmFactorySelector(), getArtifactPredicateFactory()));
+ return result;
+ }
+
+ private RepositoryLayoutProvider repositoryLayoutProvider;
+
+ public final RepositoryLayoutProvider getRepositoryLayoutProvider() {
+ checkClosed();
+ if (repositoryLayoutProvider == null) {
+ repositoryLayoutProvider = createRepositoryLayoutProvider();
+ }
+ return repositoryLayoutProvider;
+ }
+
+ protected RepositoryLayoutProvider createRepositoryLayoutProvider() {
+ return new DefaultRepositoryLayoutProvider(getRepositoryLayoutFactories());
+ }
+
+ private LocalRepositoryProvider localRepositoryProvider;
+
+ public final LocalRepositoryProvider getLocalRepositoryProvider() {
+ checkClosed();
+ if (localRepositoryProvider == null) {
+ localRepositoryProvider = createLocalRepositoryProvider();
+ }
+ return localRepositoryProvider;
+ }
+
+ protected LocalRepositoryProvider createLocalRepositoryProvider() {
+ LocalPathComposer localPathComposer = getLocalPathComposer();
+ HashMap<String, LocalRepositoryManagerFactory> localRepositoryProviders = new HashMap<>(2);
+ localRepositoryProviders.put(
+ SimpleLocalRepositoryManagerFactory.NAME, new SimpleLocalRepositoryManagerFactory(localPathComposer));
+ localRepositoryProviders.put(
+ EnhancedLocalRepositoryManagerFactory.NAME,
+ new EnhancedLocalRepositoryManagerFactory(
+ localPathComposer, getTrackingFileManager(), getLocalPathPrefixComposerFactory()));
+ return new DefaultLocalRepositoryProvider(localRepositoryProviders);
+ }
+
+ private RemoteRepositoryManager remoteRepositoryManager;
+
+ public final RemoteRepositoryManager getRemoteRepositoryManager() {
+ checkClosed();
+ if (remoteRepositoryManager == null) {
+ remoteRepositoryManager = createRemoteRepositoryManager();
+ }
+ return remoteRepositoryManager;
+ }
+
+ protected RemoteRepositoryManager createRemoteRepositoryManager() {
+ return new DefaultRemoteRepositoryManager(getUpdatePolicyAnalyzer(), getChecksumPolicyProvider());
+ }
+
+ private Map<String, RemoteRepositoryFilterSource> remoteRepositoryFilterSources;
+
+ public final Map<String, RemoteRepositoryFilterSource> getRemoteRepositoryFilterSources() {
+ checkClosed();
+ if (remoteRepositoryFilterSources == null) {
+ remoteRepositoryFilterSources = createRemoteRepositoryFilterSources();
+ }
+ return remoteRepositoryFilterSources;
+ }
+
+ protected Map<String, RemoteRepositoryFilterSource> createRemoteRepositoryFilterSources() {
+ HashMap<String, RemoteRepositoryFilterSource> result = new HashMap<>();
+ result.put(
+ GroupIdRemoteRepositoryFilterSource.NAME,
+ new GroupIdRemoteRepositoryFilterSource(getRepositorySystemLifecycle()));
+ result.put(
+ PrefixesRemoteRepositoryFilterSource.NAME,
+ new PrefixesRemoteRepositoryFilterSource(getRepositoryLayoutProvider()));
+ return result;
+ }
+
+ private RemoteRepositoryFilterManager remoteRepositoryFilterManager;
+
+ public final RemoteRepositoryFilterManager getRemoteRepositoryFilterManager() {
+ checkClosed();
+ if (remoteRepositoryFilterManager == null) {
+ remoteRepositoryFilterManager = createRemoteRepositoryFilterManager();
+ }
+ return remoteRepositoryFilterManager;
+ }
+
+ protected RemoteRepositoryFilterManager createRemoteRepositoryFilterManager() {
+ return new DefaultRemoteRepositoryFilterManager(getRemoteRepositoryFilterSources());
+ }
+
+ private Map<String, RepositoryListener> repositoryListeners;
+
+ public final Map<String, RepositoryListener> getRepositoryListeners() {
+ checkClosed();
+ if (repositoryListeners == null) {
+ repositoryListeners = createRepositoryListeners();
+ }
+ return repositoryListeners;
+ }
+
+ protected Map<String, RepositoryListener> createRepositoryListeners() {
+ return new HashMap<>();
+ }
+
+ private RepositoryEventDispatcher repositoryEventDispatcher;
+
+ public final RepositoryEventDispatcher getRepositoryEventDispatcher() {
+ checkClosed();
+ if (repositoryEventDispatcher == null) {
+ repositoryEventDispatcher = createRepositoryEventDispatcher();
+ }
+ return repositoryEventDispatcher;
+ }
+
+ protected RepositoryEventDispatcher createRepositoryEventDispatcher() {
+ return new DefaultRepositoryEventDispatcher(getRepositoryListeners());
+ }
+
+ private Map<String, TrustedChecksumsSource> trustedChecksumsSources;
+
+ public final Map<String, TrustedChecksumsSource> getTrustedChecksumsSources() {
+ checkClosed();
+ if (trustedChecksumsSources == null) {
+ trustedChecksumsSources = createTrustedChecksumsSources();
+ }
+ return trustedChecksumsSources;
+ }
+
+ protected Map<String, TrustedChecksumsSource> createTrustedChecksumsSources() {
+ HashMap<String, TrustedChecksumsSource> result = new HashMap<>();
+ result.put(
+ SparseDirectoryTrustedChecksumsSource.NAME,
+ new SparseDirectoryTrustedChecksumsSource(getChecksumProcessor(), getLocalPathComposer()));
+ result.put(
+ SummaryFileTrustedChecksumsSource.NAME,
+ new SummaryFileTrustedChecksumsSource(getLocalPathComposer(), getRepositorySystemLifecycle()));
+ return result;
+ }
+
+ private Map<String, ProvidedChecksumsSource> providedChecksumsSources;
+
+ public final Map<String, ProvidedChecksumsSource> getProvidedChecksumsSources() {
+ checkClosed();
+ if (providedChecksumsSources == null) {
+ providedChecksumsSources = createProvidedChecksumsSources();
+ }
+ return providedChecksumsSources;
+ }
+
+ protected Map<String, ProvidedChecksumsSource> createProvidedChecksumsSources() {
+ HashMap<String, ProvidedChecksumsSource> result = new HashMap<>();
+ result.put(
+ TrustedToProvidedChecksumsSourceAdapter.NAME,
+ new TrustedToProvidedChecksumsSourceAdapter(getTrustedChecksumsSources()));
+ return result;
+ }
+
+ private Map<String, ChecksumExtractorStrategy> checksumExtractorStrategies;
+
+ public final Map<String, ChecksumExtractorStrategy> getChecksumExtractorStrategies() {
+ checkClosed();
+ if (checksumExtractorStrategies == null) {
+ checksumExtractorStrategies = createChecksumExtractorStrategies();
+ }
+ return checksumExtractorStrategies;
+ }
+
+ protected Map<String, ChecksumExtractorStrategy> createChecksumExtractorStrategies() {
+ HashMap<String, ChecksumExtractorStrategy> result = new HashMap<>();
+ result.put(XChecksumExtractor.NAME, new XChecksumExtractor());
+ result.put(Nx2ChecksumExtractor.NAME, new Nx2ChecksumExtractor());
+ return result;
+ }
+
+ private ChecksumExtractor checksumExtractor;
+
+ public final ChecksumExtractor getChecksumExtractor() {
+ checkClosed();
+ if (checksumExtractor == null) {
+ checksumExtractor = createChecksumExtractor();
+ }
+ return checksumExtractor;
+ }
+
+ protected ChecksumExtractor createChecksumExtractor() {
+ return new DefaultChecksumExtractor(getChecksumExtractorStrategies());
+ }
+
+ private Map<String, TransporterFactory> transporterFactories;
+
+ public final Map<String, TransporterFactory> getTransporterFactories() {
+ checkClosed();
+ if (transporterFactories == null) {
+ transporterFactories = createTransporterFactories();
+ }
+ return transporterFactories;
+ }
+
+ protected Map<String, TransporterFactory> createTransporterFactories() {
+ HashMap<String, TransporterFactory> result = new HashMap<>();
+ result.put(FileTransporterFactory.NAME, new FileTransporterFactory());
+ result.put(
+ ApacheTransporterFactory.NAME,
+ new ApacheTransporterFactory(getChecksumExtractor(), getPathProcessor()));
+ return result;
+ }
+
+ private TransporterProvider transporterProvider;
+
+ public final TransporterProvider getTransporterProvider() {
+ checkClosed();
+ if (transporterProvider == null) {
+ transporterProvider = createTransporterProvider();
+ }
+ return transporterProvider;
+ }
+
+ protected TransporterProvider createTransporterProvider() {
+ return new DefaultTransporterProvider(getTransporterFactories());
+ }
+
+ private BasicRepositoryConnectorFactory basicRepositoryConnectorFactory;
+
+ public final BasicRepositoryConnectorFactory getBasicRepositoryConnectorFactory() {
+ checkClosed();
+ if (basicRepositoryConnectorFactory == null) {
+ basicRepositoryConnectorFactory = createBasicRepositoryConnectorFactory();
+ }
+ return basicRepositoryConnectorFactory;
+ }
+
+ protected BasicRepositoryConnectorFactory createBasicRepositoryConnectorFactory() {
+ return new BasicRepositoryConnectorFactory(
+ getTransporterProvider(),
+ getRepositoryLayoutProvider(),
+ getChecksumPolicyProvider(),
+ getChecksumProcessor(),
+ getProvidedChecksumsSources());
+ }
+
+ private Map<String, RepositoryConnectorFactory> repositoryConnectorFactories;
+
+ public final Map<String, RepositoryConnectorFactory> getRepositoryConnectorFactories() {
+ checkClosed();
+ if (repositoryConnectorFactories == null) {
+ repositoryConnectorFactories = createRepositoryConnectorFactories();
+ }
+ return repositoryConnectorFactories;
+ }
+
+ protected Map<String, RepositoryConnectorFactory> createRepositoryConnectorFactories() {
+ HashMap<String, RepositoryConnectorFactory> result = new HashMap<>();
+ result.put(BasicRepositoryConnectorFactory.NAME, getBasicRepositoryConnectorFactory());
+ return result;
+ }
+
+ private RepositoryConnectorProvider repositoryConnectorProvider;
+
+ public final RepositoryConnectorProvider getRepositoryConnectorProvider() {
+ checkClosed();
+ if (repositoryConnectorProvider == null) {
+ repositoryConnectorProvider = createRepositoryConnectorProvider();
+ }
+ return repositoryConnectorProvider;
+ }
+
+ protected RepositoryConnectorProvider createRepositoryConnectorProvider() {
+ return new DefaultRepositoryConnectorProvider(
+ getRepositoryConnectorFactories(), getRemoteRepositoryFilterManager());
+ }
+
+ private Installer installer;
+
+ public final Installer getInstaller() {
+ checkClosed();
+ if (installer == null) {
+ installer = createInstaller();
+ }
+ return installer;
+ }
+
+ protected Installer createInstaller() {
+ return new DefaultInstaller(
+ getPathProcessor(),
+ getRepositoryEventDispatcher(),
+ getArtifactGeneratorFactories(),
+ getMetadataGeneratorFactories(),
+ getSyncContextFactory());
+ }
+
+ private Deployer deployer;
+
+ public final Deployer getDeployer() {
+ checkClosed();
+ if (deployer == null) {
+ deployer = createDeployer();
+ }
+ return deployer;
+ }
+
+ protected Deployer createDeployer() {
+ return new DefaultDeployer(
+ getPathProcessor(),
+ getRepositoryEventDispatcher(),
+ getRepositoryConnectorProvider(),
+ getRemoteRepositoryManager(),
+ getUpdateCheckManager(),
+ getArtifactGeneratorFactories(),
+ getMetadataGeneratorFactories(),
+ getSyncContextFactory(),
+ getOfflineController());
+ }
+
+ private Map<String, DependencyCollectorDelegate> dependencyCollectorDelegates;
+
+ public final Map<String, DependencyCollectorDelegate> getDependencyCollectorDelegates() {
+ checkClosed();
+ if (dependencyCollectorDelegates == null) {
+ dependencyCollectorDelegates = createDependencyCollectorDelegates();
+ }
+ return dependencyCollectorDelegates;
+ }
+
+ protected Map<String, DependencyCollectorDelegate> createDependencyCollectorDelegates() {
+ RemoteRepositoryManager remoteRepositoryManager = getRemoteRepositoryManager();
+ ArtifactDescriptorReader artifactDescriptorReader = getArtifactDescriptorReader();
+ VersionRangeResolver versionRangeResolver = getVersionRangeResolver();
+ HashMap<String, DependencyCollectorDelegate> result = new HashMap<>();
+ result.put(
+ DfDependencyCollector.NAME,
+ new DfDependencyCollector(
+ remoteRepositoryManager,
+ artifactDescriptorReader,
+ versionRangeResolver,
+ getArtifactDecoratorFactories()));
+ result.put(
+ BfDependencyCollector.NAME,
+ new BfDependencyCollector(
+ remoteRepositoryManager,
+ artifactDescriptorReader,
+ versionRangeResolver,
+ getArtifactDecoratorFactories()));
+ return result;
+ }
+
+ private DependencyCollector dependencyCollector;
+
+ public final DependencyCollector getDependencyCollector() {
+ checkClosed();
+ if (dependencyCollector == null) {
+ dependencyCollector = createDependencyCollector();
+ }
+ return dependencyCollector;
+ }
+
+ protected DependencyCollector createDependencyCollector() {
+ return new DefaultDependencyCollector(getDependencyCollectorDelegates());
+ }
+
+ private Map<String, ArtifactResolverPostProcessor> artifactResolverPostProcessors;
+
+ public final Map<String, ArtifactResolverPostProcessor> getArtifactResolverPostProcessors() {
+ checkClosed();
+ if (artifactResolverPostProcessors == null) {
+ artifactResolverPostProcessors = createArtifactResolverPostProcessors();
+ }
+ return artifactResolverPostProcessors;
+ }
+
+ protected Map<String, ArtifactResolverPostProcessor> createArtifactResolverPostProcessors() {
+ HashMap<String, ArtifactResolverPostProcessor> result = new HashMap<>();
+ result.put(
+ TrustedChecksumsArtifactResolverPostProcessor.NAME,
+ new TrustedChecksumsArtifactResolverPostProcessor(
+ getChecksumAlgorithmFactorySelector(), getTrustedChecksumsSources()));
+ return result;
+ }
+
+ private ArtifactResolver artifactResolver;
+
+ public final ArtifactResolver getArtifactResolver() {
+ checkClosed();
+ if (artifactResolver == null) {
+ artifactResolver = createArtifactResolver();
+ }
+ return artifactResolver;
+ }
+
+ protected ArtifactResolver createArtifactResolver() {
+ return new DefaultArtifactResolver(
+ getPathProcessor(),
+ getRepositoryEventDispatcher(),
+ getVersionResolver(),
+ getUpdateCheckManager(),
+ getRepositoryConnectorProvider(),
+ getRemoteRepositoryManager(),
+ getSyncContextFactory(),
+ getOfflineController(),
+ getArtifactResolverPostProcessors(),
+ getRemoteRepositoryFilterManager());
+ }
+
+ private MetadataResolver metadataResolver;
+
+ public final MetadataResolver getMetadataResolver() {
+ checkClosed();
+ if (metadataResolver == null) {
+ metadataResolver = createMetadataResolver();
+ }
+ return metadataResolver;
+ }
+
+ protected MetadataResolver createMetadataResolver() {
+ return new DefaultMetadataResolver(
+ getRepositoryEventDispatcher(),
+ getUpdateCheckManager(),
+ getRepositoryConnectorProvider(),
+ getRemoteRepositoryManager(),
+ getSyncContextFactory(),
+ getOfflineController(),
+ getRemoteRepositoryFilterManager(),
+ getPathProcessor());
+ }
+
+ private VersionScheme versionScheme;
+
+ public final VersionScheme getVersionScheme() {
+ checkClosed();
+ if (versionScheme == null) {
+ versionScheme = createVersionScheme();
+ }
+ return versionScheme;
+ }
+
+ protected VersionScheme createVersionScheme() {
+ return new GenericVersionScheme();
+ }
+
+ private Map<String, ArtifactGeneratorFactory> artifactGeneratorFactories;
+
+ public final Map<String, ArtifactGeneratorFactory> getArtifactGeneratorFactories() {
+ checkClosed();
+ if (artifactGeneratorFactories == null) {
+ artifactGeneratorFactories = createArtifactGeneratorFactories();
+ }
+ return artifactGeneratorFactories;
+ }
+
+ protected Map<String, ArtifactGeneratorFactory> createArtifactGeneratorFactories() {
+ // by default none, this is extension point
+ return new HashMap<>();
+ }
+
+ private Map<String, ArtifactDecoratorFactory> artifactDecoratorFactories;
+
+ public final Map<String, ArtifactDecoratorFactory> getArtifactDecoratorFactories() {
+ checkClosed();
+ if (artifactDecoratorFactories == null) {
+ artifactDecoratorFactories = createArtifactDecoratorFactories();
+ }
+ return artifactDecoratorFactories;
+ }
+
+ protected Map<String, ArtifactDecoratorFactory> createArtifactDecoratorFactories() {
+ // by default none, this is extension point
+ return new HashMap<>();
+ }
+
+ // Maven provided
+
+ private Map<String, MetadataGeneratorFactory> metadataGeneratorFactories;
+
+ public final Map<String, MetadataGeneratorFactory> getMetadataGeneratorFactories() {
+ checkClosed();
+ if (metadataGeneratorFactories == null) {
+ metadataGeneratorFactories = createMetadataGeneratorFactories();
+ }
+ return metadataGeneratorFactories;
+ }
+
+ protected Map<String, MetadataGeneratorFactory> createMetadataGeneratorFactories() {
+ // from maven-resolver-provider
+ HashMap<String, MetadataGeneratorFactory> result = new HashMap<>();
+ result.put(PluginsMetadataGeneratorFactory.NAME, new PluginsMetadataGeneratorFactory());
+ result.put(VersionsMetadataGeneratorFactory.NAME, new VersionsMetadataGeneratorFactory());
+ result.put(SnapshotMetadataGeneratorFactory.NAME, new SnapshotMetadataGeneratorFactory());
+ return result;
+ }
+
+ private LinkedHashMap<String, MavenArtifactRelocationSource> artifactRelocationSources;
+
+ public final LinkedHashMap<String, MavenArtifactRelocationSource> getMavenArtifactRelocationSources() {
+ checkClosed();
+ if (artifactRelocationSources == null) {
+ artifactRelocationSources = createMavenArtifactRelocationSources();
+ }
+ return artifactRelocationSources;
+ }
+
+ protected LinkedHashMap<String, MavenArtifactRelocationSource> createMavenArtifactRelocationSources() {
+ // from maven-resolver-provider
+ LinkedHashMap<String, MavenArtifactRelocationSource> result = new LinkedHashMap<>();
+ result.put(UserPropertiesArtifactRelocationSource.NAME, new UserPropertiesArtifactRelocationSource());
+ result.put(
+ DistributionManagementArtifactRelocationSource.NAME,
+ new DistributionManagementArtifactRelocationSource());
+ return result;
+ }
+
+ private ArtifactDescriptorReader artifactDescriptorReader;
+
+ public final ArtifactDescriptorReader getArtifactDescriptorReader() {
+ checkClosed();
+ if (artifactDescriptorReader == null) {
+ artifactDescriptorReader = createArtifactDescriptorReader();
+ }
+ return artifactDescriptorReader;
+ }
+
+ protected ArtifactDescriptorReader createArtifactDescriptorReader() {
+ // from maven-resolver-provider
+ return new DefaultArtifactDescriptorReader(
+ getRemoteRepositoryManager(),
+ getVersionResolver(),
+ getVersionRangeResolver(),
+ getArtifactResolver(),
+ getModelBuilder(),
+ getRepositoryEventDispatcher(),
+ getMavenArtifactRelocationSources());
+ }
+
+ private VersionResolver versionResolver;
+
+ public final VersionResolver getVersionResolver() {
+ checkClosed();
+ if (versionResolver == null) {
+ versionResolver = createVersionResolver();
+ }
+ return versionResolver;
+ }
+
+ protected VersionResolver createVersionResolver() {
+ // from maven-resolver-provider
+ return new DefaultVersionResolver(
+ getMetadataResolver(), getSyncContextFactory(), getRepositoryEventDispatcher());
+ }
+
+ private VersionRangeResolver versionRangeResolver;
+
+ public final VersionRangeResolver getVersionRangeResolver() {
+ checkClosed();
+ if (versionRangeResolver == null) {
+ versionRangeResolver = createVersionRangeResolver();
+ }
+ return versionRangeResolver;
+ }
+
+ protected VersionRangeResolver createVersionRangeResolver() {
+ // from maven-resolver-provider
+ return new DefaultVersionRangeResolver(
+ getMetadataResolver(), getSyncContextFactory(), getRepositoryEventDispatcher(), getVersionScheme());
+ }
+
+ private ModelBuilder modelBuilder;
+
+ public final ModelBuilder getModelBuilder() {
+ checkClosed();
+ if (modelBuilder == null) {
+ modelBuilder = createModelBuilder();
+ }
+ return modelBuilder;
+ }
+
+ protected ModelBuilder createModelBuilder() {
+ // from maven-model-builder
+ DefaultModelProcessor modelProcessor = new DefaultModelProcessor(new DefaultModelXmlFactory(), List.of());
+ return new DefaultModelBuilder(
+ modelProcessor,
+ new DefaultModelValidator(new DefaultModelVersionProcessor()),
+ new DefaultModelNormalizer(),
+ new DefaultModelInterpolator(
+ new DefaultPathTranslator(), new DefaultUrlNormalizer(), new DefaultRootLocator()),
+ new DefaultModelPathTranslator(new DefaultPathTranslator()),
+ new DefaultModelUrlNormalizer(new DefaultUrlNormalizer()),
+ new DefaultSuperPomProvider(modelProcessor),
+ new DefaultInheritanceAssembler(),
+ new DefaultProfileSelector(),
+ new DefaultProfileInjector(),
+ new DefaultPluginManagementInjector(),
+ new DefaultDependencyManagementInjector(),
+ new DefaultDependencyManagementImporter(),
+ (m, r, b) -> m,
+ new DefaultPluginConfigurationExpander(),
+ new ProfileActivationFilePathInterpolator(new DefaultPathTranslator(), new DefaultRootLocator()),
+ new BuildModelTransformer(),
+ new DefaultModelVersionParser(getVersionScheme()),
+ getRemoteRepositoryManager());
+ }
+
+ private RepositorySystem repositorySystem;
+
+ public final RepositorySystem getRepositorySystem() {
+ checkClosed();
+ if (repositorySystem == null) {
+ repositorySystem = createRepositorySystem();
+ }
+ return repositorySystem;
+ }
+
+ protected RepositorySystem createRepositorySystem() {
+ return new DefaultRepositorySystem(
+ getVersionResolver(),
+ getVersionRangeResolver(),
+ getArtifactResolver(),
+ getMetadataResolver(),
+ getArtifactDescriptorReader(),
+ getDependencyCollector(),
+ getInstaller(),
+ getDeployer(),
+ getLocalRepositoryProvider(),
+ getSyncContextFactory(),
+ getRemoteRepositoryManager(),
+ getRepositorySystemLifecycle(),
+ getArtifactDecoratorFactories());
+ }
+
+ @Override
+ public RepositorySystem get() {
+ return getRepositorySystem();
+ }
+}
diff --git a/pom.xml b/pom.xml
index 9b957b6..207449b 100644
--- a/pom.xml
+++ b/pom.xml
@@ -182,7 +182,7 @@
<plexusInterpolationVersion>1.26</plexusInterpolationVersion>
<plexusTestingVersion>1.0.0</plexusTestingVersion>
<plexusXmlVersion>4.0.1</plexusXmlVersion>
- <resolverVersion>2.0.0-alpha-10</resolverVersion>
+ <resolverVersion>2.0.0-alpha-11</resolverVersion>
<securityDispatcherVersion>2.0</securityDispatcherVersion>
<sisuVersion>0.9.0.M2</sisuVersion>
<slf4jVersion>2.0.11</slf4jVersion>
@@ -651,6 +651,21 @@
</dependencies>
-->
+ <repositories>
+ <repository>
+ <releases>
+ <enabled>true</enabled>
+ <updatePolicy>never</updatePolicy>
+ <checksumPolicy>fail</checksumPolicy>
+ </releases>
+ <snapshots>
+ <enabled>false</enabled>
+ </snapshots>
+ <id>maven-2102</id>
+ <url>https://repository.apache.org/content/repositories/maven-2102/</url>
+ </repository>
+ </repositories>
+
<build>
<pluginManagement>
<plugins>
