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