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.TrackingFileManagerSupplier;
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 TrackingFileManagerSupplier(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                        getTransporterProvider()));
591        return result;
592    }
593
594    private RemoteRepositoryFilterManager remoteRepositoryFilterManager;
595
596    public final RemoteRepositoryFilterManager getRemoteRepositoryFilterManager() {
597        checkClosed();
598        if (remoteRepositoryFilterManager == null) {
599            remoteRepositoryFilterManager = createRemoteRepositoryFilterManager();
600        }
601        return remoteRepositoryFilterManager;
602    }
603
604    protected RemoteRepositoryFilterManager createRemoteRepositoryFilterManager() {
605        return new DefaultRemoteRepositoryFilterManager(getRemoteRepositoryFilterSources());
606    }
607
608    private Map<String, RepositoryListener> repositoryListeners;
609
610    public final Map<String, RepositoryListener> getRepositoryListeners() {
611        checkClosed();
612        if (repositoryListeners == null) {
613            repositoryListeners = createRepositoryListeners();
614        }
615        return repositoryListeners;
616    }
617
618    protected Map<String, RepositoryListener> createRepositoryListeners() {
619        return new HashMap<>();
620    }
621
622    private RepositoryEventDispatcher repositoryEventDispatcher;
623
624    public final RepositoryEventDispatcher getRepositoryEventDispatcher() {
625        checkClosed();
626        if (repositoryEventDispatcher == null) {
627            repositoryEventDispatcher = createRepositoryEventDispatcher();
628        }
629        return repositoryEventDispatcher;
630    }
631
632    protected RepositoryEventDispatcher createRepositoryEventDispatcher() {
633        return new DefaultRepositoryEventDispatcher(getRepositoryListeners());
634    }
635
636    private Map<String, TrustedChecksumsSource> trustedChecksumsSources;
637
638    public final Map<String, TrustedChecksumsSource> getTrustedChecksumsSources() {
639        checkClosed();
640        if (trustedChecksumsSources == null) {
641            trustedChecksumsSources = createTrustedChecksumsSources();
642        }
643        return trustedChecksumsSources;
644    }
645
646    protected Map<String, TrustedChecksumsSource> createTrustedChecksumsSources() {
647        HashMap<String, TrustedChecksumsSource> result = new HashMap<>();
648        result.put(
649                SparseDirectoryTrustedChecksumsSource.NAME,
650                new SparseDirectoryTrustedChecksumsSource(
651                        getRepositoryKeyFunctionFactory(), getChecksumProcessor(), getLocalPathComposer()));
652        result.put(
653                SummaryFileTrustedChecksumsSource.NAME,
654                new SummaryFileTrustedChecksumsSource(
655                        getRepositoryKeyFunctionFactory(),
656                        getLocalPathComposer(),
657                        getRepositorySystemLifecycle(),
658                        getPathProcessor()));
659        return result;
660    }
661
662    private Map<String, ProvidedChecksumsSource> providedChecksumsSources;
663
664    public final Map<String, ProvidedChecksumsSource> getProvidedChecksumsSources() {
665        checkClosed();
666        if (providedChecksumsSources == null) {
667            providedChecksumsSources = createProvidedChecksumsSources();
668        }
669        return providedChecksumsSources;
670    }
671
672    protected Map<String, ProvidedChecksumsSource> createProvidedChecksumsSources() {
673        HashMap<String, ProvidedChecksumsSource> result = new HashMap<>();
674        result.put(
675                TrustedToProvidedChecksumsSourceAdapter.NAME,
676                new TrustedToProvidedChecksumsSourceAdapter(getTrustedChecksumsSources()));
677        return result;
678    }
679
680    private Map<String, ChecksumExtractorStrategy> checksumExtractorStrategies;
681
682    public final Map<String, ChecksumExtractorStrategy> getChecksumExtractorStrategies() {
683        checkClosed();
684        if (checksumExtractorStrategies == null) {
685            checksumExtractorStrategies = createChecksumExtractorStrategies();
686        }
687        return checksumExtractorStrategies;
688    }
689
690    protected Map<String, ChecksumExtractorStrategy> createChecksumExtractorStrategies() {
691        HashMap<String, ChecksumExtractorStrategy> result = new HashMap<>();
692        result.put(XChecksumExtractor.NAME, new XChecksumExtractor());
693        result.put(Nx2ChecksumExtractor.NAME, new Nx2ChecksumExtractor());
694        return result;
695    }
696
697    private ChecksumExtractor checksumExtractor;
698
699    public final ChecksumExtractor getChecksumExtractor() {
700        checkClosed();
701        if (checksumExtractor == null) {
702            checksumExtractor = createChecksumExtractor();
703        }
704        return checksumExtractor;
705    }
706
707    protected ChecksumExtractor createChecksumExtractor() {
708        return new DefaultChecksumExtractor(getChecksumExtractorStrategies());
709    }
710
711    private Map<String, TransporterFactory> transporterFactories;
712
713    public final Map<String, TransporterFactory> getTransporterFactories() {
714        checkClosed();
715        if (transporterFactories == null) {
716            transporterFactories = createTransporterFactories();
717        }
718        return transporterFactories;
719    }
720
721    protected Map<String, TransporterFactory> createTransporterFactories() {
722        HashMap<String, TransporterFactory> result = new HashMap<>();
723        result.put(FileTransporterFactory.NAME, new FileTransporterFactory());
724        result.put(
725                ApacheTransporterFactory.NAME,
726                new ApacheTransporterFactory(getChecksumExtractor(), getPathProcessor()));
727        return result;
728    }
729
730    private TransporterProvider transporterProvider;
731
732    public final TransporterProvider getTransporterProvider() {
733        checkClosed();
734        if (transporterProvider == null) {
735            transporterProvider = createTransporterProvider();
736        }
737        return transporterProvider;
738    }
739
740    protected TransporterProvider createTransporterProvider() {
741        return new DefaultTransporterProvider(getTransporterFactories());
742    }
743
744    private BasicRepositoryConnectorFactory basicRepositoryConnectorFactory;
745
746    public final BasicRepositoryConnectorFactory getBasicRepositoryConnectorFactory() {
747        checkClosed();
748        if (basicRepositoryConnectorFactory == null) {
749            basicRepositoryConnectorFactory = createBasicRepositoryConnectorFactory();
750        }
751        return basicRepositoryConnectorFactory;
752    }
753
754    protected BasicRepositoryConnectorFactory createBasicRepositoryConnectorFactory() {
755        return new BasicRepositoryConnectorFactory(
756                getTransporterProvider(),
757                getRepositoryLayoutProvider(),
758                getChecksumPolicyProvider(),
759                getPathProcessor(),
760                getChecksumProcessor(),
761                getProvidedChecksumsSources());
762    }
763
764    private Map<String, RepositoryConnectorFactory> repositoryConnectorFactories;
765
766    public final Map<String, RepositoryConnectorFactory> getRepositoryConnectorFactories() {
767        checkClosed();
768        if (repositoryConnectorFactories == null) {
769            repositoryConnectorFactories = createRepositoryConnectorFactories();
770        }
771        return repositoryConnectorFactories;
772    }
773
774    protected Map<String, RepositoryConnectorFactory> createRepositoryConnectorFactories() {
775        HashMap<String, RepositoryConnectorFactory> result = new HashMap<>();
776        result.put(BasicRepositoryConnectorFactory.NAME, getBasicRepositoryConnectorFactory());
777        return result;
778    }
779
780    private Map<String, PipelineRepositoryConnectorFactory> pipelineRepositoryConnectorFactories;
781
782    public final Map<String, PipelineRepositoryConnectorFactory> getPipelineRepositoryConnectorFactories() {
783        checkClosed();
784        if (pipelineRepositoryConnectorFactories == null) {
785            pipelineRepositoryConnectorFactories = createPipelineRepositoryConnectorFactories();
786        }
787        return pipelineRepositoryConnectorFactories;
788    }
789
790    protected Map<String, PipelineRepositoryConnectorFactory> createPipelineRepositoryConnectorFactories() {
791        HashMap<String, PipelineRepositoryConnectorFactory> result = new HashMap<>();
792        result.put(
793                FilteringPipelineRepositoryConnectorFactory.NAME,
794                new FilteringPipelineRepositoryConnectorFactory(getRemoteRepositoryFilterManager()));
795        result.put(
796                OfflinePipelineRepositoryConnectorFactory.NAME,
797                new OfflinePipelineRepositoryConnectorFactory(getOfflineController()));
798        return result;
799    }
800
801    private RepositoryConnectorProvider repositoryConnectorProvider;
802
803    public final RepositoryConnectorProvider getRepositoryConnectorProvider() {
804        checkClosed();
805        if (repositoryConnectorProvider == null) {
806            repositoryConnectorProvider = createRepositoryConnectorProvider();
807        }
808        return repositoryConnectorProvider;
809    }
810
811    protected RepositoryConnectorProvider createRepositoryConnectorProvider() {
812        return new DefaultRepositoryConnectorProvider(
813                getRepositoryConnectorFactories(), getPipelineRepositoryConnectorFactories());
814    }
815
816    private Installer installer;
817
818    public final Installer getInstaller() {
819        checkClosed();
820        if (installer == null) {
821            installer = createInstaller();
822        }
823        return installer;
824    }
825
826    protected Installer createInstaller() {
827        return new DefaultInstaller(
828                getPathProcessor(),
829                getRepositoryEventDispatcher(),
830                getArtifactGeneratorFactories(),
831                getMetadataGeneratorFactories(),
832                getArtifactTransformers(),
833                getSyncContextFactory());
834    }
835
836    private Deployer deployer;
837
838    public final Deployer getDeployer() {
839        checkClosed();
840        if (deployer == null) {
841            deployer = createDeployer();
842        }
843        return deployer;
844    }
845
846    protected Deployer createDeployer() {
847        return new DefaultDeployer(
848                getPathProcessor(),
849                getRepositoryEventDispatcher(),
850                getRepositoryConnectorProvider(),
851                getRemoteRepositoryManager(),
852                getUpdateCheckManager(),
853                getArtifactGeneratorFactories(),
854                getMetadataGeneratorFactories(),
855                getArtifactTransformers(),
856                getSyncContextFactory(),
857                getOfflineController());
858    }
859
860    private Map<String, DependencyCollectorDelegate> dependencyCollectorDelegates;
861
862    public final Map<String, DependencyCollectorDelegate> getDependencyCollectorDelegates() {
863        checkClosed();
864        if (dependencyCollectorDelegates == null) {
865            dependencyCollectorDelegates = createDependencyCollectorDelegates();
866        }
867        return dependencyCollectorDelegates;
868    }
869
870    protected Map<String, DependencyCollectorDelegate> createDependencyCollectorDelegates() {
871        RemoteRepositoryManager remoteRepositoryManager = getRemoteRepositoryManager();
872        ArtifactDescriptorReader artifactDescriptorReader = getArtifactDescriptorReader();
873        VersionRangeResolver versionRangeResolver = getVersionRangeResolver();
874        HashMap<String, DependencyCollectorDelegate> result = new HashMap<>();
875        result.put(
876                DfDependencyCollector.NAME,
877                new DfDependencyCollector(
878                        remoteRepositoryManager,
879                        artifactDescriptorReader,
880                        versionRangeResolver,
881                        getArtifactDecoratorFactories()));
882        result.put(
883                BfDependencyCollector.NAME,
884                new BfDependencyCollector(
885                        remoteRepositoryManager,
886                        artifactDescriptorReader,
887                        versionRangeResolver,
888                        getArtifactDecoratorFactories()));
889        return result;
890    }
891
892    private DependencyCollector dependencyCollector;
893
894    public final DependencyCollector getDependencyCollector() {
895        checkClosed();
896        if (dependencyCollector == null) {
897            dependencyCollector = createDependencyCollector();
898        }
899        return dependencyCollector;
900    }
901
902    protected DependencyCollector createDependencyCollector() {
903        return new DefaultDependencyCollector(getDependencyCollectorDelegates());
904    }
905
906    private Map<String, ArtifactResolverPostProcessor> artifactResolverPostProcessors;
907
908    public final Map<String, ArtifactResolverPostProcessor> getArtifactResolverPostProcessors() {
909        checkClosed();
910        if (artifactResolverPostProcessors == null) {
911            artifactResolverPostProcessors = createArtifactResolverPostProcessors();
912        }
913        return artifactResolverPostProcessors;
914    }
915
916    protected Map<String, ArtifactResolverPostProcessor> createArtifactResolverPostProcessors() {
917        HashMap<String, ArtifactResolverPostProcessor> result = new HashMap<>();
918        result.put(
919                TrustedChecksumsArtifactResolverPostProcessor.NAME,
920                new TrustedChecksumsArtifactResolverPostProcessor(
921                        getChecksumAlgorithmFactorySelector(), getTrustedChecksumsSources()));
922        return result;
923    }
924
925    private ArtifactResolver artifactResolver;
926
927    public final ArtifactResolver getArtifactResolver() {
928        checkClosed();
929        if (artifactResolver == null) {
930            artifactResolver = createArtifactResolver();
931        }
932        return artifactResolver;
933    }
934
935    protected ArtifactResolver createArtifactResolver() {
936        return new DefaultArtifactResolver(
937                getPathProcessor(),
938                getRepositoryEventDispatcher(),
939                getVersionResolver(),
940                getUpdateCheckManager(),
941                getRepositoryConnectorProvider(),
942                getRemoteRepositoryManager(),
943                getSyncContextFactory(),
944                getOfflineController(),
945                getArtifactResolverPostProcessors(),
946                getRemoteRepositoryFilterManager());
947    }
948
949    private MetadataResolver metadataResolver;
950
951    public final MetadataResolver getMetadataResolver() {
952        checkClosed();
953        if (metadataResolver == null) {
954            metadataResolver = createMetadataResolver();
955        }
956        return metadataResolver;
957    }
958
959    protected MetadataResolver createMetadataResolver() {
960        return new DefaultMetadataResolver(
961                getRepositoryEventDispatcher(),
962                getUpdateCheckManager(),
963                getRepositoryConnectorProvider(),
964                getRemoteRepositoryManager(),
965                getSyncContextFactory(),
966                getOfflineController(),
967                getRemoteRepositoryFilterManager(),
968                getPathProcessor());
969    }
970
971    private VersionScheme versionScheme;
972
973    public final VersionScheme getVersionScheme() {
974        checkClosed();
975        if (versionScheme == null) {
976            versionScheme = createVersionScheme();
977        }
978        return versionScheme;
979    }
980
981    protected VersionScheme createVersionScheme() {
982        return new GenericVersionScheme();
983    }
984
985    private Map<String, ArtifactGeneratorFactory> artifactGeneratorFactories;
986
987    public final Map<String, ArtifactGeneratorFactory> getArtifactGeneratorFactories() {
988        checkClosed();
989        if (artifactGeneratorFactories == null) {
990            artifactGeneratorFactories = createArtifactGeneratorFactories();
991        }
992        return artifactGeneratorFactories;
993    }
994
995    protected Map<String, ArtifactGeneratorFactory> createArtifactGeneratorFactories() {
996        // by default none, this is extension point
997        return new HashMap<>();
998    }
999
1000    private Map<String, ArtifactDecoratorFactory> artifactDecoratorFactories;
1001
1002    public final Map<String, ArtifactDecoratorFactory> getArtifactDecoratorFactories() {
1003        checkClosed();
1004        if (artifactDecoratorFactories == null) {
1005            artifactDecoratorFactories = createArtifactDecoratorFactories();
1006        }
1007        return artifactDecoratorFactories;
1008    }
1009
1010    protected Map<String, ArtifactDecoratorFactory> createArtifactDecoratorFactories() {
1011        // by default none, this is extension point
1012        return new HashMap<>();
1013    }
1014
1015    // Maven provided
1016
1017    private Map<String, ArtifactTransformer> artifactTransformers;
1018
1019    public final Map<String, ArtifactTransformer> getArtifactTransformers() {
1020        checkClosed();
1021        if (artifactTransformers == null) {
1022            artifactTransformers = createArtifactTransformers();
1023        }
1024        return artifactTransformers;
1025    }
1026
1027    protected Map<String, ArtifactTransformer> createArtifactTransformers() {
1028        return new HashMap<>();
1029    }
1030
1031    private Map<String, MetadataGeneratorFactory> metadataGeneratorFactories;
1032
1033    public final Map<String, MetadataGeneratorFactory> getMetadataGeneratorFactories() {
1034        checkClosed();
1035        if (metadataGeneratorFactories == null) {
1036            metadataGeneratorFactories = createMetadataGeneratorFactories();
1037        }
1038        return metadataGeneratorFactories;
1039    }
1040
1041    protected Map<String, MetadataGeneratorFactory> createMetadataGeneratorFactories() {
1042        // from maven-resolver-provider
1043        HashMap<String, MetadataGeneratorFactory> result = new HashMap<>();
1044        result.put(PluginsMetadataGeneratorFactory.NAME, new PluginsMetadataGeneratorFactory());
1045        result.put(VersionsMetadataGeneratorFactory.NAME, new VersionsMetadataGeneratorFactory());
1046        result.put(SnapshotMetadataGeneratorFactory.NAME, new SnapshotMetadataGeneratorFactory());
1047        return result;
1048    }
1049
1050    private ArtifactDescriptorReader artifactDescriptorReader;
1051
1052    public final ArtifactDescriptorReader getArtifactDescriptorReader() {
1053        checkClosed();
1054        if (artifactDescriptorReader == null) {
1055            artifactDescriptorReader = createArtifactDescriptorReader();
1056        }
1057        return artifactDescriptorReader;
1058    }
1059
1060    protected ArtifactDescriptorReader createArtifactDescriptorReader() {
1061        // from maven-resolver-provider
1062        return new DefaultArtifactDescriptorReader(
1063                getRemoteRepositoryManager(),
1064                getVersionResolver(),
1065                getVersionRangeResolver(),
1066                getArtifactResolver(),
1067                getModelBuilder(),
1068                getRepositoryEventDispatcher(),
1069                getModelCacheFactory());
1070    }
1071
1072    private VersionResolver versionResolver;
1073
1074    public final VersionResolver getVersionResolver() {
1075        checkClosed();
1076        if (versionResolver == null) {
1077            versionResolver = createVersionResolver();
1078        }
1079        return versionResolver;
1080    }
1081
1082    protected VersionResolver createVersionResolver() {
1083        // from maven-resolver-provider
1084        return new DefaultVersionResolver(
1085                getMetadataResolver(), getSyncContextFactory(), getRepositoryEventDispatcher());
1086    }
1087
1088    private VersionRangeResolver versionRangeResolver;
1089
1090    public final VersionRangeResolver getVersionRangeResolver() {
1091        checkClosed();
1092        if (versionRangeResolver == null) {
1093            versionRangeResolver = createVersionRangeResolver();
1094        }
1095        return versionRangeResolver;
1096    }
1097
1098    protected VersionRangeResolver createVersionRangeResolver() {
1099        // from maven-resolver-provider
1100        return new DefaultVersionRangeResolver(
1101                getMetadataResolver(), getSyncContextFactory(), getRepositoryEventDispatcher());
1102    }
1103
1104    private ModelBuilder modelBuilder;
1105
1106    public final ModelBuilder getModelBuilder() {
1107        checkClosed();
1108        if (modelBuilder == null) {
1109            modelBuilder = createModelBuilder();
1110        }
1111        return modelBuilder;
1112    }
1113
1114    protected ModelBuilder createModelBuilder() {
1115        // from maven-model-builder
1116        return new DefaultModelBuilderFactory().newInstance();
1117    }
1118
1119    private ModelCacheFactory modelCacheFactory;
1120
1121    public final ModelCacheFactory getModelCacheFactory() {
1122        checkClosed();
1123        if (modelCacheFactory == null) {
1124            modelCacheFactory = createModelCacheFactory();
1125        }
1126        return modelCacheFactory;
1127    }
1128
1129    protected ModelCacheFactory createModelCacheFactory() {
1130        // from maven-resolver-provider
1131        return new DefaultModelCacheFactory();
1132    }
1133
1134    private List<ValidatorFactory> validatorFactories;
1135
1136    public final List<ValidatorFactory> getValidatorFactories() {
1137        checkClosed();
1138        if (validatorFactories == null) {
1139            validatorFactories = createValidatorFactories();
1140        }
1141        return validatorFactories;
1142    }
1143
1144    protected List<ValidatorFactory> createValidatorFactories() {
1145        return new ArrayList<>();
1146    }
1147
1148    private RepositorySystemValidator repositorySystemValidator;
1149
1150    public final RepositorySystemValidator getRepositorySystemValidator() {
1151        checkClosed();
1152        if (repositorySystemValidator == null) {
1153            repositorySystemValidator = createRepositorySystemValidator();
1154        }
1155        return repositorySystemValidator;
1156    }
1157
1158    protected RepositorySystemValidator createRepositorySystemValidator() {
1159        return new DefaultRepositorySystemValidator(getValidatorFactories());
1160    }
1161
1162    private RepositorySystem repositorySystem;
1163
1164    public final RepositorySystem getRepositorySystem() {
1165        checkClosed();
1166        if (repositorySystem == null) {
1167            repositorySystem = createRepositorySystem();
1168        }
1169        return repositorySystem;
1170    }
1171
1172    protected RepositorySystem createRepositorySystem() {
1173        return new DefaultRepositorySystem(
1174                getVersionResolver(),
1175                getVersionRangeResolver(),
1176                getArtifactResolver(),
1177                getMetadataResolver(),
1178                getArtifactDescriptorReader(),
1179                getDependencyCollector(),
1180                getInstaller(),
1181                getDeployer(),
1182                getLocalRepositoryProvider(),
1183                getSyncContextFactory(),
1184                getRemoteRepositoryManager(),
1185                getRepositorySystemLifecycle(),
1186                getArtifactDecoratorFactories(),
1187                getRepositorySystemValidator());
1188    }
1189
1190    @Override
1191    public RepositorySystem get() {
1192        return getRepositorySystem();
1193    }
1194}