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