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