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