001/* 002 * Licensed to the Apache Software Foundation (ASF) under one 003 * or more contributor license agreements. See the NOTICE file 004 * distributed with this work for additional information 005 * regarding copyright ownership. The ASF licenses this file 006 * to you under the Apache License, Version 2.0 (the 007 * "License"); you may not use this file except in compliance 008 * with the License. You may obtain a copy of the License at 009 * 010 * http://www.apache.org/licenses/LICENSE-2.0 011 * 012 * Unless required by applicable law or agreed to in writing, 013 * software distributed under the License is distributed on an 014 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 015 * KIND, either express or implied. See the License for the 016 * specific language governing permissions and limitations 017 * under the License. 018 */ 019package org.eclipse.aether.supplier; 020 021import java.util.HashMap; 022import java.util.LinkedHashMap; 023import java.util.Map; 024import java.util.concurrent.atomic.AtomicBoolean; 025import java.util.function.Supplier; 026 027import org.apache.maven.model.building.DefaultModelBuilderFactory; 028import org.apache.maven.model.building.ModelBuilder; 029import org.apache.maven.repository.internal.ArtifactDescriptorDecorator; 030import org.apache.maven.repository.internal.DefaultArtifactDescriptorReader; 031import org.apache.maven.repository.internal.DefaultModelCacheFactory; 032import org.apache.maven.repository.internal.DefaultVersionRangeResolver; 033import org.apache.maven.repository.internal.DefaultVersionResolver; 034import org.apache.maven.repository.internal.MavenArtifactRelocationSource; 035import org.apache.maven.repository.internal.ModelCacheFactory; 036import org.apache.maven.repository.internal.PluginsMetadataGeneratorFactory; 037import org.apache.maven.repository.internal.SnapshotMetadataGeneratorFactory; 038import org.apache.maven.repository.internal.VersionsMetadataGeneratorFactory; 039import org.apache.maven.repository.internal.relocation.DistributionManagementArtifactRelocationSource; 040import org.apache.maven.repository.internal.relocation.UserPropertiesArtifactRelocationSource; 041import org.eclipse.aether.RepositoryListener; 042import org.eclipse.aether.RepositorySystem; 043import org.eclipse.aether.connector.basic.BasicRepositoryConnectorFactory; 044import org.eclipse.aether.impl.ArtifactDescriptorReader; 045import org.eclipse.aether.impl.ArtifactResolver; 046import org.eclipse.aether.impl.DependencyCollector; 047import org.eclipse.aether.impl.Deployer; 048import org.eclipse.aether.impl.Installer; 049import org.eclipse.aether.impl.LocalRepositoryProvider; 050import org.eclipse.aether.impl.MetadataGeneratorFactory; 051import org.eclipse.aether.impl.MetadataResolver; 052import org.eclipse.aether.impl.NamedLockFactorySelector; 053import org.eclipse.aether.impl.OfflineController; 054import org.eclipse.aether.impl.RemoteRepositoryFilterManager; 055import org.eclipse.aether.impl.RemoteRepositoryManager; 056import org.eclipse.aether.impl.RepositoryConnectorProvider; 057import org.eclipse.aether.impl.RepositoryEventDispatcher; 058import org.eclipse.aether.impl.RepositorySystemLifecycle; 059import org.eclipse.aether.impl.RepositorySystemValidator; 060import org.eclipse.aether.impl.UpdateCheckManager; 061import org.eclipse.aether.impl.UpdatePolicyAnalyzer; 062import org.eclipse.aether.impl.VersionRangeResolver; 063import org.eclipse.aether.impl.VersionResolver; 064import org.eclipse.aether.internal.impl.DefaultArtifactPredicateFactory; 065import org.eclipse.aether.internal.impl.DefaultArtifactResolver; 066import org.eclipse.aether.internal.impl.DefaultChecksumPolicyProvider; 067import org.eclipse.aether.internal.impl.DefaultChecksumProcessor; 068import org.eclipse.aether.internal.impl.DefaultDeployer; 069import org.eclipse.aether.internal.impl.DefaultInstaller; 070import org.eclipse.aether.internal.impl.DefaultLocalPathComposer; 071import org.eclipse.aether.internal.impl.DefaultLocalPathPrefixComposerFactory; 072import org.eclipse.aether.internal.impl.DefaultLocalRepositoryProvider; 073import org.eclipse.aether.internal.impl.DefaultMetadataResolver; 074import org.eclipse.aether.internal.impl.DefaultOfflineController; 075import org.eclipse.aether.internal.impl.DefaultPathProcessor; 076import org.eclipse.aether.internal.impl.DefaultRemoteRepositoryManager; 077import org.eclipse.aether.internal.impl.DefaultRepositoryConnectorProvider; 078import org.eclipse.aether.internal.impl.DefaultRepositoryEventDispatcher; 079import org.eclipse.aether.internal.impl.DefaultRepositoryKeyFunctionFactory; 080import org.eclipse.aether.internal.impl.DefaultRepositoryLayoutProvider; 081import org.eclipse.aether.internal.impl.DefaultRepositorySystem; 082import org.eclipse.aether.internal.impl.DefaultRepositorySystemLifecycle; 083import org.eclipse.aether.internal.impl.DefaultRepositorySystemValidator; 084import org.eclipse.aether.internal.impl.DefaultTransporterProvider; 085import org.eclipse.aether.internal.impl.DefaultUpdateCheckManager; 086import org.eclipse.aether.internal.impl.DefaultUpdatePolicyAnalyzer; 087import org.eclipse.aether.internal.impl.EnhancedLocalRepositoryManagerFactory; 088import org.eclipse.aether.internal.impl.LocalPathComposer; 089import org.eclipse.aether.internal.impl.LocalPathPrefixComposerFactory; 090import org.eclipse.aether.internal.impl.Maven2RepositoryLayoutFactory; 091import org.eclipse.aether.internal.impl.SimpleLocalRepositoryManagerFactory; 092import org.eclipse.aether.internal.impl.TrackingFileManager; 093import org.eclipse.aether.internal.impl.TrackingFileManagerSupplier; 094import org.eclipse.aether.internal.impl.checksum.DefaultChecksumAlgorithmFactorySelector; 095import org.eclipse.aether.internal.impl.checksum.Md5ChecksumAlgorithmFactory; 096import org.eclipse.aether.internal.impl.checksum.Sha1ChecksumAlgorithmFactory; 097import org.eclipse.aether.internal.impl.checksum.Sha256ChecksumAlgorithmFactory; 098import org.eclipse.aether.internal.impl.checksum.Sha512ChecksumAlgorithmFactory; 099import org.eclipse.aether.internal.impl.checksum.SparseDirectoryTrustedChecksumsSource; 100import org.eclipse.aether.internal.impl.checksum.SummaryFileTrustedChecksumsSource; 101import org.eclipse.aether.internal.impl.checksum.TrustedToProvidedChecksumsSourceAdapter; 102import org.eclipse.aether.internal.impl.collect.DefaultDependencyCollector; 103import org.eclipse.aether.internal.impl.collect.DependencyCollectorDelegate; 104import org.eclipse.aether.internal.impl.collect.bf.BfDependencyCollector; 105import org.eclipse.aether.internal.impl.collect.df.DfDependencyCollector; 106import org.eclipse.aether.internal.impl.filter.DefaultRemoteRepositoryFilterManager; 107import org.eclipse.aether.internal.impl.filter.FilteringPipelineRepositoryConnectorFactory; 108import org.eclipse.aether.internal.impl.filter.GroupIdRemoteRepositoryFilterSource; 109import org.eclipse.aether.internal.impl.filter.PrefixesLockingInhibitorFactory; 110import org.eclipse.aether.internal.impl.filter.PrefixesRemoteRepositoryFilterSource; 111import org.eclipse.aether.internal.impl.named.DefaultNamedLockFactorySelector; 112import org.eclipse.aether.internal.impl.offline.OfflinePipelineRepositoryConnectorFactory; 113import org.eclipse.aether.internal.impl.resolution.TrustedChecksumsArtifactResolverPostProcessor; 114import org.eclipse.aether.internal.impl.synccontext.DefaultSyncContextFactory; 115import org.eclipse.aether.internal.impl.synccontext.named.NameMapper; 116import org.eclipse.aether.internal.impl.synccontext.named.NameMappers; 117import org.eclipse.aether.internal.impl.synccontext.named.NamedLockFactoryAdapterFactory; 118import org.eclipse.aether.internal.impl.synccontext.named.NamedLockFactoryAdapterFactoryImpl; 119import org.eclipse.aether.internal.impl.transport.http.DefaultChecksumExtractor; 120import org.eclipse.aether.internal.impl.transport.http.Nx2ChecksumExtractor; 121import org.eclipse.aether.internal.impl.transport.http.XChecksumExtractor; 122import org.eclipse.aether.named.NamedLockFactory; 123import org.eclipse.aether.named.providers.FileLockNamedLockFactory; 124import org.eclipse.aether.named.providers.LocalReadWriteLockNamedLockFactory; 125import org.eclipse.aether.named.providers.LocalSemaphoreNamedLockFactory; 126import org.eclipse.aether.named.providers.NoopNamedLockFactory; 127import org.eclipse.aether.spi.artifact.ArtifactPredicateFactory; 128import org.eclipse.aether.spi.artifact.decorator.ArtifactDecoratorFactory; 129import org.eclipse.aether.spi.artifact.generator.ArtifactGeneratorFactory; 130import org.eclipse.aether.spi.artifact.transformer.ArtifactTransformer; 131import org.eclipse.aether.spi.checksums.ProvidedChecksumsSource; 132import org.eclipse.aether.spi.checksums.TrustedChecksumsSource; 133import org.eclipse.aether.spi.connector.PipelineRepositoryConnectorFactory; 134import org.eclipse.aether.spi.connector.RepositoryConnectorFactory; 135import org.eclipse.aether.spi.connector.checksum.ChecksumAlgorithmFactory; 136import org.eclipse.aether.spi.connector.checksum.ChecksumAlgorithmFactorySelector; 137import org.eclipse.aether.spi.connector.checksum.ChecksumPolicyProvider; 138import org.eclipse.aether.spi.connector.filter.RemoteRepositoryFilterSource; 139import org.eclipse.aether.spi.connector.layout.RepositoryLayoutFactory; 140import org.eclipse.aether.spi.connector.layout.RepositoryLayoutProvider; 141import org.eclipse.aether.spi.connector.transport.TransporterFactory; 142import org.eclipse.aether.spi.connector.transport.TransporterProvider; 143import org.eclipse.aether.spi.connector.transport.http.ChecksumExtractor; 144import org.eclipse.aether.spi.connector.transport.http.ChecksumExtractorStrategy; 145import org.eclipse.aether.spi.io.ChecksumProcessor; 146import org.eclipse.aether.spi.io.PathProcessor; 147import org.eclipse.aether.spi.localrepo.LocalRepositoryManagerFactory; 148import org.eclipse.aether.spi.locking.LockingInhibitorFactory; 149import org.eclipse.aether.spi.remoterepo.RepositoryKeyFunctionFactory; 150import org.eclipse.aether.spi.resolution.ArtifactResolverPostProcessor; 151import org.eclipse.aether.spi.synccontext.SyncContextFactory; 152import org.eclipse.aether.spi.validator.ValidatorFactory; 153import org.eclipse.aether.transport.apache.ApacheTransporterFactory; 154import org.eclipse.aether.transport.file.FileTransporterFactory; 155import org.eclipse.aether.util.version.GenericVersionScheme; 156import org.eclipse.aether.version.VersionScheme; 157 158/** 159 * A simple memorizing {@link Supplier} of {@link org.eclipse.aether.RepositorySystem} instance, that on first call 160 * supplies lazily constructed instance, and on each subsequent call same instance. Hence, this instance should be 161 * thrown away immediately once repository system was created and there is no need for more instances. If new 162 * repository system instance needed, new instance of this class must be created. For proper shut down of returned 163 * repository system instance(s) use {@link RepositorySystem#shutdown()} method on supplied instance(s). 164 * <p> 165 * Since Resolver 2.0 this class offers access to various components via public getters, and allows even partial object 166 * graph construction. 167 * <p> 168 * Extend this class {@code createXXX()} methods and override to customize, if needed. The contract of this class makes 169 * sure that these (potentially overridden) methods are invoked only once, and instance created by those methods are 170 * memorized and kept as long as supplier instance is kept open. 171 * <p> 172 * This class is not thread safe and must be used from one thread only, while the constructed {@link RepositorySystem} 173 * is thread safe. 174 * <p> 175 * Important: Given the instance of supplier memorizes the supplier {@link RepositorySystem} instance it supplies, 176 * their lifecycle is shared as well: once supplied repository system is shut-down, this instance becomes closed as 177 * well. Any subsequent {@code getXXX} method invocation attempt will fail with {@link IllegalStateException}. 178 * 179 * @since 1.9.15 180 */ 181public 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 // by default none, this is extension point 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 // by default none, this is extension point 1014 return new HashMap<>(); 1015 } 1016 1017 // Maven provided 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 // from maven-resolver-provider 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 // from maven-resolver-provider 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 // from maven-resolver-provider: none by default 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 // from maven-resolver-provider 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 // from maven-resolver-provider 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 // from maven-resolver-provider 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 // from maven-model-builder 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 // from maven-resolver-provider 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}