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.*;
30  import org.apache.maven.repository.internal.relocation.DistributionManagementArtifactRelocationSource;
31  import org.apache.maven.repository.internal.relocation.UserPropertiesArtifactRelocationSource;
32  import org.eclipse.aether.RepositoryListener;
33  import org.eclipse.aether.RepositorySystem;
34  import org.eclipse.aether.connector.basic.BasicRepositoryConnectorFactory;
35  import org.eclipse.aether.impl.ArtifactDescriptorReader;
36  import org.eclipse.aether.impl.ArtifactResolver;
37  import org.eclipse.aether.impl.DependencyCollector;
38  import org.eclipse.aether.impl.Deployer;
39  import org.eclipse.aether.impl.Installer;
40  import org.eclipse.aether.impl.LocalRepositoryProvider;
41  import org.eclipse.aether.impl.MetadataGeneratorFactory;
42  import org.eclipse.aether.impl.MetadataResolver;
43  import org.eclipse.aether.impl.OfflineController;
44  import org.eclipse.aether.impl.RemoteRepositoryFilterManager;
45  import org.eclipse.aether.impl.RemoteRepositoryManager;
46  import org.eclipse.aether.impl.RepositoryConnectorProvider;
47  import org.eclipse.aether.impl.RepositoryEventDispatcher;
48  import org.eclipse.aether.impl.RepositorySystemLifecycle;
49  import org.eclipse.aether.impl.UpdateCheckManager;
50  import org.eclipse.aether.impl.UpdatePolicyAnalyzer;
51  import org.eclipse.aether.impl.VersionRangeResolver;
52  import org.eclipse.aether.impl.VersionResolver;
53  import org.eclipse.aether.internal.impl.*;
54  import org.eclipse.aether.internal.impl.checksum.DefaultChecksumAlgorithmFactorySelector;
55  import org.eclipse.aether.internal.impl.checksum.Md5ChecksumAlgorithmFactory;
56  import org.eclipse.aether.internal.impl.checksum.Sha1ChecksumAlgorithmFactory;
57  import org.eclipse.aether.internal.impl.checksum.Sha256ChecksumAlgorithmFactory;
58  import org.eclipse.aether.internal.impl.checksum.Sha512ChecksumAlgorithmFactory;
59  import org.eclipse.aether.internal.impl.checksum.SparseDirectoryTrustedChecksumsSource;
60  import org.eclipse.aether.internal.impl.checksum.SummaryFileTrustedChecksumsSource;
61  import org.eclipse.aether.internal.impl.checksum.TrustedToProvidedChecksumsSourceAdapter;
62  import org.eclipse.aether.internal.impl.collect.DefaultDependencyCollector;
63  import org.eclipse.aether.internal.impl.collect.DependencyCollectorDelegate;
64  import org.eclipse.aether.internal.impl.collect.bf.BfDependencyCollector;
65  import org.eclipse.aether.internal.impl.collect.df.DfDependencyCollector;
66  import org.eclipse.aether.internal.impl.filter.DefaultRemoteRepositoryFilterManager;
67  import org.eclipse.aether.internal.impl.filter.GroupIdRemoteRepositoryFilterSource;
68  import org.eclipse.aether.internal.impl.filter.PrefixesRemoteRepositoryFilterSource;
69  import org.eclipse.aether.internal.impl.resolution.TrustedChecksumsArtifactResolverPostProcessor;
70  import org.eclipse.aether.internal.impl.synccontext.DefaultSyncContextFactory;
71  import org.eclipse.aether.internal.impl.synccontext.named.NameMapper;
72  import org.eclipse.aether.internal.impl.synccontext.named.NameMappers;
73  import org.eclipse.aether.internal.impl.synccontext.named.NamedLockFactoryAdapterFactory;
74  import org.eclipse.aether.internal.impl.synccontext.named.NamedLockFactoryAdapterFactoryImpl;
75  import org.eclipse.aether.internal.impl.transport.http.DefaultChecksumExtractor;
76  import org.eclipse.aether.internal.impl.transport.http.Nx2ChecksumExtractor;
77  import org.eclipse.aether.internal.impl.transport.http.XChecksumExtractor;
78  import org.eclipse.aether.named.NamedLockFactory;
79  import org.eclipse.aether.named.providers.FileLockNamedLockFactory;
80  import org.eclipse.aether.named.providers.LocalReadWriteLockNamedLockFactory;
81  import org.eclipse.aether.named.providers.LocalSemaphoreNamedLockFactory;
82  import org.eclipse.aether.named.providers.NoopNamedLockFactory;
83  import org.eclipse.aether.spi.checksums.ProvidedChecksumsSource;
84  import org.eclipse.aether.spi.checksums.TrustedChecksumsSource;
85  import org.eclipse.aether.spi.connector.RepositoryConnectorFactory;
86  import org.eclipse.aether.spi.connector.checksum.ChecksumAlgorithmFactory;
87  import org.eclipse.aether.spi.connector.checksum.ChecksumAlgorithmFactorySelector;
88  import org.eclipse.aether.spi.connector.checksum.ChecksumPolicyProvider;
89  import org.eclipse.aether.spi.connector.filter.RemoteRepositoryFilterSource;
90  import org.eclipse.aether.spi.connector.layout.RepositoryLayoutFactory;
91  import org.eclipse.aether.spi.connector.layout.RepositoryLayoutProvider;
92  import org.eclipse.aether.spi.connector.transport.TransporterFactory;
93  import org.eclipse.aether.spi.connector.transport.TransporterProvider;
94  import org.eclipse.aether.spi.connector.transport.http.ChecksumExtractor;
95  import org.eclipse.aether.spi.connector.transport.http.ChecksumExtractorStrategy;
96  import org.eclipse.aether.spi.io.FileProcessor;
97  import org.eclipse.aether.spi.localrepo.LocalRepositoryManagerFactory;
98  import org.eclipse.aether.spi.resolution.ArtifactResolverPostProcessor;
99  import org.eclipse.aether.spi.synccontext.SyncContextFactory;
100 import org.eclipse.aether.transport.apache.ApacheTransporterFactory;
101 import org.eclipse.aether.transport.file.FileTransporterFactory;
102 import org.eclipse.aether.util.version.GenericVersionScheme;
103 import org.eclipse.aether.version.VersionScheme;
104 
105 /**
106  * A simple memorizing {@link Supplier} of {@link org.eclipse.aether.RepositorySystem} instance, that on first call
107  * supplies lazily constructed instance, and on each subsequent call same instance. Hence, this instance should be
108  * thrown away immediately once repository system was created and there is no need for more instances. If new
109  * repository system instance needed, new instance of this class must be created. For proper shut down of returned
110  * repository system instance(s) use {@link RepositorySystem#shutdown()} method on supplied instance(s).
111  * <p>
112  * Since Resolver 2.0 this class offers access to various components via public getters, and allows even partial object
113  * graph construction.
114  * <p>
115  * Extend this class {@code createXXX()} methods and override to customize, if needed. The contract of this class makes
116  * sure that these (potentially overridden) methods are invoked only once, and instance created by those methods are
117  * memorized and kept as long as supplier instance is kept open.
118  * <p>
119  * This class is not thread safe and must be used from one thread only, while the constructed {@link RepositorySystem}
120  * is thread safe.
121  * <p>
122  * Important: Given the instance of supplier memorizes the supplier {@link RepositorySystem} instance it supplies,
123  * their lifecycle is shared as well: once supplied repository system is shut-down, this instance becomes closed as
124  * well. Any subsequent {@code getXXX} method invocation attempt will fail with {@link IllegalStateException}.
125  *
126  * @since 1.9.15
127  */
128 public class RepositorySystemSupplier implements Supplier<RepositorySystem> {
129     private final AtomicBoolean closed = new AtomicBoolean(false);
130 
131     public RepositorySystemSupplier() {}
132 
133     private void checkClosed() {
134         if (closed.get()) {
135             throw new IllegalStateException("Supplier is closed");
136         }
137     }
138 
139     private FileProcessor fileProcessor;
140 
141     public final FileProcessor getFileProcessor() {
142         checkClosed();
143         if (fileProcessor == null) {
144             fileProcessor = createFileProcessor();
145         }
146         return fileProcessor;
147     }
148 
149     protected FileProcessor createFileProcessor() {
150         return new DefaultFileProcessor();
151     }
152 
153     private TrackingFileManager trackingFileManager;
154 
155     public final TrackingFileManager getTrackingFileManager() {
156         checkClosed();
157         if (trackingFileManager == null) {
158             trackingFileManager = createTrackingFileManager();
159         }
160         return trackingFileManager;
161     }
162 
163     protected TrackingFileManager createTrackingFileManager() {
164         return new DefaultTrackingFileManager();
165     }
166 
167     private LocalPathComposer localPathComposer;
168 
169     public final LocalPathComposer getLocalPathComposer() {
170         checkClosed();
171         if (localPathComposer == null) {
172             localPathComposer = createLocalPathComposer();
173         }
174         return localPathComposer;
175     }
176 
177     protected LocalPathComposer createLocalPathComposer() {
178         return new DefaultLocalPathComposer();
179     }
180 
181     private LocalPathPrefixComposerFactory localPathPrefixComposerFactory;
182 
183     public final LocalPathPrefixComposerFactory getLocalPathPrefixComposerFactory() {
184         checkClosed();
185         if (localPathPrefixComposerFactory == null) {
186             localPathPrefixComposerFactory = createLocalPathPrefixComposerFactory();
187         }
188         return localPathPrefixComposerFactory;
189     }
190 
191     protected LocalPathPrefixComposerFactory createLocalPathPrefixComposerFactory() {
192         return new DefaultLocalPathPrefixComposerFactory();
193     }
194 
195     private RepositorySystemLifecycle repositorySystemLifecycle;
196 
197     public final RepositorySystemLifecycle getRepositorySystemLifecycle() {
198         checkClosed();
199         if (repositorySystemLifecycle == null) {
200             repositorySystemLifecycle = createRepositorySystemLifecycle();
201             repositorySystemLifecycle.addOnSystemEndedHandler(() -> closed.set(true));
202         }
203         return repositorySystemLifecycle;
204     }
205 
206     protected RepositorySystemLifecycle createRepositorySystemLifecycle() {
207         return new DefaultRepositorySystemLifecycle();
208     }
209 
210     private OfflineController offlineController;
211 
212     public final OfflineController getOfflineController() {
213         checkClosed();
214         if (offlineController == null) {
215             offlineController = createOfflineController();
216         }
217         return offlineController;
218     }
219 
220     protected OfflineController createOfflineController() {
221         return new DefaultOfflineController();
222     }
223 
224     private UpdatePolicyAnalyzer updatePolicyAnalyzer;
225 
226     public final UpdatePolicyAnalyzer getUpdatePolicyAnalyzer() {
227         checkClosed();
228         if (updatePolicyAnalyzer == null) {
229             updatePolicyAnalyzer = createUpdatePolicyAnalyzer();
230         }
231         return updatePolicyAnalyzer;
232     }
233 
234     protected UpdatePolicyAnalyzer createUpdatePolicyAnalyzer() {
235         return new DefaultUpdatePolicyAnalyzer();
236     }
237 
238     private ChecksumPolicyProvider checksumPolicyProvider;
239 
240     public final ChecksumPolicyProvider getChecksumPolicyProvider() {
241         checkClosed();
242         if (checksumPolicyProvider == null) {
243             checksumPolicyProvider = createChecksumPolicyProvider();
244         }
245         return checksumPolicyProvider;
246     }
247 
248     protected ChecksumPolicyProvider createChecksumPolicyProvider() {
249         return new DefaultChecksumPolicyProvider();
250     }
251 
252     private UpdateCheckManager updateCheckManager;
253 
254     public final UpdateCheckManager getUpdateCheckManager() {
255         checkClosed();
256         if (updateCheckManager == null) {
257             updateCheckManager = createUpdateCheckManager();
258         }
259         return updateCheckManager;
260     }
261 
262     protected UpdateCheckManager createUpdateCheckManager() {
263         return new DefaultUpdateCheckManager(getTrackingFileManager(), getUpdatePolicyAnalyzer());
264     }
265 
266     private Map<String, NamedLockFactory> namedLockFactories;
267 
268     public final Map<String, NamedLockFactory> getNamedLockFactories() {
269         checkClosed();
270         if (namedLockFactories == null) {
271             namedLockFactories = createNamedLockFactories();
272         }
273         return namedLockFactories;
274     }
275 
276     protected Map<String, NamedLockFactory> createNamedLockFactories() {
277         HashMap<String, NamedLockFactory> result = new HashMap<>();
278         result.put(NoopNamedLockFactory.NAME, new NoopNamedLockFactory());
279         result.put(LocalReadWriteLockNamedLockFactory.NAME, new LocalReadWriteLockNamedLockFactory());
280         result.put(LocalSemaphoreNamedLockFactory.NAME, new LocalSemaphoreNamedLockFactory());
281         result.put(FileLockNamedLockFactory.NAME, new FileLockNamedLockFactory());
282         return result;
283     }
284 
285     private Map<String, NameMapper> nameMappers;
286 
287     public final Map<String, NameMapper> getNameMappers() {
288         checkClosed();
289         if (nameMappers == null) {
290             nameMappers = createNameMappers();
291         }
292         return nameMappers;
293     }
294 
295     protected Map<String, NameMapper> createNameMappers() {
296         HashMap<String, NameMapper> result = new HashMap<>();
297         result.put(NameMappers.STATIC_NAME, NameMappers.staticNameMapper());
298         result.put(NameMappers.GAV_NAME, NameMappers.gavNameMapper());
299         result.put(NameMappers.DISCRIMINATING_NAME, NameMappers.discriminatingNameMapper());
300         result.put(NameMappers.FILE_GAV_NAME, NameMappers.fileGavNameMapper());
301         result.put(NameMappers.FILE_HGAV_NAME, NameMappers.fileHashingGavNameMapper());
302         return result;
303     }
304 
305     private NamedLockFactoryAdapterFactory namedLockFactoryAdapterFactory;
306 
307     public final NamedLockFactoryAdapterFactory getNamedLockFactoryAdapterFactory() {
308         checkClosed();
309         if (namedLockFactoryAdapterFactory == null) {
310             namedLockFactoryAdapterFactory = createNamedLockFactoryAdapterFactory();
311         }
312         return namedLockFactoryAdapterFactory;
313     }
314 
315     protected NamedLockFactoryAdapterFactory createNamedLockFactoryAdapterFactory() {
316         return new NamedLockFactoryAdapterFactoryImpl(
317                 getNamedLockFactories(), getNameMappers(), getRepositorySystemLifecycle());
318     }
319 
320     private SyncContextFactory syncContextFactory;
321 
322     public final SyncContextFactory getSyncContextFactory() {
323         checkClosed();
324         if (syncContextFactory == null) {
325             syncContextFactory = createSyncContextFactory();
326         }
327         return syncContextFactory;
328     }
329 
330     protected SyncContextFactory createSyncContextFactory() {
331         return new DefaultSyncContextFactory(getNamedLockFactoryAdapterFactory());
332     }
333 
334     private Map<String, ChecksumAlgorithmFactory> checksumAlgorithmFactories;
335 
336     public final Map<String, ChecksumAlgorithmFactory> getChecksumAlgorithmFactories() {
337         checkClosed();
338         if (checksumAlgorithmFactories == null) {
339             checksumAlgorithmFactories = createChecksumAlgorithmFactories();
340         }
341         return checksumAlgorithmFactories;
342     }
343 
344     protected Map<String, ChecksumAlgorithmFactory> createChecksumAlgorithmFactories() {
345         HashMap<String, ChecksumAlgorithmFactory> result = new HashMap<>();
346         result.put(Sha512ChecksumAlgorithmFactory.NAME, new Sha512ChecksumAlgorithmFactory());
347         result.put(Sha256ChecksumAlgorithmFactory.NAME, new Sha256ChecksumAlgorithmFactory());
348         result.put(Sha1ChecksumAlgorithmFactory.NAME, new Sha1ChecksumAlgorithmFactory());
349         result.put(Md5ChecksumAlgorithmFactory.NAME, new Md5ChecksumAlgorithmFactory());
350         return result;
351     }
352 
353     private ChecksumAlgorithmFactorySelector checksumAlgorithmFactorySelector;
354 
355     public final ChecksumAlgorithmFactorySelector getChecksumAlgorithmFactorySelector() {
356         checkClosed();
357         if (checksumAlgorithmFactorySelector == null) {
358             checksumAlgorithmFactorySelector = createChecksumAlgorithmFactorySelector();
359         }
360         return checksumAlgorithmFactorySelector;
361     }
362 
363     protected ChecksumAlgorithmFactorySelector createChecksumAlgorithmFactorySelector() {
364         return new DefaultChecksumAlgorithmFactorySelector(getChecksumAlgorithmFactories());
365     }
366 
367     private Map<String, RepositoryLayoutFactory> repositoryLayoutFactories;
368 
369     public final Map<String, RepositoryLayoutFactory> getRepositoryLayoutFactories() {
370         checkClosed();
371         if (repositoryLayoutFactories == null) {
372             repositoryLayoutFactories = createRepositoryLayoutFactories();
373         }
374         return repositoryLayoutFactories;
375     }
376 
377     protected Map<String, RepositoryLayoutFactory> createRepositoryLayoutFactories() {
378         HashMap<String, RepositoryLayoutFactory> result = new HashMap<>();
379         result.put(
380                 Maven2RepositoryLayoutFactory.NAME,
381                 new Maven2RepositoryLayoutFactory(getChecksumAlgorithmFactorySelector()));
382         return result;
383     }
384 
385     private RepositoryLayoutProvider repositoryLayoutProvider;
386 
387     public final RepositoryLayoutProvider getRepositoryLayoutProvider() {
388         checkClosed();
389         if (repositoryLayoutProvider == null) {
390             repositoryLayoutProvider = createRepositoryLayoutProvider();
391         }
392         return repositoryLayoutProvider;
393     }
394 
395     protected RepositoryLayoutProvider createRepositoryLayoutProvider() {
396         return new DefaultRepositoryLayoutProvider(getRepositoryLayoutFactories());
397     }
398 
399     private LocalRepositoryProvider localRepositoryProvider;
400 
401     public final LocalRepositoryProvider getLocalRepositoryProvider() {
402         checkClosed();
403         if (localRepositoryProvider == null) {
404             localRepositoryProvider = createLocalRepositoryProvider();
405         }
406         return localRepositoryProvider;
407     }
408 
409     protected LocalRepositoryProvider createLocalRepositoryProvider() {
410         LocalPathComposer localPathComposer = getLocalPathComposer();
411         HashMap<String, LocalRepositoryManagerFactory> localRepositoryProviders = new HashMap<>(2);
412         localRepositoryProviders.put(
413                 SimpleLocalRepositoryManagerFactory.NAME, new SimpleLocalRepositoryManagerFactory(localPathComposer));
414         localRepositoryProviders.put(
415                 EnhancedLocalRepositoryManagerFactory.NAME,
416                 new EnhancedLocalRepositoryManagerFactory(
417                         localPathComposer, getTrackingFileManager(), getLocalPathPrefixComposerFactory()));
418         return new DefaultLocalRepositoryProvider(localRepositoryProviders);
419     }
420 
421     private RemoteRepositoryManager remoteRepositoryManager;
422 
423     public final RemoteRepositoryManager getRemoteRepositoryManager() {
424         checkClosed();
425         if (remoteRepositoryManager == null) {
426             remoteRepositoryManager = createRemoteRepositoryManager();
427         }
428         return remoteRepositoryManager;
429     }
430 
431     protected RemoteRepositoryManager createRemoteRepositoryManager() {
432         return new DefaultRemoteRepositoryManager(getUpdatePolicyAnalyzer(), getChecksumPolicyProvider());
433     }
434 
435     private Map<String, RemoteRepositoryFilterSource> remoteRepositoryFilterSources;
436 
437     public final Map<String, RemoteRepositoryFilterSource> getRemoteRepositoryFilterSources() {
438         checkClosed();
439         if (remoteRepositoryFilterSources == null) {
440             remoteRepositoryFilterSources = createRemoteRepositoryFilterSources();
441         }
442         return remoteRepositoryFilterSources;
443     }
444 
445     protected Map<String, RemoteRepositoryFilterSource> createRemoteRepositoryFilterSources() {
446         HashMap<String, RemoteRepositoryFilterSource> result = new HashMap<>();
447         result.put(
448                 GroupIdRemoteRepositoryFilterSource.NAME,
449                 new GroupIdRemoteRepositoryFilterSource(getRepositorySystemLifecycle()));
450         result.put(
451                 PrefixesRemoteRepositoryFilterSource.NAME,
452                 new PrefixesRemoteRepositoryFilterSource(getRepositoryLayoutProvider()));
453         return result;
454     }
455 
456     private RemoteRepositoryFilterManager remoteRepositoryFilterManager;
457 
458     public final RemoteRepositoryFilterManager getRemoteRepositoryFilterManager() {
459         checkClosed();
460         if (remoteRepositoryFilterManager == null) {
461             remoteRepositoryFilterManager = createRemoteRepositoryFilterManager();
462         }
463         return remoteRepositoryFilterManager;
464     }
465 
466     protected RemoteRepositoryFilterManager createRemoteRepositoryFilterManager() {
467         return new DefaultRemoteRepositoryFilterManager(getRemoteRepositoryFilterSources());
468     }
469 
470     private Map<String, RepositoryListener> repositoryListeners;
471 
472     public final Map<String, RepositoryListener> getRepositoryListeners() {
473         checkClosed();
474         if (repositoryListeners == null) {
475             repositoryListeners = createRepositoryListeners();
476         }
477         return repositoryListeners;
478     }
479 
480     protected Map<String, RepositoryListener> createRepositoryListeners() {
481         return new HashMap<>();
482     }
483 
484     private RepositoryEventDispatcher repositoryEventDispatcher;
485 
486     public final RepositoryEventDispatcher getRepositoryEventDispatcher() {
487         checkClosed();
488         if (repositoryEventDispatcher == null) {
489             repositoryEventDispatcher = createRepositoryEventDispatcher();
490         }
491         return repositoryEventDispatcher;
492     }
493 
494     protected RepositoryEventDispatcher createRepositoryEventDispatcher() {
495         return new DefaultRepositoryEventDispatcher(getRepositoryListeners());
496     }
497 
498     private Map<String, TrustedChecksumsSource> trustedChecksumsSources;
499 
500     public final Map<String, TrustedChecksumsSource> getTrustedChecksumsSources() {
501         checkClosed();
502         if (trustedChecksumsSources == null) {
503             trustedChecksumsSources = createTrustedChecksumsSources();
504         }
505         return trustedChecksumsSources;
506     }
507 
508     protected Map<String, TrustedChecksumsSource> createTrustedChecksumsSources() {
509         HashMap<String, TrustedChecksumsSource> result = new HashMap<>();
510         result.put(
511                 SparseDirectoryTrustedChecksumsSource.NAME,
512                 new SparseDirectoryTrustedChecksumsSource(getFileProcessor(), getLocalPathComposer()));
513         result.put(
514                 SummaryFileTrustedChecksumsSource.NAME,
515                 new SummaryFileTrustedChecksumsSource(getLocalPathComposer(), getRepositorySystemLifecycle()));
516         return result;
517     }
518 
519     private Map<String, ProvidedChecksumsSource> providedChecksumsSources;
520 
521     public final Map<String, ProvidedChecksumsSource> getProvidedChecksumsSources() {
522         checkClosed();
523         if (providedChecksumsSources == null) {
524             providedChecksumsSources = createProvidedChecksumsSources();
525         }
526         return providedChecksumsSources;
527     }
528 
529     protected Map<String, ProvidedChecksumsSource> createProvidedChecksumsSources() {
530         HashMap<String, ProvidedChecksumsSource> result = new HashMap<>();
531         result.put(
532                 TrustedToProvidedChecksumsSourceAdapter.NAME,
533                 new TrustedToProvidedChecksumsSourceAdapter(getTrustedChecksumsSources()));
534         return result;
535     }
536 
537     private Map<String, ChecksumExtractorStrategy> checksumExtractorStrategies;
538 
539     public final Map<String, ChecksumExtractorStrategy> getChecksumExtractorStrategies() {
540         checkClosed();
541         if (checksumExtractorStrategies == null) {
542             checksumExtractorStrategies = createChecksumExtractorStrategies();
543         }
544         return checksumExtractorStrategies;
545     }
546 
547     protected Map<String, ChecksumExtractorStrategy> createChecksumExtractorStrategies() {
548         HashMap<String, ChecksumExtractorStrategy> result = new HashMap<>();
549         result.put(XChecksumExtractor.NAME, new XChecksumExtractor());
550         result.put(Nx2ChecksumExtractor.NAME, new Nx2ChecksumExtractor());
551         return result;
552     }
553 
554     private ChecksumExtractor checksumExtractor;
555 
556     public final ChecksumExtractor getChecksumExtractor() {
557         checkClosed();
558         if (checksumExtractor == null) {
559             checksumExtractor = createChecksumExtractor();
560         }
561         return checksumExtractor;
562     }
563 
564     protected ChecksumExtractor createChecksumExtractor() {
565         return new DefaultChecksumExtractor(getChecksumExtractorStrategies());
566     }
567 
568     private Map<String, TransporterFactory> transporterFactories;
569 
570     public final Map<String, TransporterFactory> getTransporterFactories() {
571         checkClosed();
572         if (transporterFactories == null) {
573             transporterFactories = createTransporterFactories();
574         }
575         return transporterFactories;
576     }
577 
578     protected Map<String, TransporterFactory> createTransporterFactories() {
579         HashMap<String, TransporterFactory> result = new HashMap<>();
580         result.put(FileTransporterFactory.NAME, new FileTransporterFactory());
581         result.put(ApacheTransporterFactory.NAME, new ApacheTransporterFactory(getChecksumExtractor()));
582         return result;
583     }
584 
585     private TransporterProvider transporterProvider;
586 
587     public final TransporterProvider getTransporterProvider() {
588         checkClosed();
589         if (transporterProvider == null) {
590             transporterProvider = createTransporterProvider();
591         }
592         return transporterProvider;
593     }
594 
595     protected TransporterProvider createTransporterProvider() {
596         return new DefaultTransporterProvider(getTransporterFactories());
597     }
598 
599     private BasicRepositoryConnectorFactory basicRepositoryConnectorFactory;
600 
601     public final BasicRepositoryConnectorFactory getBasicRepositoryConnectorFactory() {
602         checkClosed();
603         if (basicRepositoryConnectorFactory == null) {
604             basicRepositoryConnectorFactory = createBasicRepositoryConnectorFactory();
605         }
606         return basicRepositoryConnectorFactory;
607     }
608 
609     protected BasicRepositoryConnectorFactory createBasicRepositoryConnectorFactory() {
610         return new BasicRepositoryConnectorFactory(
611                 getTransporterProvider(),
612                 getRepositoryLayoutProvider(),
613                 getChecksumPolicyProvider(),
614                 getFileProcessor(),
615                 getProvidedChecksumsSources());
616     }
617 
618     private Map<String, RepositoryConnectorFactory> repositoryConnectorFactories;
619 
620     public final Map<String, RepositoryConnectorFactory> getRepositoryConnectorFactories() {
621         checkClosed();
622         if (repositoryConnectorFactories == null) {
623             repositoryConnectorFactories = createRepositoryConnectorFactories();
624         }
625         return repositoryConnectorFactories;
626     }
627 
628     protected Map<String, RepositoryConnectorFactory> createRepositoryConnectorFactories() {
629         HashMap<String, RepositoryConnectorFactory> result = new HashMap<>();
630         result.put(BasicRepositoryConnectorFactory.NAME, getBasicRepositoryConnectorFactory());
631         return result;
632     }
633 
634     private RepositoryConnectorProvider repositoryConnectorProvider;
635 
636     public final RepositoryConnectorProvider getRepositoryConnectorProvider() {
637         checkClosed();
638         if (repositoryConnectorProvider == null) {
639             repositoryConnectorProvider = createRepositoryConnectorProvider();
640         }
641         return repositoryConnectorProvider;
642     }
643 
644     protected RepositoryConnectorProvider createRepositoryConnectorProvider() {
645         return new DefaultRepositoryConnectorProvider(
646                 getRepositoryConnectorFactories(), getRemoteRepositoryFilterManager());
647     }
648 
649     private Installer installer;
650 
651     public final Installer getInstaller() {
652         checkClosed();
653         if (installer == null) {
654             installer = createInstaller();
655         }
656         return installer;
657     }
658 
659     protected Installer createInstaller() {
660         return new DefaultInstaller(
661                 getFileProcessor(),
662                 getRepositoryEventDispatcher(),
663                 getMetadataGeneratorFactories(),
664                 getSyncContextFactory());
665     }
666 
667     private Deployer deployer;
668 
669     public final Deployer getDeployer() {
670         checkClosed();
671         if (deployer == null) {
672             deployer = createDeployer();
673         }
674         return deployer;
675     }
676 
677     protected Deployer createDeployer() {
678         return new DefaultDeployer(
679                 getFileProcessor(),
680                 getRepositoryEventDispatcher(),
681                 getRepositoryConnectorProvider(),
682                 getRemoteRepositoryManager(),
683                 getUpdateCheckManager(),
684                 getMetadataGeneratorFactories(),
685                 getSyncContextFactory(),
686                 getOfflineController());
687     }
688 
689     private Map<String, DependencyCollectorDelegate> dependencyCollectorDelegates;
690 
691     public final Map<String, DependencyCollectorDelegate> getDependencyCollectorDelegates() {
692         checkClosed();
693         if (dependencyCollectorDelegates == null) {
694             dependencyCollectorDelegates = createDependencyCollectorDelegates();
695         }
696         return dependencyCollectorDelegates;
697     }
698 
699     protected Map<String, DependencyCollectorDelegate> createDependencyCollectorDelegates() {
700         RemoteRepositoryManager remoteRepositoryManager = getRemoteRepositoryManager();
701         ArtifactDescriptorReader artifactDescriptorReader = getArtifactDescriptorReader();
702         VersionRangeResolver versionRangeResolver = getVersionRangeResolver();
703         HashMap<String, DependencyCollectorDelegate> result = new HashMap<>();
704         result.put(
705                 DfDependencyCollector.NAME,
706                 new DfDependencyCollector(remoteRepositoryManager, artifactDescriptorReader, versionRangeResolver));
707         result.put(
708                 BfDependencyCollector.NAME,
709                 new BfDependencyCollector(remoteRepositoryManager, artifactDescriptorReader, versionRangeResolver));
710         return result;
711     }
712 
713     private DependencyCollector dependencyCollector;
714 
715     public final DependencyCollector getDependencyCollector() {
716         checkClosed();
717         if (dependencyCollector == null) {
718             dependencyCollector = createDependencyCollector();
719         }
720         return dependencyCollector;
721     }
722 
723     protected DependencyCollector createDependencyCollector() {
724         return new DefaultDependencyCollector(getDependencyCollectorDelegates());
725     }
726 
727     private Map<String, ArtifactResolverPostProcessor> artifactResolverPostProcessors;
728 
729     public final Map<String, ArtifactResolverPostProcessor> getArtifactResolverPostProcessors() {
730         checkClosed();
731         if (artifactResolverPostProcessors == null) {
732             artifactResolverPostProcessors = createArtifactResolverPostProcessors();
733         }
734         return artifactResolverPostProcessors;
735     }
736 
737     protected Map<String, ArtifactResolverPostProcessor> createArtifactResolverPostProcessors() {
738         HashMap<String, ArtifactResolverPostProcessor> result = new HashMap<>();
739         result.put(
740                 TrustedChecksumsArtifactResolverPostProcessor.NAME,
741                 new TrustedChecksumsArtifactResolverPostProcessor(
742                         getChecksumAlgorithmFactorySelector(), getTrustedChecksumsSources()));
743         return result;
744     }
745 
746     private ArtifactResolver artifactResolver;
747 
748     public final ArtifactResolver getArtifactResolver() {
749         checkClosed();
750         if (artifactResolver == null) {
751             artifactResolver = createArtifactResolver();
752         }
753         return artifactResolver;
754     }
755 
756     protected ArtifactResolver createArtifactResolver() {
757         return new DefaultArtifactResolver(
758                 getFileProcessor(),
759                 getRepositoryEventDispatcher(),
760                 getVersionResolver(),
761                 getUpdateCheckManager(),
762                 getRepositoryConnectorProvider(),
763                 getRemoteRepositoryManager(),
764                 getSyncContextFactory(),
765                 getOfflineController(),
766                 getArtifactResolverPostProcessors(),
767                 getRemoteRepositoryFilterManager());
768     }
769 
770     private MetadataResolver metadataResolver;
771 
772     public final MetadataResolver getMetadataResolver() {
773         checkClosed();
774         if (metadataResolver == null) {
775             metadataResolver = createMetadataResolver();
776         }
777         return metadataResolver;
778     }
779 
780     protected MetadataResolver createMetadataResolver() {
781         return new DefaultMetadataResolver(
782                 getRepositoryEventDispatcher(),
783                 getUpdateCheckManager(),
784                 getRepositoryConnectorProvider(),
785                 getRemoteRepositoryManager(),
786                 getSyncContextFactory(),
787                 getOfflineController(),
788                 getRemoteRepositoryFilterManager());
789     }
790 
791     private VersionScheme versionScheme;
792 
793     public final VersionScheme getVersionScheme() {
794         checkClosed();
795         if (versionScheme == null) {
796             versionScheme = createVersionScheme();
797         }
798         return versionScheme;
799     }
800 
801     protected VersionScheme createVersionScheme() {
802         return new GenericVersionScheme();
803     }
804 
805     // Maven provided
806 
807     private Map<String, MetadataGeneratorFactory> metadataGeneratorFactories;
808 
809     public final Map<String, MetadataGeneratorFactory> getMetadataGeneratorFactories() {
810         checkClosed();
811         if (metadataGeneratorFactories == null) {
812             metadataGeneratorFactories = createMetadataGeneratorFactories();
813         }
814         return metadataGeneratorFactories;
815     }
816 
817     protected Map<String, MetadataGeneratorFactory> createMetadataGeneratorFactories() {
818         // from maven-resolver-provider
819         HashMap<String, MetadataGeneratorFactory> result = new HashMap<>();
820         result.put(PluginsMetadataGeneratorFactory.NAME, new PluginsMetadataGeneratorFactory());
821         result.put(VersionsMetadataGeneratorFactory.NAME, new VersionsMetadataGeneratorFactory());
822         result.put(SnapshotMetadataGeneratorFactory.NAME, new SnapshotMetadataGeneratorFactory());
823         return result;
824     }
825 
826     private LinkedHashMap<String, MavenArtifactRelocationSource> artifactRelocationSources;
827 
828     public final LinkedHashMap<String, MavenArtifactRelocationSource> getMavenArtifactRelocationSources() {
829         checkClosed();
830         if (artifactRelocationSources == null) {
831             artifactRelocationSources = createMavenArtifactRelocationSources();
832         }
833         return artifactRelocationSources;
834     }
835 
836     protected LinkedHashMap<String, MavenArtifactRelocationSource> createMavenArtifactRelocationSources() {
837         // from maven-resolver-provider
838         LinkedHashMap<String, MavenArtifactRelocationSource> result = new LinkedHashMap<>();
839         result.put(UserPropertiesArtifactRelocationSource.NAME, new UserPropertiesArtifactRelocationSource());
840         result.put(
841                 DistributionManagementArtifactRelocationSource.NAME,
842                 new DistributionManagementArtifactRelocationSource());
843         return result;
844     }
845 
846     private ArtifactDescriptorReader artifactDescriptorReader;
847 
848     public final ArtifactDescriptorReader getArtifactDescriptorReader() {
849         checkClosed();
850         if (artifactDescriptorReader == null) {
851             artifactDescriptorReader = createArtifactDescriptorReader();
852         }
853         return artifactDescriptorReader;
854     }
855 
856     protected ArtifactDescriptorReader createArtifactDescriptorReader() {
857         // from maven-resolver-provider
858         return new DefaultArtifactDescriptorReader(
859                 getRemoteRepositoryManager(),
860                 getVersionResolver(),
861                 getVersionRangeResolver(),
862                 getArtifactResolver(),
863                 getModelBuilder(),
864                 getRepositoryEventDispatcher(),
865                 getModelCacheFactory(),
866                 getMavenArtifactRelocationSources());
867     }
868 
869     private VersionResolver versionResolver;
870 
871     public final VersionResolver getVersionResolver() {
872         checkClosed();
873         if (versionResolver == null) {
874             versionResolver = createVersionResolver();
875         }
876         return versionResolver;
877     }
878 
879     protected VersionResolver createVersionResolver() {
880         // from maven-resolver-provider
881         return new DefaultVersionResolver(
882                 getMetadataResolver(), getSyncContextFactory(), getRepositoryEventDispatcher());
883     }
884 
885     private VersionRangeResolver versionRangeResolver;
886 
887     public final VersionRangeResolver getVersionRangeResolver() {
888         checkClosed();
889         if (versionRangeResolver == null) {
890             versionRangeResolver = createVersionRangeResolver();
891         }
892         return versionRangeResolver;
893     }
894 
895     protected VersionRangeResolver createVersionRangeResolver() {
896         // from maven-resolver-provider
897         return new DefaultVersionRangeResolver(
898                 getMetadataResolver(), getSyncContextFactory(), getRepositoryEventDispatcher(), getVersionScheme());
899     }
900 
901     private ModelBuilder modelBuilder;
902 
903     public final ModelBuilder getModelBuilder() {
904         checkClosed();
905         if (modelBuilder == null) {
906             modelBuilder = createModelBuilder();
907         }
908         return modelBuilder;
909     }
910 
911     protected ModelBuilder createModelBuilder() {
912         // from maven-model-builder
913         return new DefaultModelBuilderFactory().newInstance();
914     }
915 
916     private ModelCacheFactory modelCacheFactory;
917 
918     public final ModelCacheFactory getModelCacheFactory() {
919         checkClosed();
920         if (modelCacheFactory == null) {
921             modelCacheFactory = createModelCacheFactory();
922         }
923         return modelCacheFactory;
924     }
925 
926     protected ModelCacheFactory createModelCacheFactory() {
927         // from maven-resolver-provider
928         return new DefaultModelCacheFactory();
929     }
930 
931     private RepositorySystem repositorySystem;
932 
933     public final RepositorySystem getRepositorySystem() {
934         checkClosed();
935         if (repositorySystem == null) {
936             repositorySystem = createRepositorySystem();
937         }
938         return repositorySystem;
939     }
940 
941     protected RepositorySystem createRepositorySystem() {
942         return new DefaultRepositorySystem(
943                 getVersionResolver(),
944                 getVersionRangeResolver(),
945                 getArtifactResolver(),
946                 getMetadataResolver(),
947                 getArtifactDescriptorReader(),
948                 getDependencyCollector(),
949                 getInstaller(),
950                 getDeployer(),
951                 getLocalRepositoryProvider(),
952                 getSyncContextFactory(),
953                 getRemoteRepositoryManager(),
954                 getRepositorySystemLifecycle());
955     }
956 
957     @Override
958     public RepositorySystem get() {
959         return getRepositorySystem();
960     }
961 }