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