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