001/*
002 * Licensed to the Apache Software Foundation (ASF) under one
003 * or more contributor license agreements.  See the NOTICE file
004 * distributed with this work for additional information
005 * regarding copyright ownership.  The ASF licenses this file
006 * to you under the Apache License, Version 2.0 (the
007 * "License"); you may not use this file except in compliance
008 * with the License.  You may obtain a copy of the License at
009 *
010 *   http://www.apache.org/licenses/LICENSE-2.0
011 *
012 * Unless required by applicable law or agreed to in writing,
013 * software distributed under the License is distributed on an
014 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
015 * KIND, either express or implied.  See the License for the
016 * specific language governing permissions and limitations
017 * under the License.
018 */
019package org.eclipse.aether.supplier;
020
021import java.util.HashMap;
022import java.util.LinkedHashMap;
023import java.util.Map;
024import java.util.concurrent.atomic.AtomicBoolean;
025import java.util.function.Supplier;
026
027import org.apache.maven.model.building.DefaultModelBuilderFactory;
028import org.apache.maven.model.building.ModelBuilder;
029import org.apache.maven.repository.internal.ArtifactDescriptorDecorator;
030import org.apache.maven.repository.internal.DefaultArtifactDescriptorReader;
031import org.apache.maven.repository.internal.DefaultModelCacheFactory;
032import org.apache.maven.repository.internal.DefaultVersionRangeResolver;
033import org.apache.maven.repository.internal.DefaultVersionResolver;
034import org.apache.maven.repository.internal.MavenArtifactRelocationSource;
035import org.apache.maven.repository.internal.ModelCacheFactory;
036import org.apache.maven.repository.internal.PluginsMetadataGeneratorFactory;
037import org.apache.maven.repository.internal.SnapshotMetadataGeneratorFactory;
038import org.apache.maven.repository.internal.VersionsMetadataGeneratorFactory;
039import org.apache.maven.repository.internal.relocation.DistributionManagementArtifactRelocationSource;
040import org.apache.maven.repository.internal.relocation.UserPropertiesArtifactRelocationSource;
041import org.eclipse.aether.RepositoryListener;
042import org.eclipse.aether.RepositorySystem;
043import org.eclipse.aether.connector.basic.BasicRepositoryConnectorFactory;
044import org.eclipse.aether.impl.ArtifactDescriptorReader;
045import org.eclipse.aether.impl.ArtifactResolver;
046import org.eclipse.aether.impl.DependencyCollector;
047import org.eclipse.aether.impl.Deployer;
048import org.eclipse.aether.impl.Installer;
049import org.eclipse.aether.impl.LocalRepositoryProvider;
050import org.eclipse.aether.impl.MetadataGeneratorFactory;
051import org.eclipse.aether.impl.MetadataResolver;
052import org.eclipse.aether.impl.NamedLockFactorySelector;
053import org.eclipse.aether.impl.OfflineController;
054import org.eclipse.aether.impl.RemoteRepositoryFilterManager;
055import org.eclipse.aether.impl.RemoteRepositoryManager;
056import org.eclipse.aether.impl.RepositoryConnectorProvider;
057import org.eclipse.aether.impl.RepositoryEventDispatcher;
058import org.eclipse.aether.impl.RepositorySystemLifecycle;
059import org.eclipse.aether.impl.RepositorySystemValidator;
060import org.eclipse.aether.impl.UpdateCheckManager;
061import org.eclipse.aether.impl.UpdatePolicyAnalyzer;
062import org.eclipse.aether.impl.VersionRangeResolver;
063import org.eclipse.aether.impl.VersionResolver;
064import org.eclipse.aether.internal.impl.DefaultArtifactPredicateFactory;
065import org.eclipse.aether.internal.impl.DefaultArtifactResolver;
066import org.eclipse.aether.internal.impl.DefaultChecksumPolicyProvider;
067import org.eclipse.aether.internal.impl.DefaultChecksumProcessor;
068import org.eclipse.aether.internal.impl.DefaultDeployer;
069import org.eclipse.aether.internal.impl.DefaultInstaller;
070import org.eclipse.aether.internal.impl.DefaultLocalPathComposer;
071import org.eclipse.aether.internal.impl.DefaultLocalPathPrefixComposerFactory;
072import org.eclipse.aether.internal.impl.DefaultLocalRepositoryProvider;
073import org.eclipse.aether.internal.impl.DefaultMetadataResolver;
074import org.eclipse.aether.internal.impl.DefaultOfflineController;
075import org.eclipse.aether.internal.impl.DefaultPathProcessor;
076import org.eclipse.aether.internal.impl.DefaultRemoteRepositoryManager;
077import org.eclipse.aether.internal.impl.DefaultRepositoryConnectorProvider;
078import org.eclipse.aether.internal.impl.DefaultRepositoryEventDispatcher;
079import org.eclipse.aether.internal.impl.DefaultRepositoryKeyFunctionFactory;
080import org.eclipse.aether.internal.impl.DefaultRepositoryLayoutProvider;
081import org.eclipse.aether.internal.impl.DefaultRepositorySystem;
082import org.eclipse.aether.internal.impl.DefaultRepositorySystemLifecycle;
083import org.eclipse.aether.internal.impl.DefaultRepositorySystemValidator;
084import org.eclipse.aether.internal.impl.DefaultTransporterProvider;
085import org.eclipse.aether.internal.impl.DefaultUpdateCheckManager;
086import org.eclipse.aether.internal.impl.DefaultUpdatePolicyAnalyzer;
087import org.eclipse.aether.internal.impl.EnhancedLocalRepositoryManagerFactory;
088import org.eclipse.aether.internal.impl.LocalPathComposer;
089import org.eclipse.aether.internal.impl.LocalPathPrefixComposerFactory;
090import org.eclipse.aether.internal.impl.Maven2RepositoryLayoutFactory;
091import org.eclipse.aether.internal.impl.SimpleLocalRepositoryManagerFactory;
092import org.eclipse.aether.internal.impl.TrackingFileManager;
093import org.eclipse.aether.internal.impl.TrackingFileManagerSupplier;
094import org.eclipse.aether.internal.impl.checksum.DefaultChecksumAlgorithmFactorySelector;
095import org.eclipse.aether.internal.impl.checksum.Md5ChecksumAlgorithmFactory;
096import org.eclipse.aether.internal.impl.checksum.Sha1ChecksumAlgorithmFactory;
097import org.eclipse.aether.internal.impl.checksum.Sha256ChecksumAlgorithmFactory;
098import org.eclipse.aether.internal.impl.checksum.Sha512ChecksumAlgorithmFactory;
099import org.eclipse.aether.internal.impl.checksum.SparseDirectoryTrustedChecksumsSource;
100import org.eclipse.aether.internal.impl.checksum.SummaryFileTrustedChecksumsSource;
101import org.eclipse.aether.internal.impl.checksum.TrustedToProvidedChecksumsSourceAdapter;
102import org.eclipse.aether.internal.impl.collect.DefaultDependencyCollector;
103import org.eclipse.aether.internal.impl.collect.DependencyCollectorDelegate;
104import org.eclipse.aether.internal.impl.collect.bf.BfDependencyCollector;
105import org.eclipse.aether.internal.impl.collect.df.DfDependencyCollector;
106import org.eclipse.aether.internal.impl.filter.DefaultRemoteRepositoryFilterManager;
107import org.eclipse.aether.internal.impl.filter.FilteringPipelineRepositoryConnectorFactory;
108import org.eclipse.aether.internal.impl.filter.GroupIdRemoteRepositoryFilterSource;
109import org.eclipse.aether.internal.impl.filter.PrefixesLockingInhibitorFactory;
110import org.eclipse.aether.internal.impl.filter.PrefixesRemoteRepositoryFilterSource;
111import org.eclipse.aether.internal.impl.named.DefaultNamedLockFactorySelector;
112import org.eclipse.aether.internal.impl.offline.OfflinePipelineRepositoryConnectorFactory;
113import org.eclipse.aether.internal.impl.resolution.TrustedChecksumsArtifactResolverPostProcessor;
114import org.eclipse.aether.internal.impl.synccontext.DefaultSyncContextFactory;
115import org.eclipse.aether.internal.impl.synccontext.named.NameMapper;
116import org.eclipse.aether.internal.impl.synccontext.named.NameMappers;
117import org.eclipse.aether.internal.impl.synccontext.named.NamedLockFactoryAdapterFactory;
118import org.eclipse.aether.internal.impl.synccontext.named.NamedLockFactoryAdapterFactoryImpl;
119import org.eclipse.aether.internal.impl.transport.http.DefaultChecksumExtractor;
120import org.eclipse.aether.internal.impl.transport.http.Nx2ChecksumExtractor;
121import org.eclipse.aether.internal.impl.transport.http.XChecksumExtractor;
122import org.eclipse.aether.named.NamedLockFactory;
123import org.eclipse.aether.named.providers.FileLockNamedLockFactory;
124import org.eclipse.aether.named.providers.LocalReadWriteLockNamedLockFactory;
125import org.eclipse.aether.named.providers.LocalSemaphoreNamedLockFactory;
126import org.eclipse.aether.named.providers.NoopNamedLockFactory;
127import org.eclipse.aether.spi.artifact.ArtifactPredicateFactory;
128import org.eclipse.aether.spi.artifact.decorator.ArtifactDecoratorFactory;
129import org.eclipse.aether.spi.artifact.generator.ArtifactGeneratorFactory;
130import org.eclipse.aether.spi.artifact.transformer.ArtifactTransformer;
131import org.eclipse.aether.spi.checksums.ProvidedChecksumsSource;
132import org.eclipse.aether.spi.checksums.TrustedChecksumsSource;
133import org.eclipse.aether.spi.connector.PipelineRepositoryConnectorFactory;
134import org.eclipse.aether.spi.connector.RepositoryConnectorFactory;
135import org.eclipse.aether.spi.connector.checksum.ChecksumAlgorithmFactory;
136import org.eclipse.aether.spi.connector.checksum.ChecksumAlgorithmFactorySelector;
137import org.eclipse.aether.spi.connector.checksum.ChecksumPolicyProvider;
138import org.eclipse.aether.spi.connector.filter.RemoteRepositoryFilterSource;
139import org.eclipse.aether.spi.connector.layout.RepositoryLayoutFactory;
140import org.eclipse.aether.spi.connector.layout.RepositoryLayoutProvider;
141import org.eclipse.aether.spi.connector.transport.TransporterFactory;
142import org.eclipse.aether.spi.connector.transport.TransporterProvider;
143import org.eclipse.aether.spi.connector.transport.http.ChecksumExtractor;
144import org.eclipse.aether.spi.connector.transport.http.ChecksumExtractorStrategy;
145import org.eclipse.aether.spi.io.ChecksumProcessor;
146import org.eclipse.aether.spi.io.PathProcessor;
147import org.eclipse.aether.spi.localrepo.LocalRepositoryManagerFactory;
148import org.eclipse.aether.spi.locking.LockingInhibitorFactory;
149import org.eclipse.aether.spi.remoterepo.RepositoryKeyFunctionFactory;
150import org.eclipse.aether.spi.resolution.ArtifactResolverPostProcessor;
151import org.eclipse.aether.spi.synccontext.SyncContextFactory;
152import org.eclipse.aether.spi.validator.ValidatorFactory;
153import org.eclipse.aether.transport.apache.ApacheTransporterFactory;
154import org.eclipse.aether.transport.file.FileTransporterFactory;
155import org.eclipse.aether.util.version.GenericVersionScheme;
156import org.eclipse.aether.version.VersionScheme;
157
158/**
159 * A simple memorizing {@link Supplier} of {@link org.eclipse.aether.RepositorySystem} instance, that on first call
160 * supplies lazily constructed instance, and on each subsequent call same instance. Hence, this instance should be
161 * thrown away immediately once repository system was created and there is no need for more instances. If new
162 * repository system instance needed, new instance of this class must be created. For proper shut down of returned
163 * repository system instance(s) use {@link RepositorySystem#shutdown()} method on supplied instance(s).
164 * <p>
165 * Since Resolver 2.0 this class offers access to various components via public getters, and allows even partial object
166 * graph construction.
167 * <p>
168 * Extend this class {@code createXXX()} methods and override to customize, if needed. The contract of this class makes
169 * sure that these (potentially overridden) methods are invoked only once, and instance created by those methods are
170 * memorized and kept as long as supplier instance is kept open.
171 * <p>
172 * This class is not thread safe and must be used from one thread only, while the constructed {@link RepositorySystem}
173 * is thread safe.
174 * <p>
175 * Important: Given the instance of supplier memorizes the supplier {@link RepositorySystem} instance it supplies,
176 * their lifecycle is shared as well: once supplied repository system is shut-down, this instance becomes closed as
177 * well. Any subsequent {@code getXXX} method invocation attempt will fail with {@link IllegalStateException}.
178 *
179 * @since 1.9.15
180 */
181public class RepositorySystemSupplier implements Supplier<RepositorySystem> {
182    private final AtomicBoolean closed = new AtomicBoolean(false);
183
184    public RepositorySystemSupplier() {}
185
186    private void checkClosed() {
187        if (closed.get()) {
188            throw new IllegalStateException("Supplier is closed");
189        }
190    }
191
192    private PathProcessor pathProcessor;
193
194    public final PathProcessor getPathProcessor() {
195        checkClosed();
196        if (pathProcessor == null) {
197            pathProcessor = createPathProcessor();
198        }
199        return pathProcessor;
200    }
201
202    protected PathProcessor createPathProcessor() {
203        return new DefaultPathProcessor();
204    }
205
206    private ChecksumProcessor checksumProcessor;
207
208    public final ChecksumProcessor getChecksumProcessor() {
209        checkClosed();
210        if (checksumProcessor == null) {
211            checksumProcessor = createChecksumProcessor();
212        }
213        return checksumProcessor;
214    }
215
216    protected ChecksumProcessor createChecksumProcessor() {
217        return new DefaultChecksumProcessor(getPathProcessor());
218    }
219
220    private TrackingFileManager trackingFileManager;
221
222    public final TrackingFileManager getTrackingFileManager() {
223        checkClosed();
224        if (trackingFileManager == null) {
225            trackingFileManager = createTrackingFileManager();
226        }
227        return trackingFileManager;
228    }
229
230    protected TrackingFileManager createTrackingFileManager() {
231        return new TrackingFileManagerSupplier(getNamedLockFactorySelector(), getPathProcessor()).get();
232    }
233
234    private LocalPathComposer localPathComposer;
235
236    public final LocalPathComposer getLocalPathComposer() {
237        checkClosed();
238        if (localPathComposer == null) {
239            localPathComposer = createLocalPathComposer();
240        }
241        return localPathComposer;
242    }
243
244    protected LocalPathComposer createLocalPathComposer() {
245        return new DefaultLocalPathComposer();
246    }
247
248    private LocalPathPrefixComposerFactory localPathPrefixComposerFactory;
249
250    public final LocalPathPrefixComposerFactory getLocalPathPrefixComposerFactory() {
251        checkClosed();
252        if (localPathPrefixComposerFactory == null) {
253            localPathPrefixComposerFactory = createLocalPathPrefixComposerFactory();
254        }
255        return localPathPrefixComposerFactory;
256    }
257
258    protected LocalPathPrefixComposerFactory createLocalPathPrefixComposerFactory() {
259        return new DefaultLocalPathPrefixComposerFactory(getRepositoryKeyFunctionFactory());
260    }
261
262    private RepositorySystemLifecycle repositorySystemLifecycle;
263
264    public final RepositorySystemLifecycle getRepositorySystemLifecycle() {
265        checkClosed();
266        if (repositorySystemLifecycle == null) {
267            repositorySystemLifecycle = createRepositorySystemLifecycle();
268            repositorySystemLifecycle.addOnSystemEndedHandler(() -> closed.set(true));
269        }
270        return repositorySystemLifecycle;
271    }
272
273    protected RepositorySystemLifecycle createRepositorySystemLifecycle() {
274        return new DefaultRepositorySystemLifecycle();
275    }
276
277    private OfflineController offlineController;
278
279    public final OfflineController getOfflineController() {
280        checkClosed();
281        if (offlineController == null) {
282            offlineController = createOfflineController();
283        }
284        return offlineController;
285    }
286
287    protected OfflineController createOfflineController() {
288        return new DefaultOfflineController();
289    }
290
291    private UpdatePolicyAnalyzer updatePolicyAnalyzer;
292
293    public final UpdatePolicyAnalyzer getUpdatePolicyAnalyzer() {
294        checkClosed();
295        if (updatePolicyAnalyzer == null) {
296            updatePolicyAnalyzer = createUpdatePolicyAnalyzer();
297        }
298        return updatePolicyAnalyzer;
299    }
300
301    protected UpdatePolicyAnalyzer createUpdatePolicyAnalyzer() {
302        return new DefaultUpdatePolicyAnalyzer();
303    }
304
305    private ChecksumPolicyProvider checksumPolicyProvider;
306
307    public final ChecksumPolicyProvider getChecksumPolicyProvider() {
308        checkClosed();
309        if (checksumPolicyProvider == null) {
310            checksumPolicyProvider = createChecksumPolicyProvider();
311        }
312        return checksumPolicyProvider;
313    }
314
315    protected ChecksumPolicyProvider createChecksumPolicyProvider() {
316        return new DefaultChecksumPolicyProvider();
317    }
318
319    private UpdateCheckManager updateCheckManager;
320
321    public final UpdateCheckManager getUpdateCheckManager() {
322        checkClosed();
323        if (updateCheckManager == null) {
324            updateCheckManager = createUpdateCheckManager();
325        }
326        return updateCheckManager;
327    }
328
329    protected UpdateCheckManager createUpdateCheckManager() {
330        return new DefaultUpdateCheckManager(getTrackingFileManager(), getUpdatePolicyAnalyzer(), getPathProcessor());
331    }
332
333    private RepositoryKeyFunctionFactory repositoriesKeyFunctionFactory;
334
335    public final RepositoryKeyFunctionFactory getRepositoryKeyFunctionFactory() {
336        checkClosed();
337        if (repositoriesKeyFunctionFactory == null) {
338            repositoriesKeyFunctionFactory = createRepositoryKeyFunctionFactory();
339        }
340        return repositoriesKeyFunctionFactory;
341    }
342
343    protected RepositoryKeyFunctionFactory createRepositoryKeyFunctionFactory() {
344        return new DefaultRepositoryKeyFunctionFactory();
345    }
346
347    private Map<String, NamedLockFactory> namedLockFactories;
348
349    public final Map<String, NamedLockFactory> getNamedLockFactories() {
350        checkClosed();
351        if (namedLockFactories == null) {
352            namedLockFactories = createNamedLockFactories();
353        }
354        return namedLockFactories;
355    }
356
357    protected Map<String, NamedLockFactory> createNamedLockFactories() {
358        HashMap<String, NamedLockFactory> result = new HashMap<>();
359        result.put(NoopNamedLockFactory.NAME, new NoopNamedLockFactory());
360        result.put(LocalReadWriteLockNamedLockFactory.NAME, new LocalReadWriteLockNamedLockFactory());
361        result.put(LocalSemaphoreNamedLockFactory.NAME, new LocalSemaphoreNamedLockFactory());
362        result.put(FileLockNamedLockFactory.NAME, new FileLockNamedLockFactory());
363        return result;
364    }
365
366    private Map<String, NameMapper> nameMappers;
367
368    public final Map<String, NameMapper> getNameMappers() {
369        checkClosed();
370        if (nameMappers == null) {
371            nameMappers = createNameMappers();
372        }
373        return nameMappers;
374    }
375
376    protected Map<String, NameMapper> createNameMappers() {
377        HashMap<String, NameMapper> result = new HashMap<>();
378        result.put(NameMappers.STATIC_NAME, NameMappers.staticNameMapper());
379        result.put(NameMappers.GAV_NAME, NameMappers.gavNameMapper());
380        result.put(NameMappers.GAECV_NAME, NameMappers.gaecvNameMapper());
381        result.put(NameMappers.DISCRIMINATING_NAME, NameMappers.discriminatingNameMapper());
382        result.put(NameMappers.FILE_GAV_NAME, NameMappers.fileGavNameMapper());
383        result.put(NameMappers.FILE_GAECV_NAME, NameMappers.fileGaecvNameMapper());
384        result.put(NameMappers.FILE_HGAV_NAME, NameMappers.fileHashingGavNameMapper());
385        result.put(NameMappers.FILE_HGAECV_NAME, NameMappers.fileHashingGaecvNameMapper());
386        return result;
387    }
388
389    private Map<String, LockingInhibitorFactory> lockingInhibitorFactories;
390
391    public final Map<String, LockingInhibitorFactory> getLockingInhibitorFactories() {
392        checkClosed();
393        if (lockingInhibitorFactories == null) {
394            lockingInhibitorFactories = createLockingInhibitorFactories();
395        }
396        return lockingInhibitorFactories;
397    }
398
399    protected Map<String, LockingInhibitorFactory> createLockingInhibitorFactories() {
400        HashMap<String, LockingInhibitorFactory> result = new HashMap<>();
401        result.put(PrefixesLockingInhibitorFactory.NAME, new PrefixesLockingInhibitorFactory());
402        return result;
403    }
404
405    private NamedLockFactorySelector namedLockFactorySelector;
406
407    public final NamedLockFactorySelector getNamedLockFactorySelector() {
408        checkClosed();
409        if (namedLockFactorySelector == null) {
410            namedLockFactorySelector = createNamedLockFactorySelector();
411        }
412        return namedLockFactorySelector;
413    }
414
415    protected NamedLockFactorySelector createNamedLockFactorySelector() {
416        return new DefaultNamedLockFactorySelector(getNamedLockFactories(), getRepositorySystemLifecycle());
417    }
418
419    private NamedLockFactoryAdapterFactory namedLockFactoryAdapterFactory;
420
421    public final NamedLockFactoryAdapterFactory getNamedLockFactoryAdapterFactory() {
422        checkClosed();
423        if (namedLockFactoryAdapterFactory == null) {
424            namedLockFactoryAdapterFactory = createNamedLockFactoryAdapterFactory();
425        }
426        return namedLockFactoryAdapterFactory;
427    }
428
429    protected NamedLockFactoryAdapterFactory createNamedLockFactoryAdapterFactory() {
430        return new NamedLockFactoryAdapterFactoryImpl(
431                getNamedLockFactorySelector(), getNameMappers(), getLockingInhibitorFactories());
432    }
433
434    private SyncContextFactory syncContextFactory;
435
436    public final SyncContextFactory getSyncContextFactory() {
437        checkClosed();
438        if (syncContextFactory == null) {
439            syncContextFactory = createSyncContextFactory();
440        }
441        return syncContextFactory;
442    }
443
444    protected SyncContextFactory createSyncContextFactory() {
445        return new DefaultSyncContextFactory(getNamedLockFactoryAdapterFactory());
446    }
447
448    private Map<String, ChecksumAlgorithmFactory> checksumAlgorithmFactories;
449
450    public final Map<String, ChecksumAlgorithmFactory> getChecksumAlgorithmFactories() {
451        checkClosed();
452        if (checksumAlgorithmFactories == null) {
453            checksumAlgorithmFactories = createChecksumAlgorithmFactories();
454        }
455        return checksumAlgorithmFactories;
456    }
457
458    protected Map<String, ChecksumAlgorithmFactory> createChecksumAlgorithmFactories() {
459        HashMap<String, ChecksumAlgorithmFactory> result = new HashMap<>();
460        result.put(Sha512ChecksumAlgorithmFactory.NAME, new Sha512ChecksumAlgorithmFactory());
461        result.put(Sha256ChecksumAlgorithmFactory.NAME, new Sha256ChecksumAlgorithmFactory());
462        result.put(Sha1ChecksumAlgorithmFactory.NAME, new Sha1ChecksumAlgorithmFactory());
463        result.put(Md5ChecksumAlgorithmFactory.NAME, new Md5ChecksumAlgorithmFactory());
464        return result;
465    }
466
467    private ChecksumAlgorithmFactorySelector checksumAlgorithmFactorySelector;
468
469    public final ChecksumAlgorithmFactorySelector getChecksumAlgorithmFactorySelector() {
470        checkClosed();
471        if (checksumAlgorithmFactorySelector == null) {
472            checksumAlgorithmFactorySelector = createChecksumAlgorithmFactorySelector();
473        }
474        return checksumAlgorithmFactorySelector;
475    }
476
477    protected ChecksumAlgorithmFactorySelector createChecksumAlgorithmFactorySelector() {
478        return new DefaultChecksumAlgorithmFactorySelector(getChecksumAlgorithmFactories());
479    }
480
481    private ArtifactPredicateFactory artifactPredicateFactory;
482
483    public final ArtifactPredicateFactory getArtifactPredicateFactory() {
484        checkClosed();
485        if (artifactPredicateFactory == null) {
486            artifactPredicateFactory = createArtifactPredicateFactory();
487        }
488        return artifactPredicateFactory;
489    }
490
491    protected ArtifactPredicateFactory createArtifactPredicateFactory() {
492        return new DefaultArtifactPredicateFactory(getChecksumAlgorithmFactorySelector());
493    }
494
495    private Map<String, RepositoryLayoutFactory> repositoryLayoutFactories;
496
497    public final Map<String, RepositoryLayoutFactory> getRepositoryLayoutFactories() {
498        checkClosed();
499        if (repositoryLayoutFactories == null) {
500            repositoryLayoutFactories = createRepositoryLayoutFactories();
501        }
502        return repositoryLayoutFactories;
503    }
504
505    protected Map<String, RepositoryLayoutFactory> createRepositoryLayoutFactories() {
506        HashMap<String, RepositoryLayoutFactory> result = new HashMap<>();
507        result.put(
508                Maven2RepositoryLayoutFactory.NAME,
509                new Maven2RepositoryLayoutFactory(
510                        getChecksumAlgorithmFactorySelector(), getArtifactPredicateFactory()));
511        return result;
512    }
513
514    private RepositoryLayoutProvider repositoryLayoutProvider;
515
516    public final RepositoryLayoutProvider getRepositoryLayoutProvider() {
517        checkClosed();
518        if (repositoryLayoutProvider == null) {
519            repositoryLayoutProvider = createRepositoryLayoutProvider();
520        }
521        return repositoryLayoutProvider;
522    }
523
524    protected RepositoryLayoutProvider createRepositoryLayoutProvider() {
525        return new DefaultRepositoryLayoutProvider(getRepositoryLayoutFactories());
526    }
527
528    private LocalRepositoryProvider localRepositoryProvider;
529
530    public final LocalRepositoryProvider getLocalRepositoryProvider() {
531        checkClosed();
532        if (localRepositoryProvider == null) {
533            localRepositoryProvider = createLocalRepositoryProvider();
534        }
535        return localRepositoryProvider;
536    }
537
538    protected LocalRepositoryProvider createLocalRepositoryProvider() {
539        LocalPathComposer localPathComposer = getLocalPathComposer();
540        RepositoryKeyFunctionFactory repositoryKeyFunctionFactory = getRepositoryKeyFunctionFactory();
541        HashMap<String, LocalRepositoryManagerFactory> localRepositoryProviders = new HashMap<>(2);
542        localRepositoryProviders.put(
543                SimpleLocalRepositoryManagerFactory.NAME, new SimpleLocalRepositoryManagerFactory(localPathComposer));
544        localRepositoryProviders.put(
545                EnhancedLocalRepositoryManagerFactory.NAME,
546                new EnhancedLocalRepositoryManagerFactory(
547                        localPathComposer,
548                        getTrackingFileManager(),
549                        getLocalPathPrefixComposerFactory(),
550                        repositoryKeyFunctionFactory));
551        return new DefaultLocalRepositoryProvider(localRepositoryProviders);
552    }
553
554    private RemoteRepositoryManager remoteRepositoryManager;
555
556    public final RemoteRepositoryManager getRemoteRepositoryManager() {
557        checkClosed();
558        if (remoteRepositoryManager == null) {
559            remoteRepositoryManager = createRemoteRepositoryManager();
560        }
561        return remoteRepositoryManager;
562    }
563
564    protected RemoteRepositoryManager createRemoteRepositoryManager() {
565        return new DefaultRemoteRepositoryManager(
566                getUpdatePolicyAnalyzer(), getChecksumPolicyProvider(), getRepositoryKeyFunctionFactory());
567    }
568
569    private Map<String, RemoteRepositoryFilterSource> remoteRepositoryFilterSources;
570
571    public final Map<String, RemoteRepositoryFilterSource> getRemoteRepositoryFilterSources() {
572        checkClosed();
573        if (remoteRepositoryFilterSources == null) {
574            remoteRepositoryFilterSources = createRemoteRepositoryFilterSources();
575        }
576        return remoteRepositoryFilterSources;
577    }
578
579    protected Map<String, RemoteRepositoryFilterSource> createRemoteRepositoryFilterSources() {
580        HashMap<String, RemoteRepositoryFilterSource> result = new HashMap<>();
581        result.put(
582                GroupIdRemoteRepositoryFilterSource.NAME,
583                new GroupIdRemoteRepositoryFilterSource(
584                        getRepositoryKeyFunctionFactory(), getRepositorySystemLifecycle(), getPathProcessor()));
585        result.put(
586                PrefixesRemoteRepositoryFilterSource.NAME,
587                new PrefixesRemoteRepositoryFilterSource(
588                        getRepositoryKeyFunctionFactory(),
589                        this::getMetadataResolver,
590                        this::getRemoteRepositoryManager,
591                        getRepositoryLayoutProvider(),
592                        getTransporterProvider()));
593        return result;
594    }
595
596    private RemoteRepositoryFilterManager remoteRepositoryFilterManager;
597
598    public final RemoteRepositoryFilterManager getRemoteRepositoryFilterManager() {
599        checkClosed();
600        if (remoteRepositoryFilterManager == null) {
601            remoteRepositoryFilterManager = createRemoteRepositoryFilterManager();
602        }
603        return remoteRepositoryFilterManager;
604    }
605
606    protected RemoteRepositoryFilterManager createRemoteRepositoryFilterManager() {
607        return new DefaultRemoteRepositoryFilterManager(getRemoteRepositoryFilterSources());
608    }
609
610    private Map<String, RepositoryListener> repositoryListeners;
611
612    public final Map<String, RepositoryListener> getRepositoryListeners() {
613        checkClosed();
614        if (repositoryListeners == null) {
615            repositoryListeners = createRepositoryListeners();
616        }
617        return repositoryListeners;
618    }
619
620    protected Map<String, RepositoryListener> createRepositoryListeners() {
621        return new HashMap<>();
622    }
623
624    private RepositoryEventDispatcher repositoryEventDispatcher;
625
626    public final RepositoryEventDispatcher getRepositoryEventDispatcher() {
627        checkClosed();
628        if (repositoryEventDispatcher == null) {
629            repositoryEventDispatcher = createRepositoryEventDispatcher();
630        }
631        return repositoryEventDispatcher;
632    }
633
634    protected RepositoryEventDispatcher createRepositoryEventDispatcher() {
635        return new DefaultRepositoryEventDispatcher(getRepositoryListeners());
636    }
637
638    private Map<String, TrustedChecksumsSource> trustedChecksumsSources;
639
640    public final Map<String, TrustedChecksumsSource> getTrustedChecksumsSources() {
641        checkClosed();
642        if (trustedChecksumsSources == null) {
643            trustedChecksumsSources = createTrustedChecksumsSources();
644        }
645        return trustedChecksumsSources;
646    }
647
648    protected Map<String, TrustedChecksumsSource> createTrustedChecksumsSources() {
649        HashMap<String, TrustedChecksumsSource> result = new HashMap<>();
650        result.put(
651                SparseDirectoryTrustedChecksumsSource.NAME,
652                new SparseDirectoryTrustedChecksumsSource(
653                        getRepositoryKeyFunctionFactory(), getChecksumProcessor(), getLocalPathComposer()));
654        result.put(
655                SummaryFileTrustedChecksumsSource.NAME,
656                new SummaryFileTrustedChecksumsSource(
657                        getRepositoryKeyFunctionFactory(),
658                        getLocalPathComposer(),
659                        getRepositorySystemLifecycle(),
660                        getPathProcessor()));
661        return result;
662    }
663
664    private Map<String, ProvidedChecksumsSource> providedChecksumsSources;
665
666    public final Map<String, ProvidedChecksumsSource> getProvidedChecksumsSources() {
667        checkClosed();
668        if (providedChecksumsSources == null) {
669            providedChecksumsSources = createProvidedChecksumsSources();
670        }
671        return providedChecksumsSources;
672    }
673
674    protected Map<String, ProvidedChecksumsSource> createProvidedChecksumsSources() {
675        HashMap<String, ProvidedChecksumsSource> result = new HashMap<>();
676        result.put(
677                TrustedToProvidedChecksumsSourceAdapter.NAME,
678                new TrustedToProvidedChecksumsSourceAdapter(getTrustedChecksumsSources()));
679        return result;
680    }
681
682    private Map<String, ChecksumExtractorStrategy> checksumExtractorStrategies;
683
684    public final Map<String, ChecksumExtractorStrategy> getChecksumExtractorStrategies() {
685        checkClosed();
686        if (checksumExtractorStrategies == null) {
687            checksumExtractorStrategies = createChecksumExtractorStrategies();
688        }
689        return checksumExtractorStrategies;
690    }
691
692    protected Map<String, ChecksumExtractorStrategy> createChecksumExtractorStrategies() {
693        HashMap<String, ChecksumExtractorStrategy> result = new HashMap<>();
694        result.put(XChecksumExtractor.NAME, new XChecksumExtractor());
695        result.put(Nx2ChecksumExtractor.NAME, new Nx2ChecksumExtractor());
696        return result;
697    }
698
699    private ChecksumExtractor checksumExtractor;
700
701    public final ChecksumExtractor getChecksumExtractor() {
702        checkClosed();
703        if (checksumExtractor == null) {
704            checksumExtractor = createChecksumExtractor();
705        }
706        return checksumExtractor;
707    }
708
709    protected ChecksumExtractor createChecksumExtractor() {
710        return new DefaultChecksumExtractor(getChecksumExtractorStrategies());
711    }
712
713    private Map<String, TransporterFactory> transporterFactories;
714
715    public final Map<String, TransporterFactory> getTransporterFactories() {
716        checkClosed();
717        if (transporterFactories == null) {
718            transporterFactories = createTransporterFactories();
719        }
720        return transporterFactories;
721    }
722
723    protected Map<String, TransporterFactory> createTransporterFactories() {
724        HashMap<String, TransporterFactory> result = new HashMap<>();
725        result.put(FileTransporterFactory.NAME, new FileTransporterFactory());
726        result.put(
727                ApacheTransporterFactory.NAME,
728                new ApacheTransporterFactory(getChecksumExtractor(), getPathProcessor()));
729        return result;
730    }
731
732    private TransporterProvider transporterProvider;
733
734    public final TransporterProvider getTransporterProvider() {
735        checkClosed();
736        if (transporterProvider == null) {
737            transporterProvider = createTransporterProvider();
738        }
739        return transporterProvider;
740    }
741
742    protected TransporterProvider createTransporterProvider() {
743        return new DefaultTransporterProvider(getTransporterFactories());
744    }
745
746    private BasicRepositoryConnectorFactory basicRepositoryConnectorFactory;
747
748    public final BasicRepositoryConnectorFactory getBasicRepositoryConnectorFactory() {
749        checkClosed();
750        if (basicRepositoryConnectorFactory == null) {
751            basicRepositoryConnectorFactory = createBasicRepositoryConnectorFactory();
752        }
753        return basicRepositoryConnectorFactory;
754    }
755
756    protected BasicRepositoryConnectorFactory createBasicRepositoryConnectorFactory() {
757        return new BasicRepositoryConnectorFactory(
758                getTransporterProvider(),
759                getRepositoryLayoutProvider(),
760                getChecksumPolicyProvider(),
761                getPathProcessor(),
762                getChecksumProcessor(),
763                getProvidedChecksumsSources());
764    }
765
766    private Map<String, RepositoryConnectorFactory> repositoryConnectorFactories;
767
768    public final Map<String, RepositoryConnectorFactory> getRepositoryConnectorFactories() {
769        checkClosed();
770        if (repositoryConnectorFactories == null) {
771            repositoryConnectorFactories = createRepositoryConnectorFactories();
772        }
773        return repositoryConnectorFactories;
774    }
775
776    protected Map<String, RepositoryConnectorFactory> createRepositoryConnectorFactories() {
777        HashMap<String, RepositoryConnectorFactory> result = new HashMap<>();
778        result.put(BasicRepositoryConnectorFactory.NAME, getBasicRepositoryConnectorFactory());
779        return result;
780    }
781
782    private Map<String, PipelineRepositoryConnectorFactory> pipelineRepositoryConnectorFactories;
783
784    public final Map<String, PipelineRepositoryConnectorFactory> getPipelineRepositoryConnectorFactories() {
785        checkClosed();
786        if (pipelineRepositoryConnectorFactories == null) {
787            pipelineRepositoryConnectorFactories = createPipelineRepositoryConnectorFactories();
788        }
789        return pipelineRepositoryConnectorFactories;
790    }
791
792    protected Map<String, PipelineRepositoryConnectorFactory> createPipelineRepositoryConnectorFactories() {
793        HashMap<String, PipelineRepositoryConnectorFactory> result = new HashMap<>();
794        result.put(
795                FilteringPipelineRepositoryConnectorFactory.NAME,
796                new FilteringPipelineRepositoryConnectorFactory(getRemoteRepositoryFilterManager()));
797        result.put(
798                OfflinePipelineRepositoryConnectorFactory.NAME,
799                new OfflinePipelineRepositoryConnectorFactory(getOfflineController()));
800        return result;
801    }
802
803    private RepositoryConnectorProvider repositoryConnectorProvider;
804
805    public final RepositoryConnectorProvider getRepositoryConnectorProvider() {
806        checkClosed();
807        if (repositoryConnectorProvider == null) {
808            repositoryConnectorProvider = createRepositoryConnectorProvider();
809        }
810        return repositoryConnectorProvider;
811    }
812
813    protected RepositoryConnectorProvider createRepositoryConnectorProvider() {
814        return new DefaultRepositoryConnectorProvider(
815                getRepositoryConnectorFactories(), getPipelineRepositoryConnectorFactories());
816    }
817
818    private Installer installer;
819
820    public final Installer getInstaller() {
821        checkClosed();
822        if (installer == null) {
823            installer = createInstaller();
824        }
825        return installer;
826    }
827
828    protected Installer createInstaller() {
829        return new DefaultInstaller(
830                getPathProcessor(),
831                getRepositoryEventDispatcher(),
832                getArtifactGeneratorFactories(),
833                getMetadataGeneratorFactories(),
834                getArtifactTransformers(),
835                getSyncContextFactory());
836    }
837
838    private Deployer deployer;
839
840    public final Deployer getDeployer() {
841        checkClosed();
842        if (deployer == null) {
843            deployer = createDeployer();
844        }
845        return deployer;
846    }
847
848    protected Deployer createDeployer() {
849        return new DefaultDeployer(
850                getPathProcessor(),
851                getRepositoryEventDispatcher(),
852                getRepositoryConnectorProvider(),
853                getRemoteRepositoryManager(),
854                getUpdateCheckManager(),
855                getArtifactGeneratorFactories(),
856                getMetadataGeneratorFactories(),
857                getArtifactTransformers(),
858                getSyncContextFactory(),
859                getOfflineController());
860    }
861
862    private Map<String, DependencyCollectorDelegate> dependencyCollectorDelegates;
863
864    public final Map<String, DependencyCollectorDelegate> getDependencyCollectorDelegates() {
865        checkClosed();
866        if (dependencyCollectorDelegates == null) {
867            dependencyCollectorDelegates = createDependencyCollectorDelegates();
868        }
869        return dependencyCollectorDelegates;
870    }
871
872    protected Map<String, DependencyCollectorDelegate> createDependencyCollectorDelegates() {
873        RemoteRepositoryManager remoteRepositoryManager = getRemoteRepositoryManager();
874        ArtifactDescriptorReader artifactDescriptorReader = getArtifactDescriptorReader();
875        VersionRangeResolver versionRangeResolver = getVersionRangeResolver();
876        HashMap<String, DependencyCollectorDelegate> result = new HashMap<>();
877        result.put(
878                DfDependencyCollector.NAME,
879                new DfDependencyCollector(
880                        remoteRepositoryManager,
881                        artifactDescriptorReader,
882                        versionRangeResolver,
883                        getArtifactDecoratorFactories()));
884        result.put(
885                BfDependencyCollector.NAME,
886                new BfDependencyCollector(
887                        remoteRepositoryManager,
888                        artifactDescriptorReader,
889                        versionRangeResolver,
890                        getArtifactDecoratorFactories()));
891        return result;
892    }
893
894    private DependencyCollector dependencyCollector;
895
896    public final DependencyCollector getDependencyCollector() {
897        checkClosed();
898        if (dependencyCollector == null) {
899            dependencyCollector = createDependencyCollector();
900        }
901        return dependencyCollector;
902    }
903
904    protected DependencyCollector createDependencyCollector() {
905        return new DefaultDependencyCollector(getDependencyCollectorDelegates());
906    }
907
908    private Map<String, ArtifactResolverPostProcessor> artifactResolverPostProcessors;
909
910    public final Map<String, ArtifactResolverPostProcessor> getArtifactResolverPostProcessors() {
911        checkClosed();
912        if (artifactResolverPostProcessors == null) {
913            artifactResolverPostProcessors = createArtifactResolverPostProcessors();
914        }
915        return artifactResolverPostProcessors;
916    }
917
918    protected Map<String, ArtifactResolverPostProcessor> createArtifactResolverPostProcessors() {
919        HashMap<String, ArtifactResolverPostProcessor> result = new HashMap<>();
920        result.put(
921                TrustedChecksumsArtifactResolverPostProcessor.NAME,
922                new TrustedChecksumsArtifactResolverPostProcessor(
923                        getChecksumAlgorithmFactorySelector(), getTrustedChecksumsSources()));
924        return result;
925    }
926
927    private ArtifactResolver artifactResolver;
928
929    public final ArtifactResolver getArtifactResolver() {
930        checkClosed();
931        if (artifactResolver == null) {
932            artifactResolver = createArtifactResolver();
933        }
934        return artifactResolver;
935    }
936
937    protected ArtifactResolver createArtifactResolver() {
938        return new DefaultArtifactResolver(
939                getPathProcessor(),
940                getRepositoryEventDispatcher(),
941                getVersionResolver(),
942                getUpdateCheckManager(),
943                getRepositoryConnectorProvider(),
944                getRemoteRepositoryManager(),
945                getSyncContextFactory(),
946                getOfflineController(),
947                getArtifactResolverPostProcessors(),
948                getRemoteRepositoryFilterManager());
949    }
950
951    private MetadataResolver metadataResolver;
952
953    public final MetadataResolver getMetadataResolver() {
954        checkClosed();
955        if (metadataResolver == null) {
956            metadataResolver = createMetadataResolver();
957        }
958        return metadataResolver;
959    }
960
961    protected MetadataResolver createMetadataResolver() {
962        return new DefaultMetadataResolver(
963                getRepositoryEventDispatcher(),
964                getUpdateCheckManager(),
965                getRepositoryConnectorProvider(),
966                getRemoteRepositoryManager(),
967                getSyncContextFactory(),
968                getOfflineController(),
969                getRemoteRepositoryFilterManager(),
970                getPathProcessor());
971    }
972
973    private VersionScheme versionScheme;
974
975    public final VersionScheme getVersionScheme() {
976        checkClosed();
977        if (versionScheme == null) {
978            versionScheme = createVersionScheme();
979        }
980        return versionScheme;
981    }
982
983    protected VersionScheme createVersionScheme() {
984        return new GenericVersionScheme();
985    }
986
987    private Map<String, ArtifactGeneratorFactory> artifactGeneratorFactories;
988
989    public final Map<String, ArtifactGeneratorFactory> getArtifactGeneratorFactories() {
990        checkClosed();
991        if (artifactGeneratorFactories == null) {
992            artifactGeneratorFactories = createArtifactGeneratorFactories();
993        }
994        return artifactGeneratorFactories;
995    }
996
997    protected Map<String, ArtifactGeneratorFactory> createArtifactGeneratorFactories() {
998        // by default none, this is extension point
999        return new HashMap<>();
1000    }
1001
1002    private Map<String, ArtifactDecoratorFactory> artifactDecoratorFactories;
1003
1004    public final Map<String, ArtifactDecoratorFactory> getArtifactDecoratorFactories() {
1005        checkClosed();
1006        if (artifactDecoratorFactories == null) {
1007            artifactDecoratorFactories = createArtifactDecoratorFactories();
1008        }
1009        return artifactDecoratorFactories;
1010    }
1011
1012    protected Map<String, ArtifactDecoratorFactory> createArtifactDecoratorFactories() {
1013        // by default none, this is extension point
1014        return new HashMap<>();
1015    }
1016
1017    // Maven provided
1018
1019    private Map<String, ArtifactTransformer> artifactTransformers;
1020
1021    public final Map<String, ArtifactTransformer> getArtifactTransformers() {
1022        checkClosed();
1023        if (artifactTransformers == null) {
1024            artifactTransformers = createArtifactTransformers();
1025        }
1026        return artifactTransformers;
1027    }
1028
1029    protected Map<String, ArtifactTransformer> createArtifactTransformers() {
1030        return new HashMap<>();
1031    }
1032
1033    private Map<String, MetadataGeneratorFactory> metadataGeneratorFactories;
1034
1035    public final Map<String, MetadataGeneratorFactory> getMetadataGeneratorFactories() {
1036        checkClosed();
1037        if (metadataGeneratorFactories == null) {
1038            metadataGeneratorFactories = createMetadataGeneratorFactories();
1039        }
1040        return metadataGeneratorFactories;
1041    }
1042
1043    protected Map<String, MetadataGeneratorFactory> createMetadataGeneratorFactories() {
1044        // from maven-resolver-provider
1045        HashMap<String, MetadataGeneratorFactory> result = new HashMap<>();
1046        result.put(PluginsMetadataGeneratorFactory.NAME, new PluginsMetadataGeneratorFactory());
1047        result.put(VersionsMetadataGeneratorFactory.NAME, new VersionsMetadataGeneratorFactory());
1048        result.put(SnapshotMetadataGeneratorFactory.NAME, new SnapshotMetadataGeneratorFactory());
1049        return result;
1050    }
1051
1052    private LinkedHashMap<String, MavenArtifactRelocationSource> artifactRelocationSources;
1053
1054    public final LinkedHashMap<String, MavenArtifactRelocationSource> getMavenArtifactRelocationSources() {
1055        checkClosed();
1056        if (artifactRelocationSources == null) {
1057            artifactRelocationSources = createMavenArtifactRelocationSources();
1058        }
1059        return artifactRelocationSources;
1060    }
1061
1062    protected LinkedHashMap<String, MavenArtifactRelocationSource> createMavenArtifactRelocationSources() {
1063        // from maven-resolver-provider
1064        LinkedHashMap<String, MavenArtifactRelocationSource> result = new LinkedHashMap<>();
1065        result.put(UserPropertiesArtifactRelocationSource.NAME, new UserPropertiesArtifactRelocationSource());
1066        result.put(
1067                DistributionManagementArtifactRelocationSource.NAME,
1068                new DistributionManagementArtifactRelocationSource());
1069        return result;
1070    }
1071
1072    private LinkedHashMap<String, ArtifactDescriptorDecorator> artifactDescriptorDecorators;
1073
1074    public final LinkedHashMap<String, ArtifactDescriptorDecorator> getArtifactDescriptorDecorators() {
1075        checkClosed();
1076        if (artifactDescriptorDecorators == null) {
1077            artifactDescriptorDecorators = createArtifactDescriptorDecorators();
1078        }
1079        return artifactDescriptorDecorators;
1080    }
1081
1082    protected LinkedHashMap<String, ArtifactDescriptorDecorator> createArtifactDescriptorDecorators() {
1083        // from maven-resolver-provider: none by default
1084        return new LinkedHashMap<>();
1085    }
1086
1087    private ArtifactDescriptorReader artifactDescriptorReader;
1088
1089    public final ArtifactDescriptorReader getArtifactDescriptorReader() {
1090        checkClosed();
1091        if (artifactDescriptorReader == null) {
1092            artifactDescriptorReader = createArtifactDescriptorReader();
1093        }
1094        return artifactDescriptorReader;
1095    }
1096
1097    protected ArtifactDescriptorReader createArtifactDescriptorReader() {
1098        // from maven-resolver-provider
1099        return new DefaultArtifactDescriptorReader(
1100                getRemoteRepositoryManager(),
1101                getVersionResolver(),
1102                getVersionRangeResolver(),
1103                getArtifactResolver(),
1104                getModelBuilder(),
1105                getRepositoryEventDispatcher(),
1106                getModelCacheFactory(),
1107                getMavenArtifactRelocationSources(),
1108                getArtifactDescriptorDecorators());
1109    }
1110
1111    private VersionResolver versionResolver;
1112
1113    public final VersionResolver getVersionResolver() {
1114        checkClosed();
1115        if (versionResolver == null) {
1116            versionResolver = createVersionResolver();
1117        }
1118        return versionResolver;
1119    }
1120
1121    protected VersionResolver createVersionResolver() {
1122        // from maven-resolver-provider
1123        return new DefaultVersionResolver(
1124                getMetadataResolver(), getSyncContextFactory(), getRepositoryEventDispatcher());
1125    }
1126
1127    private VersionRangeResolver versionRangeResolver;
1128
1129    public final VersionRangeResolver getVersionRangeResolver() {
1130        checkClosed();
1131        if (versionRangeResolver == null) {
1132            versionRangeResolver = createVersionRangeResolver();
1133        }
1134        return versionRangeResolver;
1135    }
1136
1137    protected VersionRangeResolver createVersionRangeResolver() {
1138        // from maven-resolver-provider
1139        return new DefaultVersionRangeResolver(
1140                getMetadataResolver(), getSyncContextFactory(), getRepositoryEventDispatcher());
1141    }
1142
1143    private ModelBuilder modelBuilder;
1144
1145    public final ModelBuilder getModelBuilder() {
1146        checkClosed();
1147        if (modelBuilder == null) {
1148            modelBuilder = createModelBuilder();
1149        }
1150        return modelBuilder;
1151    }
1152
1153    protected ModelBuilder createModelBuilder() {
1154        // from maven-model-builder
1155        return new DefaultModelBuilderFactory().newInstance();
1156    }
1157
1158    private ModelCacheFactory modelCacheFactory;
1159
1160    public final ModelCacheFactory getModelCacheFactory() {
1161        checkClosed();
1162        if (modelCacheFactory == null) {
1163            modelCacheFactory = createModelCacheFactory();
1164        }
1165        return modelCacheFactory;
1166    }
1167
1168    protected ModelCacheFactory createModelCacheFactory() {
1169        // from maven-resolver-provider
1170        return new DefaultModelCacheFactory();
1171    }
1172
1173    private Map<String, ValidatorFactory> validatorFactories;
1174
1175    public final Map<String, ValidatorFactory> getValidatorFactories() {
1176        checkClosed();
1177        if (validatorFactories == null) {
1178            validatorFactories = createValidatorFactories();
1179        }
1180        return validatorFactories;
1181    }
1182
1183    protected Map<String, ValidatorFactory> createValidatorFactories() {
1184        return new HashMap<>();
1185    }
1186
1187    private RepositorySystemValidator repositorySystemValidator;
1188
1189    public final RepositorySystemValidator getRepositorySystemValidator() {
1190        checkClosed();
1191        if (repositorySystemValidator == null) {
1192            repositorySystemValidator = createRepositorySystemValidator();
1193        }
1194        return repositorySystemValidator;
1195    }
1196
1197    protected RepositorySystemValidator createRepositorySystemValidator() {
1198        return new DefaultRepositorySystemValidator(getValidatorFactories());
1199    }
1200
1201    private RepositorySystem repositorySystem;
1202
1203    public final RepositorySystem getRepositorySystem() {
1204        checkClosed();
1205        if (repositorySystem == null) {
1206            repositorySystem = createRepositorySystem();
1207        }
1208        return repositorySystem;
1209    }
1210
1211    protected RepositorySystem createRepositorySystem() {
1212        return new DefaultRepositorySystem(
1213                getVersionResolver(),
1214                getVersionRangeResolver(),
1215                getArtifactResolver(),
1216                getMetadataResolver(),
1217                getArtifactDescriptorReader(),
1218                getDependencyCollector(),
1219                getInstaller(),
1220                getDeployer(),
1221                getLocalRepositoryProvider(),
1222                getSyncContextFactory(),
1223                getRemoteRepositoryManager(),
1224                getRepositorySystemLifecycle(),
1225                getArtifactDecoratorFactories(),
1226                getRepositorySystemValidator());
1227    }
1228
1229    @Override
1230    public RepositorySystem get() {
1231        return getRepositorySystem();
1232    }
1233}