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