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