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