View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements.  See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership.  The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License.  You may obtain a copy of the License at
9    *
10   *   http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing,
13   * software distributed under the License is distributed on an
14   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   * KIND, either express or implied.  See the License for the
16   * specific language governing permissions and limitations
17   * under the License.
18   */
19  package org.eclipse.aether.supplier;
20  
21  import java.util.HashMap;
22  import java.util.HashSet;
23  import java.util.Map;
24  import java.util.function.Supplier;
25  
26  import org.apache.maven.model.building.DefaultModelBuilderFactory;
27  import org.apache.maven.model.building.ModelBuilder;
28  import org.apache.maven.repository.internal.DefaultArtifactDescriptorReader;
29  import org.apache.maven.repository.internal.DefaultModelCacheFactory;
30  import org.apache.maven.repository.internal.DefaultVersionRangeResolver;
31  import org.apache.maven.repository.internal.DefaultVersionResolver;
32  import org.apache.maven.repository.internal.ModelCacheFactory;
33  import org.apache.maven.repository.internal.PluginsMetadataGeneratorFactory;
34  import org.apache.maven.repository.internal.SnapshotMetadataGeneratorFactory;
35  import org.apache.maven.repository.internal.VersionsMetadataGeneratorFactory;
36  import org.eclipse.aether.RepositoryListener;
37  import org.eclipse.aether.RepositorySystem;
38  import org.eclipse.aether.connector.basic.BasicRepositoryConnectorFactory;
39  import org.eclipse.aether.impl.ArtifactDescriptorReader;
40  import org.eclipse.aether.impl.ArtifactResolver;
41  import org.eclipse.aether.impl.DependencyCollector;
42  import org.eclipse.aether.impl.Deployer;
43  import org.eclipse.aether.impl.Installer;
44  import org.eclipse.aether.impl.LocalRepositoryProvider;
45  import org.eclipse.aether.impl.MetadataGeneratorFactory;
46  import org.eclipse.aether.impl.MetadataResolver;
47  import org.eclipse.aether.impl.OfflineController;
48  import org.eclipse.aether.impl.RemoteRepositoryFilterManager;
49  import org.eclipse.aether.impl.RemoteRepositoryManager;
50  import org.eclipse.aether.impl.RepositoryConnectorProvider;
51  import org.eclipse.aether.impl.RepositoryEventDispatcher;
52  import org.eclipse.aether.impl.RepositorySystemLifecycle;
53  import org.eclipse.aether.impl.UpdateCheckManager;
54  import org.eclipse.aether.impl.UpdatePolicyAnalyzer;
55  import org.eclipse.aether.impl.VersionRangeResolver;
56  import org.eclipse.aether.impl.VersionResolver;
57  import org.eclipse.aether.internal.impl.DefaultArtifactResolver;
58  import org.eclipse.aether.internal.impl.DefaultChecksumPolicyProvider;
59  import org.eclipse.aether.internal.impl.DefaultDeployer;
60  import org.eclipse.aether.internal.impl.DefaultFileProcessor;
61  import org.eclipse.aether.internal.impl.DefaultInstaller;
62  import org.eclipse.aether.internal.impl.DefaultLocalPathComposer;
63  import org.eclipse.aether.internal.impl.DefaultLocalPathPrefixComposerFactory;
64  import org.eclipse.aether.internal.impl.DefaultLocalRepositoryProvider;
65  import org.eclipse.aether.internal.impl.DefaultMetadataResolver;
66  import org.eclipse.aether.internal.impl.DefaultOfflineController;
67  import org.eclipse.aether.internal.impl.DefaultRemoteRepositoryManager;
68  import org.eclipse.aether.internal.impl.DefaultRepositoryConnectorProvider;
69  import org.eclipse.aether.internal.impl.DefaultRepositoryEventDispatcher;
70  import org.eclipse.aether.internal.impl.DefaultRepositoryLayoutProvider;
71  import org.eclipse.aether.internal.impl.DefaultRepositorySystem;
72  import org.eclipse.aether.internal.impl.DefaultRepositorySystemLifecycle;
73  import org.eclipse.aether.internal.impl.DefaultTrackingFileManager;
74  import org.eclipse.aether.internal.impl.DefaultTransporterProvider;
75  import org.eclipse.aether.internal.impl.DefaultUpdateCheckManager;
76  import org.eclipse.aether.internal.impl.DefaultUpdatePolicyAnalyzer;
77  import org.eclipse.aether.internal.impl.EnhancedLocalRepositoryManagerFactory;
78  import org.eclipse.aether.internal.impl.LocalPathComposer;
79  import org.eclipse.aether.internal.impl.LocalPathPrefixComposerFactory;
80  import org.eclipse.aether.internal.impl.Maven2RepositoryLayoutFactory;
81  import org.eclipse.aether.internal.impl.SimpleLocalRepositoryManagerFactory;
82  import org.eclipse.aether.internal.impl.TrackingFileManager;
83  import org.eclipse.aether.internal.impl.checksum.DefaultChecksumAlgorithmFactorySelector;
84  import org.eclipse.aether.internal.impl.checksum.Md5ChecksumAlgorithmFactory;
85  import org.eclipse.aether.internal.impl.checksum.Sha1ChecksumAlgorithmFactory;
86  import org.eclipse.aether.internal.impl.checksum.Sha256ChecksumAlgorithmFactory;
87  import org.eclipse.aether.internal.impl.checksum.Sha512ChecksumAlgorithmFactory;
88  import org.eclipse.aether.internal.impl.checksum.SparseDirectoryTrustedChecksumsSource;
89  import org.eclipse.aether.internal.impl.checksum.SummaryFileTrustedChecksumsSource;
90  import org.eclipse.aether.internal.impl.checksum.TrustedToProvidedChecksumsSourceAdapter;
91  import org.eclipse.aether.internal.impl.collect.DefaultDependencyCollector;
92  import org.eclipse.aether.internal.impl.collect.DependencyCollectorDelegate;
93  import org.eclipse.aether.internal.impl.collect.bf.BfDependencyCollector;
94  import org.eclipse.aether.internal.impl.collect.df.DfDependencyCollector;
95  import org.eclipse.aether.internal.impl.filter.DefaultRemoteRepositoryFilterManager;
96  import org.eclipse.aether.internal.impl.filter.GroupIdRemoteRepositoryFilterSource;
97  import org.eclipse.aether.internal.impl.filter.PrefixesRemoteRepositoryFilterSource;
98  import org.eclipse.aether.internal.impl.resolution.TrustedChecksumsArtifactResolverPostProcessor;
99  import org.eclipse.aether.internal.impl.synccontext.DefaultSyncContextFactory;
100 import org.eclipse.aether.internal.impl.synccontext.named.NameMapper;
101 import org.eclipse.aether.internal.impl.synccontext.named.NameMappers;
102 import org.eclipse.aether.internal.impl.synccontext.named.NamedLockFactoryAdapterFactory;
103 import org.eclipse.aether.internal.impl.synccontext.named.NamedLockFactoryAdapterFactoryImpl;
104 import org.eclipse.aether.named.NamedLockFactory;
105 import org.eclipse.aether.named.providers.FileLockNamedLockFactory;
106 import org.eclipse.aether.named.providers.LocalReadWriteLockNamedLockFactory;
107 import org.eclipse.aether.named.providers.LocalSemaphoreNamedLockFactory;
108 import org.eclipse.aether.named.providers.NoopNamedLockFactory;
109 import org.eclipse.aether.spi.checksums.ProvidedChecksumsSource;
110 import org.eclipse.aether.spi.checksums.TrustedChecksumsSource;
111 import org.eclipse.aether.spi.connector.RepositoryConnectorFactory;
112 import org.eclipse.aether.spi.connector.checksum.ChecksumAlgorithmFactory;
113 import org.eclipse.aether.spi.connector.checksum.ChecksumAlgorithmFactorySelector;
114 import org.eclipse.aether.spi.connector.checksum.ChecksumPolicyProvider;
115 import org.eclipse.aether.spi.connector.filter.RemoteRepositoryFilterSource;
116 import org.eclipse.aether.spi.connector.layout.RepositoryLayoutFactory;
117 import org.eclipse.aether.spi.connector.layout.RepositoryLayoutProvider;
118 import org.eclipse.aether.spi.connector.transport.TransporterFactory;
119 import org.eclipse.aether.spi.connector.transport.TransporterProvider;
120 import org.eclipse.aether.spi.io.FileProcessor;
121 import org.eclipse.aether.spi.localrepo.LocalRepositoryManagerFactory;
122 import org.eclipse.aether.spi.resolution.ArtifactResolverPostProcessor;
123 import org.eclipse.aether.spi.synccontext.SyncContextFactory;
124 import org.eclipse.aether.transport.file.FileTransporterFactory;
125 import org.eclipse.aether.transport.http.ChecksumExtractor;
126 import org.eclipse.aether.transport.http.HttpTransporterFactory;
127 import org.eclipse.aether.transport.http.Nexus2ChecksumExtractor;
128 import 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  */
138 public 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 }