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