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