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