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.TrackingFileManagerProvider;
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 TrackingFileManagerProvider(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 return result;
591 }
592
593 private RemoteRepositoryFilterManager remoteRepositoryFilterManager;
594
595 public final RemoteRepositoryFilterManager getRemoteRepositoryFilterManager() {
596 checkClosed();
597 if (remoteRepositoryFilterManager == null) {
598 remoteRepositoryFilterManager = createRemoteRepositoryFilterManager();
599 }
600 return remoteRepositoryFilterManager;
601 }
602
603 protected RemoteRepositoryFilterManager createRemoteRepositoryFilterManager() {
604 return new DefaultRemoteRepositoryFilterManager(getRemoteRepositoryFilterSources());
605 }
606
607 private Map<String, RepositoryListener> repositoryListeners;
608
609 public final Map<String, RepositoryListener> getRepositoryListeners() {
610 checkClosed();
611 if (repositoryListeners == null) {
612 repositoryListeners = createRepositoryListeners();
613 }
614 return repositoryListeners;
615 }
616
617 protected Map<String, RepositoryListener> createRepositoryListeners() {
618 return new HashMap<>();
619 }
620
621 private RepositoryEventDispatcher repositoryEventDispatcher;
622
623 public final RepositoryEventDispatcher getRepositoryEventDispatcher() {
624 checkClosed();
625 if (repositoryEventDispatcher == null) {
626 repositoryEventDispatcher = createRepositoryEventDispatcher();
627 }
628 return repositoryEventDispatcher;
629 }
630
631 protected RepositoryEventDispatcher createRepositoryEventDispatcher() {
632 return new DefaultRepositoryEventDispatcher(getRepositoryListeners());
633 }
634
635 private Map<String, TrustedChecksumsSource> trustedChecksumsSources;
636
637 public final Map<String, TrustedChecksumsSource> getTrustedChecksumsSources() {
638 checkClosed();
639 if (trustedChecksumsSources == null) {
640 trustedChecksumsSources = createTrustedChecksumsSources();
641 }
642 return trustedChecksumsSources;
643 }
644
645 protected Map<String, TrustedChecksumsSource> createTrustedChecksumsSources() {
646 HashMap<String, TrustedChecksumsSource> result = new HashMap<>();
647 result.put(
648 SparseDirectoryTrustedChecksumsSource.NAME,
649 new SparseDirectoryTrustedChecksumsSource(
650 getRepositoryKeyFunctionFactory(), getChecksumProcessor(), getLocalPathComposer()));
651 result.put(
652 SummaryFileTrustedChecksumsSource.NAME,
653 new SummaryFileTrustedChecksumsSource(
654 getRepositoryKeyFunctionFactory(),
655 getLocalPathComposer(),
656 getRepositorySystemLifecycle(),
657 getPathProcessor()));
658 return result;
659 }
660
661 private Map<String, ProvidedChecksumsSource> providedChecksumsSources;
662
663 public final Map<String, ProvidedChecksumsSource> getProvidedChecksumsSources() {
664 checkClosed();
665 if (providedChecksumsSources == null) {
666 providedChecksumsSources = createProvidedChecksumsSources();
667 }
668 return providedChecksumsSources;
669 }
670
671 protected Map<String, ProvidedChecksumsSource> createProvidedChecksumsSources() {
672 HashMap<String, ProvidedChecksumsSource> result = new HashMap<>();
673 result.put(
674 TrustedToProvidedChecksumsSourceAdapter.NAME,
675 new TrustedToProvidedChecksumsSourceAdapter(getTrustedChecksumsSources()));
676 return result;
677 }
678
679 private Map<String, ChecksumExtractorStrategy> checksumExtractorStrategies;
680
681 public final Map<String, ChecksumExtractorStrategy> getChecksumExtractorStrategies() {
682 checkClosed();
683 if (checksumExtractorStrategies == null) {
684 checksumExtractorStrategies = createChecksumExtractorStrategies();
685 }
686 return checksumExtractorStrategies;
687 }
688
689 protected Map<String, ChecksumExtractorStrategy> createChecksumExtractorStrategies() {
690 HashMap<String, ChecksumExtractorStrategy> result = new HashMap<>();
691 result.put(XChecksumExtractor.NAME, new XChecksumExtractor());
692 result.put(Nx2ChecksumExtractor.NAME, new Nx2ChecksumExtractor());
693 return result;
694 }
695
696 private ChecksumExtractor checksumExtractor;
697
698 public final ChecksumExtractor getChecksumExtractor() {
699 checkClosed();
700 if (checksumExtractor == null) {
701 checksumExtractor = createChecksumExtractor();
702 }
703 return checksumExtractor;
704 }
705
706 protected ChecksumExtractor createChecksumExtractor() {
707 return new DefaultChecksumExtractor(getChecksumExtractorStrategies());
708 }
709
710 private Map<String, TransporterFactory> transporterFactories;
711
712 public final Map<String, TransporterFactory> getTransporterFactories() {
713 checkClosed();
714 if (transporterFactories == null) {
715 transporterFactories = createTransporterFactories();
716 }
717 return transporterFactories;
718 }
719
720 protected Map<String, TransporterFactory> createTransporterFactories() {
721 HashMap<String, TransporterFactory> result = new HashMap<>();
722 result.put(FileTransporterFactory.NAME, new FileTransporterFactory());
723 result.put(
724 ApacheTransporterFactory.NAME,
725 new ApacheTransporterFactory(getChecksumExtractor(), getPathProcessor()));
726 return result;
727 }
728
729 private TransporterProvider transporterProvider;
730
731 public final TransporterProvider getTransporterProvider() {
732 checkClosed();
733 if (transporterProvider == null) {
734 transporterProvider = createTransporterProvider();
735 }
736 return transporterProvider;
737 }
738
739 protected TransporterProvider createTransporterProvider() {
740 return new DefaultTransporterProvider(getTransporterFactories());
741 }
742
743 private BasicRepositoryConnectorFactory basicRepositoryConnectorFactory;
744
745 public final BasicRepositoryConnectorFactory getBasicRepositoryConnectorFactory() {
746 checkClosed();
747 if (basicRepositoryConnectorFactory == null) {
748 basicRepositoryConnectorFactory = createBasicRepositoryConnectorFactory();
749 }
750 return basicRepositoryConnectorFactory;
751 }
752
753 protected BasicRepositoryConnectorFactory createBasicRepositoryConnectorFactory() {
754 return new BasicRepositoryConnectorFactory(
755 getTransporterProvider(),
756 getRepositoryLayoutProvider(),
757 getChecksumPolicyProvider(),
758 getPathProcessor(),
759 getChecksumProcessor(),
760 getProvidedChecksumsSources());
761 }
762
763 private Map<String, RepositoryConnectorFactory> repositoryConnectorFactories;
764
765 public final Map<String, RepositoryConnectorFactory> getRepositoryConnectorFactories() {
766 checkClosed();
767 if (repositoryConnectorFactories == null) {
768 repositoryConnectorFactories = createRepositoryConnectorFactories();
769 }
770 return repositoryConnectorFactories;
771 }
772
773 protected Map<String, RepositoryConnectorFactory> createRepositoryConnectorFactories() {
774 HashMap<String, RepositoryConnectorFactory> result = new HashMap<>();
775 result.put(BasicRepositoryConnectorFactory.NAME, getBasicRepositoryConnectorFactory());
776 return result;
777 }
778
779 private Map<String, PipelineRepositoryConnectorFactory> pipelineRepositoryConnectorFactories;
780
781 public final Map<String, PipelineRepositoryConnectorFactory> getPipelineRepositoryConnectorFactories() {
782 checkClosed();
783 if (pipelineRepositoryConnectorFactories == null) {
784 pipelineRepositoryConnectorFactories = createPipelineRepositoryConnectorFactories();
785 }
786 return pipelineRepositoryConnectorFactories;
787 }
788
789 protected Map<String, PipelineRepositoryConnectorFactory> createPipelineRepositoryConnectorFactories() {
790 HashMap<String, PipelineRepositoryConnectorFactory> result = new HashMap<>();
791 result.put(
792 FilteringPipelineRepositoryConnectorFactory.NAME,
793 new FilteringPipelineRepositoryConnectorFactory(getRemoteRepositoryFilterManager()));
794 result.put(
795 OfflinePipelineRepositoryConnectorFactory.NAME,
796 new OfflinePipelineRepositoryConnectorFactory(getOfflineController()));
797 return result;
798 }
799
800 private RepositoryConnectorProvider repositoryConnectorProvider;
801
802 public final RepositoryConnectorProvider getRepositoryConnectorProvider() {
803 checkClosed();
804 if (repositoryConnectorProvider == null) {
805 repositoryConnectorProvider = createRepositoryConnectorProvider();
806 }
807 return repositoryConnectorProvider;
808 }
809
810 protected RepositoryConnectorProvider createRepositoryConnectorProvider() {
811 return new DefaultRepositoryConnectorProvider(
812 getRepositoryConnectorFactories(), getPipelineRepositoryConnectorFactories());
813 }
814
815 private Installer installer;
816
817 public final Installer getInstaller() {
818 checkClosed();
819 if (installer == null) {
820 installer = createInstaller();
821 }
822 return installer;
823 }
824
825 protected Installer createInstaller() {
826 return new DefaultInstaller(
827 getPathProcessor(),
828 getRepositoryEventDispatcher(),
829 getArtifactGeneratorFactories(),
830 getMetadataGeneratorFactories(),
831 getArtifactTransformers(),
832 getSyncContextFactory());
833 }
834
835 private Deployer deployer;
836
837 public final Deployer getDeployer() {
838 checkClosed();
839 if (deployer == null) {
840 deployer = createDeployer();
841 }
842 return deployer;
843 }
844
845 protected Deployer createDeployer() {
846 return new DefaultDeployer(
847 getPathProcessor(),
848 getRepositoryEventDispatcher(),
849 getRepositoryConnectorProvider(),
850 getRemoteRepositoryManager(),
851 getUpdateCheckManager(),
852 getArtifactGeneratorFactories(),
853 getMetadataGeneratorFactories(),
854 getArtifactTransformers(),
855 getSyncContextFactory(),
856 getOfflineController());
857 }
858
859 private Map<String, DependencyCollectorDelegate> dependencyCollectorDelegates;
860
861 public final Map<String, DependencyCollectorDelegate> getDependencyCollectorDelegates() {
862 checkClosed();
863 if (dependencyCollectorDelegates == null) {
864 dependencyCollectorDelegates = createDependencyCollectorDelegates();
865 }
866 return dependencyCollectorDelegates;
867 }
868
869 protected Map<String, DependencyCollectorDelegate> createDependencyCollectorDelegates() {
870 RemoteRepositoryManager remoteRepositoryManager = getRemoteRepositoryManager();
871 ArtifactDescriptorReader artifactDescriptorReader = getArtifactDescriptorReader();
872 VersionRangeResolver versionRangeResolver = getVersionRangeResolver();
873 HashMap<String, DependencyCollectorDelegate> result = new HashMap<>();
874 result.put(
875 DfDependencyCollector.NAME,
876 new DfDependencyCollector(
877 remoteRepositoryManager,
878 artifactDescriptorReader,
879 versionRangeResolver,
880 getArtifactDecoratorFactories()));
881 result.put(
882 BfDependencyCollector.NAME,
883 new BfDependencyCollector(
884 remoteRepositoryManager,
885 artifactDescriptorReader,
886 versionRangeResolver,
887 getArtifactDecoratorFactories()));
888 return result;
889 }
890
891 private DependencyCollector dependencyCollector;
892
893 public final DependencyCollector getDependencyCollector() {
894 checkClosed();
895 if (dependencyCollector == null) {
896 dependencyCollector = createDependencyCollector();
897 }
898 return dependencyCollector;
899 }
900
901 protected DependencyCollector createDependencyCollector() {
902 return new DefaultDependencyCollector(getDependencyCollectorDelegates());
903 }
904
905 private Map<String, ArtifactResolverPostProcessor> artifactResolverPostProcessors;
906
907 public final Map<String, ArtifactResolverPostProcessor> getArtifactResolverPostProcessors() {
908 checkClosed();
909 if (artifactResolverPostProcessors == null) {
910 artifactResolverPostProcessors = createArtifactResolverPostProcessors();
911 }
912 return artifactResolverPostProcessors;
913 }
914
915 protected Map<String, ArtifactResolverPostProcessor> createArtifactResolverPostProcessors() {
916 HashMap<String, ArtifactResolverPostProcessor> result = new HashMap<>();
917 result.put(
918 TrustedChecksumsArtifactResolverPostProcessor.NAME,
919 new TrustedChecksumsArtifactResolverPostProcessor(
920 getChecksumAlgorithmFactorySelector(), getTrustedChecksumsSources()));
921 return result;
922 }
923
924 private ArtifactResolver artifactResolver;
925
926 public final ArtifactResolver getArtifactResolver() {
927 checkClosed();
928 if (artifactResolver == null) {
929 artifactResolver = createArtifactResolver();
930 }
931 return artifactResolver;
932 }
933
934 protected ArtifactResolver createArtifactResolver() {
935 return new DefaultArtifactResolver(
936 getPathProcessor(),
937 getRepositoryEventDispatcher(),
938 getVersionResolver(),
939 getUpdateCheckManager(),
940 getRepositoryConnectorProvider(),
941 getRemoteRepositoryManager(),
942 getSyncContextFactory(),
943 getOfflineController(),
944 getArtifactResolverPostProcessors(),
945 getRemoteRepositoryFilterManager());
946 }
947
948 private MetadataResolver metadataResolver;
949
950 public final MetadataResolver getMetadataResolver() {
951 checkClosed();
952 if (metadataResolver == null) {
953 metadataResolver = createMetadataResolver();
954 }
955 return metadataResolver;
956 }
957
958 protected MetadataResolver createMetadataResolver() {
959 return new DefaultMetadataResolver(
960 getRepositoryEventDispatcher(),
961 getUpdateCheckManager(),
962 getRepositoryConnectorProvider(),
963 getRemoteRepositoryManager(),
964 getSyncContextFactory(),
965 getOfflineController(),
966 getRemoteRepositoryFilterManager(),
967 getPathProcessor());
968 }
969
970 private VersionScheme versionScheme;
971
972 public final VersionScheme getVersionScheme() {
973 checkClosed();
974 if (versionScheme == null) {
975 versionScheme = createVersionScheme();
976 }
977 return versionScheme;
978 }
979
980 protected VersionScheme createVersionScheme() {
981 return new GenericVersionScheme();
982 }
983
984 private Map<String, ArtifactGeneratorFactory> artifactGeneratorFactories;
985
986 public final Map<String, ArtifactGeneratorFactory> getArtifactGeneratorFactories() {
987 checkClosed();
988 if (artifactGeneratorFactories == null) {
989 artifactGeneratorFactories = createArtifactGeneratorFactories();
990 }
991 return artifactGeneratorFactories;
992 }
993
994 protected Map<String, ArtifactGeneratorFactory> createArtifactGeneratorFactories() {
995
996 return new HashMap<>();
997 }
998
999 private Map<String, ArtifactDecoratorFactory> artifactDecoratorFactories;
1000
1001 public final Map<String, ArtifactDecoratorFactory> getArtifactDecoratorFactories() {
1002 checkClosed();
1003 if (artifactDecoratorFactories == null) {
1004 artifactDecoratorFactories = createArtifactDecoratorFactories();
1005 }
1006 return artifactDecoratorFactories;
1007 }
1008
1009 protected Map<String, ArtifactDecoratorFactory> createArtifactDecoratorFactories() {
1010
1011 return new HashMap<>();
1012 }
1013
1014
1015
1016 private Map<String, ArtifactTransformer> artifactTransformers;
1017
1018 public final Map<String, ArtifactTransformer> getArtifactTransformers() {
1019 checkClosed();
1020 if (artifactTransformers == null) {
1021 artifactTransformers = createArtifactTransformers();
1022 }
1023 return artifactTransformers;
1024 }
1025
1026 protected Map<String, ArtifactTransformer> createArtifactTransformers() {
1027 return new HashMap<>();
1028 }
1029
1030 private Map<String, MetadataGeneratorFactory> metadataGeneratorFactories;
1031
1032 public final Map<String, MetadataGeneratorFactory> getMetadataGeneratorFactories() {
1033 checkClosed();
1034 if (metadataGeneratorFactories == null) {
1035 metadataGeneratorFactories = createMetadataGeneratorFactories();
1036 }
1037 return metadataGeneratorFactories;
1038 }
1039
1040 protected Map<String, MetadataGeneratorFactory> createMetadataGeneratorFactories() {
1041
1042 HashMap<String, MetadataGeneratorFactory> result = new HashMap<>();
1043 result.put(PluginsMetadataGeneratorFactory.NAME, new PluginsMetadataGeneratorFactory());
1044 result.put(VersionsMetadataGeneratorFactory.NAME, new VersionsMetadataGeneratorFactory());
1045 result.put(SnapshotMetadataGeneratorFactory.NAME, new SnapshotMetadataGeneratorFactory());
1046 return result;
1047 }
1048
1049 private ArtifactDescriptorReader artifactDescriptorReader;
1050
1051 public final ArtifactDescriptorReader getArtifactDescriptorReader() {
1052 checkClosed();
1053 if (artifactDescriptorReader == null) {
1054 artifactDescriptorReader = createArtifactDescriptorReader();
1055 }
1056 return artifactDescriptorReader;
1057 }
1058
1059 protected ArtifactDescriptorReader createArtifactDescriptorReader() {
1060
1061 return new DefaultArtifactDescriptorReader(
1062 getRemoteRepositoryManager(),
1063 getVersionResolver(),
1064 getVersionRangeResolver(),
1065 getArtifactResolver(),
1066 getModelBuilder(),
1067 getRepositoryEventDispatcher(),
1068 getModelCacheFactory());
1069 }
1070
1071 private VersionResolver versionResolver;
1072
1073 public final VersionResolver getVersionResolver() {
1074 checkClosed();
1075 if (versionResolver == null) {
1076 versionResolver = createVersionResolver();
1077 }
1078 return versionResolver;
1079 }
1080
1081 protected VersionResolver createVersionResolver() {
1082
1083 return new DefaultVersionResolver(
1084 getMetadataResolver(), getSyncContextFactory(), getRepositoryEventDispatcher());
1085 }
1086
1087 private VersionRangeResolver versionRangeResolver;
1088
1089 public final VersionRangeResolver getVersionRangeResolver() {
1090 checkClosed();
1091 if (versionRangeResolver == null) {
1092 versionRangeResolver = createVersionRangeResolver();
1093 }
1094 return versionRangeResolver;
1095 }
1096
1097 protected VersionRangeResolver createVersionRangeResolver() {
1098
1099 return new DefaultVersionRangeResolver(
1100 getMetadataResolver(), getSyncContextFactory(), getRepositoryEventDispatcher());
1101 }
1102
1103 private ModelBuilder modelBuilder;
1104
1105 public final ModelBuilder getModelBuilder() {
1106 checkClosed();
1107 if (modelBuilder == null) {
1108 modelBuilder = createModelBuilder();
1109 }
1110 return modelBuilder;
1111 }
1112
1113 protected ModelBuilder createModelBuilder() {
1114
1115 return new DefaultModelBuilderFactory().newInstance();
1116 }
1117
1118 private ModelCacheFactory modelCacheFactory;
1119
1120 public final ModelCacheFactory getModelCacheFactory() {
1121 checkClosed();
1122 if (modelCacheFactory == null) {
1123 modelCacheFactory = createModelCacheFactory();
1124 }
1125 return modelCacheFactory;
1126 }
1127
1128 protected ModelCacheFactory createModelCacheFactory() {
1129
1130 return new DefaultModelCacheFactory();
1131 }
1132
1133 private List<ValidatorFactory> validatorFactories;
1134
1135 public final List<ValidatorFactory> getValidatorFactories() {
1136 checkClosed();
1137 if (validatorFactories == null) {
1138 validatorFactories = createValidatorFactories();
1139 }
1140 return validatorFactories;
1141 }
1142
1143 protected List<ValidatorFactory> createValidatorFactories() {
1144 return new ArrayList<>();
1145 }
1146
1147 private RepositorySystemValidator repositorySystemValidator;
1148
1149 public final RepositorySystemValidator getRepositorySystemValidator() {
1150 checkClosed();
1151 if (repositorySystemValidator == null) {
1152 repositorySystemValidator = createRepositorySystemValidator();
1153 }
1154 return repositorySystemValidator;
1155 }
1156
1157 protected RepositorySystemValidator createRepositorySystemValidator() {
1158 return new DefaultRepositorySystemValidator(getValidatorFactories());
1159 }
1160
1161 private RepositorySystem repositorySystem;
1162
1163 public final RepositorySystem getRepositorySystem() {
1164 checkClosed();
1165 if (repositorySystem == null) {
1166 repositorySystem = createRepositorySystem();
1167 }
1168 return repositorySystem;
1169 }
1170
1171 protected RepositorySystem createRepositorySystem() {
1172 return new DefaultRepositorySystem(
1173 getVersionResolver(),
1174 getVersionRangeResolver(),
1175 getArtifactResolver(),
1176 getMetadataResolver(),
1177 getArtifactDescriptorReader(),
1178 getDependencyCollector(),
1179 getInstaller(),
1180 getDeployer(),
1181 getLocalRepositoryProvider(),
1182 getSyncContextFactory(),
1183 getRemoteRepositoryManager(),
1184 getRepositorySystemLifecycle(),
1185 getArtifactDecoratorFactories(),
1186 getRepositorySystemValidator());
1187 }
1188
1189 @Override
1190 public RepositorySystem get() {
1191 return getRepositorySystem();
1192 }
1193 }