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.DISCRIMINATING_NAME, NameMappers.discriminatingNameMapper());
190        result.put(NameMappers.FILE_GAV_NAME, NameMappers.fileGavNameMapper());
191        result.put(NameMappers.FILE_HGAV_NAME, NameMappers.fileHashingGavNameMapper());
192        return result;
193    }
194
195    protected NamedLockFactoryAdapterFactory getNamedLockFactoryAdapterFactory(
196            Map<String, NamedLockFactory> namedLockFactories,
197            Map<String, NameMapper> nameMappers,
198            RepositorySystemLifecycle repositorySystemLifecycle) {
199        return new NamedLockFactoryAdapterFactoryImpl(namedLockFactories, nameMappers, repositorySystemLifecycle);
200    }
201
202    protected SyncContextFactory getSyncContextFactory(NamedLockFactoryAdapterFactory namedLockFactoryAdapterFactory) {
203        return new DefaultSyncContextFactory(namedLockFactoryAdapterFactory);
204    }
205
206    protected Map<String, ChecksumAlgorithmFactory> getChecksumAlgorithmFactories() {
207        HashMap<String, ChecksumAlgorithmFactory> result = new HashMap<>();
208        result.put(Sha512ChecksumAlgorithmFactory.NAME, new Sha512ChecksumAlgorithmFactory());
209        result.put(Sha256ChecksumAlgorithmFactory.NAME, new Sha256ChecksumAlgorithmFactory());
210        result.put(Sha1ChecksumAlgorithmFactory.NAME, new Sha1ChecksumAlgorithmFactory());
211        result.put(Md5ChecksumAlgorithmFactory.NAME, new Md5ChecksumAlgorithmFactory());
212        return result;
213    }
214
215    protected ChecksumAlgorithmFactorySelector getChecksumAlgorithmFactorySelector(
216            Map<String, ChecksumAlgorithmFactory> checksumAlgorithmFactories) {
217        return new DefaultChecksumAlgorithmFactorySelector(checksumAlgorithmFactories);
218    }
219
220    protected Map<String, RepositoryLayoutFactory> getRepositoryLayoutFactories(
221            ChecksumAlgorithmFactorySelector checksumAlgorithmFactorySelector) {
222        HashMap<String, RepositoryLayoutFactory> result = new HashMap<>();
223        result.put("maven2", new Maven2RepositoryLayoutFactory(checksumAlgorithmFactorySelector));
224        return result;
225    }
226
227    protected RepositoryLayoutProvider getRepositoryLayoutProvider(
228            Map<String, RepositoryLayoutFactory> repositoryLayoutFactories) {
229        return new DefaultRepositoryLayoutProvider(new HashSet<>(repositoryLayoutFactories.values()));
230    }
231
232    protected LocalRepositoryProvider getLocalRepositoryProvider(
233            LocalPathComposer localPathComposer,
234            TrackingFileManager trackingFileManager,
235            LocalPathPrefixComposerFactory localPathPrefixComposerFactory) {
236        HashSet<LocalRepositoryManagerFactory> localRepositoryProviders = new HashSet<>(2);
237        localRepositoryProviders.add(new SimpleLocalRepositoryManagerFactory(localPathComposer));
238        localRepositoryProviders.add(new EnhancedLocalRepositoryManagerFactory(
239                localPathComposer, trackingFileManager, localPathPrefixComposerFactory));
240        return new DefaultLocalRepositoryProvider(localRepositoryProviders);
241    }
242
243    protected RemoteRepositoryManager getRemoteRepositoryManager(
244            UpdatePolicyAnalyzer updatePolicyAnalyzer, ChecksumPolicyProvider checksumPolicyProvider) {
245        return new DefaultRemoteRepositoryManager(updatePolicyAnalyzer, checksumPolicyProvider);
246    }
247
248    protected Map<String, RemoteRepositoryFilterSource> getRemoteRepositoryFilterSources(
249            RepositorySystemLifecycle repositorySystemLifecycle, RepositoryLayoutProvider repositoryLayoutProvider) {
250        HashMap<String, RemoteRepositoryFilterSource> result = new HashMap<>();
251        result.put(
252                GroupIdRemoteRepositoryFilterSource.NAME,
253                new GroupIdRemoteRepositoryFilterSource(repositorySystemLifecycle));
254        result.put(
255                PrefixesRemoteRepositoryFilterSource.NAME,
256                new PrefixesRemoteRepositoryFilterSource(repositoryLayoutProvider));
257        return result;
258    }
259
260    protected RemoteRepositoryFilterManager getRemoteRepositoryFilterManager(
261            Map<String, RemoteRepositoryFilterSource> remoteRepositoryFilterSources) {
262        return new DefaultRemoteRepositoryFilterManager(remoteRepositoryFilterSources);
263    }
264
265    protected Map<String, RepositoryListener> getRepositoryListeners() {
266        return new HashMap<>();
267    }
268
269    protected RepositoryEventDispatcher getRepositoryEventDispatcher(
270            Map<String, RepositoryListener> repositoryListeners) {
271        return new DefaultRepositoryEventDispatcher(new HashSet<>(repositoryListeners.values()));
272    }
273
274    protected Map<String, TrustedChecksumsSource> getTrustedChecksumsSources(
275            FileProcessor fileProcessor,
276            LocalPathComposer localPathComposer,
277            RepositorySystemLifecycle repositorySystemLifecycle) {
278        HashMap<String, TrustedChecksumsSource> result = new HashMap<>();
279        result.put(
280                SparseDirectoryTrustedChecksumsSource.NAME,
281                new SparseDirectoryTrustedChecksumsSource(fileProcessor, localPathComposer));
282        result.put(
283                SummaryFileTrustedChecksumsSource.NAME,
284                new SummaryFileTrustedChecksumsSource(localPathComposer, repositorySystemLifecycle));
285        return result;
286    }
287
288    protected Map<String, ProvidedChecksumsSource> getProvidedChecksumsSources(
289            Map<String, TrustedChecksumsSource> trustedChecksumsSources) {
290        HashMap<String, ProvidedChecksumsSource> result = new HashMap<>();
291        result.put(
292                TrustedToProvidedChecksumsSourceAdapter.NAME,
293                new TrustedToProvidedChecksumsSourceAdapter(trustedChecksumsSources));
294        return result;
295    }
296
297    protected Map<String, ChecksumExtractor> getChecksumExtractors() {
298        HashMap<String, ChecksumExtractor> result = new HashMap<>();
299        result.put(Nexus2ChecksumExtractor.NAME, new Nexus2ChecksumExtractor());
300        result.put(XChecksumChecksumExtractor.NAME, new XChecksumChecksumExtractor());
301        return result;
302    }
303
304    protected Map<String, TransporterFactory> getTransporterFactories(Map<String, ChecksumExtractor> extractors) {
305        HashMap<String, TransporterFactory> result = new HashMap<>();
306        result.put("file", new FileTransporterFactory());
307        result.put("http", new HttpTransporterFactory(extractors));
308        return result;
309    }
310
311    protected TransporterProvider getTransporterProvider(Map<String, TransporterFactory> transporterFactories) {
312        return new DefaultTransporterProvider(new HashSet<>(transporterFactories.values()));
313    }
314
315    protected BasicRepositoryConnectorFactory getBasicRepositoryConnectorFactory(
316            TransporterProvider transporterProvider,
317            RepositoryLayoutProvider repositoryLayoutProvider,
318            ChecksumPolicyProvider checksumPolicyProvider,
319            FileProcessor fileProcessor,
320            Map<String, ProvidedChecksumsSource> providedChecksumsSources) {
321        return new BasicRepositoryConnectorFactory(
322                transporterProvider,
323                repositoryLayoutProvider,
324                checksumPolicyProvider,
325                fileProcessor,
326                providedChecksumsSources);
327    }
328
329    protected Map<String, RepositoryConnectorFactory> getRepositoryConnectorFactories(
330            BasicRepositoryConnectorFactory basicRepositoryConnectorFactory) {
331        HashMap<String, RepositoryConnectorFactory> result = new HashMap<>();
332        result.put("basic", basicRepositoryConnectorFactory);
333        return result;
334    }
335
336    protected RepositoryConnectorProvider getRepositoryConnectorProvider(
337            Map<String, RepositoryConnectorFactory> repositoryConnectorFactories,
338            RemoteRepositoryFilterManager remoteRepositoryFilterManager) {
339        return new DefaultRepositoryConnectorProvider(
340                new HashSet<>(repositoryConnectorFactories.values()), remoteRepositoryFilterManager);
341    }
342
343    protected Installer getInstaller(
344            FileProcessor fileProcessor,
345            RepositoryEventDispatcher repositoryEventDispatcher,
346            Map<String, MetadataGeneratorFactory> metadataGeneratorFactories,
347            SyncContextFactory syncContextFactory) {
348        return new DefaultInstaller(
349                fileProcessor,
350                repositoryEventDispatcher,
351                new HashSet<>(metadataGeneratorFactories.values()),
352                syncContextFactory);
353    }
354
355    @SuppressWarnings("checkstyle:parameternumber")
356    protected Deployer getDeployer(
357            FileProcessor fileProcessor,
358            RepositoryEventDispatcher repositoryEventDispatcher,
359            RepositoryConnectorProvider repositoryConnectorProvider,
360            RemoteRepositoryManager remoteRepositoryManager,
361            UpdateCheckManager updateCheckManager,
362            Map<String, MetadataGeneratorFactory> metadataGeneratorFactories,
363            SyncContextFactory syncContextFactory,
364            OfflineController offlineController) {
365        return new DefaultDeployer(
366                fileProcessor,
367                repositoryEventDispatcher,
368                repositoryConnectorProvider,
369                remoteRepositoryManager,
370                updateCheckManager,
371                new HashSet<>(metadataGeneratorFactories.values()),
372                syncContextFactory,
373                offlineController);
374    }
375
376    protected Map<String, DependencyCollectorDelegate> getDependencyCollectorDelegates(
377            RemoteRepositoryManager remoteRepositoryManager,
378            ArtifactDescriptorReader artifactDescriptorReader,
379            VersionRangeResolver versionRangeResolver) {
380        HashMap<String, DependencyCollectorDelegate> result = new HashMap<>();
381        result.put(
382                DfDependencyCollector.NAME,
383                new DfDependencyCollector(remoteRepositoryManager, artifactDescriptorReader, versionRangeResolver));
384        result.put(
385                BfDependencyCollector.NAME,
386                new BfDependencyCollector(remoteRepositoryManager, artifactDescriptorReader, versionRangeResolver));
387        return result;
388    }
389
390    protected DependencyCollector getDependencyCollector(
391            Map<String, DependencyCollectorDelegate> dependencyCollectorDelegates) {
392        return new DefaultDependencyCollector(dependencyCollectorDelegates);
393    }
394
395    protected Map<String, ArtifactResolverPostProcessor> getArtifactResolverPostProcessors(
396            ChecksumAlgorithmFactorySelector checksumAlgorithmFactorySelector,
397            Map<String, TrustedChecksumsSource> trustedChecksumsSources) {
398        HashMap<String, ArtifactResolverPostProcessor> result = new HashMap<>();
399        result.put(
400                TrustedChecksumsArtifactResolverPostProcessor.NAME,
401                new TrustedChecksumsArtifactResolverPostProcessor(
402                        checksumAlgorithmFactorySelector, trustedChecksumsSources));
403        return result;
404    }
405
406    @SuppressWarnings("checkstyle:parameternumber")
407    protected ArtifactResolver getArtifactResolver(
408            FileProcessor fileProcessor,
409            RepositoryEventDispatcher repositoryEventDispatcher,
410            VersionResolver versionResolver,
411            UpdateCheckManager updateCheckManager,
412            RepositoryConnectorProvider repositoryConnectorProvider,
413            RemoteRepositoryManager remoteRepositoryManager,
414            SyncContextFactory syncContextFactory,
415            OfflineController offlineController,
416            Map<String, ArtifactResolverPostProcessor> artifactResolverPostProcessors,
417            RemoteRepositoryFilterManager remoteRepositoryFilterManager) {
418        return new DefaultArtifactResolver(
419                fileProcessor,
420                repositoryEventDispatcher,
421                versionResolver,
422                updateCheckManager,
423                repositoryConnectorProvider,
424                remoteRepositoryManager,
425                syncContextFactory,
426                offlineController,
427                artifactResolverPostProcessors,
428                remoteRepositoryFilterManager);
429    }
430
431    protected MetadataResolver getMetadataResolver(
432            RepositoryEventDispatcher repositoryEventDispatcher,
433            UpdateCheckManager updateCheckManager,
434            RepositoryConnectorProvider repositoryConnectorProvider,
435            RemoteRepositoryManager remoteRepositoryManager,
436            SyncContextFactory syncContextFactory,
437            OfflineController offlineController,
438            RemoteRepositoryFilterManager remoteRepositoryFilterManager) {
439        return new DefaultMetadataResolver(
440                repositoryEventDispatcher,
441                updateCheckManager,
442                repositoryConnectorProvider,
443                remoteRepositoryManager,
444                syncContextFactory,
445                offlineController,
446                remoteRepositoryFilterManager);
447    }
448
449    // Maven provided
450
451    protected Map<String, MetadataGeneratorFactory> getMetadataGeneratorFactories() {
452        // from maven-resolver-provider
453        HashMap<String, MetadataGeneratorFactory> result = new HashMap<>();
454        result.put("plugins", new PluginsMetadataGeneratorFactory());
455        result.put("versions", new VersionsMetadataGeneratorFactory());
456        result.put("snapshot", new SnapshotMetadataGeneratorFactory());
457        return result;
458    }
459
460    protected ArtifactDescriptorReader getArtifactDescriptorReader(
461            RemoteRepositoryManager remoteRepositoryManager,
462            VersionResolver versionResolver,
463            VersionRangeResolver versionRangeResolver,
464            ArtifactResolver artifactResolver,
465            ModelBuilder modelBuilder,
466            RepositoryEventDispatcher repositoryEventDispatcher,
467            ModelCacheFactory modelCacheFactory) {
468        // from maven-resolver-provider
469        DefaultArtifactDescriptorReader result = new DefaultArtifactDescriptorReader();
470        result.setRemoteRepositoryManager(remoteRepositoryManager);
471        result.setVersionResolver(versionResolver);
472        result.setVersionRangeResolver(versionRangeResolver);
473        result.setArtifactResolver(artifactResolver);
474        result.setModelBuilder(modelBuilder);
475        result.setRepositoryEventDispatcher(repositoryEventDispatcher);
476        result.setModelCacheFactory(modelCacheFactory);
477        return result;
478    }
479
480    protected VersionResolver getVersionResolver(
481            MetadataResolver metadataResolver,
482            SyncContextFactory syncContextFactory,
483            RepositoryEventDispatcher repositoryEventDispatcher) {
484        // from maven-resolver-provider
485        DefaultVersionResolver result = new DefaultVersionResolver();
486        result.setMetadataResolver(metadataResolver);
487        result.setSyncContextFactory(syncContextFactory);
488        result.setRepositoryEventDispatcher(repositoryEventDispatcher);
489        return result;
490    }
491
492    protected VersionRangeResolver getVersionRangeResolver(
493            MetadataResolver metadataResolver,
494            SyncContextFactory syncContextFactory,
495            RepositoryEventDispatcher repositoryEventDispatcher) {
496        // from maven-resolver-provider
497        DefaultVersionRangeResolver result = new DefaultVersionRangeResolver();
498        result.setMetadataResolver(metadataResolver);
499        result.setSyncContextFactory(syncContextFactory);
500        result.setRepositoryEventDispatcher(repositoryEventDispatcher);
501        return result;
502    }
503
504    protected ModelBuilder getModelBuilder() {
505        // from maven-model-builder
506        return new DefaultModelBuilderFactory().newInstance();
507    }
508
509    protected ModelCacheFactory getModelCacheFactory() {
510        // from maven-resolver-provider
511        return new DefaultModelCacheFactory();
512    }
513
514    @Override
515    public RepositorySystem get() {
516        FileProcessor fileProcessor = getFileProcessor();
517        TrackingFileManager trackingFileManager = getTrackingFileManager();
518        LocalPathComposer localPathComposer = getLocalPathComposer();
519        LocalPathPrefixComposerFactory localPathPrefixComposerFactory = getLocalPathPrefixComposerFactory();
520        RepositorySystemLifecycle repositorySystemLifecycle = getRepositorySystemLifecycle();
521        OfflineController offlineController = getOfflineController();
522        UpdatePolicyAnalyzer updatePolicyAnalyzer = getUpdatePolicyAnalyzer();
523        ChecksumPolicyProvider checksumPolicyProvider = getChecksumPolicyProvider();
524
525        UpdateCheckManager updateCheckManager = getUpdateCheckManager(trackingFileManager, updatePolicyAnalyzer);
526
527        Map<String, NamedLockFactory> namedLockFactories = getNamedLockFactories();
528        Map<String, NameMapper> nameMappers = getNameMappers();
529        NamedLockFactoryAdapterFactory namedLockFactoryAdapterFactory =
530                getNamedLockFactoryAdapterFactory(namedLockFactories, nameMappers, repositorySystemLifecycle);
531        SyncContextFactory syncContextFactory = getSyncContextFactory(namedLockFactoryAdapterFactory);
532
533        Map<String, ChecksumAlgorithmFactory> checksumAlgorithmFactories = getChecksumAlgorithmFactories();
534        ChecksumAlgorithmFactorySelector checksumAlgorithmFactorySelector =
535                getChecksumAlgorithmFactorySelector(checksumAlgorithmFactories);
536
537        Map<String, RepositoryLayoutFactory> repositoryLayoutFactories =
538                getRepositoryLayoutFactories(checksumAlgorithmFactorySelector);
539        RepositoryLayoutProvider repositoryLayoutProvider = getRepositoryLayoutProvider(repositoryLayoutFactories);
540
541        LocalRepositoryProvider localRepositoryProvider =
542                getLocalRepositoryProvider(localPathComposer, trackingFileManager, localPathPrefixComposerFactory);
543
544        RemoteRepositoryManager remoteRepositoryManager =
545                getRemoteRepositoryManager(updatePolicyAnalyzer, checksumPolicyProvider);
546        Map<String, RemoteRepositoryFilterSource> remoteRepositoryFilterSources =
547                getRemoteRepositoryFilterSources(repositorySystemLifecycle, repositoryLayoutProvider);
548        RemoteRepositoryFilterManager remoteRepositoryFilterManager =
549                getRemoteRepositoryFilterManager(remoteRepositoryFilterSources);
550
551        Map<String, RepositoryListener> repositoryListeners = getRepositoryListeners();
552        RepositoryEventDispatcher repositoryEventDispatcher = getRepositoryEventDispatcher(repositoryListeners);
553
554        Map<String, TrustedChecksumsSource> trustedChecksumsSources =
555                getTrustedChecksumsSources(fileProcessor, localPathComposer, repositorySystemLifecycle);
556        Map<String, ProvidedChecksumsSource> providedChecksumsSources =
557                getProvidedChecksumsSources(trustedChecksumsSources);
558
559        Map<String, ChecksumExtractor> checksumExtractors = getChecksumExtractors();
560        Map<String, TransporterFactory> transporterFactories = getTransporterFactories(checksumExtractors);
561        TransporterProvider transporterProvider = getTransporterProvider(transporterFactories);
562
563        BasicRepositoryConnectorFactory basic = getBasicRepositoryConnectorFactory(
564                transporterProvider,
565                repositoryLayoutProvider,
566                checksumPolicyProvider,
567                fileProcessor,
568                providedChecksumsSources);
569        Map<String, RepositoryConnectorFactory> repositoryConnectorFactories = getRepositoryConnectorFactories(basic);
570        RepositoryConnectorProvider repositoryConnectorProvider =
571                getRepositoryConnectorProvider(repositoryConnectorFactories, remoteRepositoryFilterManager);
572
573        Map<String, MetadataGeneratorFactory> metadataGeneratorFactories = getMetadataGeneratorFactories();
574
575        Installer installer =
576                getInstaller(fileProcessor, repositoryEventDispatcher, metadataGeneratorFactories, syncContextFactory);
577        Deployer deployer = getDeployer(
578                fileProcessor,
579                repositoryEventDispatcher,
580                repositoryConnectorProvider,
581                remoteRepositoryManager,
582                updateCheckManager,
583                metadataGeneratorFactories,
584                syncContextFactory,
585                offlineController);
586
587        MetadataResolver metadataResolver = getMetadataResolver(
588                repositoryEventDispatcher,
589                updateCheckManager,
590                repositoryConnectorProvider,
591                remoteRepositoryManager,
592                syncContextFactory,
593                offlineController,
594                remoteRepositoryFilterManager);
595
596        VersionResolver versionResolver =
597                getVersionResolver(metadataResolver, syncContextFactory, repositoryEventDispatcher);
598        VersionRangeResolver versionRangeResolver =
599                getVersionRangeResolver(metadataResolver, syncContextFactory, repositoryEventDispatcher);
600
601        Map<String, ArtifactResolverPostProcessor> artifactResolverPostProcessors =
602                getArtifactResolverPostProcessors(checksumAlgorithmFactorySelector, trustedChecksumsSources);
603        ArtifactResolver artifactResolver = getArtifactResolver(
604                fileProcessor,
605                repositoryEventDispatcher,
606                versionResolver,
607                updateCheckManager,
608                repositoryConnectorProvider,
609                remoteRepositoryManager,
610                syncContextFactory,
611                offlineController,
612                artifactResolverPostProcessors,
613                remoteRepositoryFilterManager);
614
615        ModelBuilder modelBuilder = getModelBuilder();
616        ModelCacheFactory modelCacheFactory = getModelCacheFactory();
617
618        ArtifactDescriptorReader artifactDescriptorReader = getArtifactDescriptorReader(
619                remoteRepositoryManager,
620                versionResolver,
621                versionRangeResolver,
622                artifactResolver,
623                modelBuilder,
624                repositoryEventDispatcher,
625                modelCacheFactory);
626
627        Map<String, DependencyCollectorDelegate> dependencyCollectorDelegates = getDependencyCollectorDelegates(
628                remoteRepositoryManager, artifactDescriptorReader, versionRangeResolver);
629        DependencyCollector dependencyCollector = getDependencyCollector(dependencyCollectorDelegates);
630
631        return new DefaultRepositorySystem(
632                versionResolver,
633                versionRangeResolver,
634                artifactResolver,
635                metadataResolver,
636                artifactDescriptorReader,
637                dependencyCollector,
638                installer,
639                deployer,
640                localRepositoryProvider,
641                syncContextFactory,
642                remoteRepositoryManager,
643                repositorySystemLifecycle);
644    }
645}