in core/camel-main/src/main/java/org/apache/camel/main/DefaultConfigurationConfigurer.java [371:649]
public static void afterConfigure(final CamelContext camelContext) throws Exception {
final Registry registry = camelContext.getRegistry();
final ManagementStrategy managementStrategy = camelContext.getManagementStrategy();
StartupStepRecorder ssr = getSingleBeanOfType(registry, StartupStepRecorder.class);
if (ssr != null) {
camelContext.getCamelContextExtension().setStartupStepRecorder(ssr);
}
CliConnectorFactory ccf = getSingleBeanOfType(registry, CliConnectorFactory.class);
if (ccf != null) {
camelContext.getCamelContextExtension().addContextPlugin(CliConnectorFactory.class, ccf);
}
VariableRepositoryFactory vrf = getSingleBeanOfType(registry, VariableRepositoryFactory.class);
if (vrf != null) {
camelContext.getCamelContextExtension().addContextPlugin(VariableRepositoryFactory.class, vrf);
}
PropertiesComponent pc = getSingleBeanOfType(registry, PropertiesComponent.class);
if (pc != null) {
camelContext.setPropertiesComponent(pc);
}
BacklogTracer bt = getSingleBeanOfType(registry, BacklogTracer.class);
if (bt != null) {
camelContext.getCamelContextExtension().addContextPlugin(BacklogTracer.class, bt);
}
BacklogDebugger bd = getSingleBeanOfType(registry, BacklogDebugger.class);
if (bd != null) {
camelContext.getCamelContextExtension().addContextPlugin(BacklogDebugger.class, bd);
}
InflightRepository ir = getSingleBeanOfType(registry, InflightRepository.class);
if (ir != null) {
camelContext.setInflightRepository(ir);
}
AsyncProcessorAwaitManager apam = getSingleBeanOfType(registry, AsyncProcessorAwaitManager.class);
if (apam != null) {
camelContext.getCamelContextExtension().addContextPlugin(AsyncProcessorAwaitManager.class, apam);
}
ManagementStrategy ms = getSingleBeanOfType(registry, ManagementStrategy.class);
if (ms != null) {
camelContext.setManagementStrategy(ms);
}
ManagementObjectNameStrategy mons = getSingleBeanOfType(registry, ManagementObjectNameStrategy.class);
if (mons != null) {
managementStrategy.setManagementObjectNameStrategy(mons);
}
EventFactory ef = getSingleBeanOfType(registry, EventFactory.class);
if (ef != null) {
managementStrategy.setEventFactory(ef);
}
UnitOfWorkFactory uowf = getSingleBeanOfType(registry, UnitOfWorkFactory.class);
if (uowf != null) {
camelContext.getCamelContextExtension().addContextPlugin(UnitOfWorkFactory.class, uowf);
}
RuntimeEndpointRegistry rer = getSingleBeanOfType(registry, RuntimeEndpointRegistry.class);
if (rer != null) {
camelContext.setRuntimeEndpointRegistry(rer);
}
EndpointServiceRegistry esr = getSingleBeanOfType(registry, EndpointServiceRegistry.class);
if (esr != null) {
camelContext.getCamelContextExtension().addContextPlugin(EndpointServiceRegistry.class, esr);
}
ModelJAXBContextFactory mjcf = getSingleBeanOfType(registry, ModelJAXBContextFactory.class);
if (mjcf != null) {
camelContext.getCamelContextExtension().addContextPlugin(ModelJAXBContextFactory.class, mjcf);
}
ClassResolver cr = getSingleBeanOfType(registry, ClassResolver.class);
if (cr != null) {
camelContext.setClassResolver(cr);
}
FactoryFinderResolver ffr = getSingleBeanOfType(registry, FactoryFinderResolver.class);
if (ffr != null) {
camelContext.getCamelContextExtension().addContextPlugin(FactoryFinderResolver.class, ffr);
}
RouteController rc = getSingleBeanOfType(registry, RouteController.class);
if (rc != null) {
camelContext.setRouteController(rc);
}
UuidGenerator ug = getSingleBeanOfType(registry, UuidGenerator.class);
if (ug != null) {
camelContext.setUuidGenerator(ug);
}
ExecutorServiceManager esm = getSingleBeanOfType(registry, ExecutorServiceManager.class);
if (esm != null) {
camelContext.setExecutorServiceManager(esm);
}
ThreadPoolFactory tpf = getSingleBeanOfType(registry, ThreadPoolFactory.class);
if (tpf != null) {
camelContext.getExecutorServiceManager().setThreadPoolFactory(tpf);
}
ProcessorFactory pf = getSingleBeanOfType(registry, ProcessorFactory.class);
if (pf != null) {
camelContext.getCamelContextExtension().addContextPlugin(ProcessorFactory.class, pf);
}
Debugger debugger = getSingleBeanOfType(registry, Debugger.class);
if (debugger != null) {
camelContext.setDebugger(debugger);
}
NodeIdFactory nif = getSingleBeanOfType(registry, NodeIdFactory.class);
if (nif != null) {
camelContext.getCamelContextExtension().addContextPlugin(NodeIdFactory.class, nif);
}
MessageHistoryFactory mhf = getSingleBeanOfType(registry, MessageHistoryFactory.class);
if (mhf != null) {
camelContext.setMessageHistoryFactory(mhf);
}
ReactiveExecutor re = getSingleBeanOfType(registry, ReactiveExecutor.class);
if (re != null) {
camelContext.getCamelContextExtension().setReactiveExecutor(re);
}
ShutdownStrategy ss = getSingleBeanOfType(registry, ShutdownStrategy.class);
if (ss != null) {
camelContext.setShutdownStrategy(ss);
}
ExchangeFactory exf = getSingleBeanOfType(registry, ExchangeFactory.class);
if (exf != null) {
camelContext.getCamelContextExtension().setExchangeFactory(exf);
}
Set<TypeConverters> tcs = registry.findByType(TypeConverters.class);
if (!tcs.isEmpty()) {
tcs.forEach(t -> camelContext.getTypeConverterRegistry().addTypeConverters(t));
}
Set<EventNotifier> ens = registry.findByType(EventNotifier.class);
if (!ens.isEmpty()) {
ens.forEach(n -> camelContext.getManagementStrategy().addEventNotifier(n));
}
Set<EndpointStrategy> ess = registry.findByType(EndpointStrategy.class);
if (!ess.isEmpty()) {
ess.forEach(camelContext.getCamelContextExtension()::registerEndpointCallback);
}
Set<CamelClusterService> csss = registry.findByType(CamelClusterService.class);
if (!csss.isEmpty()) {
for (CamelClusterService css : csss) {
camelContext.addService(css);
}
}
Set<RoutePolicyFactory> rpfs = registry.findByType(RoutePolicyFactory.class);
if (!rpfs.isEmpty()) {
rpfs.forEach(camelContext::addRoutePolicyFactory);
}
final Predicate<EventNotifier> containsEventNotifier = managementStrategy.getEventNotifiers()::contains;
registerPropertiesForBeanTypesWithCondition(registry, EventNotifier.class, containsEventNotifier.negate(),
managementStrategy::addEventNotifier);
final Predicate<InterceptStrategy> containsInterceptStrategy
= camelContext.getCamelContextExtension().getInterceptStrategies()::contains;
registerPropertiesForBeanTypesWithCondition(registry, InterceptStrategy.class, containsInterceptStrategy.negate(),
camelContext.getCamelContextExtension()::addInterceptStrategy);
final Predicate<LifecycleStrategy> containsLifecycleStrategy = camelContext.getLifecycleStrategies()::contains;
registerPropertiesForBeanTypesWithCondition(registry, LifecycleStrategy.class, containsLifecycleStrategy.negate(),
camelContext::addLifecycleStrategy);
ModelCamelContext mcc = (ModelCamelContext) camelContext;
final Predicate<ModelLifecycleStrategy> containsModelLifecycleStrategy = mcc.getModelLifecycleStrategies()::contains;
registerPropertiesForBeanTypesWithCondition(registry, ModelLifecycleStrategy.class,
containsModelLifecycleStrategy.negate(), mcc::addModelLifecycleStrategy);
// log listeners
Map<String, LogListener> logListeners = registry.findByTypeWithName(LogListener.class);
if (logListeners != null && !logListeners.isEmpty()) {
for (LogListener logListener : logListeners.values()) {
boolean contains = camelContext.getCamelContextExtension().getLogListeners() != null
&& camelContext.getCamelContextExtension().getLogListeners().contains(logListener);
if (!contains) {
camelContext.getCamelContextExtension().addLogListener(logListener);
}
}
}
// service registry
Map<String, ServiceRegistry> serviceRegistries = registry.findByTypeWithName(ServiceRegistry.class);
if (serviceRegistries != null && !serviceRegistries.isEmpty()) {
for (Map.Entry<String, ServiceRegistry> entry : serviceRegistries.entrySet()) {
ServiceRegistry service = entry.getValue();
if (service.getId() == null) {
service.setGeneratedId(camelContext.getUuidGenerator().generateUuid());
}
LOG.info("Adding Camel Cloud ServiceRegistry with id: {} and implementation: {}", service.getId(), service);
camelContext.addService(service);
}
}
// SSL context parameters
GlobalSSLContextParametersSupplier sslContextParametersSupplier
= getSingleBeanOfType(registry, GlobalSSLContextParametersSupplier.class);
if (sslContextParametersSupplier != null) {
camelContext.setSSLContextParameters(sslContextParametersSupplier.get());
}
// health check
HealthCheckRegistry healthCheckRegistry = getSingleBeanOfType(registry, HealthCheckRegistry.class);
if (healthCheckRegistry != null) {
healthCheckRegistry.setCamelContext(camelContext);
LOG.debug("Using HealthCheckRegistry: {}", healthCheckRegistry);
camelContext.getCamelContextExtension().addContextPlugin(HealthCheckRegistry.class, healthCheckRegistry);
} else {
// okay attempt to inject this camel context into existing health check (if any)
healthCheckRegistry = HealthCheckRegistry.get(camelContext);
if (healthCheckRegistry != null) {
healthCheckRegistry.setCamelContext(camelContext);
}
}
if (healthCheckRegistry != null) {
// Health check repository
Set<HealthCheckRepository> repositories = registry.findByType(HealthCheckRepository.class);
if (org.apache.camel.util.ObjectHelper.isNotEmpty(repositories)) {
for (HealthCheckRepository repository : repositories) {
healthCheckRegistry.register(repository);
}
}
}
// dev console
DevConsoleRegistry devConsoleRegistry = getSingleBeanOfType(registry, DevConsoleRegistry.class);
if (devConsoleRegistry != null) {
devConsoleRegistry.setCamelContext(camelContext);
LOG.debug("Using DevConsoleRegistry: {}", devConsoleRegistry);
camelContext.getCamelContextExtension().addContextPlugin(DevConsoleRegistry.class, devConsoleRegistry);
} else {
// okay attempt to inject this camel context into existing dev console (if any)
devConsoleRegistry = DevConsoleRegistry.get(camelContext);
if (devConsoleRegistry != null) {
devConsoleRegistry.setCamelContext(camelContext);
}
}
if (devConsoleRegistry != null) {
Set<DevConsole> consoles = registry.findByType(DevConsole.class);
for (DevConsole console : consoles) {
devConsoleRegistry.register(console);
}
}
// set the default thread pool profile if defined
initThreadPoolProfiles(registry, camelContext);
// vaults
AwsVaultConfiguration aws = getSingleBeanOfType(registry, AwsVaultConfiguration.class);
if (aws != null) {
VaultConfiguration vault = camelContext.getVaultConfiguration();
vault.setAwsVaultConfiguration(aws);
}
GcpVaultConfiguration gcp = getSingleBeanOfType(registry, GcpVaultConfiguration.class);
if (gcp != null) {
VaultConfiguration vault = camelContext.getVaultConfiguration();
vault.setGcpVaultConfiguration(gcp);
}
AzureVaultConfiguration azure = getSingleBeanOfType(registry, AzureVaultConfiguration.class);
if (azure != null) {
VaultConfiguration vault = camelContext.getVaultConfiguration();
vault.setAzureVaultConfiguration(azure);
}
HashicorpVaultConfiguration hashicorp = getSingleBeanOfType(registry, HashicorpVaultConfiguration.class);
if (hashicorp != null) {
VaultConfiguration vault = camelContext.getVaultConfiguration();
vault.setHashicorpVaultConfiguration(hashicorp);
}
KubernetesVaultConfiguration kubernetes = getSingleBeanOfType(registry, KubernetesVaultConfiguration.class);
if (kubernetes != null) {
VaultConfiguration vault = camelContext.getVaultConfiguration();
vault.setKubernetesVaultConfiguration(kubernetes);
}
KubernetesConfigMapVaultConfiguration kubernetesConfigmaps
= getSingleBeanOfType(registry, KubernetesConfigMapVaultConfiguration.class);
if (kubernetesConfigmaps != null) {
VaultConfiguration vault = camelContext.getVaultConfiguration();
vault.setKubernetesConfigMapVaultConfiguration(kubernetesConfigmaps);
}
IBMSecretsManagerVaultConfiguration ibmSecretsManager
= getSingleBeanOfType(registry, IBMSecretsManagerVaultConfiguration.class);
if (ibmSecretsManager != null) {
VaultConfiguration vault = camelContext.getVaultConfiguration();
vault.setIBMSecretsManagerVaultConfiguration(ibmSecretsManager);
}
configureVaultRefresh(camelContext);
// apply custom configurations if any
Set<CamelContextCustomizer> customizers = registry.findByType(CamelContextCustomizer.class);
if (!customizers.isEmpty()) {
customizers.stream()
.sorted(Comparator.comparing(CamelContextCustomizer::getOrder))
.forEach(c -> c.configure(camelContext));
}
}