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.HashMap;
022import java.util.HashSet;
023import java.util.Map;
024import java.util.function.Supplier;
025
026import org.apache.maven.model.building.DefaultModelBuilderFactory;
027import org.apache.maven.model.building.ModelBuilder;
028import org.apache.maven.repository.internal.DefaultArtifactDescriptorReader;
029import org.apache.maven.repository.internal.DefaultModelCacheFactory;
030import org.apache.maven.repository.internal.DefaultVersionRangeResolver;
031import org.apache.maven.repository.internal.DefaultVersionResolver;
032import org.apache.maven.repository.internal.ModelCacheFactory;
033import org.apache.maven.repository.internal.PluginsMetadataGeneratorFactory;
034import org.apache.maven.repository.internal.SnapshotMetadataGeneratorFactory;
035import org.apache.maven.repository.internal.VersionsMetadataGeneratorFactory;
036import org.eclipse.aether.RepositoryListener;
037import org.eclipse.aether.RepositorySystem;
038import org.eclipse.aether.connector.basic.BasicRepositoryConnectorFactory;
039import org.eclipse.aether.impl.ArtifactDescriptorReader;
040import org.eclipse.aether.impl.ArtifactResolver;
041import org.eclipse.aether.impl.DependencyCollector;
042import org.eclipse.aether.impl.Deployer;
043import org.eclipse.aether.impl.Installer;
044import org.eclipse.aether.impl.LocalRepositoryProvider;
045import org.eclipse.aether.impl.MetadataGeneratorFactory;
046import org.eclipse.aether.impl.MetadataResolver;
047import org.eclipse.aether.impl.OfflineController;
048import org.eclipse.aether.impl.RemoteRepositoryFilterManager;
049import org.eclipse.aether.impl.RemoteRepositoryManager;
050import org.eclipse.aether.impl.RepositoryConnectorProvider;
051import org.eclipse.aether.impl.RepositoryEventDispatcher;
052import org.eclipse.aether.impl.RepositorySystemLifecycle;
053import org.eclipse.aether.impl.UpdateCheckManager;
054import org.eclipse.aether.impl.UpdatePolicyAnalyzer;
055import org.eclipse.aether.impl.VersionRangeResolver;
056import org.eclipse.aether.impl.VersionResolver;
057import org.eclipse.aether.internal.impl.DefaultArtifactResolver;
058import org.eclipse.aether.internal.impl.DefaultChecksumPolicyProvider;
059import org.eclipse.aether.internal.impl.DefaultDeployer;
060import org.eclipse.aether.internal.impl.DefaultFileProcessor;
061import org.eclipse.aether.internal.impl.DefaultInstaller;
062import org.eclipse.aether.internal.impl.DefaultLocalPathComposer;
063import org.eclipse.aether.internal.impl.DefaultLocalPathPrefixComposerFactory;
064import org.eclipse.aether.internal.impl.DefaultLocalRepositoryProvider;
065import org.eclipse.aether.internal.impl.DefaultMetadataResolver;
066import org.eclipse.aether.internal.impl.DefaultOfflineController;
067import org.eclipse.aether.internal.impl.DefaultRemoteRepositoryManager;
068import org.eclipse.aether.internal.impl.DefaultRepositoryConnectorProvider;
069import org.eclipse.aether.internal.impl.DefaultRepositoryEventDispatcher;
070import org.eclipse.aether.internal.impl.DefaultRepositoryLayoutProvider;
071import org.eclipse.aether.internal.impl.DefaultRepositorySystem;
072import org.eclipse.aether.internal.impl.DefaultRepositorySystemLifecycle;
073import org.eclipse.aether.internal.impl.DefaultTrackingFileManager;
074import org.eclipse.aether.internal.impl.DefaultTransporterProvider;
075import org.eclipse.aether.internal.impl.DefaultUpdateCheckManager;
076import org.eclipse.aether.internal.impl.DefaultUpdatePolicyAnalyzer;
077import org.eclipse.aether.internal.impl.EnhancedLocalRepositoryManagerFactory;
078import org.eclipse.aether.internal.impl.LocalPathComposer;
079import org.eclipse.aether.internal.impl.LocalPathPrefixComposerFactory;
080import org.eclipse.aether.internal.impl.Maven2RepositoryLayoutFactory;
081import org.eclipse.aether.internal.impl.SimpleLocalRepositoryManagerFactory;
082import org.eclipse.aether.internal.impl.TrackingFileManager;
083import org.eclipse.aether.internal.impl.checksum.DefaultChecksumAlgorithmFactorySelector;
084import org.eclipse.aether.internal.impl.checksum.Md5ChecksumAlgorithmFactory;
085import org.eclipse.aether.internal.impl.checksum.Sha1ChecksumAlgorithmFactory;
086import org.eclipse.aether.internal.impl.checksum.Sha256ChecksumAlgorithmFactory;
087import org.eclipse.aether.internal.impl.checksum.Sha512ChecksumAlgorithmFactory;
088import org.eclipse.aether.internal.impl.checksum.SparseDirectoryTrustedChecksumsSource;
089import org.eclipse.aether.internal.impl.checksum.SummaryFileTrustedChecksumsSource;
090import org.eclipse.aether.internal.impl.checksum.TrustedToProvidedChecksumsSourceAdapter;
091import org.eclipse.aether.internal.impl.collect.DefaultDependencyCollector;
092import org.eclipse.aether.internal.impl.collect.DependencyCollectorDelegate;
093import org.eclipse.aether.internal.impl.collect.bf.BfDependencyCollector;
094import org.eclipse.aether.internal.impl.collect.df.DfDependencyCollector;
095import org.eclipse.aether.internal.impl.filter.DefaultRemoteRepositoryFilterManager;
096import org.eclipse.aether.internal.impl.filter.GroupIdRemoteRepositoryFilterSource;
097import org.eclipse.aether.internal.impl.filter.PrefixesRemoteRepositoryFilterSource;
098import org.eclipse.aether.internal.impl.resolution.TrustedChecksumsArtifactResolverPostProcessor;
099import org.eclipse.aether.internal.impl.synccontext.DefaultSyncContextFactory;
100import org.eclipse.aether.internal.impl.synccontext.named.NameMapper;
101import org.eclipse.aether.internal.impl.synccontext.named.NameMappers;
102import org.eclipse.aether.internal.impl.synccontext.named.NamedLockFactoryAdapterFactory;
103import org.eclipse.aether.internal.impl.synccontext.named.NamedLockFactoryAdapterFactoryImpl;
104import org.eclipse.aether.named.NamedLockFactory;
105import org.eclipse.aether.named.providers.FileLockNamedLockFactory;
106import org.eclipse.aether.named.providers.LocalReadWriteLockNamedLockFactory;
107import org.eclipse.aether.named.providers.LocalSemaphoreNamedLockFactory;
108import org.eclipse.aether.named.providers.NoopNamedLockFactory;
109import org.eclipse.aether.spi.checksums.ProvidedChecksumsSource;
110import org.eclipse.aether.spi.checksums.TrustedChecksumsSource;
111import org.eclipse.aether.spi.connector.RepositoryConnectorFactory;
112import org.eclipse.aether.spi.connector.checksum.ChecksumAlgorithmFactory;
113import org.eclipse.aether.spi.connector.checksum.ChecksumAlgorithmFactorySelector;
114import org.eclipse.aether.spi.connector.checksum.ChecksumPolicyProvider;
115import org.eclipse.aether.spi.connector.filter.RemoteRepositoryFilterSource;
116import org.eclipse.aether.spi.connector.layout.RepositoryLayoutFactory;
117import org.eclipse.aether.spi.connector.layout.RepositoryLayoutProvider;
118import org.eclipse.aether.spi.connector.transport.TransporterFactory;
119import org.eclipse.aether.spi.connector.transport.TransporterProvider;
120import org.eclipse.aether.spi.io.FileProcessor;
121import org.eclipse.aether.spi.localrepo.LocalRepositoryManagerFactory;
122import org.eclipse.aether.spi.resolution.ArtifactResolverPostProcessor;
123import org.eclipse.aether.spi.synccontext.SyncContextFactory;
124import org.eclipse.aether.transport.file.FileTransporterFactory;
125import org.eclipse.aether.transport.http.ChecksumExtractor;
126import org.eclipse.aether.transport.http.HttpTransporterFactory;
127import org.eclipse.aether.transport.http.Nexus2ChecksumExtractor;
128import org.eclipse.aether.transport.http.XChecksumChecksumExtractor;
129
130/**
131 * A simple {@link Supplier} of {@link org.eclipse.aether.RepositorySystem} instances, that on each call supplies newly
132 * constructed instance. For proper shut down, use {@link RepositorySystem#shutdown()} method on supplied instance(s).
133 * <p>
134 * Extend this class and override methods to customize, if needed.
135 *
136 * @since 1.9.15
137 */
138public class RepositorySystemSupplier implements Supplier<RepositorySystem> {
139    protected FileProcessor getFileProcessor() {
140        return new DefaultFileProcessor();
141    }
142
143    protected TrackingFileManager getTrackingFileManager() {
144        return new DefaultTrackingFileManager();
145    }
146
147    protected LocalPathComposer getLocalPathComposer() {
148        return new DefaultLocalPathComposer();
149    }
150
151    protected LocalPathPrefixComposerFactory getLocalPathPrefixComposerFactory() {
152        return new DefaultLocalPathPrefixComposerFactory();
153    }
154
155    protected RepositorySystemLifecycle getRepositorySystemLifecycle() {
156        return new DefaultRepositorySystemLifecycle();
157    }
158
159    protected OfflineController getOfflineController() {
160        return new DefaultOfflineController();
161    }
162
163    protected UpdatePolicyAnalyzer getUpdatePolicyAnalyzer() {
164        return new DefaultUpdatePolicyAnalyzer();
165    }
166
167    protected ChecksumPolicyProvider getChecksumPolicyProvider() {
168        return new DefaultChecksumPolicyProvider();
169    }
170
171    protected UpdateCheckManager getUpdateCheckManager(
172            TrackingFileManager trackingFileManager, UpdatePolicyAnalyzer updatePolicyAnalyzer) {
173        return new DefaultUpdateCheckManager(trackingFileManager, updatePolicyAnalyzer);
174    }
175
176    protected Map<String, NamedLockFactory> getNamedLockFactories() {
177        HashMap<String, NamedLockFactory> result = new HashMap<>();
178        result.put(NoopNamedLockFactory.NAME, new NoopNamedLockFactory());
179        result.put(LocalReadWriteLockNamedLockFactory.NAME, new LocalReadWriteLockNamedLockFactory());
180        result.put(LocalSemaphoreNamedLockFactory.NAME, new LocalSemaphoreNamedLockFactory());
181        result.put(FileLockNamedLockFactory.NAME, new FileLockNamedLockFactory());
182        return result;
183    }
184
185    protected Map<String, NameMapper> getNameMappers() {
186        HashMap<String, NameMapper> result = new HashMap<>();
187        result.put(NameMappers.STATIC_NAME, NameMappers.staticNameMapper());
188        result.put(NameMappers.GAV_NAME, NameMappers.gavNameMapper());
189        result.put(NameMappers.GAECV_NAME, NameMappers.gaecvNameMapper());
190        result.put(NameMappers.DISCRIMINATING_NAME, NameMappers.discriminatingNameMapper());
191        result.put(NameMappers.FILE_GAV_NAME, NameMappers.fileGavNameMapper());
192        result.put(NameMappers.FILE_GAECV_NAME, NameMappers.fileGaecvNameMapper());
193        result.put(NameMappers.FILE_HGAV_NAME, NameMappers.fileHashingGavNameMapper());
194        result.put(NameMappers.FILE_HGAECV_NAME, NameMappers.fileHashingGaecvNameMapper());
195        return result;
196    }
197
198    protected NamedLockFactoryAdapterFactory getNamedLockFactoryAdapterFactory(
199            Map<String, NamedLockFactory> namedLockFactories,
200            Map<String, NameMapper> nameMappers,
201            RepositorySystemLifecycle repositorySystemLifecycle) {
202        return new NamedLockFactoryAdapterFactoryImpl(namedLockFactories, nameMappers, repositorySystemLifecycle);
203    }
204
205    protected SyncContextFactory getSyncContextFactory(NamedLockFactoryAdapterFactory namedLockFactoryAdapterFactory) {
206        return new DefaultSyncContextFactory(namedLockFactoryAdapterFactory);
207    }
208
209    protected Map<String, ChecksumAlgorithmFactory> getChecksumAlgorithmFactories() {
210        HashMap<String, ChecksumAlgorithmFactory> result = new HashMap<>();
211        result.put(Sha512ChecksumAlgorithmFactory.NAME, new Sha512ChecksumAlgorithmFactory());
212        result.put(Sha256ChecksumAlgorithmFactory.NAME, new Sha256ChecksumAlgorithmFactory());
213        result.put(Sha1ChecksumAlgorithmFactory.NAME, new Sha1ChecksumAlgorithmFactory());
214        result.put(Md5ChecksumAlgorithmFactory.NAME, new Md5ChecksumAlgorithmFactory());
215        return result;
216    }
217
218    protected ChecksumAlgorithmFactorySelector getChecksumAlgorithmFactorySelector(
219            Map<String, ChecksumAlgorithmFactory> checksumAlgorithmFactories) {
220        return new DefaultChecksumAlgorithmFactorySelector(checksumAlgorithmFactories);
221    }
222
223    protected Map<String, RepositoryLayoutFactory> getRepositoryLayoutFactories(
224            ChecksumAlgorithmFactorySelector checksumAlgorithmFactorySelector) {
225        HashMap<String, RepositoryLayoutFactory> result = new HashMap<>();
226        result.put(
227                Maven2RepositoryLayoutFactory.NAME,
228                new Maven2RepositoryLayoutFactory(checksumAlgorithmFactorySelector));
229        return result;
230    }
231
232    protected RepositoryLayoutProvider getRepositoryLayoutProvider(
233            Map<String, RepositoryLayoutFactory> repositoryLayoutFactories) {
234        return new DefaultRepositoryLayoutProvider(new HashSet<>(repositoryLayoutFactories.values()));
235    }
236
237    protected LocalRepositoryProvider getLocalRepositoryProvider(
238            LocalPathComposer localPathComposer,
239            TrackingFileManager trackingFileManager,
240            LocalPathPrefixComposerFactory localPathPrefixComposerFactory) {
241        HashSet<LocalRepositoryManagerFactory> localRepositoryProviders = new HashSet<>(2);
242        localRepositoryProviders.add(new SimpleLocalRepositoryManagerFactory(localPathComposer));
243        localRepositoryProviders.add(new EnhancedLocalRepositoryManagerFactory(
244                localPathComposer, trackingFileManager, localPathPrefixComposerFactory));
245        return new DefaultLocalRepositoryProvider(localRepositoryProviders);
246    }
247
248    protected RemoteRepositoryManager getRemoteRepositoryManager(
249            UpdatePolicyAnalyzer updatePolicyAnalyzer, ChecksumPolicyProvider checksumPolicyProvider) {
250        return new DefaultRemoteRepositoryManager(updatePolicyAnalyzer, checksumPolicyProvider);
251    }
252
253    protected Map<String, RemoteRepositoryFilterSource> getRemoteRepositoryFilterSources(
254            RepositorySystemLifecycle repositorySystemLifecycle, RepositoryLayoutProvider repositoryLayoutProvider) {
255        HashMap<String, RemoteRepositoryFilterSource> result = new HashMap<>();
256        result.put(
257                GroupIdRemoteRepositoryFilterSource.NAME,
258                new GroupIdRemoteRepositoryFilterSource(repositorySystemLifecycle));
259        result.put(
260                PrefixesRemoteRepositoryFilterSource.NAME,
261                new PrefixesRemoteRepositoryFilterSource(repositoryLayoutProvider));
262        return result;
263    }
264
265    protected RemoteRepositoryFilterManager getRemoteRepositoryFilterManager(
266            Map<String, RemoteRepositoryFilterSource> remoteRepositoryFilterSources) {
267        return new DefaultRemoteRepositoryFilterManager(remoteRepositoryFilterSources);
268    }
269
270    protected Map<String, RepositoryListener> getRepositoryListeners() {
271        return new HashMap<>();
272    }
273
274    protected RepositoryEventDispatcher getRepositoryEventDispatcher(
275            Map<String, RepositoryListener> repositoryListeners) {
276        return new DefaultRepositoryEventDispatcher(new HashSet<>(repositoryListeners.values()));
277    }
278
279    protected Map<String, TrustedChecksumsSource> getTrustedChecksumsSources(
280            FileProcessor fileProcessor,
281            LocalPathComposer localPathComposer,
282            RepositorySystemLifecycle repositorySystemLifecycle) {
283        HashMap<String, TrustedChecksumsSource> result = new HashMap<>();
284        result.put(
285                SparseDirectoryTrustedChecksumsSource.NAME,
286                new SparseDirectoryTrustedChecksumsSource(fileProcessor, localPathComposer));
287        result.put(
288                SummaryFileTrustedChecksumsSource.NAME,
289                new SummaryFileTrustedChecksumsSource(localPathComposer, repositorySystemLifecycle));
290        return result;
291    }
292
293    protected Map<String, ProvidedChecksumsSource> getProvidedChecksumsSources(
294            Map<String, TrustedChecksumsSource> trustedChecksumsSources) {
295        HashMap<String, ProvidedChecksumsSource> result = new HashMap<>();
296        result.put(
297                TrustedToProvidedChecksumsSourceAdapter.NAME,
298                new TrustedToProvidedChecksumsSourceAdapter(trustedChecksumsSources));
299        return result;
300    }
301
302    protected Map<String, ChecksumExtractor> getChecksumExtractors() {
303        HashMap<String, ChecksumExtractor> result = new HashMap<>();
304        result.put(Nexus2ChecksumExtractor.NAME, new Nexus2ChecksumExtractor());
305        result.put(XChecksumChecksumExtractor.NAME, new XChecksumChecksumExtractor());
306        return result;
307    }
308
309    protected Map<String, TransporterFactory> getTransporterFactories(Map<String, ChecksumExtractor> extractors) {
310        HashMap<String, TransporterFactory> result = new HashMap<>();
311        result.put(FileTransporterFactory.NAME, new FileTransporterFactory());
312        result.put(HttpTransporterFactory.NAME, new HttpTransporterFactory(extractors));
313        return result;
314    }
315
316    protected TransporterProvider getTransporterProvider(Map<String, TransporterFactory> transporterFactories) {
317        return new DefaultTransporterProvider(new HashSet<>(transporterFactories.values()));
318    }
319
320    protected BasicRepositoryConnectorFactory getBasicRepositoryConnectorFactory(
321            TransporterProvider transporterProvider,
322            RepositoryLayoutProvider repositoryLayoutProvider,
323            ChecksumPolicyProvider checksumPolicyProvider,
324            FileProcessor fileProcessor,
325            Map<String, ProvidedChecksumsSource> providedChecksumsSources) {
326        return new BasicRepositoryConnectorFactory(
327                transporterProvider,
328                repositoryLayoutProvider,
329                checksumPolicyProvider,
330                fileProcessor,
331                providedChecksumsSources);
332    }
333
334    protected Map<String, RepositoryConnectorFactory> getRepositoryConnectorFactories(
335            BasicRepositoryConnectorFactory basicRepositoryConnectorFactory) {
336        HashMap<String, RepositoryConnectorFactory> result = new HashMap<>();
337        result.put(BasicRepositoryConnectorFactory.NAME, basicRepositoryConnectorFactory);
338        return result;
339    }
340
341    protected RepositoryConnectorProvider getRepositoryConnectorProvider(
342            Map<String, RepositoryConnectorFactory> repositoryConnectorFactories,
343            RemoteRepositoryFilterManager remoteRepositoryFilterManager) {
344        return new DefaultRepositoryConnectorProvider(
345                new HashSet<>(repositoryConnectorFactories.values()), remoteRepositoryFilterManager);
346    }
347
348    protected Installer getInstaller(
349            FileProcessor fileProcessor,
350            RepositoryEventDispatcher repositoryEventDispatcher,
351            Map<String, MetadataGeneratorFactory> metadataGeneratorFactories,
352            SyncContextFactory syncContextFactory) {
353        return new DefaultInstaller(
354                fileProcessor,
355                repositoryEventDispatcher,
356                new HashSet<>(metadataGeneratorFactories.values()),
357                syncContextFactory);
358    }
359
360    @SuppressWarnings("checkstyle:parameternumber")
361    protected Deployer getDeployer(
362            FileProcessor fileProcessor,
363            RepositoryEventDispatcher repositoryEventDispatcher,
364            RepositoryConnectorProvider repositoryConnectorProvider,
365            RemoteRepositoryManager remoteRepositoryManager,
366            UpdateCheckManager updateCheckManager,
367            Map<String, MetadataGeneratorFactory> metadataGeneratorFactories,
368            SyncContextFactory syncContextFactory,
369            OfflineController offlineController) {
370        return new DefaultDeployer(
371                fileProcessor,
372                repositoryEventDispatcher,
373                repositoryConnectorProvider,
374                remoteRepositoryManager,
375                updateCheckManager,
376                new HashSet<>(metadataGeneratorFactories.values()),
377                syncContextFactory,
378                offlineController);
379    }
380
381    protected Map<String, DependencyCollectorDelegate> getDependencyCollectorDelegates(
382            RemoteRepositoryManager remoteRepositoryManager,
383            ArtifactDescriptorReader artifactDescriptorReader,
384            VersionRangeResolver versionRangeResolver) {
385        HashMap<String, DependencyCollectorDelegate> result = new HashMap<>();
386        result.put(
387                DfDependencyCollector.NAME,
388                new DfDependencyCollector(remoteRepositoryManager, artifactDescriptorReader, versionRangeResolver));
389        result.put(
390                BfDependencyCollector.NAME,
391                new BfDependencyCollector(remoteRepositoryManager, artifactDescriptorReader, versionRangeResolver));
392        return result;
393    }
394
395    protected DependencyCollector getDependencyCollector(
396            Map<String, DependencyCollectorDelegate> dependencyCollectorDelegates) {
397        return new DefaultDependencyCollector(dependencyCollectorDelegates);
398    }
399
400    protected Map<String, ArtifactResolverPostProcessor> getArtifactResolverPostProcessors(
401            ChecksumAlgorithmFactorySelector checksumAlgorithmFactorySelector,
402            Map<String, TrustedChecksumsSource> trustedChecksumsSources) {
403        HashMap<String, ArtifactResolverPostProcessor> result = new HashMap<>();
404        result.put(
405                TrustedChecksumsArtifactResolverPostProcessor.NAME,
406                new TrustedChecksumsArtifactResolverPostProcessor(
407                        checksumAlgorithmFactorySelector, trustedChecksumsSources));
408        return result;
409    }
410
411    @SuppressWarnings("checkstyle:parameternumber")
412    protected ArtifactResolver getArtifactResolver(
413            FileProcessor fileProcessor,
414            RepositoryEventDispatcher repositoryEventDispatcher,
415            VersionResolver versionResolver,
416            UpdateCheckManager updateCheckManager,
417            RepositoryConnectorProvider repositoryConnectorProvider,
418            RemoteRepositoryManager remoteRepositoryManager,
419            SyncContextFactory syncContextFactory,
420            OfflineController offlineController,
421            Map<String, ArtifactResolverPostProcessor> artifactResolverPostProcessors,
422            RemoteRepositoryFilterManager remoteRepositoryFilterManager) {
423        return new DefaultArtifactResolver(
424                fileProcessor,
425                repositoryEventDispatcher,
426                versionResolver,
427                updateCheckManager,
428                repositoryConnectorProvider,
429                remoteRepositoryManager,
430                syncContextFactory,
431                offlineController,
432                artifactResolverPostProcessors,
433                remoteRepositoryFilterManager);
434    }
435
436    protected MetadataResolver getMetadataResolver(
437            RepositoryEventDispatcher repositoryEventDispatcher,
438            UpdateCheckManager updateCheckManager,
439            RepositoryConnectorProvider repositoryConnectorProvider,
440            RemoteRepositoryManager remoteRepositoryManager,
441            SyncContextFactory syncContextFactory,
442            OfflineController offlineController,
443            RemoteRepositoryFilterManager remoteRepositoryFilterManager) {
444        return new DefaultMetadataResolver(
445                repositoryEventDispatcher,
446                updateCheckManager,
447                repositoryConnectorProvider,
448                remoteRepositoryManager,
449                syncContextFactory,
450                offlineController,
451                remoteRepositoryFilterManager);
452    }
453
454    // Maven provided
455
456    protected Map<String, MetadataGeneratorFactory> getMetadataGeneratorFactories() {
457        // from maven-resolver-provider
458        HashMap<String, MetadataGeneratorFactory> result = new HashMap<>();
459        // TODO: Fix this once MNG-7874 done and released
460        result.put("plugins", new PluginsMetadataGeneratorFactory());
461        result.put("versions", new VersionsMetadataGeneratorFactory());
462        result.put("snapshot", new SnapshotMetadataGeneratorFactory());
463        return result;
464    }
465
466    protected ArtifactDescriptorReader getArtifactDescriptorReader(
467            RemoteRepositoryManager remoteRepositoryManager,
468            VersionResolver versionResolver,
469            VersionRangeResolver versionRangeResolver,
470            ArtifactResolver artifactResolver,
471            ModelBuilder modelBuilder,
472            RepositoryEventDispatcher repositoryEventDispatcher,
473            ModelCacheFactory modelCacheFactory) {
474        // from maven-resolver-provider
475        DefaultArtifactDescriptorReader result = new DefaultArtifactDescriptorReader();
476        result.setRemoteRepositoryManager(remoteRepositoryManager);
477        result.setVersionResolver(versionResolver);
478        result.setVersionRangeResolver(versionRangeResolver);
479        result.setArtifactResolver(artifactResolver);
480        result.setModelBuilder(modelBuilder);
481        result.setRepositoryEventDispatcher(repositoryEventDispatcher);
482        result.setModelCacheFactory(modelCacheFactory);
483        return result;
484    }
485
486    protected VersionResolver getVersionResolver(
487            MetadataResolver metadataResolver,
488            SyncContextFactory syncContextFactory,
489            RepositoryEventDispatcher repositoryEventDispatcher) {
490        // from maven-resolver-provider
491        DefaultVersionResolver result = new DefaultVersionResolver();
492        result.setMetadataResolver(metadataResolver);
493        result.setSyncContextFactory(syncContextFactory);
494        result.setRepositoryEventDispatcher(repositoryEventDispatcher);
495        return result;
496    }
497
498    protected VersionRangeResolver getVersionRangeResolver(
499            MetadataResolver metadataResolver,
500            SyncContextFactory syncContextFactory,
501            RepositoryEventDispatcher repositoryEventDispatcher) {
502        // from maven-resolver-provider
503        DefaultVersionRangeResolver result = new DefaultVersionRangeResolver();
504        result.setMetadataResolver(metadataResolver);
505        result.setSyncContextFactory(syncContextFactory);
506        result.setRepositoryEventDispatcher(repositoryEventDispatcher);
507        return result;
508    }
509
510    protected ModelBuilder getModelBuilder() {
511        // from maven-model-builder
512        return new DefaultModelBuilderFactory().newInstance();
513    }
514
515    protected ModelCacheFactory getModelCacheFactory() {
516        // from maven-resolver-provider
517        return new DefaultModelCacheFactory();
518    }
519
520    @Override
521    public RepositorySystem get() {
522        FileProcessor fileProcessor = getFileProcessor();
523        TrackingFileManager trackingFileManager = getTrackingFileManager();
524        LocalPathComposer localPathComposer = getLocalPathComposer();
525        LocalPathPrefixComposerFactory localPathPrefixComposerFactory = getLocalPathPrefixComposerFactory();
526        RepositorySystemLifecycle repositorySystemLifecycle = getRepositorySystemLifecycle();
527        OfflineController offlineController = getOfflineController();
528        UpdatePolicyAnalyzer updatePolicyAnalyzer = getUpdatePolicyAnalyzer();
529        ChecksumPolicyProvider checksumPolicyProvider = getChecksumPolicyProvider();
530
531        UpdateCheckManager updateCheckManager = getUpdateCheckManager(trackingFileManager, updatePolicyAnalyzer);
532
533        Map<String, NamedLockFactory> namedLockFactories = getNamedLockFactories();
534        Map<String, NameMapper> nameMappers = getNameMappers();
535        NamedLockFactoryAdapterFactory namedLockFactoryAdapterFactory =
536                getNamedLockFactoryAdapterFactory(namedLockFactories, nameMappers, repositorySystemLifecycle);
537        SyncContextFactory syncContextFactory = getSyncContextFactory(namedLockFactoryAdapterFactory);
538
539        Map<String, ChecksumAlgorithmFactory> checksumAlgorithmFactories = getChecksumAlgorithmFactories();
540        ChecksumAlgorithmFactorySelector checksumAlgorithmFactorySelector =
541                getChecksumAlgorithmFactorySelector(checksumAlgorithmFactories);
542
543        Map<String, RepositoryLayoutFactory> repositoryLayoutFactories =
544                getRepositoryLayoutFactories(checksumAlgorithmFactorySelector);
545        RepositoryLayoutProvider repositoryLayoutProvider = getRepositoryLayoutProvider(repositoryLayoutFactories);
546
547        LocalRepositoryProvider localRepositoryProvider =
548                getLocalRepositoryProvider(localPathComposer, trackingFileManager, localPathPrefixComposerFactory);
549
550        RemoteRepositoryManager remoteRepositoryManager =
551                getRemoteRepositoryManager(updatePolicyAnalyzer, checksumPolicyProvider);
552        Map<String, RemoteRepositoryFilterSource> remoteRepositoryFilterSources =
553                getRemoteRepositoryFilterSources(repositorySystemLifecycle, repositoryLayoutProvider);
554        RemoteRepositoryFilterManager remoteRepositoryFilterManager =
555                getRemoteRepositoryFilterManager(remoteRepositoryFilterSources);
556
557        Map<String, RepositoryListener> repositoryListeners = getRepositoryListeners();
558        RepositoryEventDispatcher repositoryEventDispatcher = getRepositoryEventDispatcher(repositoryListeners);
559
560        Map<String, TrustedChecksumsSource> trustedChecksumsSources =
561                getTrustedChecksumsSources(fileProcessor, localPathComposer, repositorySystemLifecycle);
562        Map<String, ProvidedChecksumsSource> providedChecksumsSources =
563                getProvidedChecksumsSources(trustedChecksumsSources);
564
565        Map<String, ChecksumExtractor> checksumExtractors = getChecksumExtractors();
566        Map<String, TransporterFactory> transporterFactories = getTransporterFactories(checksumExtractors);
567        TransporterProvider transporterProvider = getTransporterProvider(transporterFactories);
568
569        BasicRepositoryConnectorFactory basic = getBasicRepositoryConnectorFactory(
570                transporterProvider,
571                repositoryLayoutProvider,
572                checksumPolicyProvider,
573                fileProcessor,
574                providedChecksumsSources);
575        Map<String, RepositoryConnectorFactory> repositoryConnectorFactories = getRepositoryConnectorFactories(basic);
576        RepositoryConnectorProvider repositoryConnectorProvider =
577                getRepositoryConnectorProvider(repositoryConnectorFactories, remoteRepositoryFilterManager);
578
579        Map<String, MetadataGeneratorFactory> metadataGeneratorFactories = getMetadataGeneratorFactories();
580
581        Installer installer =
582                getInstaller(fileProcessor, repositoryEventDispatcher, metadataGeneratorFactories, syncContextFactory);
583        Deployer deployer = getDeployer(
584                fileProcessor,
585                repositoryEventDispatcher,
586                repositoryConnectorProvider,
587                remoteRepositoryManager,
588                updateCheckManager,
589                metadataGeneratorFactories,
590                syncContextFactory,
591                offlineController);
592
593        MetadataResolver metadataResolver = getMetadataResolver(
594                repositoryEventDispatcher,
595                updateCheckManager,
596                repositoryConnectorProvider,
597                remoteRepositoryManager,
598                syncContextFactory,
599                offlineController,
600                remoteRepositoryFilterManager);
601
602        VersionResolver versionResolver =
603                getVersionResolver(metadataResolver, syncContextFactory, repositoryEventDispatcher);
604        VersionRangeResolver versionRangeResolver =
605                getVersionRangeResolver(metadataResolver, syncContextFactory, repositoryEventDispatcher);
606
607        Map<String, ArtifactResolverPostProcessor> artifactResolverPostProcessors =
608                getArtifactResolverPostProcessors(checksumAlgorithmFactorySelector, trustedChecksumsSources);
609        ArtifactResolver artifactResolver = getArtifactResolver(
610                fileProcessor,
611                repositoryEventDispatcher,
612                versionResolver,
613                updateCheckManager,
614                repositoryConnectorProvider,
615                remoteRepositoryManager,
616                syncContextFactory,
617                offlineController,
618                artifactResolverPostProcessors,
619                remoteRepositoryFilterManager);
620
621        ModelBuilder modelBuilder = getModelBuilder();
622        ModelCacheFactory modelCacheFactory = getModelCacheFactory();
623
624        ArtifactDescriptorReader artifactDescriptorReader = getArtifactDescriptorReader(
625                remoteRepositoryManager,
626                versionResolver,
627                versionRangeResolver,
628                artifactResolver,
629                modelBuilder,
630                repositoryEventDispatcher,
631                modelCacheFactory);
632
633        Map<String, DependencyCollectorDelegate> dependencyCollectorDelegates = getDependencyCollectorDelegates(
634                remoteRepositoryManager, artifactDescriptorReader, versionRangeResolver);
635        DependencyCollector dependencyCollector = getDependencyCollector(dependencyCollectorDelegates);
636
637        return new DefaultRepositorySystem(
638                versionResolver,
639                versionRangeResolver,
640                artifactResolver,
641                metadataResolver,
642                artifactDescriptorReader,
643                dependencyCollector,
644                installer,
645                deployer,
646                localRepositoryProvider,
647                syncContextFactory,
648                remoteRepositoryManager,
649                repositorySystemLifecycle);
650    }
651}