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