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