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