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