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.*;
30 import org.apache.maven.repository.internal.relocation.DistributionManagementArtifactRelocationSource;
31 import org.apache.maven.repository.internal.relocation.UserPropertiesArtifactRelocationSource;
32 import org.eclipse.aether.RepositoryListener;
33 import org.eclipse.aether.RepositorySystem;
34 import org.eclipse.aether.connector.basic.BasicRepositoryConnectorFactory;
35 import org.eclipse.aether.impl.ArtifactDescriptorReader;
36 import org.eclipse.aether.impl.ArtifactResolver;
37 import org.eclipse.aether.impl.DependencyCollector;
38 import org.eclipse.aether.impl.Deployer;
39 import org.eclipse.aether.impl.Installer;
40 import org.eclipse.aether.impl.LocalRepositoryProvider;
41 import org.eclipse.aether.impl.MetadataGeneratorFactory;
42 import org.eclipse.aether.impl.MetadataResolver;
43 import org.eclipse.aether.impl.OfflineController;
44 import org.eclipse.aether.impl.RemoteRepositoryFilterManager;
45 import org.eclipse.aether.impl.RemoteRepositoryManager;
46 import org.eclipse.aether.impl.RepositoryConnectorProvider;
47 import org.eclipse.aether.impl.RepositoryEventDispatcher;
48 import org.eclipse.aether.impl.RepositorySystemLifecycle;
49 import org.eclipse.aether.impl.UpdateCheckManager;
50 import org.eclipse.aether.impl.UpdatePolicyAnalyzer;
51 import org.eclipse.aether.impl.VersionRangeResolver;
52 import org.eclipse.aether.impl.VersionResolver;
53 import org.eclipse.aether.internal.impl.*;
54 import org.eclipse.aether.internal.impl.checksum.DefaultChecksumAlgorithmFactorySelector;
55 import org.eclipse.aether.internal.impl.checksum.Md5ChecksumAlgorithmFactory;
56 import org.eclipse.aether.internal.impl.checksum.Sha1ChecksumAlgorithmFactory;
57 import org.eclipse.aether.internal.impl.checksum.Sha256ChecksumAlgorithmFactory;
58 import org.eclipse.aether.internal.impl.checksum.Sha512ChecksumAlgorithmFactory;
59 import org.eclipse.aether.internal.impl.checksum.SparseDirectoryTrustedChecksumsSource;
60 import org.eclipse.aether.internal.impl.checksum.SummaryFileTrustedChecksumsSource;
61 import org.eclipse.aether.internal.impl.checksum.TrustedToProvidedChecksumsSourceAdapter;
62 import org.eclipse.aether.internal.impl.collect.DefaultDependencyCollector;
63 import org.eclipse.aether.internal.impl.collect.DependencyCollectorDelegate;
64 import org.eclipse.aether.internal.impl.collect.bf.BfDependencyCollector;
65 import org.eclipse.aether.internal.impl.collect.df.DfDependencyCollector;
66 import org.eclipse.aether.internal.impl.filter.DefaultRemoteRepositoryFilterManager;
67 import org.eclipse.aether.internal.impl.filter.GroupIdRemoteRepositoryFilterSource;
68 import org.eclipse.aether.internal.impl.filter.PrefixesRemoteRepositoryFilterSource;
69 import org.eclipse.aether.internal.impl.resolution.TrustedChecksumsArtifactResolverPostProcessor;
70 import org.eclipse.aether.internal.impl.synccontext.DefaultSyncContextFactory;
71 import org.eclipse.aether.internal.impl.synccontext.named.NameMapper;
72 import org.eclipse.aether.internal.impl.synccontext.named.NameMappers;
73 import org.eclipse.aether.internal.impl.synccontext.named.NamedLockFactoryAdapterFactory;
74 import org.eclipse.aether.internal.impl.synccontext.named.NamedLockFactoryAdapterFactoryImpl;
75 import org.eclipse.aether.internal.impl.transport.http.DefaultChecksumExtractor;
76 import org.eclipse.aether.internal.impl.transport.http.Nx2ChecksumExtractor;
77 import org.eclipse.aether.internal.impl.transport.http.XChecksumExtractor;
78 import org.eclipse.aether.named.NamedLockFactory;
79 import org.eclipse.aether.named.providers.FileLockNamedLockFactory;
80 import org.eclipse.aether.named.providers.LocalReadWriteLockNamedLockFactory;
81 import org.eclipse.aether.named.providers.LocalSemaphoreNamedLockFactory;
82 import org.eclipse.aether.named.providers.NoopNamedLockFactory;
83 import org.eclipse.aether.spi.checksums.ProvidedChecksumsSource;
84 import org.eclipse.aether.spi.checksums.TrustedChecksumsSource;
85 import org.eclipse.aether.spi.connector.RepositoryConnectorFactory;
86 import org.eclipse.aether.spi.connector.checksum.ChecksumAlgorithmFactory;
87 import org.eclipse.aether.spi.connector.checksum.ChecksumAlgorithmFactorySelector;
88 import org.eclipse.aether.spi.connector.checksum.ChecksumPolicyProvider;
89 import org.eclipse.aether.spi.connector.filter.RemoteRepositoryFilterSource;
90 import org.eclipse.aether.spi.connector.layout.RepositoryLayoutFactory;
91 import org.eclipse.aether.spi.connector.layout.RepositoryLayoutProvider;
92 import org.eclipse.aether.spi.connector.transport.TransporterFactory;
93 import org.eclipse.aether.spi.connector.transport.TransporterProvider;
94 import org.eclipse.aether.spi.connector.transport.http.ChecksumExtractor;
95 import org.eclipse.aether.spi.connector.transport.http.ChecksumExtractorStrategy;
96 import org.eclipse.aether.spi.io.FileProcessor;
97 import org.eclipse.aether.spi.localrepo.LocalRepositoryManagerFactory;
98 import org.eclipse.aether.spi.resolution.ArtifactResolverPostProcessor;
99 import org.eclipse.aether.spi.synccontext.SyncContextFactory;
100 import org.eclipse.aether.transport.apache.ApacheTransporterFactory;
101 import org.eclipse.aether.transport.file.FileTransporterFactory;
102 import org.eclipse.aether.util.version.GenericVersionScheme;
103 import org.eclipse.aether.version.VersionScheme;
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128 public class RepositorySystemSupplier implements Supplier<RepositorySystem> {
129 private final AtomicBoolean closed = new AtomicBoolean(false);
130
131 public RepositorySystemSupplier() {}
132
133 private void checkClosed() {
134 if (closed.get()) {
135 throw new IllegalStateException("Supplier is closed");
136 }
137 }
138
139 private FileProcessor fileProcessor;
140
141 public final FileProcessor getFileProcessor() {
142 checkClosed();
143 if (fileProcessor == null) {
144 fileProcessor = createFileProcessor();
145 }
146 return fileProcessor;
147 }
148
149 protected FileProcessor createFileProcessor() {
150 return new DefaultFileProcessor();
151 }
152
153 private TrackingFileManager trackingFileManager;
154
155 public final TrackingFileManager getTrackingFileManager() {
156 checkClosed();
157 if (trackingFileManager == null) {
158 trackingFileManager = createTrackingFileManager();
159 }
160 return trackingFileManager;
161 }
162
163 protected TrackingFileManager createTrackingFileManager() {
164 return new DefaultTrackingFileManager();
165 }
166
167 private LocalPathComposer localPathComposer;
168
169 public final LocalPathComposer getLocalPathComposer() {
170 checkClosed();
171 if (localPathComposer == null) {
172 localPathComposer = createLocalPathComposer();
173 }
174 return localPathComposer;
175 }
176
177 protected LocalPathComposer createLocalPathComposer() {
178 return new DefaultLocalPathComposer();
179 }
180
181 private LocalPathPrefixComposerFactory localPathPrefixComposerFactory;
182
183 public final LocalPathPrefixComposerFactory getLocalPathPrefixComposerFactory() {
184 checkClosed();
185 if (localPathPrefixComposerFactory == null) {
186 localPathPrefixComposerFactory = createLocalPathPrefixComposerFactory();
187 }
188 return localPathPrefixComposerFactory;
189 }
190
191 protected LocalPathPrefixComposerFactory createLocalPathPrefixComposerFactory() {
192 return new DefaultLocalPathPrefixComposerFactory();
193 }
194
195 private RepositorySystemLifecycle repositorySystemLifecycle;
196
197 public final RepositorySystemLifecycle getRepositorySystemLifecycle() {
198 checkClosed();
199 if (repositorySystemLifecycle == null) {
200 repositorySystemLifecycle = createRepositorySystemLifecycle();
201 repositorySystemLifecycle.addOnSystemEndedHandler(() -> closed.set(true));
202 }
203 return repositorySystemLifecycle;
204 }
205
206 protected RepositorySystemLifecycle createRepositorySystemLifecycle() {
207 return new DefaultRepositorySystemLifecycle();
208 }
209
210 private OfflineController offlineController;
211
212 public final OfflineController getOfflineController() {
213 checkClosed();
214 if (offlineController == null) {
215 offlineController = createOfflineController();
216 }
217 return offlineController;
218 }
219
220 protected OfflineController createOfflineController() {
221 return new DefaultOfflineController();
222 }
223
224 private UpdatePolicyAnalyzer updatePolicyAnalyzer;
225
226 public final UpdatePolicyAnalyzer getUpdatePolicyAnalyzer() {
227 checkClosed();
228 if (updatePolicyAnalyzer == null) {
229 updatePolicyAnalyzer = createUpdatePolicyAnalyzer();
230 }
231 return updatePolicyAnalyzer;
232 }
233
234 protected UpdatePolicyAnalyzer createUpdatePolicyAnalyzer() {
235 return new DefaultUpdatePolicyAnalyzer();
236 }
237
238 private ChecksumPolicyProvider checksumPolicyProvider;
239
240 public final ChecksumPolicyProvider getChecksumPolicyProvider() {
241 checkClosed();
242 if (checksumPolicyProvider == null) {
243 checksumPolicyProvider = createChecksumPolicyProvider();
244 }
245 return checksumPolicyProvider;
246 }
247
248 protected ChecksumPolicyProvider createChecksumPolicyProvider() {
249 return new DefaultChecksumPolicyProvider();
250 }
251
252 private UpdateCheckManager updateCheckManager;
253
254 public final UpdateCheckManager getUpdateCheckManager() {
255 checkClosed();
256 if (updateCheckManager == null) {
257 updateCheckManager = createUpdateCheckManager();
258 }
259 return updateCheckManager;
260 }
261
262 protected UpdateCheckManager createUpdateCheckManager() {
263 return new DefaultUpdateCheckManager(getTrackingFileManager(), getUpdatePolicyAnalyzer());
264 }
265
266 private Map<String, NamedLockFactory> namedLockFactories;
267
268 public final Map<String, NamedLockFactory> getNamedLockFactories() {
269 checkClosed();
270 if (namedLockFactories == null) {
271 namedLockFactories = createNamedLockFactories();
272 }
273 return namedLockFactories;
274 }
275
276 protected Map<String, NamedLockFactory> createNamedLockFactories() {
277 HashMap<String, NamedLockFactory> result = new HashMap<>();
278 result.put(NoopNamedLockFactory.NAME, new NoopNamedLockFactory());
279 result.put(LocalReadWriteLockNamedLockFactory.NAME, new LocalReadWriteLockNamedLockFactory());
280 result.put(LocalSemaphoreNamedLockFactory.NAME, new LocalSemaphoreNamedLockFactory());
281 result.put(FileLockNamedLockFactory.NAME, new FileLockNamedLockFactory());
282 return result;
283 }
284
285 private Map<String, NameMapper> nameMappers;
286
287 public final Map<String, NameMapper> getNameMappers() {
288 checkClosed();
289 if (nameMappers == null) {
290 nameMappers = createNameMappers();
291 }
292 return nameMappers;
293 }
294
295 protected Map<String, NameMapper> createNameMappers() {
296 HashMap<String, NameMapper> result = new HashMap<>();
297 result.put(NameMappers.STATIC_NAME, NameMappers.staticNameMapper());
298 result.put(NameMappers.GAV_NAME, NameMappers.gavNameMapper());
299 result.put(NameMappers.DISCRIMINATING_NAME, NameMappers.discriminatingNameMapper());
300 result.put(NameMappers.FILE_GAV_NAME, NameMappers.fileGavNameMapper());
301 result.put(NameMappers.FILE_HGAV_NAME, NameMappers.fileHashingGavNameMapper());
302 return result;
303 }
304
305 private NamedLockFactoryAdapterFactory namedLockFactoryAdapterFactory;
306
307 public final NamedLockFactoryAdapterFactory getNamedLockFactoryAdapterFactory() {
308 checkClosed();
309 if (namedLockFactoryAdapterFactory == null) {
310 namedLockFactoryAdapterFactory = createNamedLockFactoryAdapterFactory();
311 }
312 return namedLockFactoryAdapterFactory;
313 }
314
315 protected NamedLockFactoryAdapterFactory createNamedLockFactoryAdapterFactory() {
316 return new NamedLockFactoryAdapterFactoryImpl(
317 getNamedLockFactories(), getNameMappers(), getRepositorySystemLifecycle());
318 }
319
320 private SyncContextFactory syncContextFactory;
321
322 public final SyncContextFactory getSyncContextFactory() {
323 checkClosed();
324 if (syncContextFactory == null) {
325 syncContextFactory = createSyncContextFactory();
326 }
327 return syncContextFactory;
328 }
329
330 protected SyncContextFactory createSyncContextFactory() {
331 return new DefaultSyncContextFactory(getNamedLockFactoryAdapterFactory());
332 }
333
334 private Map<String, ChecksumAlgorithmFactory> checksumAlgorithmFactories;
335
336 public final Map<String, ChecksumAlgorithmFactory> getChecksumAlgorithmFactories() {
337 checkClosed();
338 if (checksumAlgorithmFactories == null) {
339 checksumAlgorithmFactories = createChecksumAlgorithmFactories();
340 }
341 return checksumAlgorithmFactories;
342 }
343
344 protected Map<String, ChecksumAlgorithmFactory> createChecksumAlgorithmFactories() {
345 HashMap<String, ChecksumAlgorithmFactory> result = new HashMap<>();
346 result.put(Sha512ChecksumAlgorithmFactory.NAME, new Sha512ChecksumAlgorithmFactory());
347 result.put(Sha256ChecksumAlgorithmFactory.NAME, new Sha256ChecksumAlgorithmFactory());
348 result.put(Sha1ChecksumAlgorithmFactory.NAME, new Sha1ChecksumAlgorithmFactory());
349 result.put(Md5ChecksumAlgorithmFactory.NAME, new Md5ChecksumAlgorithmFactory());
350 return result;
351 }
352
353 private ChecksumAlgorithmFactorySelector checksumAlgorithmFactorySelector;
354
355 public final ChecksumAlgorithmFactorySelector getChecksumAlgorithmFactorySelector() {
356 checkClosed();
357 if (checksumAlgorithmFactorySelector == null) {
358 checksumAlgorithmFactorySelector = createChecksumAlgorithmFactorySelector();
359 }
360 return checksumAlgorithmFactorySelector;
361 }
362
363 protected ChecksumAlgorithmFactorySelector createChecksumAlgorithmFactorySelector() {
364 return new DefaultChecksumAlgorithmFactorySelector(getChecksumAlgorithmFactories());
365 }
366
367 private Map<String, RepositoryLayoutFactory> repositoryLayoutFactories;
368
369 public final Map<String, RepositoryLayoutFactory> getRepositoryLayoutFactories() {
370 checkClosed();
371 if (repositoryLayoutFactories == null) {
372 repositoryLayoutFactories = createRepositoryLayoutFactories();
373 }
374 return repositoryLayoutFactories;
375 }
376
377 protected Map<String, RepositoryLayoutFactory> createRepositoryLayoutFactories() {
378 HashMap<String, RepositoryLayoutFactory> result = new HashMap<>();
379 result.put(
380 Maven2RepositoryLayoutFactory.NAME,
381 new Maven2RepositoryLayoutFactory(getChecksumAlgorithmFactorySelector()));
382 return result;
383 }
384
385 private RepositoryLayoutProvider repositoryLayoutProvider;
386
387 public final RepositoryLayoutProvider getRepositoryLayoutProvider() {
388 checkClosed();
389 if (repositoryLayoutProvider == null) {
390 repositoryLayoutProvider = createRepositoryLayoutProvider();
391 }
392 return repositoryLayoutProvider;
393 }
394
395 protected RepositoryLayoutProvider createRepositoryLayoutProvider() {
396 return new DefaultRepositoryLayoutProvider(getRepositoryLayoutFactories());
397 }
398
399 private LocalRepositoryProvider localRepositoryProvider;
400
401 public final LocalRepositoryProvider getLocalRepositoryProvider() {
402 checkClosed();
403 if (localRepositoryProvider == null) {
404 localRepositoryProvider = createLocalRepositoryProvider();
405 }
406 return localRepositoryProvider;
407 }
408
409 protected LocalRepositoryProvider createLocalRepositoryProvider() {
410 LocalPathComposer localPathComposer = getLocalPathComposer();
411 HashMap<String, LocalRepositoryManagerFactory> localRepositoryProviders = new HashMap<>(2);
412 localRepositoryProviders.put(
413 SimpleLocalRepositoryManagerFactory.NAME, new SimpleLocalRepositoryManagerFactory(localPathComposer));
414 localRepositoryProviders.put(
415 EnhancedLocalRepositoryManagerFactory.NAME,
416 new EnhancedLocalRepositoryManagerFactory(
417 localPathComposer, getTrackingFileManager(), getLocalPathPrefixComposerFactory()));
418 return new DefaultLocalRepositoryProvider(localRepositoryProviders);
419 }
420
421 private RemoteRepositoryManager remoteRepositoryManager;
422
423 public final RemoteRepositoryManager getRemoteRepositoryManager() {
424 checkClosed();
425 if (remoteRepositoryManager == null) {
426 remoteRepositoryManager = createRemoteRepositoryManager();
427 }
428 return remoteRepositoryManager;
429 }
430
431 protected RemoteRepositoryManager createRemoteRepositoryManager() {
432 return new DefaultRemoteRepositoryManager(getUpdatePolicyAnalyzer(), getChecksumPolicyProvider());
433 }
434
435 private Map<String, RemoteRepositoryFilterSource> remoteRepositoryFilterSources;
436
437 public final Map<String, RemoteRepositoryFilterSource> getRemoteRepositoryFilterSources() {
438 checkClosed();
439 if (remoteRepositoryFilterSources == null) {
440 remoteRepositoryFilterSources = createRemoteRepositoryFilterSources();
441 }
442 return remoteRepositoryFilterSources;
443 }
444
445 protected Map<String, RemoteRepositoryFilterSource> createRemoteRepositoryFilterSources() {
446 HashMap<String, RemoteRepositoryFilterSource> result = new HashMap<>();
447 result.put(
448 GroupIdRemoteRepositoryFilterSource.NAME,
449 new GroupIdRemoteRepositoryFilterSource(getRepositorySystemLifecycle()));
450 result.put(
451 PrefixesRemoteRepositoryFilterSource.NAME,
452 new PrefixesRemoteRepositoryFilterSource(getRepositoryLayoutProvider()));
453 return result;
454 }
455
456 private RemoteRepositoryFilterManager remoteRepositoryFilterManager;
457
458 public final RemoteRepositoryFilterManager getRemoteRepositoryFilterManager() {
459 checkClosed();
460 if (remoteRepositoryFilterManager == null) {
461 remoteRepositoryFilterManager = createRemoteRepositoryFilterManager();
462 }
463 return remoteRepositoryFilterManager;
464 }
465
466 protected RemoteRepositoryFilterManager createRemoteRepositoryFilterManager() {
467 return new DefaultRemoteRepositoryFilterManager(getRemoteRepositoryFilterSources());
468 }
469
470 private Map<String, RepositoryListener> repositoryListeners;
471
472 public final Map<String, RepositoryListener> getRepositoryListeners() {
473 checkClosed();
474 if (repositoryListeners == null) {
475 repositoryListeners = createRepositoryListeners();
476 }
477 return repositoryListeners;
478 }
479
480 protected Map<String, RepositoryListener> createRepositoryListeners() {
481 return new HashMap<>();
482 }
483
484 private RepositoryEventDispatcher repositoryEventDispatcher;
485
486 public final RepositoryEventDispatcher getRepositoryEventDispatcher() {
487 checkClosed();
488 if (repositoryEventDispatcher == null) {
489 repositoryEventDispatcher = createRepositoryEventDispatcher();
490 }
491 return repositoryEventDispatcher;
492 }
493
494 protected RepositoryEventDispatcher createRepositoryEventDispatcher() {
495 return new DefaultRepositoryEventDispatcher(getRepositoryListeners());
496 }
497
498 private Map<String, TrustedChecksumsSource> trustedChecksumsSources;
499
500 public final Map<String, TrustedChecksumsSource> getTrustedChecksumsSources() {
501 checkClosed();
502 if (trustedChecksumsSources == null) {
503 trustedChecksumsSources = createTrustedChecksumsSources();
504 }
505 return trustedChecksumsSources;
506 }
507
508 protected Map<String, TrustedChecksumsSource> createTrustedChecksumsSources() {
509 HashMap<String, TrustedChecksumsSource> result = new HashMap<>();
510 result.put(
511 SparseDirectoryTrustedChecksumsSource.NAME,
512 new SparseDirectoryTrustedChecksumsSource(getFileProcessor(), getLocalPathComposer()));
513 result.put(
514 SummaryFileTrustedChecksumsSource.NAME,
515 new SummaryFileTrustedChecksumsSource(getLocalPathComposer(), getRepositorySystemLifecycle()));
516 return result;
517 }
518
519 private Map<String, ProvidedChecksumsSource> providedChecksumsSources;
520
521 public final Map<String, ProvidedChecksumsSource> getProvidedChecksumsSources() {
522 checkClosed();
523 if (providedChecksumsSources == null) {
524 providedChecksumsSources = createProvidedChecksumsSources();
525 }
526 return providedChecksumsSources;
527 }
528
529 protected Map<String, ProvidedChecksumsSource> createProvidedChecksumsSources() {
530 HashMap<String, ProvidedChecksumsSource> result = new HashMap<>();
531 result.put(
532 TrustedToProvidedChecksumsSourceAdapter.NAME,
533 new TrustedToProvidedChecksumsSourceAdapter(getTrustedChecksumsSources()));
534 return result;
535 }
536
537 private Map<String, ChecksumExtractorStrategy> checksumExtractorStrategies;
538
539 public final Map<String, ChecksumExtractorStrategy> getChecksumExtractorStrategies() {
540 checkClosed();
541 if (checksumExtractorStrategies == null) {
542 checksumExtractorStrategies = createChecksumExtractorStrategies();
543 }
544 return checksumExtractorStrategies;
545 }
546
547 protected Map<String, ChecksumExtractorStrategy> createChecksumExtractorStrategies() {
548 HashMap<String, ChecksumExtractorStrategy> result = new HashMap<>();
549 result.put(XChecksumExtractor.NAME, new XChecksumExtractor());
550 result.put(Nx2ChecksumExtractor.NAME, new Nx2ChecksumExtractor());
551 return result;
552 }
553
554 private ChecksumExtractor checksumExtractor;
555
556 public final ChecksumExtractor getChecksumExtractor() {
557 checkClosed();
558 if (checksumExtractor == null) {
559 checksumExtractor = createChecksumExtractor();
560 }
561 return checksumExtractor;
562 }
563
564 protected ChecksumExtractor createChecksumExtractor() {
565 return new DefaultChecksumExtractor(getChecksumExtractorStrategies());
566 }
567
568 private Map<String, TransporterFactory> transporterFactories;
569
570 public final Map<String, TransporterFactory> getTransporterFactories() {
571 checkClosed();
572 if (transporterFactories == null) {
573 transporterFactories = createTransporterFactories();
574 }
575 return transporterFactories;
576 }
577
578 protected Map<String, TransporterFactory> createTransporterFactories() {
579 HashMap<String, TransporterFactory> result = new HashMap<>();
580 result.put(FileTransporterFactory.NAME, new FileTransporterFactory());
581 result.put(ApacheTransporterFactory.NAME, new ApacheTransporterFactory(getChecksumExtractor()));
582 return result;
583 }
584
585 private TransporterProvider transporterProvider;
586
587 public final TransporterProvider getTransporterProvider() {
588 checkClosed();
589 if (transporterProvider == null) {
590 transporterProvider = createTransporterProvider();
591 }
592 return transporterProvider;
593 }
594
595 protected TransporterProvider createTransporterProvider() {
596 return new DefaultTransporterProvider(getTransporterFactories());
597 }
598
599 private BasicRepositoryConnectorFactory basicRepositoryConnectorFactory;
600
601 public final BasicRepositoryConnectorFactory getBasicRepositoryConnectorFactory() {
602 checkClosed();
603 if (basicRepositoryConnectorFactory == null) {
604 basicRepositoryConnectorFactory = createBasicRepositoryConnectorFactory();
605 }
606 return basicRepositoryConnectorFactory;
607 }
608
609 protected BasicRepositoryConnectorFactory createBasicRepositoryConnectorFactory() {
610 return new BasicRepositoryConnectorFactory(
611 getTransporterProvider(),
612 getRepositoryLayoutProvider(),
613 getChecksumPolicyProvider(),
614 getFileProcessor(),
615 getProvidedChecksumsSources());
616 }
617
618 private Map<String, RepositoryConnectorFactory> repositoryConnectorFactories;
619
620 public final Map<String, RepositoryConnectorFactory> getRepositoryConnectorFactories() {
621 checkClosed();
622 if (repositoryConnectorFactories == null) {
623 repositoryConnectorFactories = createRepositoryConnectorFactories();
624 }
625 return repositoryConnectorFactories;
626 }
627
628 protected Map<String, RepositoryConnectorFactory> createRepositoryConnectorFactories() {
629 HashMap<String, RepositoryConnectorFactory> result = new HashMap<>();
630 result.put(BasicRepositoryConnectorFactory.NAME, getBasicRepositoryConnectorFactory());
631 return result;
632 }
633
634 private RepositoryConnectorProvider repositoryConnectorProvider;
635
636 public final RepositoryConnectorProvider getRepositoryConnectorProvider() {
637 checkClosed();
638 if (repositoryConnectorProvider == null) {
639 repositoryConnectorProvider = createRepositoryConnectorProvider();
640 }
641 return repositoryConnectorProvider;
642 }
643
644 protected RepositoryConnectorProvider createRepositoryConnectorProvider() {
645 return new DefaultRepositoryConnectorProvider(
646 getRepositoryConnectorFactories(), getRemoteRepositoryFilterManager());
647 }
648
649 private Installer installer;
650
651 public final Installer getInstaller() {
652 checkClosed();
653 if (installer == null) {
654 installer = createInstaller();
655 }
656 return installer;
657 }
658
659 protected Installer createInstaller() {
660 return new DefaultInstaller(
661 getFileProcessor(),
662 getRepositoryEventDispatcher(),
663 getMetadataGeneratorFactories(),
664 getSyncContextFactory());
665 }
666
667 private Deployer deployer;
668
669 public final Deployer getDeployer() {
670 checkClosed();
671 if (deployer == null) {
672 deployer = createDeployer();
673 }
674 return deployer;
675 }
676
677 protected Deployer createDeployer() {
678 return new DefaultDeployer(
679 getFileProcessor(),
680 getRepositoryEventDispatcher(),
681 getRepositoryConnectorProvider(),
682 getRemoteRepositoryManager(),
683 getUpdateCheckManager(),
684 getMetadataGeneratorFactories(),
685 getSyncContextFactory(),
686 getOfflineController());
687 }
688
689 private Map<String, DependencyCollectorDelegate> dependencyCollectorDelegates;
690
691 public final Map<String, DependencyCollectorDelegate> getDependencyCollectorDelegates() {
692 checkClosed();
693 if (dependencyCollectorDelegates == null) {
694 dependencyCollectorDelegates = createDependencyCollectorDelegates();
695 }
696 return dependencyCollectorDelegates;
697 }
698
699 protected Map<String, DependencyCollectorDelegate> createDependencyCollectorDelegates() {
700 RemoteRepositoryManager remoteRepositoryManager = getRemoteRepositoryManager();
701 ArtifactDescriptorReader artifactDescriptorReader = getArtifactDescriptorReader();
702 VersionRangeResolver versionRangeResolver = getVersionRangeResolver();
703 HashMap<String, DependencyCollectorDelegate> result = new HashMap<>();
704 result.put(
705 DfDependencyCollector.NAME,
706 new DfDependencyCollector(remoteRepositoryManager, artifactDescriptorReader, versionRangeResolver));
707 result.put(
708 BfDependencyCollector.NAME,
709 new BfDependencyCollector(remoteRepositoryManager, artifactDescriptorReader, versionRangeResolver));
710 return result;
711 }
712
713 private DependencyCollector dependencyCollector;
714
715 public final DependencyCollector getDependencyCollector() {
716 checkClosed();
717 if (dependencyCollector == null) {
718 dependencyCollector = createDependencyCollector();
719 }
720 return dependencyCollector;
721 }
722
723 protected DependencyCollector createDependencyCollector() {
724 return new DefaultDependencyCollector(getDependencyCollectorDelegates());
725 }
726
727 private Map<String, ArtifactResolverPostProcessor> artifactResolverPostProcessors;
728
729 public final Map<String, ArtifactResolverPostProcessor> getArtifactResolverPostProcessors() {
730 checkClosed();
731 if (artifactResolverPostProcessors == null) {
732 artifactResolverPostProcessors = createArtifactResolverPostProcessors();
733 }
734 return artifactResolverPostProcessors;
735 }
736
737 protected Map<String, ArtifactResolverPostProcessor> createArtifactResolverPostProcessors() {
738 HashMap<String, ArtifactResolverPostProcessor> result = new HashMap<>();
739 result.put(
740 TrustedChecksumsArtifactResolverPostProcessor.NAME,
741 new TrustedChecksumsArtifactResolverPostProcessor(
742 getChecksumAlgorithmFactorySelector(), getTrustedChecksumsSources()));
743 return result;
744 }
745
746 private ArtifactResolver artifactResolver;
747
748 public final ArtifactResolver getArtifactResolver() {
749 checkClosed();
750 if (artifactResolver == null) {
751 artifactResolver = createArtifactResolver();
752 }
753 return artifactResolver;
754 }
755
756 protected ArtifactResolver createArtifactResolver() {
757 return new DefaultArtifactResolver(
758 getFileProcessor(),
759 getRepositoryEventDispatcher(),
760 getVersionResolver(),
761 getUpdateCheckManager(),
762 getRepositoryConnectorProvider(),
763 getRemoteRepositoryManager(),
764 getSyncContextFactory(),
765 getOfflineController(),
766 getArtifactResolverPostProcessors(),
767 getRemoteRepositoryFilterManager());
768 }
769
770 private MetadataResolver metadataResolver;
771
772 public final MetadataResolver getMetadataResolver() {
773 checkClosed();
774 if (metadataResolver == null) {
775 metadataResolver = createMetadataResolver();
776 }
777 return metadataResolver;
778 }
779
780 protected MetadataResolver createMetadataResolver() {
781 return new DefaultMetadataResolver(
782 getRepositoryEventDispatcher(),
783 getUpdateCheckManager(),
784 getRepositoryConnectorProvider(),
785 getRemoteRepositoryManager(),
786 getSyncContextFactory(),
787 getOfflineController(),
788 getRemoteRepositoryFilterManager());
789 }
790
791 private VersionScheme versionScheme;
792
793 public final VersionScheme getVersionScheme() {
794 checkClosed();
795 if (versionScheme == null) {
796 versionScheme = createVersionScheme();
797 }
798 return versionScheme;
799 }
800
801 protected VersionScheme createVersionScheme() {
802 return new GenericVersionScheme();
803 }
804
805
806
807 private Map<String, MetadataGeneratorFactory> metadataGeneratorFactories;
808
809 public final Map<String, MetadataGeneratorFactory> getMetadataGeneratorFactories() {
810 checkClosed();
811 if (metadataGeneratorFactories == null) {
812 metadataGeneratorFactories = createMetadataGeneratorFactories();
813 }
814 return metadataGeneratorFactories;
815 }
816
817 protected Map<String, MetadataGeneratorFactory> createMetadataGeneratorFactories() {
818
819 HashMap<String, MetadataGeneratorFactory> result = new HashMap<>();
820 result.put(PluginsMetadataGeneratorFactory.NAME, new PluginsMetadataGeneratorFactory());
821 result.put(VersionsMetadataGeneratorFactory.NAME, new VersionsMetadataGeneratorFactory());
822 result.put(SnapshotMetadataGeneratorFactory.NAME, new SnapshotMetadataGeneratorFactory());
823 return result;
824 }
825
826 private LinkedHashMap<String, MavenArtifactRelocationSource> artifactRelocationSources;
827
828 public final LinkedHashMap<String, MavenArtifactRelocationSource> getMavenArtifactRelocationSources() {
829 checkClosed();
830 if (artifactRelocationSources == null) {
831 artifactRelocationSources = createMavenArtifactRelocationSources();
832 }
833 return artifactRelocationSources;
834 }
835
836 protected LinkedHashMap<String, MavenArtifactRelocationSource> createMavenArtifactRelocationSources() {
837
838 LinkedHashMap<String, MavenArtifactRelocationSource> result = new LinkedHashMap<>();
839 result.put(UserPropertiesArtifactRelocationSource.NAME, new UserPropertiesArtifactRelocationSource());
840 result.put(
841 DistributionManagementArtifactRelocationSource.NAME,
842 new DistributionManagementArtifactRelocationSource());
843 return result;
844 }
845
846 private ArtifactDescriptorReader artifactDescriptorReader;
847
848 public final ArtifactDescriptorReader getArtifactDescriptorReader() {
849 checkClosed();
850 if (artifactDescriptorReader == null) {
851 artifactDescriptorReader = createArtifactDescriptorReader();
852 }
853 return artifactDescriptorReader;
854 }
855
856 protected ArtifactDescriptorReader createArtifactDescriptorReader() {
857
858 return new DefaultArtifactDescriptorReader(
859 getRemoteRepositoryManager(),
860 getVersionResolver(),
861 getVersionRangeResolver(),
862 getArtifactResolver(),
863 getModelBuilder(),
864 getRepositoryEventDispatcher(),
865 getModelCacheFactory(),
866 getMavenArtifactRelocationSources());
867 }
868
869 private VersionResolver versionResolver;
870
871 public final VersionResolver getVersionResolver() {
872 checkClosed();
873 if (versionResolver == null) {
874 versionResolver = createVersionResolver();
875 }
876 return versionResolver;
877 }
878
879 protected VersionResolver createVersionResolver() {
880
881 return new DefaultVersionResolver(
882 getMetadataResolver(), getSyncContextFactory(), getRepositoryEventDispatcher());
883 }
884
885 private VersionRangeResolver versionRangeResolver;
886
887 public final VersionRangeResolver getVersionRangeResolver() {
888 checkClosed();
889 if (versionRangeResolver == null) {
890 versionRangeResolver = createVersionRangeResolver();
891 }
892 return versionRangeResolver;
893 }
894
895 protected VersionRangeResolver createVersionRangeResolver() {
896
897 return new DefaultVersionRangeResolver(
898 getMetadataResolver(), getSyncContextFactory(), getRepositoryEventDispatcher(), getVersionScheme());
899 }
900
901 private ModelBuilder modelBuilder;
902
903 public final ModelBuilder getModelBuilder() {
904 checkClosed();
905 if (modelBuilder == null) {
906 modelBuilder = createModelBuilder();
907 }
908 return modelBuilder;
909 }
910
911 protected ModelBuilder createModelBuilder() {
912
913 return new DefaultModelBuilderFactory().newInstance();
914 }
915
916 private ModelCacheFactory modelCacheFactory;
917
918 public final ModelCacheFactory getModelCacheFactory() {
919 checkClosed();
920 if (modelCacheFactory == null) {
921 modelCacheFactory = createModelCacheFactory();
922 }
923 return modelCacheFactory;
924 }
925
926 protected ModelCacheFactory createModelCacheFactory() {
927
928 return new DefaultModelCacheFactory();
929 }
930
931 private RepositorySystem repositorySystem;
932
933 public final RepositorySystem getRepositorySystem() {
934 checkClosed();
935 if (repositorySystem == null) {
936 repositorySystem = createRepositorySystem();
937 }
938 return repositorySystem;
939 }
940
941 protected RepositorySystem createRepositorySystem() {
942 return new DefaultRepositorySystem(
943 getVersionResolver(),
944 getVersionRangeResolver(),
945 getArtifactResolver(),
946 getMetadataResolver(),
947 getArtifactDescriptorReader(),
948 getDependencyCollector(),
949 getInstaller(),
950 getDeployer(),
951 getLocalRepositoryProvider(),
952 getSyncContextFactory(),
953 getRemoteRepositoryManager(),
954 getRepositorySystemLifecycle());
955 }
956
957 @Override
958 public RepositorySystem get() {
959 return getRepositorySystem();
960 }
961 }