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