1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.maven.repository.supplier;
20
21 import java.util.HashMap;
22 import java.util.Map;
23 import java.util.concurrent.atomic.AtomicBoolean;
24 import java.util.function.Supplier;
25
26 import org.apache.maven.model.building.DefaultModelBuilderFactory;
27 import org.apache.maven.model.building.ModelBuilder;
28 import org.apache.maven.repository.internal.DefaultArtifactDescriptorReader;
29 import org.apache.maven.repository.internal.DefaultModelCacheFactory;
30 import org.apache.maven.repository.internal.DefaultVersionRangeResolver;
31 import org.apache.maven.repository.internal.DefaultVersionResolver;
32 import org.apache.maven.repository.internal.ModelCacheFactory;
33 import org.apache.maven.repository.internal.PluginsMetadataGeneratorFactory;
34 import org.apache.maven.repository.internal.SnapshotMetadataGeneratorFactory;
35 import org.apache.maven.repository.internal.VersionsMetadataGeneratorFactory;
36 import org.eclipse.aether.RepositoryListener;
37 import org.eclipse.aether.RepositorySystem;
38 import org.eclipse.aether.connector.basic.BasicRepositoryConnectorFactory;
39 import org.eclipse.aether.impl.ArtifactDescriptorReader;
40 import org.eclipse.aether.impl.ArtifactResolver;
41 import org.eclipse.aether.impl.DependencyCollector;
42 import org.eclipse.aether.impl.Deployer;
43 import org.eclipse.aether.impl.Installer;
44 import org.eclipse.aether.impl.LocalRepositoryProvider;
45 import org.eclipse.aether.impl.MetadataGeneratorFactory;
46 import org.eclipse.aether.impl.MetadataResolver;
47 import org.eclipse.aether.impl.NamedLockFactorySelector;
48 import org.eclipse.aether.impl.OfflineController;
49 import org.eclipse.aether.impl.RemoteRepositoryFilterManager;
50 import org.eclipse.aether.impl.RemoteRepositoryManager;
51 import org.eclipse.aether.impl.RepositoryConnectorProvider;
52 import org.eclipse.aether.impl.RepositoryEventDispatcher;
53 import org.eclipse.aether.impl.RepositorySystemLifecycle;
54 import org.eclipse.aether.impl.RepositorySystemValidator;
55 import org.eclipse.aether.impl.UpdateCheckManager;
56 import org.eclipse.aether.impl.UpdatePolicyAnalyzer;
57 import org.eclipse.aether.impl.VersionRangeResolver;
58 import org.eclipse.aether.impl.VersionResolver;
59 import org.eclipse.aether.internal.impl.DefaultArtifactPredicateFactory;
60 import org.eclipse.aether.internal.impl.DefaultArtifactResolver;
61 import org.eclipse.aether.internal.impl.DefaultChecksumPolicyProvider;
62 import org.eclipse.aether.internal.impl.DefaultChecksumProcessor;
63 import org.eclipse.aether.internal.impl.DefaultDeployer;
64 import org.eclipse.aether.internal.impl.DefaultInstaller;
65 import org.eclipse.aether.internal.impl.DefaultLocalPathComposer;
66 import org.eclipse.aether.internal.impl.DefaultLocalPathPrefixComposerFactory;
67 import org.eclipse.aether.internal.impl.DefaultLocalRepositoryProvider;
68 import org.eclipse.aether.internal.impl.DefaultMetadataResolver;
69 import org.eclipse.aether.internal.impl.DefaultOfflineController;
70 import org.eclipse.aether.internal.impl.DefaultPathProcessor;
71 import org.eclipse.aether.internal.impl.DefaultRemoteRepositoryManager;
72 import org.eclipse.aether.internal.impl.DefaultRepositoryConnectorProvider;
73 import org.eclipse.aether.internal.impl.DefaultRepositoryEventDispatcher;
74 import org.eclipse.aether.internal.impl.DefaultRepositoryKeyFunctionFactory;
75 import org.eclipse.aether.internal.impl.DefaultRepositoryLayoutProvider;
76 import org.eclipse.aether.internal.impl.DefaultRepositorySystem;
77 import org.eclipse.aether.internal.impl.DefaultRepositorySystemLifecycle;
78 import org.eclipse.aether.internal.impl.DefaultRepositorySystemValidator;
79 import org.eclipse.aether.internal.impl.DefaultTransporterProvider;
80 import org.eclipse.aether.internal.impl.DefaultUpdateCheckManager;
81 import org.eclipse.aether.internal.impl.DefaultUpdatePolicyAnalyzer;
82 import org.eclipse.aether.internal.impl.EnhancedLocalRepositoryManagerFactory;
83 import org.eclipse.aether.internal.impl.LocalPathComposer;
84 import org.eclipse.aether.internal.impl.LocalPathPrefixComposerFactory;
85 import org.eclipse.aether.internal.impl.Maven2RepositoryLayoutFactory;
86 import org.eclipse.aether.internal.impl.SimpleLocalRepositoryManagerFactory;
87 import org.eclipse.aether.internal.impl.TrackingFileManager;
88 import org.eclipse.aether.internal.impl.TrackingFileManagerSupplier;
89 import org.eclipse.aether.internal.impl.checksum.DefaultChecksumAlgorithmFactorySelector;
90 import org.eclipse.aether.internal.impl.checksum.Md5ChecksumAlgorithmFactory;
91 import org.eclipse.aether.internal.impl.checksum.Sha1ChecksumAlgorithmFactory;
92 import org.eclipse.aether.internal.impl.checksum.Sha256ChecksumAlgorithmFactory;
93 import org.eclipse.aether.internal.impl.checksum.Sha512ChecksumAlgorithmFactory;
94 import org.eclipse.aether.internal.impl.checksum.SparseDirectoryTrustedChecksumsSource;
95 import org.eclipse.aether.internal.impl.checksum.SummaryFileTrustedChecksumsSource;
96 import org.eclipse.aether.internal.impl.checksum.TrustedToProvidedChecksumsSourceAdapter;
97 import org.eclipse.aether.internal.impl.collect.DefaultDependencyCollector;
98 import org.eclipse.aether.internal.impl.collect.DependencyCollectorDelegate;
99 import org.eclipse.aether.internal.impl.collect.bf.BfDependencyCollector;
100 import org.eclipse.aether.internal.impl.collect.df.DfDependencyCollector;
101 import org.eclipse.aether.internal.impl.filter.DefaultRemoteRepositoryFilterManager;
102 import org.eclipse.aether.internal.impl.filter.FilteringPipelineRepositoryConnectorFactory;
103 import org.eclipse.aether.internal.impl.filter.GroupIdRemoteRepositoryFilterSource;
104 import org.eclipse.aether.internal.impl.filter.PrefixesLockingInhibitorFactory;
105 import org.eclipse.aether.internal.impl.filter.PrefixesRemoteRepositoryFilterSource;
106 import org.eclipse.aether.internal.impl.named.DefaultNamedLockFactorySelector;
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 TrackingFileManagerSupplier(getNamedLockFactorySelector()).get();
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 NamedLockFactorySelector namedLockFactorySelector;
401
402 public final NamedLockFactorySelector getNamedLockFactorySelector() {
403 checkClosed();
404 if (namedLockFactorySelector == null) {
405 namedLockFactorySelector = createNamedLockFactorySelector();
406 }
407 return namedLockFactorySelector;
408 }
409
410 protected NamedLockFactorySelector createNamedLockFactorySelector() {
411 return new DefaultNamedLockFactorySelector(getNamedLockFactories(), getRepositorySystemLifecycle());
412 }
413
414 private NamedLockFactoryAdapterFactory namedLockFactoryAdapterFactory;
415
416 public final NamedLockFactoryAdapterFactory getNamedLockFactoryAdapterFactory() {
417 checkClosed();
418 if (namedLockFactoryAdapterFactory == null) {
419 namedLockFactoryAdapterFactory = createNamedLockFactoryAdapterFactory();
420 }
421 return namedLockFactoryAdapterFactory;
422 }
423
424 protected NamedLockFactoryAdapterFactory createNamedLockFactoryAdapterFactory() {
425 return new NamedLockFactoryAdapterFactoryImpl(
426 getNamedLockFactorySelector(), getNameMappers(), getLockingInhibitorFactories());
427 }
428
429 private SyncContextFactory syncContextFactory;
430
431 public final SyncContextFactory getSyncContextFactory() {
432 checkClosed();
433 if (syncContextFactory == null) {
434 syncContextFactory = createSyncContextFactory();
435 }
436 return syncContextFactory;
437 }
438
439 protected SyncContextFactory createSyncContextFactory() {
440 return new DefaultSyncContextFactory(getNamedLockFactoryAdapterFactory());
441 }
442
443 private Map<String, ChecksumAlgorithmFactory> checksumAlgorithmFactories;
444
445 public final Map<String, ChecksumAlgorithmFactory> getChecksumAlgorithmFactories() {
446 checkClosed();
447 if (checksumAlgorithmFactories == null) {
448 checksumAlgorithmFactories = createChecksumAlgorithmFactories();
449 }
450 return checksumAlgorithmFactories;
451 }
452
453 protected Map<String, ChecksumAlgorithmFactory> createChecksumAlgorithmFactories() {
454 HashMap<String, ChecksumAlgorithmFactory> result = new HashMap<>();
455 result.put(Sha512ChecksumAlgorithmFactory.NAME, new Sha512ChecksumAlgorithmFactory());
456 result.put(Sha256ChecksumAlgorithmFactory.NAME, new Sha256ChecksumAlgorithmFactory());
457 result.put(Sha1ChecksumAlgorithmFactory.NAME, new Sha1ChecksumAlgorithmFactory());
458 result.put(Md5ChecksumAlgorithmFactory.NAME, new Md5ChecksumAlgorithmFactory());
459 return result;
460 }
461
462 private ChecksumAlgorithmFactorySelector checksumAlgorithmFactorySelector;
463
464 public final ChecksumAlgorithmFactorySelector getChecksumAlgorithmFactorySelector() {
465 checkClosed();
466 if (checksumAlgorithmFactorySelector == null) {
467 checksumAlgorithmFactorySelector = createChecksumAlgorithmFactorySelector();
468 }
469 return checksumAlgorithmFactorySelector;
470 }
471
472 protected ChecksumAlgorithmFactorySelector createChecksumAlgorithmFactorySelector() {
473 return new DefaultChecksumAlgorithmFactorySelector(getChecksumAlgorithmFactories());
474 }
475
476 private ArtifactPredicateFactory artifactPredicateFactory;
477
478 public final ArtifactPredicateFactory getArtifactPredicateFactory() {
479 checkClosed();
480 if (artifactPredicateFactory == null) {
481 artifactPredicateFactory = createArtifactPredicateFactory();
482 }
483 return artifactPredicateFactory;
484 }
485
486 protected ArtifactPredicateFactory createArtifactPredicateFactory() {
487 return new DefaultArtifactPredicateFactory(getChecksumAlgorithmFactorySelector());
488 }
489
490 private Map<String, RepositoryLayoutFactory> repositoryLayoutFactories;
491
492 public final Map<String, RepositoryLayoutFactory> getRepositoryLayoutFactories() {
493 checkClosed();
494 if (repositoryLayoutFactories == null) {
495 repositoryLayoutFactories = createRepositoryLayoutFactories();
496 }
497 return repositoryLayoutFactories;
498 }
499
500 protected Map<String, RepositoryLayoutFactory> createRepositoryLayoutFactories() {
501 HashMap<String, RepositoryLayoutFactory> result = new HashMap<>();
502 result.put(
503 Maven2RepositoryLayoutFactory.NAME,
504 new Maven2RepositoryLayoutFactory(
505 getChecksumAlgorithmFactorySelector(), getArtifactPredicateFactory()));
506 return result;
507 }
508
509 private RepositoryLayoutProvider repositoryLayoutProvider;
510
511 public final RepositoryLayoutProvider getRepositoryLayoutProvider() {
512 checkClosed();
513 if (repositoryLayoutProvider == null) {
514 repositoryLayoutProvider = createRepositoryLayoutProvider();
515 }
516 return repositoryLayoutProvider;
517 }
518
519 protected RepositoryLayoutProvider createRepositoryLayoutProvider() {
520 return new DefaultRepositoryLayoutProvider(getRepositoryLayoutFactories());
521 }
522
523 private LocalRepositoryProvider localRepositoryProvider;
524
525 public final LocalRepositoryProvider getLocalRepositoryProvider() {
526 checkClosed();
527 if (localRepositoryProvider == null) {
528 localRepositoryProvider = createLocalRepositoryProvider();
529 }
530 return localRepositoryProvider;
531 }
532
533 protected LocalRepositoryProvider createLocalRepositoryProvider() {
534 LocalPathComposer localPathComposer = getLocalPathComposer();
535 RepositoryKeyFunctionFactory repositoryKeyFunctionFactory = getRepositoryKeyFunctionFactory();
536 HashMap<String, LocalRepositoryManagerFactory> localRepositoryProviders = new HashMap<>(2);
537 localRepositoryProviders.put(
538 SimpleLocalRepositoryManagerFactory.NAME, new SimpleLocalRepositoryManagerFactory(localPathComposer));
539 localRepositoryProviders.put(
540 EnhancedLocalRepositoryManagerFactory.NAME,
541 new EnhancedLocalRepositoryManagerFactory(
542 localPathComposer,
543 getTrackingFileManager(),
544 getLocalPathPrefixComposerFactory(),
545 repositoryKeyFunctionFactory));
546 return new DefaultLocalRepositoryProvider(localRepositoryProviders);
547 }
548
549 private RemoteRepositoryManager remoteRepositoryManager;
550
551 public final RemoteRepositoryManager getRemoteRepositoryManager() {
552 checkClosed();
553 if (remoteRepositoryManager == null) {
554 remoteRepositoryManager = createRemoteRepositoryManager();
555 }
556 return remoteRepositoryManager;
557 }
558
559 protected RemoteRepositoryManager createRemoteRepositoryManager() {
560 return new DefaultRemoteRepositoryManager(
561 getUpdatePolicyAnalyzer(), getChecksumPolicyProvider(), getRepositoryKeyFunctionFactory());
562 }
563
564 private Map<String, RemoteRepositoryFilterSource> remoteRepositoryFilterSources;
565
566 public final Map<String, RemoteRepositoryFilterSource> getRemoteRepositoryFilterSources() {
567 checkClosed();
568 if (remoteRepositoryFilterSources == null) {
569 remoteRepositoryFilterSources = createRemoteRepositoryFilterSources();
570 }
571 return remoteRepositoryFilterSources;
572 }
573
574 protected Map<String, RemoteRepositoryFilterSource> createRemoteRepositoryFilterSources() {
575 HashMap<String, RemoteRepositoryFilterSource> result = new HashMap<>();
576 result.put(
577 GroupIdRemoteRepositoryFilterSource.NAME,
578 new GroupIdRemoteRepositoryFilterSource(
579 getRepositoryKeyFunctionFactory(), getRepositorySystemLifecycle(), getPathProcessor()));
580 result.put(
581 PrefixesRemoteRepositoryFilterSource.NAME,
582 new PrefixesRemoteRepositoryFilterSource(
583 getRepositoryKeyFunctionFactory(),
584 this::getMetadataResolver,
585 this::getRemoteRepositoryManager,
586 getRepositoryLayoutProvider(),
587 getTransporterProvider()));
588 return result;
589 }
590
591 private RemoteRepositoryFilterManager remoteRepositoryFilterManager;
592
593 public final RemoteRepositoryFilterManager getRemoteRepositoryFilterManager() {
594 checkClosed();
595 if (remoteRepositoryFilterManager == null) {
596 remoteRepositoryFilterManager = createRemoteRepositoryFilterManager();
597 }
598 return remoteRepositoryFilterManager;
599 }
600
601 protected RemoteRepositoryFilterManager createRemoteRepositoryFilterManager() {
602 return new DefaultRemoteRepositoryFilterManager(getRemoteRepositoryFilterSources());
603 }
604
605 private Map<String, RepositoryListener> repositoryListeners;
606
607 public final Map<String, RepositoryListener> getRepositoryListeners() {
608 checkClosed();
609 if (repositoryListeners == null) {
610 repositoryListeners = createRepositoryListeners();
611 }
612 return repositoryListeners;
613 }
614
615 protected Map<String, RepositoryListener> createRepositoryListeners() {
616 return new HashMap<>();
617 }
618
619 private RepositoryEventDispatcher repositoryEventDispatcher;
620
621 public final RepositoryEventDispatcher getRepositoryEventDispatcher() {
622 checkClosed();
623 if (repositoryEventDispatcher == null) {
624 repositoryEventDispatcher = createRepositoryEventDispatcher();
625 }
626 return repositoryEventDispatcher;
627 }
628
629 protected RepositoryEventDispatcher createRepositoryEventDispatcher() {
630 return new DefaultRepositoryEventDispatcher(getRepositoryListeners());
631 }
632
633 private Map<String, TrustedChecksumsSource> trustedChecksumsSources;
634
635 public final Map<String, TrustedChecksumsSource> getTrustedChecksumsSources() {
636 checkClosed();
637 if (trustedChecksumsSources == null) {
638 trustedChecksumsSources = createTrustedChecksumsSources();
639 }
640 return trustedChecksumsSources;
641 }
642
643 protected Map<String, TrustedChecksumsSource> createTrustedChecksumsSources() {
644 HashMap<String, TrustedChecksumsSource> result = new HashMap<>();
645 result.put(
646 SparseDirectoryTrustedChecksumsSource.NAME,
647 new SparseDirectoryTrustedChecksumsSource(
648 getRepositoryKeyFunctionFactory(), getChecksumProcessor(), getLocalPathComposer()));
649 result.put(
650 SummaryFileTrustedChecksumsSource.NAME,
651 new SummaryFileTrustedChecksumsSource(
652 getRepositoryKeyFunctionFactory(),
653 getLocalPathComposer(),
654 getRepositorySystemLifecycle(),
655 getPathProcessor()));
656 return result;
657 }
658
659 private Map<String, ProvidedChecksumsSource> providedChecksumsSources;
660
661 public final Map<String, ProvidedChecksumsSource> getProvidedChecksumsSources() {
662 checkClosed();
663 if (providedChecksumsSources == null) {
664 providedChecksumsSources = createProvidedChecksumsSources();
665 }
666 return providedChecksumsSources;
667 }
668
669 protected Map<String, ProvidedChecksumsSource> createProvidedChecksumsSources() {
670 HashMap<String, ProvidedChecksumsSource> result = new HashMap<>();
671 result.put(
672 TrustedToProvidedChecksumsSourceAdapter.NAME,
673 new TrustedToProvidedChecksumsSourceAdapter(getTrustedChecksumsSources()));
674 return result;
675 }
676
677 private Map<String, ChecksumExtractorStrategy> checksumExtractorStrategies;
678
679 public final Map<String, ChecksumExtractorStrategy> getChecksumExtractorStrategies() {
680 checkClosed();
681 if (checksumExtractorStrategies == null) {
682 checksumExtractorStrategies = createChecksumExtractorStrategies();
683 }
684 return checksumExtractorStrategies;
685 }
686
687 protected Map<String, ChecksumExtractorStrategy> createChecksumExtractorStrategies() {
688 HashMap<String, ChecksumExtractorStrategy> result = new HashMap<>();
689 result.put(XChecksumExtractor.NAME, new XChecksumExtractor());
690 result.put(Nx2ChecksumExtractor.NAME, new Nx2ChecksumExtractor());
691 return result;
692 }
693
694 private ChecksumExtractor checksumExtractor;
695
696 public final ChecksumExtractor getChecksumExtractor() {
697 checkClosed();
698 if (checksumExtractor == null) {
699 checksumExtractor = createChecksumExtractor();
700 }
701 return checksumExtractor;
702 }
703
704 protected ChecksumExtractor createChecksumExtractor() {
705 return new DefaultChecksumExtractor(getChecksumExtractorStrategies());
706 }
707
708 private Map<String, TransporterFactory> transporterFactories;
709
710 public final Map<String, TransporterFactory> getTransporterFactories() {
711 checkClosed();
712 if (transporterFactories == null) {
713 transporterFactories = createTransporterFactories();
714 }
715 return transporterFactories;
716 }
717
718 protected Map<String, TransporterFactory> createTransporterFactories() {
719 HashMap<String, TransporterFactory> result = new HashMap<>();
720 result.put(FileTransporterFactory.NAME, new FileTransporterFactory());
721 result.put(
722 ApacheTransporterFactory.NAME,
723 new ApacheTransporterFactory(getChecksumExtractor(), getPathProcessor()));
724 return result;
725 }
726
727 private TransporterProvider transporterProvider;
728
729 public final TransporterProvider getTransporterProvider() {
730 checkClosed();
731 if (transporterProvider == null) {
732 transporterProvider = createTransporterProvider();
733 }
734 return transporterProvider;
735 }
736
737 protected TransporterProvider createTransporterProvider() {
738 return new DefaultTransporterProvider(getTransporterFactories());
739 }
740
741 private BasicRepositoryConnectorFactory basicRepositoryConnectorFactory;
742
743 public final BasicRepositoryConnectorFactory getBasicRepositoryConnectorFactory() {
744 checkClosed();
745 if (basicRepositoryConnectorFactory == null) {
746 basicRepositoryConnectorFactory = createBasicRepositoryConnectorFactory();
747 }
748 return basicRepositoryConnectorFactory;
749 }
750
751 protected BasicRepositoryConnectorFactory createBasicRepositoryConnectorFactory() {
752 return new BasicRepositoryConnectorFactory(
753 getTransporterProvider(),
754 getRepositoryLayoutProvider(),
755 getChecksumPolicyProvider(),
756 getPathProcessor(),
757 getChecksumProcessor(),
758 getProvidedChecksumsSources());
759 }
760
761 private Map<String, RepositoryConnectorFactory> repositoryConnectorFactories;
762
763 public final Map<String, RepositoryConnectorFactory> getRepositoryConnectorFactories() {
764 checkClosed();
765 if (repositoryConnectorFactories == null) {
766 repositoryConnectorFactories = createRepositoryConnectorFactories();
767 }
768 return repositoryConnectorFactories;
769 }
770
771 protected Map<String, RepositoryConnectorFactory> createRepositoryConnectorFactories() {
772 HashMap<String, RepositoryConnectorFactory> result = new HashMap<>();
773 result.put(BasicRepositoryConnectorFactory.NAME, getBasicRepositoryConnectorFactory());
774 return result;
775 }
776
777 private Map<String, PipelineRepositoryConnectorFactory> pipelineRepositoryConnectorFactories;
778
779 public final Map<String, PipelineRepositoryConnectorFactory> getPipelineRepositoryConnectorFactories() {
780 checkClosed();
781 if (pipelineRepositoryConnectorFactories == null) {
782 pipelineRepositoryConnectorFactories = createPipelineRepositoryConnectorFactories();
783 }
784 return pipelineRepositoryConnectorFactories;
785 }
786
787 protected Map<String, PipelineRepositoryConnectorFactory> createPipelineRepositoryConnectorFactories() {
788 HashMap<String, PipelineRepositoryConnectorFactory> result = new HashMap<>();
789 result.put(
790 FilteringPipelineRepositoryConnectorFactory.NAME,
791 new FilteringPipelineRepositoryConnectorFactory(getRemoteRepositoryFilterManager()));
792 result.put(
793 OfflinePipelineRepositoryConnectorFactory.NAME,
794 new OfflinePipelineRepositoryConnectorFactory(getOfflineController()));
795 return result;
796 }
797
798 private RepositoryConnectorProvider repositoryConnectorProvider;
799
800 public final RepositoryConnectorProvider getRepositoryConnectorProvider() {
801 checkClosed();
802 if (repositoryConnectorProvider == null) {
803 repositoryConnectorProvider = createRepositoryConnectorProvider();
804 }
805 return repositoryConnectorProvider;
806 }
807
808 protected RepositoryConnectorProvider createRepositoryConnectorProvider() {
809 return new DefaultRepositoryConnectorProvider(
810 getRepositoryConnectorFactories(), getPipelineRepositoryConnectorFactories());
811 }
812
813 private Installer installer;
814
815 public final Installer getInstaller() {
816 checkClosed();
817 if (installer == null) {
818 installer = createInstaller();
819 }
820 return installer;
821 }
822
823 protected Installer createInstaller() {
824 return new DefaultInstaller(
825 getPathProcessor(),
826 getRepositoryEventDispatcher(),
827 getArtifactGeneratorFactories(),
828 getMetadataGeneratorFactories(),
829 getArtifactTransformers(),
830 getSyncContextFactory());
831 }
832
833 private Deployer deployer;
834
835 public final Deployer getDeployer() {
836 checkClosed();
837 if (deployer == null) {
838 deployer = createDeployer();
839 }
840 return deployer;
841 }
842
843 protected Deployer createDeployer() {
844 return new DefaultDeployer(
845 getPathProcessor(),
846 getRepositoryEventDispatcher(),
847 getRepositoryConnectorProvider(),
848 getRemoteRepositoryManager(),
849 getUpdateCheckManager(),
850 getArtifactGeneratorFactories(),
851 getMetadataGeneratorFactories(),
852 getArtifactTransformers(),
853 getSyncContextFactory(),
854 getOfflineController());
855 }
856
857 private Map<String, DependencyCollectorDelegate> dependencyCollectorDelegates;
858
859 public final Map<String, DependencyCollectorDelegate> getDependencyCollectorDelegates() {
860 checkClosed();
861 if (dependencyCollectorDelegates == null) {
862 dependencyCollectorDelegates = createDependencyCollectorDelegates();
863 }
864 return dependencyCollectorDelegates;
865 }
866
867 protected Map<String, DependencyCollectorDelegate> createDependencyCollectorDelegates() {
868 RemoteRepositoryManager remoteRepositoryManager = getRemoteRepositoryManager();
869 ArtifactDescriptorReader artifactDescriptorReader = getArtifactDescriptorReader();
870 VersionRangeResolver versionRangeResolver = getVersionRangeResolver();
871 HashMap<String, DependencyCollectorDelegate> result = new HashMap<>();
872 result.put(
873 DfDependencyCollector.NAME,
874 new DfDependencyCollector(
875 remoteRepositoryManager,
876 artifactDescriptorReader,
877 versionRangeResolver,
878 getArtifactDecoratorFactories()));
879 result.put(
880 BfDependencyCollector.NAME,
881 new BfDependencyCollector(
882 remoteRepositoryManager,
883 artifactDescriptorReader,
884 versionRangeResolver,
885 getArtifactDecoratorFactories()));
886 return result;
887 }
888
889 private DependencyCollector dependencyCollector;
890
891 public final DependencyCollector getDependencyCollector() {
892 checkClosed();
893 if (dependencyCollector == null) {
894 dependencyCollector = createDependencyCollector();
895 }
896 return dependencyCollector;
897 }
898
899 protected DependencyCollector createDependencyCollector() {
900 return new DefaultDependencyCollector(getDependencyCollectorDelegates());
901 }
902
903 private Map<String, ArtifactResolverPostProcessor> artifactResolverPostProcessors;
904
905 public final Map<String, ArtifactResolverPostProcessor> getArtifactResolverPostProcessors() {
906 checkClosed();
907 if (artifactResolverPostProcessors == null) {
908 artifactResolverPostProcessors = createArtifactResolverPostProcessors();
909 }
910 return artifactResolverPostProcessors;
911 }
912
913 protected Map<String, ArtifactResolverPostProcessor> createArtifactResolverPostProcessors() {
914 HashMap<String, ArtifactResolverPostProcessor> result = new HashMap<>();
915 result.put(
916 TrustedChecksumsArtifactResolverPostProcessor.NAME,
917 new TrustedChecksumsArtifactResolverPostProcessor(
918 getChecksumAlgorithmFactorySelector(), getTrustedChecksumsSources()));
919 return result;
920 }
921
922 private ArtifactResolver artifactResolver;
923
924 public final ArtifactResolver getArtifactResolver() {
925 checkClosed();
926 if (artifactResolver == null) {
927 artifactResolver = createArtifactResolver();
928 }
929 return artifactResolver;
930 }
931
932 protected ArtifactResolver createArtifactResolver() {
933 return new DefaultArtifactResolver(
934 getPathProcessor(),
935 getRepositoryEventDispatcher(),
936 getVersionResolver(),
937 getUpdateCheckManager(),
938 getRepositoryConnectorProvider(),
939 getRemoteRepositoryManager(),
940 getSyncContextFactory(),
941 getOfflineController(),
942 getArtifactResolverPostProcessors(),
943 getRemoteRepositoryFilterManager());
944 }
945
946 private MetadataResolver metadataResolver;
947
948 public final MetadataResolver getMetadataResolver() {
949 checkClosed();
950 if (metadataResolver == null) {
951 metadataResolver = createMetadataResolver();
952 }
953 return metadataResolver;
954 }
955
956 protected MetadataResolver createMetadataResolver() {
957 return new DefaultMetadataResolver(
958 getRepositoryEventDispatcher(),
959 getUpdateCheckManager(),
960 getRepositoryConnectorProvider(),
961 getRemoteRepositoryManager(),
962 getSyncContextFactory(),
963 getOfflineController(),
964 getRemoteRepositoryFilterManager(),
965 getPathProcessor());
966 }
967
968 private VersionScheme versionScheme;
969
970 public final VersionScheme getVersionScheme() {
971 checkClosed();
972 if (versionScheme == null) {
973 versionScheme = createVersionScheme();
974 }
975 return versionScheme;
976 }
977
978 protected VersionScheme createVersionScheme() {
979 return new GenericVersionScheme();
980 }
981
982 private Map<String, ArtifactGeneratorFactory> artifactGeneratorFactories;
983
984 public final Map<String, ArtifactGeneratorFactory> getArtifactGeneratorFactories() {
985 checkClosed();
986 if (artifactGeneratorFactories == null) {
987 artifactGeneratorFactories = createArtifactGeneratorFactories();
988 }
989 return artifactGeneratorFactories;
990 }
991
992 protected Map<String, ArtifactGeneratorFactory> createArtifactGeneratorFactories() {
993
994 return new HashMap<>();
995 }
996
997 private Map<String, ArtifactDecoratorFactory> artifactDecoratorFactories;
998
999 public final Map<String, ArtifactDecoratorFactory> getArtifactDecoratorFactories() {
1000 checkClosed();
1001 if (artifactDecoratorFactories == null) {
1002 artifactDecoratorFactories = createArtifactDecoratorFactories();
1003 }
1004 return artifactDecoratorFactories;
1005 }
1006
1007 protected Map<String, ArtifactDecoratorFactory> createArtifactDecoratorFactories() {
1008
1009 return new HashMap<>();
1010 }
1011
1012
1013
1014 private Map<String, ArtifactTransformer> artifactTransformers;
1015
1016 public final Map<String, ArtifactTransformer> getArtifactTransformers() {
1017 checkClosed();
1018 if (artifactTransformers == null) {
1019 artifactTransformers = createArtifactTransformers();
1020 }
1021 return artifactTransformers;
1022 }
1023
1024 protected Map<String, ArtifactTransformer> createArtifactTransformers() {
1025 return new HashMap<>();
1026 }
1027
1028 private Map<String, MetadataGeneratorFactory> metadataGeneratorFactories;
1029
1030 public final Map<String, MetadataGeneratorFactory> getMetadataGeneratorFactories() {
1031 checkClosed();
1032 if (metadataGeneratorFactories == null) {
1033 metadataGeneratorFactories = createMetadataGeneratorFactories();
1034 }
1035 return metadataGeneratorFactories;
1036 }
1037
1038 protected Map<String, MetadataGeneratorFactory> createMetadataGeneratorFactories() {
1039
1040 HashMap<String, MetadataGeneratorFactory> result = new HashMap<>();
1041 result.put(PluginsMetadataGeneratorFactory.NAME, new PluginsMetadataGeneratorFactory());
1042 result.put(VersionsMetadataGeneratorFactory.NAME, new VersionsMetadataGeneratorFactory());
1043 result.put(SnapshotMetadataGeneratorFactory.NAME, new SnapshotMetadataGeneratorFactory());
1044 return result;
1045 }
1046
1047 private ArtifactDescriptorReader artifactDescriptorReader;
1048
1049 public final ArtifactDescriptorReader getArtifactDescriptorReader() {
1050 checkClosed();
1051 if (artifactDescriptorReader == null) {
1052 artifactDescriptorReader = createArtifactDescriptorReader();
1053 }
1054 return artifactDescriptorReader;
1055 }
1056
1057 protected ArtifactDescriptorReader createArtifactDescriptorReader() {
1058
1059 return new DefaultArtifactDescriptorReader(
1060 getRemoteRepositoryManager(),
1061 getVersionResolver(),
1062 getVersionRangeResolver(),
1063 getArtifactResolver(),
1064 getModelBuilder(),
1065 getRepositoryEventDispatcher(),
1066 getModelCacheFactory());
1067 }
1068
1069 private VersionResolver versionResolver;
1070
1071 public final VersionResolver getVersionResolver() {
1072 checkClosed();
1073 if (versionResolver == null) {
1074 versionResolver = createVersionResolver();
1075 }
1076 return versionResolver;
1077 }
1078
1079 protected VersionResolver createVersionResolver() {
1080
1081 return new DefaultVersionResolver(
1082 getMetadataResolver(), getSyncContextFactory(), getRepositoryEventDispatcher());
1083 }
1084
1085 private VersionRangeResolver versionRangeResolver;
1086
1087 public final VersionRangeResolver getVersionRangeResolver() {
1088 checkClosed();
1089 if (versionRangeResolver == null) {
1090 versionRangeResolver = createVersionRangeResolver();
1091 }
1092 return versionRangeResolver;
1093 }
1094
1095 protected VersionRangeResolver createVersionRangeResolver() {
1096
1097 return new DefaultVersionRangeResolver(
1098 getMetadataResolver(), getSyncContextFactory(), getRepositoryEventDispatcher());
1099 }
1100
1101 private ModelBuilder modelBuilder;
1102
1103 public final ModelBuilder getModelBuilder() {
1104 checkClosed();
1105 if (modelBuilder == null) {
1106 modelBuilder = createModelBuilder();
1107 }
1108 return modelBuilder;
1109 }
1110
1111 protected ModelBuilder createModelBuilder() {
1112
1113 return new DefaultModelBuilderFactory().newInstance();
1114 }
1115
1116 private ModelCacheFactory modelCacheFactory;
1117
1118 public final ModelCacheFactory getModelCacheFactory() {
1119 checkClosed();
1120 if (modelCacheFactory == null) {
1121 modelCacheFactory = createModelCacheFactory();
1122 }
1123 return modelCacheFactory;
1124 }
1125
1126 protected ModelCacheFactory createModelCacheFactory() {
1127
1128 return new DefaultModelCacheFactory();
1129 }
1130
1131 private Map<String, ValidatorFactory> validatorFactories;
1132
1133 public final Map<String, ValidatorFactory> getValidatorFactories() {
1134 checkClosed();
1135 if (validatorFactories == null) {
1136 validatorFactories = createValidatorFactories();
1137 }
1138 return validatorFactories;
1139 }
1140
1141 protected Map<String, ValidatorFactory> createValidatorFactories() {
1142 return new HashMap<>();
1143 }
1144
1145 private RepositorySystemValidator repositorySystemValidator;
1146
1147 public final RepositorySystemValidator getRepositorySystemValidator() {
1148 checkClosed();
1149 if (repositorySystemValidator == null) {
1150 repositorySystemValidator = createRepositorySystemValidator();
1151 }
1152 return repositorySystemValidator;
1153 }
1154
1155 protected RepositorySystemValidator createRepositorySystemValidator() {
1156 return new DefaultRepositorySystemValidator(getValidatorFactories());
1157 }
1158
1159 private RepositorySystem repositorySystem;
1160
1161 public final RepositorySystem getRepositorySystem() {
1162 checkClosed();
1163 if (repositorySystem == null) {
1164 repositorySystem = createRepositorySystem();
1165 }
1166 return repositorySystem;
1167 }
1168
1169 protected RepositorySystem createRepositorySystem() {
1170 return new DefaultRepositorySystem(
1171 getVersionResolver(),
1172 getVersionRangeResolver(),
1173 getArtifactResolver(),
1174 getMetadataResolver(),
1175 getArtifactDescriptorReader(),
1176 getDependencyCollector(),
1177 getInstaller(),
1178 getDeployer(),
1179 getLocalRepositoryProvider(),
1180 getSyncContextFactory(),
1181 getRemoteRepositoryManager(),
1182 getRepositorySystemLifecycle(),
1183 getArtifactDecoratorFactories(),
1184 getRepositorySystemValidator());
1185 }
1186
1187 @Override
1188 public RepositorySystem get() {
1189 return getRepositorySystem();
1190 }
1191 }