You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@camel.apache.org by or...@apache.org on 2023/02/25 14:14:13 UTC
[camel] 09/13: CAMEL-15105: implement a wrapper Configurer so that the context and the extended context configuration can be done as one
This is an automated email from the ASF dual-hosted git repository.
orpiske pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel.git
commit a26635e18b6f289e15a161a2bfd0d2b8cb91f56e
Author: Otavio Rodolfo Piske <an...@gmail.com>
AuthorDate: Mon Feb 20 12:10:47 2023 +0100
CAMEL-15105: implement a wrapper Configurer so that the context and the extended context configuration can be done as one
- This also makes the code resolve the CamelContext before the others
- Adjust DefaultConfigurerResolverTest to reflect the new wrapper class and newer behavior
- Split the auto-configuration for the CamelContext and the CamelContextExtension
---
.../impl/engine/DefaultConfigurerResolver.java | 71 +++-
core/camel-core-engine/pom.xml | 1 +
.../apache/camel/impl/CamelContextConfigurer.java | 376 +++++++++++++++++++++
.../camel/configurer/org.apache.camel.CamelContext | 2 +
.../impl/engine/DefaultConfigurerResolverTest.java | 40 ++-
.../org/apache/camel/main/BaseMainSupport.java | 3 +
6 files changed, 479 insertions(+), 14 deletions(-)
diff --git a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultConfigurerResolver.java b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultConfigurerResolver.java
index c850c865337..c5f23a0f741 100644
--- a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultConfigurerResolver.java
+++ b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultConfigurerResolver.java
@@ -33,6 +33,30 @@ import org.slf4j.LoggerFactory;
* <b>META-INF/services/org/apache/camel/configurer/</b>.
*/
public class DefaultConfigurerResolver implements ConfigurerResolver {
+ /**
+ * This is a special container for the CamelContext because, with Camel 4, we split the CamelContext and the former
+ * ExtendedCamelContext. This holds them in a single configuration, directing the target appropriately
+ */
+ public static class ContextConfigurer implements PropertyConfigurer {
+ private final PropertyConfigurer contextConfigurer;
+ private final PropertyConfigurer extensionConfigurer;
+
+ public ContextConfigurer(PropertyConfigurer contextConfigurer, PropertyConfigurer extensionConfigurer) {
+ this.contextConfigurer = contextConfigurer;
+ this.extensionConfigurer = extensionConfigurer;
+ }
+
+ @Override
+ public boolean configure(CamelContext camelContext, Object target, String name, Object value, boolean ignoreCase) {
+ if (target instanceof CamelContext contextTarget) {
+ if (!contextConfigurer.configure(camelContext, contextTarget, name, value, ignoreCase)) {
+ return extensionConfigurer.configure(camelContext, contextTarget.getCamelContextExtension(), name, value, ignoreCase);
+ }
+ }
+
+ return false;
+ }
+ }
private static final Logger LOG = LoggerFactory.getLogger(DefaultConfigurerResolver.class);
@@ -65,15 +89,25 @@ public class DefaultConfigurerResolver implements ConfigurerResolver {
// not in registry then use configurer factory
Class<?> type;
try {
- type = findConfigurer(name, context);
- if (type == null) {
- if (name.startsWith("org.apache.camel.") && name.contains("CamelContext")) {
- // fallback special for camel context itself as we have an extended configurer
- type = findConfigurer(ExtendedCamelContext.class.getName(), context);
+ // fallback special for camel context itself as we have an extended configurer
+ if (name.startsWith("org.apache.camel.") && name.contains("CamelContext") && !name.contains("Extension")) {
+ type = findConfigurer(CamelContext.class.getName(), context);
+
+ if (type != null) {
+ var extensionType = findConfigurer(ExtendedCamelContext.class.getName(), context);
+
+ if (extensionType != null) {
+ return createPropertyConfigurerForContext(name, context, type, extensionType);
+ }
}
+ //
+ } else {
+ type = findConfigurer(name, context);
if (type == null) {
- // not found
- return null;
+
+ if (type == null) {
+ return null;
+ }
}
}
} catch (NoFactoryAvailableException e) {
@@ -82,6 +116,10 @@ public class DefaultConfigurerResolver implements ConfigurerResolver {
throw new IllegalArgumentException("Invalid URI, no Configurer registered for scheme: " + name, e);
}
+ return createPropertyConfigurer(name, context, type);
+ }
+
+ private PropertyConfigurer createPropertyConfigurer(String name, CamelContext context, Class<?> type) {
if (getLog().isDebugEnabled()) {
getLog().debug("Found configurer: {} via type: {} via: {}{}", name, type.getName(), factoryFinder.getResourcePath(),
name);
@@ -96,6 +134,25 @@ public class DefaultConfigurerResolver implements ConfigurerResolver {
}
}
+ private PropertyConfigurer createPropertyConfigurerForContext(String name, CamelContext context, Class<?> type, Class<?> extensionType) {
+ if (getLog().isDebugEnabled()) {
+ getLog().debug("Found configurer: {} via type: {} via: {}{}", name, type.getName(), factoryFinder.getResourcePath(),
+ name);
+ }
+
+ var contextConfigurer = (PropertyConfigurer) context.getInjector().newInstance(type, false);
+ var extensionConfigurer = (PropertyConfigurer) context.getInjector().newInstance(extensionType, false);
+
+
+ // create the component
+ if (PropertyConfigurer.class.isAssignableFrom(type)) {
+ return new ContextConfigurer(contextConfigurer, extensionConfigurer);
+ } else {
+ throw new IllegalArgumentException(
+ "Type is not a PropertyConfigurer implementation. Found: " + type.getName());
+ }
+ }
+
private Class<?> findConfigurer(String name, CamelContext context) throws IOException {
if (factoryFinder == null) {
factoryFinder = context.getCamelContextExtension().getFactoryFinder(ConfigurerResolver.RESOURCE_PATH);
diff --git a/core/camel-core-engine/pom.xml b/core/camel-core-engine/pom.xml
index a51ca30f0ff..fb7b18ce7a9 100644
--- a/core/camel-core-engine/pom.xml
+++ b/core/camel-core-engine/pom.xml
@@ -127,6 +127,7 @@
<class>org.apache.camel.ExtendedCamelContext=org.apache.camel.impl.ExtendedCamelContext</class>
<!-- we want to have configurer for RestConfiguration in camel-core-engine -->
<class>org.apache.camel.spi.RestConfiguration=org.apache.camel.impl.RestConfiguration</class>
+ <class>org.apache.camel.CamelContext=org.apache.camel.impl.CamelContext</class>
</classes>
</configuration>
</execution>
diff --git a/core/camel-core-engine/src/generated/java/org/apache/camel/impl/CamelContextConfigurer.java b/core/camel-core-engine/src/generated/java/org/apache/camel/impl/CamelContextConfigurer.java
new file mode 100644
index 00000000000..ac9d605f8b8
--- /dev/null
+++ b/core/camel-core-engine/src/generated/java/org/apache/camel/impl/CamelContextConfigurer.java
@@ -0,0 +1,376 @@
+/* Generated by camel build tools - do NOT edit this file! */
+package org.apache.camel.impl;
+
+import java.util.Map;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.spi.ExtendedPropertyConfigurerGetter;
+import org.apache.camel.spi.PropertyConfigurerGetter;
+import org.apache.camel.spi.ConfigurerStrategy;
+import org.apache.camel.spi.GeneratedPropertyConfigurer;
+import org.apache.camel.util.CaseInsensitiveMap;
+import org.apache.camel.CamelContext;
+
+/**
+ * Generated by camel build tools - do NOT edit this file!
+ */
+@SuppressWarnings("unchecked")
+public class CamelContextConfigurer extends org.apache.camel.support.component.PropertyConfigurerSupport implements GeneratedPropertyConfigurer, PropertyConfigurerGetter {
+
+ @Override
+ public boolean configure(CamelContext camelContext, Object obj, String name, Object value, boolean ignoreCase) {
+ org.apache.camel.CamelContext target = (org.apache.camel.CamelContext) obj;
+ switch (ignoreCase ? name.toLowerCase() : name) {
+ case "allowuseoriginalmessage":
+ case "AllowUseOriginalMessage": target.setAllowUseOriginalMessage(property(camelContext, java.lang.Boolean.class, value)); return true;
+ case "applicationcontextclassloader":
+ case "ApplicationContextClassLoader": target.setApplicationContextClassLoader(property(camelContext, java.lang.ClassLoader.class, value)); return true;
+ case "autostartup":
+ case "AutoStartup": target.setAutoStartup(property(camelContext, java.lang.Boolean.class, value)); return true;
+ case "autowiredenabled":
+ case "AutowiredEnabled": target.setAutowiredEnabled(property(camelContext, java.lang.Boolean.class, value)); return true;
+ case "backlogtracing":
+ case "BacklogTracing": target.setBacklogTracing(property(camelContext, java.lang.Boolean.class, value)); return true;
+ case "backlogtracingstandby":
+ case "BacklogTracingStandby": target.setBacklogTracingStandby(property(camelContext, boolean.class, value)); return true;
+ case "caseinsensitiveheaders":
+ case "CaseInsensitiveHeaders": target.setCaseInsensitiveHeaders(property(camelContext, java.lang.Boolean.class, value)); return true;
+ case "classresolver":
+ case "ClassResolver": target.setClassResolver(property(camelContext, org.apache.camel.spi.ClassResolver.class, value)); return true;
+ case "debugger":
+ case "Debugger": target.setDebugger(property(camelContext, org.apache.camel.spi.Debugger.class, value)); return true;
+ case "debugging":
+ case "Debugging": target.setDebugging(property(camelContext, java.lang.Boolean.class, value)); return true;
+ case "delayer":
+ case "Delayer": target.setDelayer(property(camelContext, java.lang.Long.class, value)); return true;
+ case "devconsole":
+ case "DevConsole": target.setDevConsole(property(camelContext, java.lang.Boolean.class, value)); return true;
+ case "dumproutes":
+ case "DumpRoutes": target.setDumpRoutes(property(camelContext, java.lang.Boolean.class, value)); return true;
+ case "executorservicemanager":
+ case "ExecutorServiceManager": target.setExecutorServiceManager(property(camelContext, org.apache.camel.spi.ExecutorServiceManager.class, value)); return true;
+ case "globaloptions":
+ case "GlobalOptions": target.setGlobalOptions(property(camelContext, java.util.Map.class, value)); return true;
+ case "inflightrepository":
+ case "InflightRepository": target.setInflightRepository(property(camelContext, org.apache.camel.spi.InflightRepository.class, value)); return true;
+ case "injector":
+ case "Injector": target.setInjector(property(camelContext, org.apache.camel.spi.Injector.class, value)); return true;
+ case "loadhealthchecks":
+ case "LoadHealthChecks": target.setLoadHealthChecks(property(camelContext, java.lang.Boolean.class, value)); return true;
+ case "loadtypeconverters":
+ case "LoadTypeConverters": target.setLoadTypeConverters(property(camelContext, java.lang.Boolean.class, value)); return true;
+ case "logexhaustedmessagebody":
+ case "LogExhaustedMessageBody": target.setLogExhaustedMessageBody(property(camelContext, java.lang.Boolean.class, value)); return true;
+ case "logmask":
+ case "LogMask": target.setLogMask(property(camelContext, java.lang.Boolean.class, value)); return true;
+ case "mdcloggingkeyspattern":
+ case "MDCLoggingKeysPattern": target.setMDCLoggingKeysPattern(property(camelContext, java.lang.String.class, value)); return true;
+ case "managementname":
+ case "ManagementName": target.setManagementName(property(camelContext, java.lang.String.class, value)); return true;
+ case "managementnamestrategy":
+ case "ManagementNameStrategy": target.setManagementNameStrategy(property(camelContext, org.apache.camel.spi.ManagementNameStrategy.class, value)); return true;
+ case "managementstrategy":
+ case "ManagementStrategy": target.setManagementStrategy(property(camelContext, org.apache.camel.spi.ManagementStrategy.class, value)); return true;
+ case "messagehistory":
+ case "MessageHistory": target.setMessageHistory(property(camelContext, java.lang.Boolean.class, value)); return true;
+ case "messagehistoryfactory":
+ case "MessageHistoryFactory": target.setMessageHistoryFactory(property(camelContext, org.apache.camel.spi.MessageHistoryFactory.class, value)); return true;
+ case "modeline":
+ case "Modeline": target.setModeline(property(camelContext, java.lang.Boolean.class, value)); return true;
+ case "namestrategy":
+ case "NameStrategy": target.setNameStrategy(property(camelContext, org.apache.camel.spi.CamelContextNameStrategy.class, value)); return true;
+ case "propertiescomponent":
+ case "PropertiesComponent": target.setPropertiesComponent(property(camelContext, org.apache.camel.spi.PropertiesComponent.class, value)); return true;
+ case "restconfiguration":
+ case "RestConfiguration": target.setRestConfiguration(property(camelContext, org.apache.camel.spi.RestConfiguration.class, value)); return true;
+ case "restregistry":
+ case "RestRegistry": target.setRestRegistry(property(camelContext, org.apache.camel.spi.RestRegistry.class, value)); return true;
+ case "routecontroller":
+ case "RouteController": target.setRouteController(property(camelContext, org.apache.camel.spi.RouteController.class, value)); return true;
+ case "runtimeendpointregistry":
+ case "RuntimeEndpointRegistry": target.setRuntimeEndpointRegistry(property(camelContext, org.apache.camel.spi.RuntimeEndpointRegistry.class, value)); return true;
+ case "sslcontextparameters":
+ case "SSLContextParameters": target.setSSLContextParameters(property(camelContext, org.apache.camel.support.jsse.SSLContextParameters.class, value)); return true;
+ case "shutdownroute":
+ case "ShutdownRoute": target.setShutdownRoute(property(camelContext, org.apache.camel.ShutdownRoute.class, value)); return true;
+ case "shutdownrunningtask":
+ case "ShutdownRunningTask": target.setShutdownRunningTask(property(camelContext, org.apache.camel.ShutdownRunningTask.class, value)); return true;
+ case "shutdownstrategy":
+ case "ShutdownStrategy": target.setShutdownStrategy(property(camelContext, org.apache.camel.spi.ShutdownStrategy.class, value)); return true;
+ case "sourcelocationenabled":
+ case "SourceLocationEnabled": target.setSourceLocationEnabled(property(camelContext, java.lang.Boolean.class, value)); return true;
+ case "startupsummarylevel":
+ case "StartupSummaryLevel": target.setStartupSummaryLevel(property(camelContext, org.apache.camel.StartupSummaryLevel.class, value)); return true;
+ case "streamcaching":
+ case "StreamCaching": target.setStreamCaching(property(camelContext, java.lang.Boolean.class, value)); return true;
+ case "streamcachingstrategy":
+ case "StreamCachingStrategy": target.setStreamCachingStrategy(property(camelContext, org.apache.camel.spi.StreamCachingStrategy.class, value)); return true;
+ case "tracer":
+ case "Tracer": target.setTracer(property(camelContext, org.apache.camel.spi.Tracer.class, value)); return true;
+ case "tracing":
+ case "Tracing": target.setTracing(property(camelContext, java.lang.Boolean.class, value)); return true;
+ case "tracingloggingformat":
+ case "TracingLoggingFormat": target.setTracingLoggingFormat(property(camelContext, java.lang.String.class, value)); return true;
+ case "tracingpattern":
+ case "TracingPattern": target.setTracingPattern(property(camelContext, java.lang.String.class, value)); return true;
+ case "tracingstandby":
+ case "TracingStandby": target.setTracingStandby(property(camelContext, boolean.class, value)); return true;
+ case "typeconverterregistry":
+ case "TypeConverterRegistry": target.setTypeConverterRegistry(property(camelContext, org.apache.camel.spi.TypeConverterRegistry.class, value)); return true;
+ case "typeconverterstatisticsenabled":
+ case "TypeConverterStatisticsEnabled": target.setTypeConverterStatisticsEnabled(property(camelContext, java.lang.Boolean.class, value)); return true;
+ case "usebreadcrumb":
+ case "UseBreadcrumb": target.setUseBreadcrumb(property(camelContext, java.lang.Boolean.class, value)); return true;
+ case "usedatatype":
+ case "UseDataType": target.setUseDataType(property(camelContext, java.lang.Boolean.class, value)); return true;
+ case "usemdclogging":
+ case "UseMDCLogging": target.setUseMDCLogging(property(camelContext, java.lang.Boolean.class, value)); return true;
+ case "uuidgenerator":
+ case "UuidGenerator": target.setUuidGenerator(property(camelContext, org.apache.camel.spi.UuidGenerator.class, value)); return true;
+ case "vaultconfiguration":
+ case "VaultConfiguration": target.setVaultConfiguration(property(camelContext, org.apache.camel.vault.VaultConfiguration.class, value)); return true;
+ default: return false;
+ }
+ }
+
+ @Override
+ public Class<?> getOptionType(String name, boolean ignoreCase) {
+ switch (ignoreCase ? name.toLowerCase() : name) {
+ case "allowuseoriginalmessage":
+ case "AllowUseOriginalMessage": return java.lang.Boolean.class;
+ case "applicationcontextclassloader":
+ case "ApplicationContextClassLoader": return java.lang.ClassLoader.class;
+ case "autostartup":
+ case "AutoStartup": return java.lang.Boolean.class;
+ case "autowiredenabled":
+ case "AutowiredEnabled": return java.lang.Boolean.class;
+ case "backlogtracing":
+ case "BacklogTracing": return java.lang.Boolean.class;
+ case "backlogtracingstandby":
+ case "BacklogTracingStandby": return boolean.class;
+ case "caseinsensitiveheaders":
+ case "CaseInsensitiveHeaders": return java.lang.Boolean.class;
+ case "classresolver":
+ case "ClassResolver": return org.apache.camel.spi.ClassResolver.class;
+ case "debugger":
+ case "Debugger": return org.apache.camel.spi.Debugger.class;
+ case "debugging":
+ case "Debugging": return java.lang.Boolean.class;
+ case "delayer":
+ case "Delayer": return java.lang.Long.class;
+ case "devconsole":
+ case "DevConsole": return java.lang.Boolean.class;
+ case "dumproutes":
+ case "DumpRoutes": return java.lang.Boolean.class;
+ case "executorservicemanager":
+ case "ExecutorServiceManager": return org.apache.camel.spi.ExecutorServiceManager.class;
+ case "globaloptions":
+ case "GlobalOptions": return java.util.Map.class;
+ case "inflightrepository":
+ case "InflightRepository": return org.apache.camel.spi.InflightRepository.class;
+ case "injector":
+ case "Injector": return org.apache.camel.spi.Injector.class;
+ case "loadhealthchecks":
+ case "LoadHealthChecks": return java.lang.Boolean.class;
+ case "loadtypeconverters":
+ case "LoadTypeConverters": return java.lang.Boolean.class;
+ case "logexhaustedmessagebody":
+ case "LogExhaustedMessageBody": return java.lang.Boolean.class;
+ case "logmask":
+ case "LogMask": return java.lang.Boolean.class;
+ case "mdcloggingkeyspattern":
+ case "MDCLoggingKeysPattern": return java.lang.String.class;
+ case "managementname":
+ case "ManagementName": return java.lang.String.class;
+ case "managementnamestrategy":
+ case "ManagementNameStrategy": return org.apache.camel.spi.ManagementNameStrategy.class;
+ case "managementstrategy":
+ case "ManagementStrategy": return org.apache.camel.spi.ManagementStrategy.class;
+ case "messagehistory":
+ case "MessageHistory": return java.lang.Boolean.class;
+ case "messagehistoryfactory":
+ case "MessageHistoryFactory": return org.apache.camel.spi.MessageHistoryFactory.class;
+ case "modeline":
+ case "Modeline": return java.lang.Boolean.class;
+ case "namestrategy":
+ case "NameStrategy": return org.apache.camel.spi.CamelContextNameStrategy.class;
+ case "propertiescomponent":
+ case "PropertiesComponent": return org.apache.camel.spi.PropertiesComponent.class;
+ case "restconfiguration":
+ case "RestConfiguration": return org.apache.camel.spi.RestConfiguration.class;
+ case "restregistry":
+ case "RestRegistry": return org.apache.camel.spi.RestRegistry.class;
+ case "routecontroller":
+ case "RouteController": return org.apache.camel.spi.RouteController.class;
+ case "runtimeendpointregistry":
+ case "RuntimeEndpointRegistry": return org.apache.camel.spi.RuntimeEndpointRegistry.class;
+ case "sslcontextparameters":
+ case "SSLContextParameters": return org.apache.camel.support.jsse.SSLContextParameters.class;
+ case "shutdownroute":
+ case "ShutdownRoute": return org.apache.camel.ShutdownRoute.class;
+ case "shutdownrunningtask":
+ case "ShutdownRunningTask": return org.apache.camel.ShutdownRunningTask.class;
+ case "shutdownstrategy":
+ case "ShutdownStrategy": return org.apache.camel.spi.ShutdownStrategy.class;
+ case "sourcelocationenabled":
+ case "SourceLocationEnabled": return java.lang.Boolean.class;
+ case "startupsummarylevel":
+ case "StartupSummaryLevel": return org.apache.camel.StartupSummaryLevel.class;
+ case "streamcaching":
+ case "StreamCaching": return java.lang.Boolean.class;
+ case "streamcachingstrategy":
+ case "StreamCachingStrategy": return org.apache.camel.spi.StreamCachingStrategy.class;
+ case "tracer":
+ case "Tracer": return org.apache.camel.spi.Tracer.class;
+ case "tracing":
+ case "Tracing": return java.lang.Boolean.class;
+ case "tracingloggingformat":
+ case "TracingLoggingFormat": return java.lang.String.class;
+ case "tracingpattern":
+ case "TracingPattern": return java.lang.String.class;
+ case "tracingstandby":
+ case "TracingStandby": return boolean.class;
+ case "typeconverterregistry":
+ case "TypeConverterRegistry": return org.apache.camel.spi.TypeConverterRegistry.class;
+ case "typeconverterstatisticsenabled":
+ case "TypeConverterStatisticsEnabled": return java.lang.Boolean.class;
+ case "usebreadcrumb":
+ case "UseBreadcrumb": return java.lang.Boolean.class;
+ case "usedatatype":
+ case "UseDataType": return java.lang.Boolean.class;
+ case "usemdclogging":
+ case "UseMDCLogging": return java.lang.Boolean.class;
+ case "uuidgenerator":
+ case "UuidGenerator": return org.apache.camel.spi.UuidGenerator.class;
+ case "vaultconfiguration":
+ case "VaultConfiguration": return org.apache.camel.vault.VaultConfiguration.class;
+ default: return null;
+ }
+ }
+
+ @Override
+ public Object getOptionValue(Object obj, String name, boolean ignoreCase) {
+ org.apache.camel.CamelContext target = (org.apache.camel.CamelContext) obj;
+ switch (ignoreCase ? name.toLowerCase() : name) {
+ case "allowuseoriginalmessage":
+ case "AllowUseOriginalMessage": return target.isAllowUseOriginalMessage();
+ case "applicationcontextclassloader":
+ case "ApplicationContextClassLoader": return target.getApplicationContextClassLoader();
+ case "autostartup":
+ case "AutoStartup": return target.isAutoStartup();
+ case "autowiredenabled":
+ case "AutowiredEnabled": return target.isAutowiredEnabled();
+ case "backlogtracing":
+ case "BacklogTracing": return target.isBacklogTracing();
+ case "backlogtracingstandby":
+ case "BacklogTracingStandby": return target.isBacklogTracingStandby();
+ case "caseinsensitiveheaders":
+ case "CaseInsensitiveHeaders": return target.isCaseInsensitiveHeaders();
+ case "classresolver":
+ case "ClassResolver": return target.getClassResolver();
+ case "debugger":
+ case "Debugger": return target.getDebugger();
+ case "debugging":
+ case "Debugging": return target.isDebugging();
+ case "delayer":
+ case "Delayer": return target.getDelayer();
+ case "devconsole":
+ case "DevConsole": return target.isDevConsole();
+ case "dumproutes":
+ case "DumpRoutes": return target.isDumpRoutes();
+ case "executorservicemanager":
+ case "ExecutorServiceManager": return target.getExecutorServiceManager();
+ case "globaloptions":
+ case "GlobalOptions": return target.getGlobalOptions();
+ case "inflightrepository":
+ case "InflightRepository": return target.getInflightRepository();
+ case "injector":
+ case "Injector": return target.getInjector();
+ case "loadhealthchecks":
+ case "LoadHealthChecks": return target.isLoadHealthChecks();
+ case "loadtypeconverters":
+ case "LoadTypeConverters": return target.isLoadTypeConverters();
+ case "logexhaustedmessagebody":
+ case "LogExhaustedMessageBody": return target.isLogExhaustedMessageBody();
+ case "logmask":
+ case "LogMask": return target.isLogMask();
+ case "mdcloggingkeyspattern":
+ case "MDCLoggingKeysPattern": return target.getMDCLoggingKeysPattern();
+ case "managementname":
+ case "ManagementName": return target.getManagementName();
+ case "managementnamestrategy":
+ case "ManagementNameStrategy": return target.getManagementNameStrategy();
+ case "managementstrategy":
+ case "ManagementStrategy": return target.getManagementStrategy();
+ case "messagehistory":
+ case "MessageHistory": return target.isMessageHistory();
+ case "messagehistoryfactory":
+ case "MessageHistoryFactory": return target.getMessageHistoryFactory();
+ case "modeline":
+ case "Modeline": return target.isModeline();
+ case "namestrategy":
+ case "NameStrategy": return target.getNameStrategy();
+ case "propertiescomponent":
+ case "PropertiesComponent": return target.getPropertiesComponent();
+ case "restconfiguration":
+ case "RestConfiguration": return target.getRestConfiguration();
+ case "restregistry":
+ case "RestRegistry": return target.getRestRegistry();
+ case "routecontroller":
+ case "RouteController": return target.getRouteController();
+ case "runtimeendpointregistry":
+ case "RuntimeEndpointRegistry": return target.getRuntimeEndpointRegistry();
+ case "sslcontextparameters":
+ case "SSLContextParameters": return target.getSSLContextParameters();
+ case "shutdownroute":
+ case "ShutdownRoute": return target.getShutdownRoute();
+ case "shutdownrunningtask":
+ case "ShutdownRunningTask": return target.getShutdownRunningTask();
+ case "shutdownstrategy":
+ case "ShutdownStrategy": return target.getShutdownStrategy();
+ case "sourcelocationenabled":
+ case "SourceLocationEnabled": return target.isSourceLocationEnabled();
+ case "startupsummarylevel":
+ case "StartupSummaryLevel": return target.getStartupSummaryLevel();
+ case "streamcaching":
+ case "StreamCaching": return target.isStreamCaching();
+ case "streamcachingstrategy":
+ case "StreamCachingStrategy": return target.getStreamCachingStrategy();
+ case "tracer":
+ case "Tracer": return target.getTracer();
+ case "tracing":
+ case "Tracing": return target.isTracing();
+ case "tracingloggingformat":
+ case "TracingLoggingFormat": return target.getTracingLoggingFormat();
+ case "tracingpattern":
+ case "TracingPattern": return target.getTracingPattern();
+ case "tracingstandby":
+ case "TracingStandby": return target.isTracingStandby();
+ case "typeconverterregistry":
+ case "TypeConverterRegistry": return target.getTypeConverterRegistry();
+ case "typeconverterstatisticsenabled":
+ case "TypeConverterStatisticsEnabled": return target.isTypeConverterStatisticsEnabled();
+ case "usebreadcrumb":
+ case "UseBreadcrumb": return target.isUseBreadcrumb();
+ case "usedatatype":
+ case "UseDataType": return target.isUseDataType();
+ case "usemdclogging":
+ case "UseMDCLogging": return target.isUseMDCLogging();
+ case "uuidgenerator":
+ case "UuidGenerator": return target.getUuidGenerator();
+ case "vaultconfiguration":
+ case "VaultConfiguration": return target.getVaultConfiguration();
+ default: return null;
+ }
+ }
+
+ @Override
+ public Object getCollectionValueType(Object target, String name, boolean ignoreCase) {
+ switch (ignoreCase ? name.toLowerCase() : name) {
+ case "globaloptions":
+ case "GlobalOptions": return java.lang.String.class;
+ default: return null;
+ }
+ }
+}
+
diff --git a/core/camel-core-engine/src/generated/resources/META-INF/services/org/apache/camel/configurer/org.apache.camel.CamelContext b/core/camel-core-engine/src/generated/resources/META-INF/services/org/apache/camel/configurer/org.apache.camel.CamelContext
new file mode 100644
index 00000000000..de20c75ed9a
--- /dev/null
+++ b/core/camel-core-engine/src/generated/resources/META-INF/services/org/apache/camel/configurer/org.apache.camel.CamelContext
@@ -0,0 +1,2 @@
+# Generated by camel build tools - do NOT edit this file!
+class=org.apache.camel.impl.CamelContextConfigurer
diff --git a/core/camel-core/src/test/java/org/apache/camel/impl/engine/DefaultConfigurerResolverTest.java b/core/camel-core/src/test/java/org/apache/camel/impl/engine/DefaultConfigurerResolverTest.java
index a4ba3d9865e..966be88e25d 100644
--- a/core/camel-core/src/test/java/org/apache/camel/impl/engine/DefaultConfigurerResolverTest.java
+++ b/core/camel-core/src/test/java/org/apache/camel/impl/engine/DefaultConfigurerResolverTest.java
@@ -19,9 +19,9 @@ package org.apache.camel.impl.engine;
import java.util.stream.Stream;
import org.apache.camel.CamelContext;
-import org.apache.camel.ExtendedCamelContext;
import org.apache.camel.impl.DefaultCamelContext;
-import org.apache.camel.impl.ExtendedCamelContextConfigurer;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
@@ -29,19 +29,45 @@ import static org.assertj.core.api.Assertions.assertThat;
class DefaultConfigurerResolverTest {
private DefaultConfigurerResolver resolver;
+ private DefaultCamelContext ctx;
+ @BeforeEach
+ public void setup() {
+ resolver = new DefaultConfigurerResolver();
+ ctx = new DefaultCamelContext();
+ }
+
+ @DisplayName("Test that the configurer uses the ContextConfigurer wrapper for the CamelContext and subclasses")
+ @Test
+ void resolvePropertyConfigurerShouldFallbackToDefaultConfigurer() {
+ Stream.of(CamelContext.class.getName(), SimpleCamelContext.class.getName(), "org.apache.camel.model.ModelCamelContext",
+ "org.apache.camel.SomeCamelContextStuff")
+ .forEach(name -> assertThat(resolver.resolvePropertyConfigurer(name, ctx))
+ .as(name).isInstanceOf(DefaultConfigurerResolver.ContextConfigurer.class));
+
+ Stream.of(DefaultCamelContextExtension.class.getName(), "org.apache.camel.SomeCamelContextStuffExtension")
+ .forEach(name -> assertThat(resolver.resolvePropertyConfigurer(name, ctx))
+ .as(name).isNull());
+ }
+
+ // Note, this might change when we fully decouple the extension from the context
+ @DisplayName("Test that the configurer defaults to null if given the extension (ContextConfiguration must be done via Context configurers)")
@Test
- void resolvePropertyConfigurerShouldFallbackToExtendedCamelContextOnlyForCamelComponents() {
+ void resolvePropertyConfigurerForContextExtension() {
resolver = new DefaultConfigurerResolver();
DefaultCamelContext ctx = new DefaultCamelContext();
- Stream.of(CamelContext.class.getName(), ExtendedCamelContext.class.getName(),
- SimpleCamelContext.class.getName(), "org.apache.camel.SomeCamelContextStuff")
+ Stream.of(DefaultCamelContextExtension.class.getName(), "org.apache.camel.SomeCamelContextStuffExtension")
.forEach(name -> assertThat(resolver.resolvePropertyConfigurer(name, ctx))
- .as(name).isInstanceOf(ExtendedCamelContextConfigurer.class));
+ .as(name).isNull());
+ }
+
+ @DisplayName("Test that the configurer returns null for classes named similarly, but unrelated to CamelContext")
+ @Test
+ void resolvePropertyConfigurerShouldFallbackToExtendedCamelContextOnlyForCamelComponents3() {
Stream.of(
- "CamelContext", "ExtendedCamelContext", "SimpleCamelContext",
+ "CamelContext", "SimpleCamelContext",
"org.somepackage.CamelContext", "it.apache.camel.ExtendedCamelContext")
.forEach(name -> assertThat(resolver.resolvePropertyConfigurer(name, ctx)).as(name).isNull());
diff --git a/core/camel-main/src/main/java/org/apache/camel/main/BaseMainSupport.java b/core/camel-main/src/main/java/org/apache/camel/main/BaseMainSupport.java
index 1de4e76f1d5..0152ea5e354 100644
--- a/core/camel-main/src/main/java/org/apache/camel/main/BaseMainSupport.java
+++ b/core/camel-main/src/main/java/org/apache/camel/main/BaseMainSupport.java
@@ -1067,6 +1067,9 @@ public abstract class BaseMainSupport extends BaseService {
LOG.debug("Auto-configuring CamelContext from loaded properties: {}", contextProperties.size());
setPropertiesOnTarget(camelContext, camelContext, contextProperties, "camel.context.",
mainConfigurationProperties.isAutoConfigurationFailFast(), true, autoConfiguredProperties);
+
+ setPropertiesOnTarget(camelContext, camelContext.getCamelContextExtension(), contextProperties, "camel.context.extension",
+ mainConfigurationProperties.isAutoConfigurationFailFast(), true, autoConfiguredProperties);
}
if (!restProperties.isEmpty() || mainConfigurationProperties.hasRestConfiguration()) {