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