View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements.  See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership.  The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License.  You may obtain a copy of the License at
9    *
10   *   http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing,
13   * software distributed under the License is distributed on an
14   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   * KIND, either express or implied.  See the License for the
16   * specific language governing permissions and limitations
17   * under the License.
18   */
19  package org.eclipse.aether.supplier;
20  
21  import java.util.HashMap;
22  import java.util.LinkedHashMap;
23  import java.util.Map;
24  import java.util.concurrent.atomic.AtomicBoolean;
25  import java.util.function.Supplier;
26  
27  import org.apache.maven.model.building.DefaultModelBuilderFactory;
28  import org.apache.maven.model.building.ModelBuilder;
29  import org.apache.maven.repository.internal.ArtifactDescriptorDecorator;
30  import org.apache.maven.repository.internal.DefaultArtifactDescriptorReader;
31  import org.apache.maven.repository.internal.DefaultModelCacheFactory;
32  import org.apache.maven.repository.internal.DefaultVersionRangeResolver;
33  import org.apache.maven.repository.internal.DefaultVersionResolver;
34  import org.apache.maven.repository.internal.MavenArtifactRelocationSource;
35  import org.apache.maven.repository.internal.ModelCacheFactory;
36  import org.apache.maven.repository.internal.PluginsMetadataGeneratorFactory;
37  import org.apache.maven.repository.internal.SnapshotMetadataGeneratorFactory;
38  import org.apache.maven.repository.internal.VersionsMetadataGeneratorFactory;
39  import org.apache.maven.repository.internal.relocation.DistributionManagementArtifactRelocationSource;
40  import org.apache.maven.repository.internal.relocation.UserPropertiesArtifactRelocationSource;
41  import org.eclipse.aether.RepositoryListener;
42  import org.eclipse.aether.RepositorySystem;
43  import org.eclipse.aether.connector.basic.BasicRepositoryConnectorFactory;
44  import org.eclipse.aether.impl.ArtifactDescriptorReader;
45  import org.eclipse.aether.impl.ArtifactResolver;
46  import org.eclipse.aether.impl.DependencyCollector;
47  import org.eclipse.aether.impl.Deployer;
48  import org.eclipse.aether.impl.Installer;
49  import org.eclipse.aether.impl.LocalRepositoryProvider;
50  import org.eclipse.aether.impl.MetadataGeneratorFactory;
51  import org.eclipse.aether.impl.MetadataResolver;
52  import org.eclipse.aether.impl.NamedLockFactorySelector;
53  import org.eclipse.aether.impl.OfflineController;
54  import org.eclipse.aether.impl.RemoteRepositoryFilterManager;
55  import org.eclipse.aether.impl.RemoteRepositoryManager;
56  import org.eclipse.aether.impl.RepositoryConnectorProvider;
57  import org.eclipse.aether.impl.RepositoryEventDispatcher;
58  import org.eclipse.aether.impl.RepositorySystemLifecycle;
59  import org.eclipse.aether.impl.RepositorySystemValidator;
60  import org.eclipse.aether.impl.UpdateCheckManager;
61  import org.eclipse.aether.impl.UpdatePolicyAnalyzer;
62  import org.eclipse.aether.impl.VersionRangeResolver;
63  import org.eclipse.aether.impl.VersionResolver;
64  import org.eclipse.aether.internal.impl.DefaultArtifactPredicateFactory;
65  import org.eclipse.aether.internal.impl.DefaultArtifactResolver;
66  import org.eclipse.aether.internal.impl.DefaultChecksumPolicyProvider;
67  import org.eclipse.aether.internal.impl.DefaultChecksumProcessor;
68  import org.eclipse.aether.internal.impl.DefaultDeployer;
69  import org.eclipse.aether.internal.impl.DefaultInstaller;
70  import org.eclipse.aether.internal.impl.DefaultLocalPathComposer;
71  import org.eclipse.aether.internal.impl.DefaultLocalPathPrefixComposerFactory;
72  import org.eclipse.aether.internal.impl.DefaultLocalRepositoryProvider;
73  import org.eclipse.aether.internal.impl.DefaultMetadataResolver;
74  import org.eclipse.aether.internal.impl.DefaultOfflineController;
75  import org.eclipse.aether.internal.impl.DefaultPathProcessor;
76  import org.eclipse.aether.internal.impl.DefaultRemoteRepositoryManager;
77  import org.eclipse.aether.internal.impl.DefaultRepositoryConnectorProvider;
78  import org.eclipse.aether.internal.impl.DefaultRepositoryEventDispatcher;
79  import org.eclipse.aether.internal.impl.DefaultRepositoryKeyFunctionFactory;
80  import org.eclipse.aether.internal.impl.DefaultRepositoryLayoutProvider;
81  import org.eclipse.aether.internal.impl.DefaultRepositorySystem;
82  import org.eclipse.aether.internal.impl.DefaultRepositorySystemLifecycle;
83  import org.eclipse.aether.internal.impl.DefaultRepositorySystemValidator;
84  import org.eclipse.aether.internal.impl.DefaultTransporterProvider;
85  import org.eclipse.aether.internal.impl.DefaultUpdateCheckManager;
86  import org.eclipse.aether.internal.impl.DefaultUpdatePolicyAnalyzer;
87  import org.eclipse.aether.internal.impl.EnhancedLocalRepositoryManagerFactory;
88  import org.eclipse.aether.internal.impl.LocalPathComposer;
89  import org.eclipse.aether.internal.impl.LocalPathPrefixComposerFactory;
90  import org.eclipse.aether.internal.impl.Maven2RepositoryLayoutFactory;
91  import org.eclipse.aether.internal.impl.SimpleLocalRepositoryManagerFactory;
92  import org.eclipse.aether.internal.impl.TrackingFileManager;
93  import org.eclipse.aether.internal.impl.TrackingFileManagerSupplier;
94  import org.eclipse.aether.internal.impl.checksum.DefaultChecksumAlgorithmFactorySelector;
95  import org.eclipse.aether.internal.impl.checksum.Md5ChecksumAlgorithmFactory;
96  import org.eclipse.aether.internal.impl.checksum.Sha1ChecksumAlgorithmFactory;
97  import org.eclipse.aether.internal.impl.checksum.Sha256ChecksumAlgorithmFactory;
98  import org.eclipse.aether.internal.impl.checksum.Sha512ChecksumAlgorithmFactory;
99  import org.eclipse.aether.internal.impl.checksum.SparseDirectoryTrustedChecksumsSource;
100 import org.eclipse.aether.internal.impl.checksum.SummaryFileTrustedChecksumsSource;
101 import org.eclipse.aether.internal.impl.checksum.TrustedToProvidedChecksumsSourceAdapter;
102 import org.eclipse.aether.internal.impl.collect.DefaultDependencyCollector;
103 import org.eclipse.aether.internal.impl.collect.DependencyCollectorDelegate;
104 import org.eclipse.aether.internal.impl.collect.bf.BfDependencyCollector;
105 import org.eclipse.aether.internal.impl.collect.df.DfDependencyCollector;
106 import org.eclipse.aether.internal.impl.filter.DefaultRemoteRepositoryFilterManager;
107 import org.eclipse.aether.internal.impl.filter.FilteringPipelineRepositoryConnectorFactory;
108 import org.eclipse.aether.internal.impl.filter.GroupIdRemoteRepositoryFilterSource;
109 import org.eclipse.aether.internal.impl.filter.PrefixesLockingInhibitorFactory;
110 import org.eclipse.aether.internal.impl.filter.PrefixesRemoteRepositoryFilterSource;
111 import org.eclipse.aether.internal.impl.named.DefaultNamedLockFactorySelector;
112 import org.eclipse.aether.internal.impl.offline.OfflinePipelineRepositoryConnectorFactory;
113 import org.eclipse.aether.internal.impl.resolution.TrustedChecksumsArtifactResolverPostProcessor;
114 import org.eclipse.aether.internal.impl.synccontext.DefaultSyncContextFactory;
115 import org.eclipse.aether.internal.impl.synccontext.named.NameMapper;
116 import org.eclipse.aether.internal.impl.synccontext.named.NameMappers;
117 import org.eclipse.aether.internal.impl.synccontext.named.NamedLockFactoryAdapterFactory;
118 import org.eclipse.aether.internal.impl.synccontext.named.NamedLockFactoryAdapterFactoryImpl;
119 import org.eclipse.aether.internal.impl.transport.http.DefaultChecksumExtractor;
120 import org.eclipse.aether.internal.impl.transport.http.Nx2ChecksumExtractor;
121 import org.eclipse.aether.internal.impl.transport.http.XChecksumExtractor;
122 import org.eclipse.aether.named.NamedLockFactory;
123 import org.eclipse.aether.named.providers.FileLockNamedLockFactory;
124 import org.eclipse.aether.named.providers.LocalReadWriteLockNamedLockFactory;
125 import org.eclipse.aether.named.providers.LocalSemaphoreNamedLockFactory;
126 import org.eclipse.aether.named.providers.NoopNamedLockFactory;
127 import org.eclipse.aether.spi.artifact.ArtifactPredicateFactory;
128 import org.eclipse.aether.spi.artifact.decorator.ArtifactDecoratorFactory;
129 import org.eclipse.aether.spi.artifact.generator.ArtifactGeneratorFactory;
130 import org.eclipse.aether.spi.artifact.transformer.ArtifactTransformer;
131 import org.eclipse.aether.spi.checksums.ProvidedChecksumsSource;
132 import org.eclipse.aether.spi.checksums.TrustedChecksumsSource;
133 import org.eclipse.aether.spi.connector.PipelineRepositoryConnectorFactory;
134 import org.eclipse.aether.spi.connector.RepositoryConnectorFactory;
135 import org.eclipse.aether.spi.connector.checksum.ChecksumAlgorithmFactory;
136 import org.eclipse.aether.spi.connector.checksum.ChecksumAlgorithmFactorySelector;
137 import org.eclipse.aether.spi.connector.checksum.ChecksumPolicyProvider;
138 import org.eclipse.aether.spi.connector.filter.RemoteRepositoryFilterSource;
139 import org.eclipse.aether.spi.connector.layout.RepositoryLayoutFactory;
140 import org.eclipse.aether.spi.connector.layout.RepositoryLayoutProvider;
141 import org.eclipse.aether.spi.connector.transport.TransporterFactory;
142 import org.eclipse.aether.spi.connector.transport.TransporterProvider;
143 import org.eclipse.aether.spi.connector.transport.http.ChecksumExtractor;
144 import org.eclipse.aether.spi.connector.transport.http.ChecksumExtractorStrategy;
145 import org.eclipse.aether.spi.io.ChecksumProcessor;
146 import org.eclipse.aether.spi.io.PathProcessor;
147 import org.eclipse.aether.spi.localrepo.LocalRepositoryManagerFactory;
148 import org.eclipse.aether.spi.locking.LockingInhibitorFactory;
149 import org.eclipse.aether.spi.remoterepo.RepositoryKeyFunctionFactory;
150 import org.eclipse.aether.spi.resolution.ArtifactResolverPostProcessor;
151 import org.eclipse.aether.spi.synccontext.SyncContextFactory;
152 import org.eclipse.aether.spi.validator.ValidatorFactory;
153 import org.eclipse.aether.transport.apache.ApacheTransporterFactory;
154 import org.eclipse.aether.transport.file.FileTransporterFactory;
155 import org.eclipse.aether.util.version.GenericVersionScheme;
156 import 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  */
181 public 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 }