This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch rc-config
in repository https://gitbox.apache.org/repos/asf/camel.git
commit 577f229030792d9e8a357941a94ecfc90553f9d5
Author: Claus Ibsen <claus.ib...@gmail.com>
AuthorDate: Sun Dec 17 10:50:13 2023 +0100
CAMEL-20243: camel-main - Move route controller options into its own group
---
.../main/camel-main-configuration-metadata.json | 25 +-
.../MainConfigurationPropertiesConfigurer.java | 72 ----
...ontrollerConfigurationPropertiesConfigurer.java | 115 +++++++
.../camel-main-configuration-metadata.json | 25 +-
...mel.main.RouteControllerConfigurationProperties | 2 +
core/camel-main/src/main/docs/main.adoc | 35 +-
.../org/apache/camel/main/BaseMainSupport.java | 69 ++++
.../camel/main/DefaultConfigurationConfigurer.java | 35 --
.../camel/main/DefaultConfigurationProperties.java | 305 -----------------
.../camel/main/MainConfigurationProperties.java | 35 +-
.../RouteControllerConfigurationProperties.java | 361 +++++++++++++++++++++
...gRouteControllerFilterFailToStartRouteTest.java | 12 +-
.../main/MainSupervisingRouteControllerTest.java | 24 +-
.../ROOT/pages/camel-4x-upgrade-guide-4_4.adoc | 15 +
.../modules/ROOT/pages/route-controller.adoc | 29 +-
.../maven/packaging/PrepareCamelMainMojo.java | 6 +
16 files changed, 671 insertions(+), 494 deletions(-)
diff --git
a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/main/camel-main-configuration-metadata.json
b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/main/camel-main-configuration-metadata.json
index 1bf93cf0c12..26f84fc86e0 100644
---
a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/main/camel-main-configuration-metadata.json
+++
b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/main/camel-main-configuration-metadata.json
@@ -1,6 +1,7 @@
{
"groups": [
{ "name": "camel.main", "description": "Camel Main configurations",
"sourceType": "org.apache.camel.main.DefaultConfigurationProperties" },
+ { "name": "camel.routecontroller", "description": "Camel Route Controller
configurations", "sourceType":
"org.apache.camel.main.RouteControllerConfigurationProperties" },
{ "name": "camel.server", "description": "Camel Embedded HTTP Server (only
for standalone; not Spring Boot or Quarkus) configurations", "sourceType":
"org.apache.camel.main.HttpServerConfigurationProperties" },
{ "name": "camel.debug", "description": "Camel Debugger configurations",
"sourceType": "org.apache.camel.main.DebuggerConfigurationProperties" },
{ "name": "camel.ssl", "description": "Camel SSL configurations",
"sourceType": "org.apache.camel.main.SSLConfigurationProperties" },
@@ -82,18 +83,6 @@
{ "name": "camel.main.modeline", "description": "Whether camel-k style
modeline is also enabled when not using camel-k. Enabling this allows to use a
camel-k like experience by being able to configure various settings using
modeline directly in your route source code.", "sourceType":
"org.apache.camel.main.DefaultConfigurationProperties", "type": "boolean",
"javaType": "boolean", "defaultValue": "false" },
{ "name": "camel.main.name", "description": "Sets the name of the
CamelContext.", "sourceType":
"org.apache.camel.main.DefaultConfigurationProperties", "type": "string",
"javaType": "java.lang.String" },
{ "name": "camel.main.producerTemplateCacheSize", "description": "Producer
template endpoints cache size.", "sourceType":
"org.apache.camel.main.DefaultConfigurationProperties", "type": "integer",
"javaType": "int", "defaultValue": 1000 },
- { "name": "camel.main.routeControllerBackOffDelay", "description":
"Backoff delay in millis when restarting a route that failed to startup.",
"sourceType": "org.apache.camel.main.DefaultConfigurationProperties", "type":
"integer", "javaType": "long" },
- { "name": "camel.main.routeControllerBackOffMaxAttempts", "description":
"Backoff maximum number of attempts to restart a route that failed to startup.
When this threshold has been exceeded then the controller will give up
attempting to restart the route, and the route will remain as stopped.",
"sourceType": "org.apache.camel.main.DefaultConfigurationProperties", "type":
"integer", "javaType": "long" },
- { "name": "camel.main.routeControllerBackOffMaxDelay", "description":
"Backoff maximum delay in millis when restarting a route that failed to
startup.", "sourceType":
"org.apache.camel.main.DefaultConfigurationProperties", "type": "integer",
"javaType": "long" },
- { "name": "camel.main.routeControllerBackOffMaxElapsedTime",
"description": "Backoff maximum elapsed time in millis, after which the backoff
should be considered exhausted and no more attempts should be made.",
"sourceType": "org.apache.camel.main.DefaultConfigurationProperties", "type":
"integer", "javaType": "long" },
- { "name": "camel.main.routeControllerBackOffMultiplier", "description":
"Backoff multiplier to use for exponential backoff. This is used to extend the
delay between restart attempts.", "sourceType":
"org.apache.camel.main.DefaultConfigurationProperties", "type": "number",
"javaType": "double" },
- { "name": "camel.main.routeControllerExcludeRoutes", "description":
"Pattern for filtering routes to be excluded as supervised. The pattern is
matching on route id, and endpoint uri for the route. Multiple patterns can be
separated by comma. For example to exclude all JMS routes, you can say jms:.
And to exclude routes with specific route ids
mySpecialRoute,myOtherSpecialRoute. The pattern supports wildcards and uses the
matcher from org.apache.camel.support.PatternHelper#matchPatter [...]
- { "name": "camel.main.routeControllerIncludeRoutes", "description":
"Pattern for filtering routes to be included as supervised. The pattern is
matching on route id, and endpoint uri for the route. Multiple patterns can be
separated by comma. For example to include all kafka routes, you can say
kafka:. And to include routes with specific route ids myRoute,myOtherRoute. The
pattern supports wildcards and uses the matcher from
org.apache.camel.support.PatternHelper#matchPattern.", "sour [...]
- { "name": "camel.main.routeControllerInitialDelay", "description":
"Initial delay in milli seconds before the route controller starts, after
CamelContext has been started.", "sourceType":
"org.apache.camel.main.DefaultConfigurationProperties", "type": "integer",
"javaType": "long" },
- { "name": "camel.main.routeControllerSuperviseEnabled", "description": "To
enable using supervising route controller which allows Camel to startup and
then the controller takes care of starting the routes in a safe manner. This
can be used when you want to startup Camel despite a route may otherwise fail
fast during startup and cause Camel to fail to startup as well. By delegating
the route startup to the supervising route controller then its manages the
startup using a background th [...]
- { "name": "camel.main.routeControllerThreadPoolSize", "description": "The
number of threads used by the route controller scheduled thread pool that are
used for restarting routes. The pool uses 1 thread by default, but you can
increase this to allow the controller to concurrently attempt to restart
multiple routes in case more than one route has problems starting.",
"sourceType": "org.apache.camel.main.DefaultConfigurationProperties", "type":
"integer", "javaType": "int" },
- { "name": "camel.main.routeControllerUnhealthyOnExhausted", "description":
"Whether to mark the route as unhealthy (down) when all restarting attempts
(backoff) have failed and the route is not successfully started and the route
manager is giving up. Setting this to true allows health checks to know about
this and can report the Camel application as DOWN. The default is false.",
"sourceType": "org.apache.camel.main.DefaultConfigurationProperties", "type":
"boolean", "javaType": "bool [...]
- { "name": "camel.main.routeControllerUnhealthyOnRestarting",
"description": "Whether to mark the route as unhealthy (down) when the route
failed to initially start, and is being controlled for restarting (backoff).
Setting this to true allows health checks to know about this and can report the
Camel application as DOWN. The default is false.", "sourceType":
"org.apache.camel.main.DefaultConfigurationProperties", "type": "boolean",
"javaType": "boolean", "defaultValue": "false" },
{ "name": "camel.main.routeFilterExcludePattern", "description": "Used for
filtering routes routes matching the given pattern, which follows the following
rules: - Match by route id - Match by route input endpoint uri The matching is
using exact match, by wildcard and regular expression as documented by
PatternHelper#matchPattern(String,String) . For example to only include routes
which starts with foo in their route id's, use: include=foo* And to exclude
routes which starts from [...]
{ "name": "camel.main.routeFilterIncludePattern", "description": "Used for
filtering routes matching the given pattern, which follows the following rules:
- Match by route id - Match by route input endpoint uri The matching is using
exact match, by wildcard and regular expression as documented by
PatternHelper#matchPattern(String,String) . For example to only include routes
which starts with foo in their route id's, use: include=foo* And to exclude
routes which starts from JMS en [...]
{ "name": "camel.main.routesBuilderClasses", "description": "Sets classes
names that implement RoutesBuilder .", "sourceType":
"org.apache.camel.main.MainConfigurationProperties", "type": "string",
"javaType": "java.lang.String" },
@@ -243,6 +232,18 @@
{ "name": "camel.rest.skipBindingOnErrorCode", "description": "Whether to
skip binding output if there is a custom HTTP error code, and instead use the
response body as-is. This option is default true.", "sourceType":
"org.apache.camel.spi.RestConfiguration", "type": "boolean", "javaType":
"boolean", "defaultValue": true },
{ "name": "camel.rest.useXForwardHeaders", "description": "Whether to use
X-Forward headers to set host etc. for Swagger. This option is default true.",
"sourceType": "org.apache.camel.spi.RestConfiguration", "type": "boolean",
"javaType": "boolean", "defaultValue": true },
{ "name": "camel.rest.xmlDataFormat", "description": "Sets a custom xml
data format to be used. Important: This option is only for setting a custom
name of the data format, not to refer to an existing data format instance.",
"sourceType": "org.apache.camel.spi.RestConfiguration", "type": "string",
"javaType": "java.lang.String" },
+ { "name": "camel.routecontroller.backOffDelay", "description": "Backoff
delay in millis when restarting a route that failed to startup.", "sourceType":
"org.apache.camel.main.RouteControllerConfigurationProperties", "type":
"integer", "javaType": "long", "defaultValue": 2000 },
+ { "name": "camel.routecontroller.backOffMaxAttempts", "description":
"Backoff maximum number of attempts to restart a route that failed to startup.
When this threshold has been exceeded then the controller will give up
attempting to restart the route, and the route will remain as stopped.",
"sourceType": "org.apache.camel.main.RouteControllerConfigurationProperties",
"type": "integer", "javaType": "long" },
+ { "name": "camel.routecontroller.backOffMaxDelay", "description": "Backoff
maximum delay in millis when restarting a route that failed to startup.",
"sourceType": "org.apache.camel.main.RouteControllerConfigurationProperties",
"type": "integer", "javaType": "long" },
+ { "name": "camel.routecontroller.backOffMaxElapsedTime", "description":
"Backoff maximum elapsed time in millis, after which the backoff should be
considered exhausted and no more attempts should be made.", "sourceType":
"org.apache.camel.main.RouteControllerConfigurationProperties", "type":
"integer", "javaType": "long" },
+ { "name": "camel.routecontroller.backOffMultiplier", "description":
"Backoff multiplier to use for exponential backoff. This is used to extend the
delay between restart attempts.", "sourceType":
"org.apache.camel.main.RouteControllerConfigurationProperties", "type":
"number", "javaType": "double" },
+ { "name": "camel.routecontroller.excludeRoutes", "description": "Pattern
for filtering routes to be excluded as supervised. The pattern is matching on
route id, and endpoint uri for the route. Multiple patterns can be separated by
comma. For example to exclude all JMS routes, you can say jms:. And to exclude
routes with specific route ids mySpecialRoute,myOtherSpecialRoute. The pattern
supports wildcards and uses the matcher from
org.apache.camel.support.PatternHelper#matchPattern.", [...]
+ { "name": "camel.routecontroller.includeRoutes", "description": "Pattern
for filtering routes to be included as supervised. The pattern is matching on
route id, and endpoint uri for the route. Multiple patterns can be separated by
comma. For example to include all kafka routes, you can say kafka:. And to
include routes with specific route ids myRoute,myOtherRoute. The pattern
supports wildcards and uses the matcher from
org.apache.camel.support.PatternHelper#matchPattern.", "sourceTy [...]
+ { "name": "camel.routecontroller.initialDelay", "description": "Initial
delay in milli seconds before the route controller starts, after CamelContext
has been started.", "sourceType":
"org.apache.camel.main.RouteControllerConfigurationProperties", "type":
"integer", "javaType": "long" },
+ { "name": "camel.routecontroller.superviseEnabled", "description": "To
enable using supervising route controller which allows Camel to startup and
then the controller takes care of starting the routes in a safe manner. This
can be used when you want to startup Camel despite a route may otherwise fail
fast during startup and cause Camel to fail to startup as well. By delegating
the route startup to the supervising route controller then its manages the
startup using a background thread [...]
+ { "name": "camel.routecontroller.threadPoolSize", "description": "The
number of threads used by the route controller scheduled thread pool that are
used for restarting routes. The pool uses 1 thread by default, but you can
increase this to allow the controller to concurrently attempt to restart
multiple routes in case more than one route has problems starting.",
"sourceType": "org.apache.camel.main.RouteControllerConfigurationProperties",
"type": "integer", "javaType": "int", "defaul [...]
+ { "name": "camel.routecontroller.unhealthyOnExhausted", "description":
"Whether to mark the route as unhealthy (down) when all restarting attempts
(backoff) have failed and the route is not successfully started and the route
manager is giving up. Setting this to true allows health checks to know about
this and can report the Camel application as DOWN. The default is false.",
"sourceType": "org.apache.camel.main.RouteControllerConfigurationProperties",
"type": "boolean", "javaType": " [...]
+ { "name": "camel.routecontroller.unhealthyOnRestarting", "description":
"Whether to mark the route as unhealthy (down) when the route failed to
initially start, and is being controlled for restarting (backoff). Setting this
to true allows health checks to know about this and can report the Camel
application as DOWN. The default is false.", "sourceType":
"org.apache.camel.main.RouteControllerConfigurationProperties", "type":
"boolean", "javaType": "boolean", "defaultValue": "false" },
{ "name": "camel.server.devConsoleEnabled", "description": "Whether to
enable developer console (not intended for production use). Dev console must
also be enabled on CamelContext. For example by setting
camel.context.dev-console=true in application.properties, or via code
camelContext.setDevConsole(true); If enabled then you can access a basic
developer console on context-path: \/q\/dev.", "sourceType":
"org.apache.camel.main.HttpServerConfigurationProperties", "type": "boolean",
"j [...]
{ "name": "camel.server.enabled", "description": "Whether embedded HTTP
server is enabled. By default, the server is not enabled.", "sourceType":
"org.apache.camel.main.HttpServerConfigurationProperties", "type": "boolean",
"javaType": "boolean", "defaultValue": "false" },
{ "name": "camel.server.healthCheckEnabled", "description": "Whether to
enable health-check console. If enabled then you can access health-check status
on context-path: \/q\/health", "sourceType":
"org.apache.camel.main.HttpServerConfigurationProperties", "type": "boolean",
"javaType": "boolean", "defaultValue": "false" },
diff --git
a/core/camel-main/src/generated/java/org/apache/camel/main/MainConfigurationPropertiesConfigurer.java
b/core/camel-main/src/generated/java/org/apache/camel/main/MainConfigurationPropertiesConfigurer.java
index 35c2a6e7c7a..6c7daa578bc 100644
---
a/core/camel-main/src/generated/java/org/apache/camel/main/MainConfigurationPropertiesConfigurer.java
+++
b/core/camel-main/src/generated/java/org/apache/camel/main/MainConfigurationPropertiesConfigurer.java
@@ -151,30 +151,6 @@ public class MainConfigurationPropertiesConfigurer extends
org.apache.camel.supp
case "Name": target.setName(property(camelContext,
java.lang.String.class, value)); return true;
case "producertemplatecachesize":
case "ProducerTemplateCacheSize":
target.setProducerTemplateCacheSize(property(camelContext, int.class, value));
return true;
- case "routecontrollerbackoffdelay":
- case "RouteControllerBackOffDelay":
target.setRouteControllerBackOffDelay(property(camelContext, long.class,
value)); return true;
- case "routecontrollerbackoffmaxattempts":
- case "RouteControllerBackOffMaxAttempts":
target.setRouteControllerBackOffMaxAttempts(property(camelContext, long.class,
value)); return true;
- case "routecontrollerbackoffmaxdelay":
- case "RouteControllerBackOffMaxDelay":
target.setRouteControllerBackOffMaxDelay(property(camelContext, long.class,
value)); return true;
- case "routecontrollerbackoffmaxelapsedtime":
- case "RouteControllerBackOffMaxElapsedTime":
target.setRouteControllerBackOffMaxElapsedTime(property(camelContext,
long.class, value)); return true;
- case "routecontrollerbackoffmultiplier":
- case "RouteControllerBackOffMultiplier":
target.setRouteControllerBackOffMultiplier(property(camelContext, double.class,
value)); return true;
- case "routecontrollerexcluderoutes":
- case "RouteControllerExcludeRoutes":
target.setRouteControllerExcludeRoutes(property(camelContext,
java.lang.String.class, value)); return true;
- case "routecontrollerincluderoutes":
- case "RouteControllerIncludeRoutes":
target.setRouteControllerIncludeRoutes(property(camelContext,
java.lang.String.class, value)); return true;
- case "routecontrollerinitialdelay":
- case "RouteControllerInitialDelay":
target.setRouteControllerInitialDelay(property(camelContext, long.class,
value)); return true;
- case "routecontrollersuperviseenabled":
- case "RouteControllerSuperviseEnabled":
target.setRouteControllerSuperviseEnabled(property(camelContext, boolean.class,
value)); return true;
- case "routecontrollerthreadpoolsize":
- case "RouteControllerThreadPoolSize":
target.setRouteControllerThreadPoolSize(property(camelContext, int.class,
value)); return true;
- case "routecontrollerunhealthyonexhausted":
- case "RouteControllerUnhealthyOnExhausted":
target.setRouteControllerUnhealthyOnExhausted(property(camelContext,
boolean.class, value)); return true;
- case "routecontrollerunhealthyonrestarting":
- case "RouteControllerUnhealthyOnRestarting":
target.setRouteControllerUnhealthyOnRestarting(property(camelContext,
boolean.class, value)); return true;
case "routefilterexcludepattern":
case "RouteFilterExcludePattern":
target.setRouteFilterExcludePattern(property(camelContext,
java.lang.String.class, value)); return true;
case "routefilterincludepattern":
@@ -414,30 +390,6 @@ public class MainConfigurationPropertiesConfigurer extends
org.apache.camel.supp
case "Name": return java.lang.String.class;
case "producertemplatecachesize":
case "ProducerTemplateCacheSize": return int.class;
- case "routecontrollerbackoffdelay":
- case "RouteControllerBackOffDelay": return long.class;
- case "routecontrollerbackoffmaxattempts":
- case "RouteControllerBackOffMaxAttempts": return long.class;
- case "routecontrollerbackoffmaxdelay":
- case "RouteControllerBackOffMaxDelay": return long.class;
- case "routecontrollerbackoffmaxelapsedtime":
- case "RouteControllerBackOffMaxElapsedTime": return long.class;
- case "routecontrollerbackoffmultiplier":
- case "RouteControllerBackOffMultiplier": return double.class;
- case "routecontrollerexcluderoutes":
- case "RouteControllerExcludeRoutes": return java.lang.String.class;
- case "routecontrollerincluderoutes":
- case "RouteControllerIncludeRoutes": return java.lang.String.class;
- case "routecontrollerinitialdelay":
- case "RouteControllerInitialDelay": return long.class;
- case "routecontrollersuperviseenabled":
- case "RouteControllerSuperviseEnabled": return boolean.class;
- case "routecontrollerthreadpoolsize":
- case "RouteControllerThreadPoolSize": return int.class;
- case "routecontrollerunhealthyonexhausted":
- case "RouteControllerUnhealthyOnExhausted": return boolean.class;
- case "routecontrollerunhealthyonrestarting":
- case "RouteControllerUnhealthyOnRestarting": return boolean.class;
case "routefilterexcludepattern":
case "RouteFilterExcludePattern": return java.lang.String.class;
case "routefilterincludepattern":
@@ -678,30 +630,6 @@ public class MainConfigurationPropertiesConfigurer extends
org.apache.camel.supp
case "Name": return target.getName();
case "producertemplatecachesize":
case "ProducerTemplateCacheSize": return
target.getProducerTemplateCacheSize();
- case "routecontrollerbackoffdelay":
- case "RouteControllerBackOffDelay": return
target.getRouteControllerBackOffDelay();
- case "routecontrollerbackoffmaxattempts":
- case "RouteControllerBackOffMaxAttempts": return
target.getRouteControllerBackOffMaxAttempts();
- case "routecontrollerbackoffmaxdelay":
- case "RouteControllerBackOffMaxDelay": return
target.getRouteControllerBackOffMaxDelay();
- case "routecontrollerbackoffmaxelapsedtime":
- case "RouteControllerBackOffMaxElapsedTime": return
target.getRouteControllerBackOffMaxElapsedTime();
- case "routecontrollerbackoffmultiplier":
- case "RouteControllerBackOffMultiplier": return
target.getRouteControllerBackOffMultiplier();
- case "routecontrollerexcluderoutes":
- case "RouteControllerExcludeRoutes": return
target.getRouteControllerExcludeRoutes();
- case "routecontrollerincluderoutes":
- case "RouteControllerIncludeRoutes": return
target.getRouteControllerIncludeRoutes();
- case "routecontrollerinitialdelay":
- case "RouteControllerInitialDelay": return
target.getRouteControllerInitialDelay();
- case "routecontrollersuperviseenabled":
- case "RouteControllerSuperviseEnabled": return
target.isRouteControllerSuperviseEnabled();
- case "routecontrollerthreadpoolsize":
- case "RouteControllerThreadPoolSize": return
target.getRouteControllerThreadPoolSize();
- case "routecontrollerunhealthyonexhausted":
- case "RouteControllerUnhealthyOnExhausted": return
target.isRouteControllerUnhealthyOnExhausted();
- case "routecontrollerunhealthyonrestarting":
- case "RouteControllerUnhealthyOnRestarting": return
target.isRouteControllerUnhealthyOnRestarting();
case "routefilterexcludepattern":
case "RouteFilterExcludePattern": return
target.getRouteFilterExcludePattern();
case "routefilterincludepattern":
diff --git
a/core/camel-main/src/generated/java/org/apache/camel/main/RouteControllerConfigurationPropertiesConfigurer.java
b/core/camel-main/src/generated/java/org/apache/camel/main/RouteControllerConfigurationPropertiesConfigurer.java
new file mode 100644
index 00000000000..9d3b965ad34
--- /dev/null
+++
b/core/camel-main/src/generated/java/org/apache/camel/main/RouteControllerConfigurationPropertiesConfigurer.java
@@ -0,0 +1,115 @@
+/* Generated by camel build tools - do NOT edit this file! */
+package org.apache.camel.main;
+
+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.main.RouteControllerConfigurationProperties;
+
+/**
+ * Generated by camel build tools - do NOT edit this file!
+ */
+@SuppressWarnings("unchecked")
+public class RouteControllerConfigurationPropertiesConfigurer 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.main.RouteControllerConfigurationProperties target =
(org.apache.camel.main.RouteControllerConfigurationProperties) obj;
+ switch (ignoreCase ? name.toLowerCase() : name) {
+ case "backoffdelay":
+ case "BackOffDelay": target.setBackOffDelay(property(camelContext,
long.class, value)); return true;
+ case "backoffmaxattempts":
+ case "BackOffMaxAttempts":
target.setBackOffMaxAttempts(property(camelContext, long.class, value)); return
true;
+ case "backoffmaxdelay":
+ case "BackOffMaxDelay":
target.setBackOffMaxDelay(property(camelContext, long.class, value)); return
true;
+ case "backoffmaxelapsedtime":
+ case "BackOffMaxElapsedTime":
target.setBackOffMaxElapsedTime(property(camelContext, long.class, value));
return true;
+ case "backoffmultiplier":
+ case "BackOffMultiplier":
target.setBackOffMultiplier(property(camelContext, double.class, value));
return true;
+ case "excluderoutes":
+ case "ExcludeRoutes": target.setExcludeRoutes(property(camelContext,
java.lang.String.class, value)); return true;
+ case "includeroutes":
+ case "IncludeRoutes": target.setIncludeRoutes(property(camelContext,
java.lang.String.class, value)); return true;
+ case "initialdelay":
+ case "InitialDelay": target.setInitialDelay(property(camelContext,
long.class, value)); return true;
+ case "superviseenabled":
+ case "SuperviseEnabled":
target.setSuperviseEnabled(property(camelContext, boolean.class, value));
return true;
+ case "threadpoolsize":
+ case "ThreadPoolSize": target.setThreadPoolSize(property(camelContext,
int.class, value)); return true;
+ case "unhealthyonexhausted":
+ case "UnhealthyOnExhausted":
target.setUnhealthyOnExhausted(property(camelContext, boolean.class, value));
return true;
+ case "unhealthyonrestarting":
+ case "UnhealthyOnRestarting":
target.setUnhealthyOnRestarting(property(camelContext, boolean.class, value));
return true;
+ default: return false;
+ }
+ }
+
+ @Override
+ public Class<?> getOptionType(String name, boolean ignoreCase) {
+ switch (ignoreCase ? name.toLowerCase() : name) {
+ case "backoffdelay":
+ case "BackOffDelay": return long.class;
+ case "backoffmaxattempts":
+ case "BackOffMaxAttempts": return long.class;
+ case "backoffmaxdelay":
+ case "BackOffMaxDelay": return long.class;
+ case "backoffmaxelapsedtime":
+ case "BackOffMaxElapsedTime": return long.class;
+ case "backoffmultiplier":
+ case "BackOffMultiplier": return double.class;
+ case "excluderoutes":
+ case "ExcludeRoutes": return java.lang.String.class;
+ case "includeroutes":
+ case "IncludeRoutes": return java.lang.String.class;
+ case "initialdelay":
+ case "InitialDelay": return long.class;
+ case "superviseenabled":
+ case "SuperviseEnabled": return boolean.class;
+ case "threadpoolsize":
+ case "ThreadPoolSize": return int.class;
+ case "unhealthyonexhausted":
+ case "UnhealthyOnExhausted": return boolean.class;
+ case "unhealthyonrestarting":
+ case "UnhealthyOnRestarting": return boolean.class;
+ default: return null;
+ }
+ }
+
+ @Override
+ public Object getOptionValue(Object obj, String name, boolean ignoreCase) {
+ org.apache.camel.main.RouteControllerConfigurationProperties target =
(org.apache.camel.main.RouteControllerConfigurationProperties) obj;
+ switch (ignoreCase ? name.toLowerCase() : name) {
+ case "backoffdelay":
+ case "BackOffDelay": return target.getBackOffDelay();
+ case "backoffmaxattempts":
+ case "BackOffMaxAttempts": return target.getBackOffMaxAttempts();
+ case "backoffmaxdelay":
+ case "BackOffMaxDelay": return target.getBackOffMaxDelay();
+ case "backoffmaxelapsedtime":
+ case "BackOffMaxElapsedTime": return target.getBackOffMaxElapsedTime();
+ case "backoffmultiplier":
+ case "BackOffMultiplier": return target.getBackOffMultiplier();
+ case "excluderoutes":
+ case "ExcludeRoutes": return target.getExcludeRoutes();
+ case "includeroutes":
+ case "IncludeRoutes": return target.getIncludeRoutes();
+ case "initialdelay":
+ case "InitialDelay": return target.getInitialDelay();
+ case "superviseenabled":
+ case "SuperviseEnabled": return target.isSuperviseEnabled();
+ case "threadpoolsize":
+ case "ThreadPoolSize": return target.getThreadPoolSize();
+ case "unhealthyonexhausted":
+ case "UnhealthyOnExhausted": return target.isUnhealthyOnExhausted();
+ case "unhealthyonrestarting":
+ case "UnhealthyOnRestarting": return target.isUnhealthyOnRestarting();
+ default: return null;
+ }
+ }
+}
+
diff --git
a/core/camel-main/src/generated/resources/META-INF/camel-main-configuration-metadata.json
b/core/camel-main/src/generated/resources/META-INF/camel-main-configuration-metadata.json
index 1bf93cf0c12..26f84fc86e0 100644
---
a/core/camel-main/src/generated/resources/META-INF/camel-main-configuration-metadata.json
+++
b/core/camel-main/src/generated/resources/META-INF/camel-main-configuration-metadata.json
@@ -1,6 +1,7 @@
{
"groups": [
{ "name": "camel.main", "description": "Camel Main configurations",
"sourceType": "org.apache.camel.main.DefaultConfigurationProperties" },
+ { "name": "camel.routecontroller", "description": "Camel Route Controller
configurations", "sourceType":
"org.apache.camel.main.RouteControllerConfigurationProperties" },
{ "name": "camel.server", "description": "Camel Embedded HTTP Server (only
for standalone; not Spring Boot or Quarkus) configurations", "sourceType":
"org.apache.camel.main.HttpServerConfigurationProperties" },
{ "name": "camel.debug", "description": "Camel Debugger configurations",
"sourceType": "org.apache.camel.main.DebuggerConfigurationProperties" },
{ "name": "camel.ssl", "description": "Camel SSL configurations",
"sourceType": "org.apache.camel.main.SSLConfigurationProperties" },
@@ -82,18 +83,6 @@
{ "name": "camel.main.modeline", "description": "Whether camel-k style
modeline is also enabled when not using camel-k. Enabling this allows to use a
camel-k like experience by being able to configure various settings using
modeline directly in your route source code.", "sourceType":
"org.apache.camel.main.DefaultConfigurationProperties", "type": "boolean",
"javaType": "boolean", "defaultValue": "false" },
{ "name": "camel.main.name", "description": "Sets the name of the
CamelContext.", "sourceType":
"org.apache.camel.main.DefaultConfigurationProperties", "type": "string",
"javaType": "java.lang.String" },
{ "name": "camel.main.producerTemplateCacheSize", "description": "Producer
template endpoints cache size.", "sourceType":
"org.apache.camel.main.DefaultConfigurationProperties", "type": "integer",
"javaType": "int", "defaultValue": 1000 },
- { "name": "camel.main.routeControllerBackOffDelay", "description":
"Backoff delay in millis when restarting a route that failed to startup.",
"sourceType": "org.apache.camel.main.DefaultConfigurationProperties", "type":
"integer", "javaType": "long" },
- { "name": "camel.main.routeControllerBackOffMaxAttempts", "description":
"Backoff maximum number of attempts to restart a route that failed to startup.
When this threshold has been exceeded then the controller will give up
attempting to restart the route, and the route will remain as stopped.",
"sourceType": "org.apache.camel.main.DefaultConfigurationProperties", "type":
"integer", "javaType": "long" },
- { "name": "camel.main.routeControllerBackOffMaxDelay", "description":
"Backoff maximum delay in millis when restarting a route that failed to
startup.", "sourceType":
"org.apache.camel.main.DefaultConfigurationProperties", "type": "integer",
"javaType": "long" },
- { "name": "camel.main.routeControllerBackOffMaxElapsedTime",
"description": "Backoff maximum elapsed time in millis, after which the backoff
should be considered exhausted and no more attempts should be made.",
"sourceType": "org.apache.camel.main.DefaultConfigurationProperties", "type":
"integer", "javaType": "long" },
- { "name": "camel.main.routeControllerBackOffMultiplier", "description":
"Backoff multiplier to use for exponential backoff. This is used to extend the
delay between restart attempts.", "sourceType":
"org.apache.camel.main.DefaultConfigurationProperties", "type": "number",
"javaType": "double" },
- { "name": "camel.main.routeControllerExcludeRoutes", "description":
"Pattern for filtering routes to be excluded as supervised. The pattern is
matching on route id, and endpoint uri for the route. Multiple patterns can be
separated by comma. For example to exclude all JMS routes, you can say jms:.
And to exclude routes with specific route ids
mySpecialRoute,myOtherSpecialRoute. The pattern supports wildcards and uses the
matcher from org.apache.camel.support.PatternHelper#matchPatter [...]
- { "name": "camel.main.routeControllerIncludeRoutes", "description":
"Pattern for filtering routes to be included as supervised. The pattern is
matching on route id, and endpoint uri for the route. Multiple patterns can be
separated by comma. For example to include all kafka routes, you can say
kafka:. And to include routes with specific route ids myRoute,myOtherRoute. The
pattern supports wildcards and uses the matcher from
org.apache.camel.support.PatternHelper#matchPattern.", "sour [...]
- { "name": "camel.main.routeControllerInitialDelay", "description":
"Initial delay in milli seconds before the route controller starts, after
CamelContext has been started.", "sourceType":
"org.apache.camel.main.DefaultConfigurationProperties", "type": "integer",
"javaType": "long" },
- { "name": "camel.main.routeControllerSuperviseEnabled", "description": "To
enable using supervising route controller which allows Camel to startup and
then the controller takes care of starting the routes in a safe manner. This
can be used when you want to startup Camel despite a route may otherwise fail
fast during startup and cause Camel to fail to startup as well. By delegating
the route startup to the supervising route controller then its manages the
startup using a background th [...]
- { "name": "camel.main.routeControllerThreadPoolSize", "description": "The
number of threads used by the route controller scheduled thread pool that are
used for restarting routes. The pool uses 1 thread by default, but you can
increase this to allow the controller to concurrently attempt to restart
multiple routes in case more than one route has problems starting.",
"sourceType": "org.apache.camel.main.DefaultConfigurationProperties", "type":
"integer", "javaType": "int" },
- { "name": "camel.main.routeControllerUnhealthyOnExhausted", "description":
"Whether to mark the route as unhealthy (down) when all restarting attempts
(backoff) have failed and the route is not successfully started and the route
manager is giving up. Setting this to true allows health checks to know about
this and can report the Camel application as DOWN. The default is false.",
"sourceType": "org.apache.camel.main.DefaultConfigurationProperties", "type":
"boolean", "javaType": "bool [...]
- { "name": "camel.main.routeControllerUnhealthyOnRestarting",
"description": "Whether to mark the route as unhealthy (down) when the route
failed to initially start, and is being controlled for restarting (backoff).
Setting this to true allows health checks to know about this and can report the
Camel application as DOWN. The default is false.", "sourceType":
"org.apache.camel.main.DefaultConfigurationProperties", "type": "boolean",
"javaType": "boolean", "defaultValue": "false" },
{ "name": "camel.main.routeFilterExcludePattern", "description": "Used for
filtering routes routes matching the given pattern, which follows the following
rules: - Match by route id - Match by route input endpoint uri The matching is
using exact match, by wildcard and regular expression as documented by
PatternHelper#matchPattern(String,String) . For example to only include routes
which starts with foo in their route id's, use: include=foo* And to exclude
routes which starts from [...]
{ "name": "camel.main.routeFilterIncludePattern", "description": "Used for
filtering routes matching the given pattern, which follows the following rules:
- Match by route id - Match by route input endpoint uri The matching is using
exact match, by wildcard and regular expression as documented by
PatternHelper#matchPattern(String,String) . For example to only include routes
which starts with foo in their route id's, use: include=foo* And to exclude
routes which starts from JMS en [...]
{ "name": "camel.main.routesBuilderClasses", "description": "Sets classes
names that implement RoutesBuilder .", "sourceType":
"org.apache.camel.main.MainConfigurationProperties", "type": "string",
"javaType": "java.lang.String" },
@@ -243,6 +232,18 @@
{ "name": "camel.rest.skipBindingOnErrorCode", "description": "Whether to
skip binding output if there is a custom HTTP error code, and instead use the
response body as-is. This option is default true.", "sourceType":
"org.apache.camel.spi.RestConfiguration", "type": "boolean", "javaType":
"boolean", "defaultValue": true },
{ "name": "camel.rest.useXForwardHeaders", "description": "Whether to use
X-Forward headers to set host etc. for Swagger. This option is default true.",
"sourceType": "org.apache.camel.spi.RestConfiguration", "type": "boolean",
"javaType": "boolean", "defaultValue": true },
{ "name": "camel.rest.xmlDataFormat", "description": "Sets a custom xml
data format to be used. Important: This option is only for setting a custom
name of the data format, not to refer to an existing data format instance.",
"sourceType": "org.apache.camel.spi.RestConfiguration", "type": "string",
"javaType": "java.lang.String" },
+ { "name": "camel.routecontroller.backOffDelay", "description": "Backoff
delay in millis when restarting a route that failed to startup.", "sourceType":
"org.apache.camel.main.RouteControllerConfigurationProperties", "type":
"integer", "javaType": "long", "defaultValue": 2000 },
+ { "name": "camel.routecontroller.backOffMaxAttempts", "description":
"Backoff maximum number of attempts to restart a route that failed to startup.
When this threshold has been exceeded then the controller will give up
attempting to restart the route, and the route will remain as stopped.",
"sourceType": "org.apache.camel.main.RouteControllerConfigurationProperties",
"type": "integer", "javaType": "long" },
+ { "name": "camel.routecontroller.backOffMaxDelay", "description": "Backoff
maximum delay in millis when restarting a route that failed to startup.",
"sourceType": "org.apache.camel.main.RouteControllerConfigurationProperties",
"type": "integer", "javaType": "long" },
+ { "name": "camel.routecontroller.backOffMaxElapsedTime", "description":
"Backoff maximum elapsed time in millis, after which the backoff should be
considered exhausted and no more attempts should be made.", "sourceType":
"org.apache.camel.main.RouteControllerConfigurationProperties", "type":
"integer", "javaType": "long" },
+ { "name": "camel.routecontroller.backOffMultiplier", "description":
"Backoff multiplier to use for exponential backoff. This is used to extend the
delay between restart attempts.", "sourceType":
"org.apache.camel.main.RouteControllerConfigurationProperties", "type":
"number", "javaType": "double" },
+ { "name": "camel.routecontroller.excludeRoutes", "description": "Pattern
for filtering routes to be excluded as supervised. The pattern is matching on
route id, and endpoint uri for the route. Multiple patterns can be separated by
comma. For example to exclude all JMS routes, you can say jms:. And to exclude
routes with specific route ids mySpecialRoute,myOtherSpecialRoute. The pattern
supports wildcards and uses the matcher from
org.apache.camel.support.PatternHelper#matchPattern.", [...]
+ { "name": "camel.routecontroller.includeRoutes", "description": "Pattern
for filtering routes to be included as supervised. The pattern is matching on
route id, and endpoint uri for the route. Multiple patterns can be separated by
comma. For example to include all kafka routes, you can say kafka:. And to
include routes with specific route ids myRoute,myOtherRoute. The pattern
supports wildcards and uses the matcher from
org.apache.camel.support.PatternHelper#matchPattern.", "sourceTy [...]
+ { "name": "camel.routecontroller.initialDelay", "description": "Initial
delay in milli seconds before the route controller starts, after CamelContext
has been started.", "sourceType":
"org.apache.camel.main.RouteControllerConfigurationProperties", "type":
"integer", "javaType": "long" },
+ { "name": "camel.routecontroller.superviseEnabled", "description": "To
enable using supervising route controller which allows Camel to startup and
then the controller takes care of starting the routes in a safe manner. This
can be used when you want to startup Camel despite a route may otherwise fail
fast during startup and cause Camel to fail to startup as well. By delegating
the route startup to the supervising route controller then its manages the
startup using a background thread [...]
+ { "name": "camel.routecontroller.threadPoolSize", "description": "The
number of threads used by the route controller scheduled thread pool that are
used for restarting routes. The pool uses 1 thread by default, but you can
increase this to allow the controller to concurrently attempt to restart
multiple routes in case more than one route has problems starting.",
"sourceType": "org.apache.camel.main.RouteControllerConfigurationProperties",
"type": "integer", "javaType": "int", "defaul [...]
+ { "name": "camel.routecontroller.unhealthyOnExhausted", "description":
"Whether to mark the route as unhealthy (down) when all restarting attempts
(backoff) have failed and the route is not successfully started and the route
manager is giving up. Setting this to true allows health checks to know about
this and can report the Camel application as DOWN. The default is false.",
"sourceType": "org.apache.camel.main.RouteControllerConfigurationProperties",
"type": "boolean", "javaType": " [...]
+ { "name": "camel.routecontroller.unhealthyOnRestarting", "description":
"Whether to mark the route as unhealthy (down) when the route failed to
initially start, and is being controlled for restarting (backoff). Setting this
to true allows health checks to know about this and can report the Camel
application as DOWN. The default is false.", "sourceType":
"org.apache.camel.main.RouteControllerConfigurationProperties", "type":
"boolean", "javaType": "boolean", "defaultValue": "false" },
{ "name": "camel.server.devConsoleEnabled", "description": "Whether to
enable developer console (not intended for production use). Dev console must
also be enabled on CamelContext. For example by setting
camel.context.dev-console=true in application.properties, or via code
camelContext.setDevConsole(true); If enabled then you can access a basic
developer console on context-path: \/q\/dev.", "sourceType":
"org.apache.camel.main.HttpServerConfigurationProperties", "type": "boolean",
"j [...]
{ "name": "camel.server.enabled", "description": "Whether embedded HTTP
server is enabled. By default, the server is not enabled.", "sourceType":
"org.apache.camel.main.HttpServerConfigurationProperties", "type": "boolean",
"javaType": "boolean", "defaultValue": "false" },
{ "name": "camel.server.healthCheckEnabled", "description": "Whether to
enable health-check console. If enabled then you can access health-check status
on context-path: \/q\/health", "sourceType":
"org.apache.camel.main.HttpServerConfigurationProperties", "type": "boolean",
"javaType": "boolean", "defaultValue": "false" },
diff --git
a/core/camel-main/src/generated/resources/META-INF/services/org/apache/camel/configurer/org.apache.camel.main.RouteControllerConfigurationProperties
b/core/camel-main/src/generated/resources/META-INF/services/org/apache/camel/configurer/org.apache.camel.main.RouteControllerConfigurationProperties
new file mode 100644
index 00000000000..c288b291e78
--- /dev/null
+++
b/core/camel-main/src/generated/resources/META-INF/services/org/apache/camel/configurer/org.apache.camel.main.RouteControllerConfigurationProperties
@@ -0,0 +1,2 @@
+# Generated by camel build tools - do NOT edit this file!
+class=org.apache.camel.main.RouteControllerConfigurationPropertiesConfigurer
diff --git a/core/camel-main/src/main/docs/main.adoc
b/core/camel-main/src/main/docs/main.adoc
index be566a90ec8..3e2deee5bb8 100644
--- a/core/camel-main/src/main/docs/main.adoc
+++ b/core/camel-main/src/main/docs/main.adoc
@@ -19,7 +19,7 @@ The following tables lists all the options:
// main options: START
=== Camel Main configurations
-The camel.main supports 128 options, which are listed below.
+The camel.main supports 116 options, which are listed below.
[width="100%",cols="2,5,^1,2",options="header"]
|===
@@ -89,18 +89,6 @@ The camel.main supports 128 options, which are listed below.
| *camel.main.modeline* | Whether camel-k style modeline is also enabled when
not using camel-k. Enabling this allows to use a camel-k like experience by
being able to configure various settings using modeline directly in your route
source code. | false | boolean
| *camel.main.name* | Sets the name of the CamelContext. | | String
| *camel.main.producerTemplate{zwsp}CacheSize* | Producer template endpoints
cache size. | 1000 | int
-| *camel.main.routeControllerBack{zwsp}OffDelay* | Backoff delay in millis
when restarting a route that failed to startup. | | long
-| *camel.main.routeControllerBack{zwsp}OffMaxAttempts* | Backoff maximum
number of attempts to restart a route that failed to startup. When this
threshold has been exceeded then the controller will give up attempting to
restart the route, and the route will remain as stopped. | | long
-| *camel.main.routeControllerBack{zwsp}OffMaxDelay* | Backoff maximum delay in
millis when restarting a route that failed to startup. | | long
-| *camel.main.routeControllerBack{zwsp}OffMaxElapsedTime* | Backoff maximum
elapsed time in millis, after which the backoff should be considered exhausted
and no more attempts should be made. | | long
-| *camel.main.routeControllerBack{zwsp}OffMultiplier* | Backoff multiplier to
use for exponential backoff. This is used to extend the delay between restart
attempts. | | double
-| *camel.main.routeController{zwsp}ExcludeRoutes* | Pattern for filtering
routes to be excluded as supervised. The pattern is matching on route id, and
endpoint uri for the route. Multiple patterns can be separated by comma. For
example to exclude all JMS routes, you can say jms:. And to exclude routes with
specific route ids mySpecialRoute,myOtherSpecialRoute. The pattern supports
wildcards and uses the matcher from
org.apache.camel.support.PatternHelper#matchPattern. | | String
-| *camel.main.routeController{zwsp}IncludeRoutes* | Pattern for filtering
routes to be included as supervised. The pattern is matching on route id, and
endpoint uri for the route. Multiple patterns can be separated by comma. For
example to include all kafka routes, you can say kafka:. And to include routes
with specific route ids myRoute,myOtherRoute. The pattern supports wildcards
and uses the matcher from org.apache.camel.support.PatternHelper#matchPattern.
| | String
-| *camel.main.routeController{zwsp}InitialDelay* | Initial delay in milli
seconds before the route controller starts, after CamelContext has been
started. | | long
-| *camel.main.routeController{zwsp}SuperviseEnabled* | To enable using
supervising route controller which allows Camel to startup and then the
controller takes care of starting the routes in a safe manner. This can be used
when you want to startup Camel despite a route may otherwise fail fast during
startup and cause Camel to fail to startup as well. By delegating the route
startup to the supervising route controller then its manages the startup using
a background thread. The controller [...]
-| *camel.main.routeController{zwsp}ThreadPoolSize* | The number of threads
used by the route controller scheduled thread pool that are used for restarting
routes. The pool uses 1 thread by default, but you can increase this to allow
the controller to concurrently attempt to restart multiple routes in case more
than one route has problems starting. | | int
-| *camel.main.routeController{zwsp}UnhealthyOnExhausted* | Whether to mark the
route as unhealthy (down) when all restarting attempts (backoff) have failed
and the route is not successfully started and the route manager is giving up.
Setting this to true allows health checks to know about this and can report the
Camel application as DOWN. The default is false. | false | boolean
-| *camel.main.routeController{zwsp}UnhealthyOnRestarting* | Whether to mark
the route as unhealthy (down) when the route failed to initially start, and is
being controlled for restarting (backoff). Setting this to true allows health
checks to know about this and can report the Camel application as DOWN. The
default is false. | false | boolean
| *camel.main.routeFilterExclude{zwsp}Pattern* | Used for filtering routes
routes matching the given pattern, which follows the following rules: - Match
by route id - Match by route input endpoint uri The matching is using exact
match, by wildcard and regular expression as documented by
PatternHelper#matchPattern(String,String) . For example to only include routes
which starts with foo in their route id's, use: include=foo* And to exclude
routes which starts from JMS endpoints, use: [...]
| *camel.main.routeFilterInclude{zwsp}Pattern* | Used for filtering routes
matching the given pattern, which follows the following rules: - Match by route
id - Match by route input endpoint uri The matching is using exact match, by
wildcard and regular expression as documented by
PatternHelper#matchPattern(String,String) . For example to only include routes
which starts with foo in their route id's, use: include=foo* And to exclude
routes which starts from JMS endpoints, use: exclude [...]
| *camel.main.routesBuilder{zwsp}Classes* | Sets classes names that implement
RoutesBuilder . | | String
@@ -155,6 +143,27 @@ The camel.main supports 128 options, which are listed
below.
|===
+=== Camel Route Controller configurations
+The camel.routecontroller supports 12 options, which are listed below.
+
+[width="100%",cols="2,5,^1,2",options="header"]
+|===
+| Name | Description | Default | Type
+| *camel.routecontroller.backOff{zwsp}Delay* | Backoff delay in millis when
restarting a route that failed to startup. | 2000 | long
+| *camel.routecontroller.backOff{zwsp}MaxAttempts* | Backoff maximum number of
attempts to restart a route that failed to startup. When this threshold has
been exceeded then the controller will give up attempting to restart the route,
and the route will remain as stopped. | | long
+| *camel.routecontroller.backOff{zwsp}MaxDelay* | Backoff maximum delay in
millis when restarting a route that failed to startup. | | long
+| *camel.routecontroller.backOff{zwsp}MaxElapsedTime* | Backoff maximum
elapsed time in millis, after which the backoff should be considered exhausted
and no more attempts should be made. | | long
+| *camel.routecontroller.backOff{zwsp}Multiplier* | Backoff multiplier to use
for exponential backoff. This is used to extend the delay between restart
attempts. | | double
+| *camel.routecontroller.exclude{zwsp}Routes* | Pattern for filtering routes
to be excluded as supervised. The pattern is matching on route id, and endpoint
uri for the route. Multiple patterns can be separated by comma. For example to
exclude all JMS routes, you can say jms:. And to exclude routes with specific
route ids mySpecialRoute,myOtherSpecialRoute. The pattern supports wildcards
and uses the matcher from org.apache.camel.support.PatternHelper#matchPattern.
| | String
+| *camel.routecontroller.include{zwsp}Routes* | Pattern for filtering routes
to be included as supervised. The pattern is matching on route id, and endpoint
uri for the route. Multiple patterns can be separated by comma. For example to
include all kafka routes, you can say kafka:. And to include routes with
specific route ids myRoute,myOtherRoute. The pattern supports wildcards and
uses the matcher from org.apache.camel.support.PatternHelper#matchPattern. | |
String
+| *camel.routecontroller.initial{zwsp}Delay* | Initial delay in milli seconds
before the route controller starts, after CamelContext has been started. | |
long
+| *{zwsp}camel.routecontroller.supervise{zwsp}Enabled* | To enable using
supervising route controller which allows Camel to startup and then the
controller takes care of starting the routes in a safe manner. This can be used
when you want to startup Camel despite a route may otherwise fail fast during
startup and cause Camel to fail to startup as well. By delegating the route
startup to the supervising route controller then its manages the startup using
a background thread. The controlle [...]
+| *camel.routecontroller.thread{zwsp}PoolSize* | The number of threads used by
the route controller scheduled thread pool that are used for restarting routes.
The pool uses 1 thread by default, but you can increase this to allow the
controller to concurrently attempt to restart multiple routes in case more than
one route has problems starting. | 1 | int
+| *{zwsp}camel.routecontroller.unhealthy{zwsp}OnExhausted* | Whether to mark
the route as unhealthy (down) when all restarting attempts (backoff) have
failed and the route is not successfully started and the route manager is
giving up. Setting this to true allows health checks to know about this and can
report the Camel application as DOWN. The default is false. | false | boolean
+| *{zwsp}camel.routecontroller.unhealthy{zwsp}OnRestarting* | Whether to mark
the route as unhealthy (down) when the route failed to initially start, and is
being controlled for restarting (backoff). Setting this to true allows health
checks to know about this and can report the Camel application as DOWN. The
default is false. | false | boolean
+|===
+
+
=== Camel Embedded HTTP Server (only for standalone; not Spring Boot or
Quarkus) configurations
The camel.server supports 11 options, which are listed below.
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 47935f61e0e..97bb04b9b74 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
@@ -72,6 +72,7 @@ import org.apache.camel.spi.Registry;
import org.apache.camel.spi.RouteTemplateParameterSource;
import org.apache.camel.spi.RoutesLoader;
import org.apache.camel.spi.StartupStepRecorder;
+import org.apache.camel.spi.SupervisingRouteController;
import org.apache.camel.support.CamelContextHelper;
import org.apache.camel.support.DefaultContextReloadStrategy;
import org.apache.camel.support.LifecycleStrategySupport;
@@ -975,6 +976,7 @@ public abstract class BaseMainSupport extends BaseService {
OrderedLocationProperties httpServerProperties = new
OrderedLocationProperties();
OrderedLocationProperties sslProperties = new
OrderedLocationProperties();
OrderedLocationProperties debuggerProperties = new
OrderedLocationProperties();
+ OrderedLocationProperties routeControllerProperties = new
OrderedLocationProperties();
for (String key : prop.stringPropertyNames()) {
String loc = prop.getLocation(key);
if (key.startsWith("camel.context.")) {
@@ -1079,6 +1081,12 @@ public abstract class BaseMainSupport extends
BaseService {
String option = key.substring(12);
validateOptionAndValue(key, option, value);
debuggerProperties.put(loc, optionKey(option), value);
+ } else if (key.startsWith("camel.routeController.")) {
+ // grab the value
+ String value = prop.getProperty(key);
+ String option = key.substring(22);
+ validateOptionAndValue(key, option, value);
+ routeControllerProperties.put(loc, optionKey(option), value);
}
}
@@ -1172,6 +1180,12 @@ public abstract class BaseMainSupport extends
BaseService {
mainConfigurationProperties.isAutoConfigurationFailFast(),
autoConfiguredProperties);
}
+ if (!routeControllerProperties.isEmpty() ||
mainConfigurationProperties.hasRouteControllerConfiguration()) {
+ LOG.debug("Auto-configuring Route Controller from loaded
properties: {}", routeControllerProperties.size());
+ setRouteControllerProperties(camelContext,
routeControllerProperties,
+ mainConfigurationProperties.isAutoConfigurationFailFast(),
+ autoConfiguredProperties);
+ }
// configure which requires access to the model
MainSupportModelConfigurer.configureModelCamelContext(camelContext,
mainConfigurationProperties,
@@ -1228,6 +1242,16 @@ public abstract class BaseMainSupport extends
BaseService {
LOG.warn("Property not auto-configured: camel.debug.{}={}", k,
v);
});
}
+ if (!routeControllerProperties.isEmpty()) {
+ routeControllerProperties.forEach((k, v) -> {
+ LOG.warn("Property not auto-configured:
camel.routeController.{}={}", k, v);
+ });
+ }
+ if (!devConsoleProperties.isEmpty()) {
+ devConsoleProperties.forEach((k, v) -> {
+ LOG.warn("Property not auto-configured:
camel.devConsole.{}={}", k, v);
+ });
+ }
if (!routeTemplateProperties.isEmpty()) {
routeTemplateProperties.forEach((k, v) -> {
LOG.warn("Property not auto-configured:
camel.routetemplate.{}={}", k, v);
@@ -1618,6 +1642,51 @@ public abstract class BaseMainSupport extends
BaseService {
camelContext.addService(debugger);
}
+ private void setRouteControllerProperties(
+ CamelContext camelContext, OrderedLocationProperties properties,
+ boolean failIfNotSet, OrderedLocationProperties
autoConfiguredProperties)
+ throws Exception {
+
+ RouteControllerConfigurationProperties config =
mainConfigurationProperties.routeControllerConfig();
+ setPropertiesOnTarget(camelContext, config, properties,
"camel.routeController.",
+ failIfNotSet, true, autoConfiguredProperties);
+
+ // supervising route controller
+ if (config.isSuperviseEnabled()) {
+ SupervisingRouteController src =
camelContext.getRouteController().supervising();
+ if (config.getIncludeRoutes() != null) {
+ src.setIncludeRoutes(config.getIncludeRoutes());
+ }
+ if (config.getExcludeRoutes() != null) {
+ src.setExcludeRoutes(config.getExcludeRoutes());
+ }
+ if (config.getThreadPoolSize() > 0) {
+ src.setThreadPoolSize(config.getThreadPoolSize());
+ }
+ if (config.getBackOffDelay() > 0) {
+ src.setBackOffDelay(config.getBackOffDelay());
+ }
+ if (config.getInitialDelay() > 0) {
+ src.setInitialDelay(config.getInitialDelay());
+ }
+ if (config.getBackOffMaxAttempts() > 0) {
+ src.setBackOffMaxAttempts(config.getBackOffMaxAttempts());
+ }
+ if (config.getBackOffMaxDelay() > 0) {
+ src.setBackOffMaxDelay(config.getBackOffDelay());
+ }
+ if (config.getBackOffMaxElapsedTime() > 0) {
+
src.setBackOffMaxElapsedTime(config.getBackOffMaxElapsedTime());
+ }
+ if (config.getBackOffMultiplier() > 0) {
+ src.setBackOffMultiplier(config.getBackOffMultiplier());
+ }
+ src.setUnhealthyOnExhausted(config.isUnhealthyOnExhausted());
+ src.setUnhealthyOnRestarting(config.isUnhealthyOnRestarting());
+ }
+
+ }
+
private void bindBeansToRegistry(
CamelContext camelContext, OrderedLocationProperties properties,
String optionPrefix, boolean failIfNotSet, boolean logSummary,
boolean ignoreCase,
diff --git
a/core/camel-main/src/main/java/org/apache/camel/main/DefaultConfigurationConfigurer.java
b/core/camel-main/src/main/java/org/apache/camel/main/DefaultConfigurationConfigurer.java
index 09bd2dceab3..1ed607290fa 100644
---
a/core/camel-main/src/main/java/org/apache/camel/main/DefaultConfigurationConfigurer.java
+++
b/core/camel-main/src/main/java/org/apache/camel/main/DefaultConfigurationConfigurer.java
@@ -78,7 +78,6 @@ import org.apache.camel.spi.RuntimeEndpointRegistry;
import org.apache.camel.spi.ShutdownStrategy;
import org.apache.camel.spi.StartupStepRecorder;
import org.apache.camel.spi.StreamCachingStrategy;
-import org.apache.camel.spi.SupervisingRouteController;
import org.apache.camel.spi.ThreadPoolFactory;
import org.apache.camel.spi.ThreadPoolProfile;
import org.apache.camel.spi.UnitOfWorkFactory;
@@ -346,40 +345,6 @@ public final class DefaultConfigurationConfigurer {
config.getRouteFilterIncludePattern(),
config.getRouteFilterExcludePattern());
}
-
- // supervising route controller
- if (config.isRouteControllerSuperviseEnabled()) {
- SupervisingRouteController src =
camelContext.getRouteController().supervising();
- if (config.getRouteControllerIncludeRoutes() != null) {
- src.setIncludeRoutes(config.getRouteControllerIncludeRoutes());
- }
- if (config.getRouteControllerExcludeRoutes() != null) {
- src.setExcludeRoutes(config.getRouteControllerExcludeRoutes());
- }
- if (config.getRouteControllerThreadPoolSize() > 0) {
-
src.setThreadPoolSize(config.getRouteControllerThreadPoolSize());
- }
- if (config.getRouteControllerBackOffDelay() > 0) {
- src.setBackOffDelay(config.getRouteControllerBackOffDelay());
- }
- if (config.getRouteControllerInitialDelay() > 0) {
- src.setInitialDelay(config.getRouteControllerInitialDelay());
- }
- if (config.getRouteControllerBackOffMaxAttempts() > 0) {
-
src.setBackOffMaxAttempts(config.getRouteControllerBackOffMaxAttempts());
- }
- if (config.getRouteControllerBackOffMaxDelay() > 0) {
-
src.setBackOffMaxDelay(config.getRouteControllerBackOffDelay());
- }
- if (config.getRouteControllerBackOffMaxElapsedTime() > 0) {
-
src.setBackOffMaxElapsedTime(config.getRouteControllerBackOffMaxElapsedTime());
- }
- if (config.getRouteControllerBackOffMultiplier() > 0) {
-
src.setBackOffMultiplier(config.getRouteControllerBackOffMultiplier());
- }
-
src.setUnhealthyOnExhausted(config.isRouteControllerUnhealthyOnExhausted());
-
src.setUnhealthyOnRestarting(config.isRouteControllerUnhealthyOnRestarting());
- }
}
/**
diff --git
a/core/camel-main/src/main/java/org/apache/camel/main/DefaultConfigurationProperties.java
b/core/camel-main/src/main/java/org/apache/camel/main/DefaultConfigurationProperties.java
index d918b39705b..3cdff9ae560 100644
---
a/core/camel-main/src/main/java/org/apache/camel/main/DefaultConfigurationProperties.java
+++
b/core/camel-main/src/main/java/org/apache/camel/main/DefaultConfigurationProperties.java
@@ -140,19 +140,6 @@ public abstract class DefaultConfigurationProperties<T> {
private boolean dumpRoutesGeneratedIds;
private String dumpRoutesOutput;
private Map<String, String> globalOptions;
- // route controller
- private boolean routeControllerSuperviseEnabled;
- private String routeControllerIncludeRoutes;
- private String routeControllerExcludeRoutes;
- private int routeControllerThreadPoolSize;
- private long routeControllerInitialDelay;
- private long routeControllerBackOffDelay;
- private long routeControllerBackOffMaxDelay;
- private long routeControllerBackOffMaxElapsedTime;
- private long routeControllerBackOffMaxAttempts;
- private double routeControllerBackOffMultiplier;
- private boolean routeControllerUnhealthyOnExhausted;
- private boolean routeControllerUnhealthyOnRestarting;
// startup recorder
@Metadata(enums = "false,off,java-flight-recorder,jfr,logging,backlog")
private String startupRecorder;
@@ -1507,170 +1494,6 @@ public abstract class DefaultConfigurationProperties<T>
{
this.globalOptions.put(key, value.toString());
}
- public boolean isRouteControllerSuperviseEnabled() {
- return routeControllerSuperviseEnabled;
- }
-
- /**
- * To enable using supervising route controller which allows Camel to
startup and then the controller takes care of
- * starting the routes in a safe manner.
- *
- * This can be used when you want to startup Camel despite a route may
otherwise fail fast during startup and cause
- * Camel to fail to startup as well. By delegating the route startup to
the supervising route controller then its
- * manages the startup using a background thread. The controller allows to
be configured with various settings to
- * attempt to restart failing routes.
- */
- public void setRouteControllerSuperviseEnabled(boolean
routeControllerSuperviseEnabled) {
- this.routeControllerSuperviseEnabled = routeControllerSuperviseEnabled;
- }
-
- public String getRouteControllerIncludeRoutes() {
- return routeControllerIncludeRoutes;
- }
-
- /**
- * Pattern for filtering routes to be included as supervised.
- *
- * The pattern is matching on route id, and endpoint uri for the route.
Multiple patterns can be separated by comma.
- *
- * For example to include all kafka routes, you can say <tt>kafka:*</tt>.
And to include routes with specific route
- * ids <tt>myRoute,myOtherRoute</tt>. The pattern supports wildcards and
uses the matcher from
- * org.apache.camel.support.PatternHelper#matchPattern.
- */
- public void setRouteControllerIncludeRoutes(String
routeControllerIncludeRoutes) {
- this.routeControllerIncludeRoutes = routeControllerIncludeRoutes;
- }
-
- public String getRouteControllerExcludeRoutes() {
- return routeControllerExcludeRoutes;
- }
-
- /**
- * Pattern for filtering routes to be excluded as supervised.
- *
- * The pattern is matching on route id, and endpoint uri for the route.
Multiple patterns can be separated by comma.
- *
- * For example to exclude all JMS routes, you can say <tt>jms:*</tt>. And
to exclude routes with specific route ids
- * <tt>mySpecialRoute,myOtherSpecialRoute</tt>. The pattern supports
wildcards and uses the matcher from
- * org.apache.camel.support.PatternHelper#matchPattern.
- */
- public void setRouteControllerExcludeRoutes(String
routeControllerExcludeRoutes) {
- this.routeControllerExcludeRoutes = routeControllerExcludeRoutes;
- }
-
- public int getRouteControllerThreadPoolSize() {
- return routeControllerThreadPoolSize;
- }
-
- /**
- * The number of threads used by the route controller scheduled thread
pool that are used for restarting routes. The
- * pool uses 1 thread by default, but you can increase this to allow the
controller to concurrently attempt to
- * restart multiple routes in case more than one route has problems
starting.
- */
- public void setRouteControllerThreadPoolSize(int
routeControllerThreadPoolSize) {
- this.routeControllerThreadPoolSize = routeControllerThreadPoolSize;
- }
-
- public long getRouteControllerInitialDelay() {
- return routeControllerInitialDelay;
- }
-
- /**
- * Initial delay in milli seconds before the route controller starts,
after CamelContext has been started.
- */
- public void setRouteControllerInitialDelay(long
routeControllerInitialDelay) {
- this.routeControllerInitialDelay = routeControllerInitialDelay;
- }
-
- public long getRouteControllerBackOffDelay() {
- return routeControllerBackOffDelay;
- }
-
- /**
- * Backoff delay in millis when restarting a route that failed to startup.
- */
- public void setRouteControllerBackOffDelay(long
routeControllerBackOffDelay) {
- this.routeControllerBackOffDelay = routeControllerBackOffDelay;
- }
-
- public long getRouteControllerBackOffMaxDelay() {
- return routeControllerBackOffMaxDelay;
- }
-
- /**
- * Backoff maximum delay in millis when restarting a route that failed to
startup.
- */
- public void setRouteControllerBackOffMaxDelay(long
routeControllerBackOffMaxDelay) {
- this.routeControllerBackOffMaxDelay = routeControllerBackOffMaxDelay;
- }
-
- public long getRouteControllerBackOffMaxElapsedTime() {
- return routeControllerBackOffMaxElapsedTime;
- }
-
- /**
- * Backoff maximum elapsed time in millis, after which the backoff should
be considered exhausted and no more
- * attempts should be made.
- */
- public void setRouteControllerBackOffMaxElapsedTime(long
routeControllerBackOffMaxElapsedTime) {
- this.routeControllerBackOffMaxElapsedTime =
routeControllerBackOffMaxElapsedTime;
- }
-
- public long getRouteControllerBackOffMaxAttempts() {
- return routeControllerBackOffMaxAttempts;
- }
-
- /**
- * Backoff maximum number of attempts to restart a route that failed to
startup. When this threshold has been
- * exceeded then the controller will give up attempting to restart the
route, and the route will remain as stopped.
- */
- public void setRouteControllerBackOffMaxAttempts(long
routeControllerBackOffMaxAttempts) {
- this.routeControllerBackOffMaxAttempts =
routeControllerBackOffMaxAttempts;
- }
-
- public double getRouteControllerBackOffMultiplier() {
- return routeControllerBackOffMultiplier;
- }
-
- /**
- * Backoff multiplier to use for exponential backoff. This is used to
extend the delay between restart attempts.
- */
- public void setRouteControllerBackOffMultiplier(double
routeControllerBackOffMultiplier) {
- this.routeControllerBackOffMultiplier =
routeControllerBackOffMultiplier;
- }
-
- public boolean isRouteControllerUnhealthyOnExhausted() {
- return routeControllerUnhealthyOnExhausted;
- }
-
- /**
- * Whether to mark the route as unhealthy (down) when all restarting
attempts (backoff) have failed and the route is
- * not successfully started and the route manager is giving up.
- *
- * Setting this to true allows health checks to know about this and can
report the Camel application as DOWN.
- *
- * The default is false.
- */
- public void setRouteControllerUnhealthyOnExhausted(boolean
routeControllerUnhealthyOnExhausted) {
- this.routeControllerUnhealthyOnExhausted =
routeControllerUnhealthyOnExhausted;
- }
-
- public boolean isRouteControllerUnhealthyOnRestarting() {
- return routeControllerUnhealthyOnRestarting;
- }
-
- /**
- * Whether to mark the route as unhealthy (down) when the route failed to
initially start, and is being controlled
- * for restarting (backoff).
- *
- * Setting this to true allows health checks to know about this and can
report the Camel application as DOWN.
- *
- * The default is false.
- */
- public void setRouteControllerUnhealthyOnRestarting(boolean
routeControllerUnhealthyOnRestarting) {
- this.routeControllerUnhealthyOnRestarting =
routeControllerUnhealthyOnRestarting;
- }
-
public String getStartupRecorder() {
return startupRecorder;
}
@@ -2780,134 +2603,6 @@ public abstract class DefaultConfigurationProperties<T>
{
return (T) this;
}
- /**
- * To enable using supervising route controller which allows Camel to
startup and then the controller takes care of
- * starting the routes in a safe manner.
- *
- * This can be used when you want to startup Camel despite a route may
otherwise fail fast during startup and cause
- * Camel to fail to startup as well. By delegating the route startup to
the supervising route controller then its
- * manages the startup using a background thread. The controller allows to
be configured with various settings to
- * attempt to restart failing routes.
- */
- public T withRouteControllerSuperviseEnabled(boolean
routeControllerSuperviseEnabled) {
- this.routeControllerSuperviseEnabled = routeControllerSuperviseEnabled;
- return (T) this;
- }
-
- /**
- * Initial delay in milli seconds before the route controller starts,
after CamelContext has been started.
- */
- public T withRouteControllerInitialDelay(long routeControllerInitialDelay)
{
- this.routeControllerInitialDelay = routeControllerInitialDelay;
- return (T) this;
- }
-
- /**
- * Backoff delay in millis when restarting a route that failed to startup.
- */
- public T withRouteControllerBackOffDelay(long routeControllerBackOffDelay)
{
- this.routeControllerBackOffDelay = routeControllerBackOffDelay;
- return (T) this;
- }
-
- /**
- * Backoff maximum delay in millis when restarting a route that failed to
startup.
- */
- public T withRouteControllerBackOffMaxDelay(long
routeControllerBackOffMaxDelay) {
- this.routeControllerBackOffMaxDelay = routeControllerBackOffMaxDelay;
- return (T) this;
- }
-
- /**
- * Backoff maximum elapsed time in millis, after which the backoff should
be considered exhausted and no more
- * attempts should be made.
- */
- public T withRouteControllerBackOffMaxElapsedTime(long
routeControllerBackOffMaxElapsedTime) {
- this.routeControllerBackOffMaxElapsedTime =
routeControllerBackOffMaxElapsedTime;
- return (T) this;
- }
-
- /**
- * Backoff maximum number of attempts to restart a route that failed to
startup. When this threshold has been
- * exceeded then the controller will give up attempting to restart the
route, and the route will remain as stopped.
- */
- public T withRouteControllerBackOffMaxAttempts(long
routeControllerBackOffMaxAttempts) {
- this.routeControllerBackOffMaxAttempts =
routeControllerBackOffMaxAttempts;
- return (T) this;
- }
-
- /**
- * Backoff multiplier to use for exponential backoff. This is used to
extend the delay between restart attempts.
- */
- public T withRouteControllerBackOffMultiplier(double
routeControllerBackOffMultiplier) {
- this.routeControllerBackOffMultiplier =
routeControllerBackOffMultiplier;
- return (T) this;
- }
-
- /**
- * The number of threads used by the route controller scheduled thread
pool that are used for restarting routes. The
- * pool uses 1 thread by default, but you can increase this to allow the
controller to concurrently attempt to
- * restart multiple routes in case more than one route has problems
starting.
- */
- public T withRouteControllerThreadPoolSize(int
routeControllerThreadPoolSize) {
- this.routeControllerThreadPoolSize = routeControllerThreadPoolSize;
- return (T) this;
- }
-
- /**
- * Pattern for filtering routes to be included as supervised.
- *
- * The pattern is matching on route id, and endpoint uri for the route.
Multiple patterns can be separated by comma.
- *
- * For example to include all kafka routes, you can say <tt>kafka:*</tt>.
And to include routes with specific route
- * ids <tt>myRoute,myOtherRoute</tt>. The pattern supports wildcards and
uses the matcher from
- * org.apache.camel.support.PatternHelper#matchPattern.
- */
- public T withRouteControllerIncludeRoutes(String
routeControllerIncludeRoutes) {
- this.routeControllerIncludeRoutes = routeControllerIncludeRoutes;
- return (T) this;
- }
-
- /**
- * Pattern for filtering routes to be excluded as supervised.
- *
- * The pattern is matching on route id, and endpoint uri for the route.
Multiple patterns can be separated by comma.
- *
- * For example to exclude all JMS routes, you can say <tt>jms:*</tt>. And
to exclude routes with specific route ids
- * <tt>mySpecialRoute,myOtherSpecialRoute</tt>. The pattern supports
wildcards and uses the matcher from
- * org.apache.camel.support.PatternHelper#matchPattern.
- */
- public T withRouteControllerExcludeRoutes(String
routeControllerExcludeRoutes) {
- this.routeControllerExcludeRoutes = routeControllerExcludeRoutes;
- return (T) this;
- }
-
- /**
- * Whether to mark the route as unhealthy (down) when all restarting
attempts (backoff) have failed and the route is
- * not successfully started and the route manager is giving up.
- *
- * Setting this to true allows health checks to know about this and can
report the Camel application as DOWN.
- *
- * The default is false.
- */
- public T withRouteControllerUnhealthyOnExhausted(boolean
unhealthyOnExhausted) {
- this.routeControllerUnhealthyOnExhausted = unhealthyOnExhausted;
- return (T) this;
- }
-
- /**
- * Whether to mark the route as unhealthy (down) when the route failed to
initially start, and is being controlled
- * for restarting (backoff).
- *
- * Setting this to true allows health checks to know about this and can
report the Camel application as DOWN.
- *
- * The default is false.
- */
- public T withRouteControllerUnhealthyOnRestarting(boolean
routeControllerUnhealthyOnRestarting) {
- this.routeControllerUnhealthyOnRestarting =
routeControllerUnhealthyOnRestarting;
- return (T) this;
- }
-
/**
* To use startup recorder for capturing execution time during starting
Camel. The recorder can be one of: false (or
* off), logging, backlog, java-flight-recorder (or jfr).
diff --git
a/core/camel-main/src/main/java/org/apache/camel/main/MainConfigurationProperties.java
b/core/camel-main/src/main/java/org/apache/camel/main/MainConfigurationProperties.java
index 70300e16c70..e3d8512ef36 100644
---
a/core/camel-main/src/main/java/org/apache/camel/main/MainConfigurationProperties.java
+++
b/core/camel-main/src/main/java/org/apache/camel/main/MainConfigurationProperties.java
@@ -63,6 +63,7 @@ public class MainConfigurationProperties extends
DefaultConfigurationProperties<
private HttpServerConfigurationProperties
httpServerConfigurationProperties;
private SSLConfigurationProperties sslConfigurationProperties;
private DebuggerConfigurationProperties debuggerConfigurationProperties;
+ private RouteControllerConfigurationProperties
routeControllerConfigurationProperties;
@Override
public void close() {
@@ -114,6 +115,10 @@ public class MainConfigurationProperties extends
DefaultConfigurationProperties<
debuggerConfigurationProperties.close();
debuggerConfigurationProperties = null;
}
+ if (routeControllerConfigurationProperties != null) {
+ routeControllerConfigurationProperties.close();
+ routeControllerConfigurationProperties = null;
+ }
if (routesBuilders != null) {
routesBuilders.clear();
routesBuilders = null;
@@ -223,6 +228,13 @@ public class MainConfigurationProperties extends
DefaultConfigurationProperties<
return sslConfigurationProperties;
}
+ /**
+ * Whether there has been any SSL configuration specified.
+ */
+ public boolean hasSslConfiguration() {
+ return sslConfigurationProperties != null;
+ }
+
/**
* To configure Debugger.
*/
@@ -235,17 +247,28 @@ public class MainConfigurationProperties extends
DefaultConfigurationProperties<
}
/**
- * Whether there has been any SSL configuration specified.
+ * Whether there has been any Debugger configuration specified.
*/
- public boolean hasSslConfiguration() {
- return sslConfigurationProperties != null;
+ public boolean hasDebuggerConfiguration() {
+ return debuggerConfigurationProperties != null;
}
/**
- * Whether there has been any Debugger configuration specified.
+ * To configure Route Controller.
*/
- public boolean hasDebuggerConfiguration() {
- return debuggerConfigurationProperties != null;
+ public RouteControllerConfigurationProperties routeControllerConfig() {
+ if (routeControllerConfigurationProperties == null) {
+ routeControllerConfigurationProperties = new
RouteControllerConfigurationProperties(this);
+ }
+
+ return routeControllerConfigurationProperties;
+ }
+
+ /**
+ * Whether there has been any Route Controller configuration specified.
+ */
+ public boolean hasRouteControllerConfiguration() {
+ return routeControllerConfigurationProperties != null;
}
/**
diff --git
a/core/camel-main/src/main/java/org/apache/camel/main/RouteControllerConfigurationProperties.java
b/core/camel-main/src/main/java/org/apache/camel/main/RouteControllerConfigurationProperties.java
new file mode 100644
index 00000000000..c33d00e68a2
--- /dev/null
+++
b/core/camel-main/src/main/java/org/apache/camel/main/RouteControllerConfigurationProperties.java
@@ -0,0 +1,361 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.main;
+
+import org.apache.camel.spi.BootstrapCloseable;
+import org.apache.camel.spi.Configurer;
+import org.apache.camel.spi.Metadata;
+
+/**
+ * Route controller configuration.
+ */
+@Configurer(bootstrap = true)
+public class RouteControllerConfigurationProperties implements
BootstrapCloseable {
+
+ private MainConfigurationProperties parent;
+
+ @Metadata
+ private boolean superviseEnabled;
+ @Metadata
+ private String includeRoutes;
+ @Metadata
+ private String excludeRoutes;
+ @Metadata
+ private boolean unhealthyOnExhausted;
+ @Metadata
+ private boolean unhealthyOnRestarting;
+ @Metadata
+ private long initialDelay;
+ @Metadata(defaultValue = "2000")
+ private long backOffDelay;
+ @Metadata
+ private long backOffMaxDelay;
+ @Metadata
+ private long backOffMaxElapsedTime;
+ @Metadata
+ private long backOffMaxAttempts;
+ @Metadata
+ private double backOffMultiplier;
+ @Metadata(label = "advanced", defaultValue = "1")
+ private int threadPoolSize;
+
+ public RouteControllerConfigurationProperties(MainConfigurationProperties
parent) {
+ this.parent = parent;
+ }
+
+ public MainConfigurationProperties end() {
+ return parent;
+ }
+
+ @Override
+ public void close() {
+ parent = null;
+ }
+
+ public boolean isSuperviseEnabled() {
+ return superviseEnabled;
+ }
+
+ /**
+ * To enable using supervising route controller which allows Camel to
startup and then the controller takes care of
+ * starting the routes in a safe manner.
+ *
+ * This can be used when you want to startup Camel despite a route may
otherwise fail fast during startup and cause
+ * Camel to fail to startup as well. By delegating the route startup to
the supervising route controller then its
+ * manages the startup using a background thread. The controller allows to
be configured with various settings to
+ * attempt to restart failing routes.
+ */
+ public void setSuperviseEnabled(boolean superviseEnabled) {
+ this.superviseEnabled = superviseEnabled;
+ }
+
+ public String getIncludeRoutes() {
+ return includeRoutes;
+ }
+
+ /**
+ * Pattern for filtering routes to be included as supervised.
+ *
+ * The pattern is matching on route id, and endpoint uri for the route.
Multiple patterns can be separated by comma.
+ *
+ * For example to include all kafka routes, you can say <tt>kafka:*</tt>.
And to include routes with specific route
+ * ids <tt>myRoute,myOtherRoute</tt>. The pattern supports wildcards and
uses the matcher from
+ * org.apache.camel.support.PatternHelper#matchPattern.
+ */
+ public void setIncludeRoutes(String includeRoutes) {
+ this.includeRoutes = includeRoutes;
+ }
+
+ public String getExcludeRoutes() {
+ return excludeRoutes;
+ }
+
+ /**
+ * Pattern for filtering routes to be excluded as supervised.
+ *
+ * The pattern is matching on route id, and endpoint uri for the route.
Multiple patterns can be separated by comma.
+ *
+ * For example to exclude all JMS routes, you can say <tt>jms:*</tt>. And
to exclude routes with specific route ids
+ * <tt>mySpecialRoute,myOtherSpecialRoute</tt>. The pattern supports
wildcards and uses the matcher from
+ * org.apache.camel.support.PatternHelper#matchPattern.
+ */
+ public void setExcludeRoutes(String excludeRoutes) {
+ this.excludeRoutes = excludeRoutes;
+ }
+
+ public int getThreadPoolSize() {
+ return threadPoolSize;
+ }
+
+ /**
+ * The number of threads used by the route controller scheduled thread
pool that are used for restarting routes. The
+ * pool uses 1 thread by default, but you can increase this to allow the
controller to concurrently attempt to
+ * restart multiple routes in case more than one route has problems
starting.
+ */
+ public void setThreadPoolSize(int threadPoolSize) {
+ this.threadPoolSize = threadPoolSize;
+ }
+
+ public long getInitialDelay() {
+ return initialDelay;
+ }
+
+ /**
+ * Initial delay in milli seconds before the route controller starts,
after CamelContext has been started.
+ */
+ public void setInitialDelay(long initialDelay) {
+ this.initialDelay = initialDelay;
+ }
+
+ public long getBackOffDelay() {
+ return backOffDelay;
+ }
+
+ /**
+ * Backoff delay in millis when restarting a route that failed to startup.
+ */
+ public void setBackOffDelay(long backOffDelay) {
+ this.backOffDelay = backOffDelay;
+ }
+
+ public long getBackOffMaxDelay() {
+ return backOffMaxDelay;
+ }
+
+ /**
+ * Backoff maximum delay in millis when restarting a route that failed to
startup.
+ */
+ public void setBackOffMaxDelay(long backOffMaxDelay) {
+ this.backOffMaxDelay = backOffMaxDelay;
+ }
+
+ public long getBackOffMaxElapsedTime() {
+ return backOffMaxElapsedTime;
+ }
+
+ /**
+ * Backoff maximum elapsed time in millis, after which the backoff should
be considered exhausted and no more
+ * attempts should be made.
+ */
+ public void setBackOffMaxElapsedTime(long backOffMaxElapsedTime) {
+ this.backOffMaxElapsedTime = backOffMaxElapsedTime;
+ }
+
+ public long getBackOffMaxAttempts() {
+ return backOffMaxAttempts;
+ }
+
+ /**
+ * Backoff maximum number of attempts to restart a route that failed to
startup. When this threshold has been
+ * exceeded then the controller will give up attempting to restart the
route, and the route will remain as stopped.
+ */
+ public void setBackOffMaxAttempts(long backOffMaxAttempts) {
+ this.backOffMaxAttempts = backOffMaxAttempts;
+ }
+
+ public double getBackOffMultiplier() {
+ return backOffMultiplier;
+ }
+
+ /**
+ * Backoff multiplier to use for exponential backoff. This is used to
extend the delay between restart attempts.
+ */
+ public void setBackOffMultiplier(double backOffMultiplier) {
+ this.backOffMultiplier = backOffMultiplier;
+ }
+
+ public boolean isUnhealthyOnExhausted() {
+ return unhealthyOnExhausted;
+ }
+
+ /**
+ * Whether to mark the route as unhealthy (down) when all restarting
attempts (backoff) have failed and the route is
+ * not successfully started and the route manager is giving up.
+ *
+ * Setting this to true allows health checks to know about this and can
report the Camel application as DOWN.
+ *
+ * The default is false.
+ */
+ public void setUnhealthyOnExhausted(boolean unhealthyOnExhausted) {
+ this.unhealthyOnExhausted = unhealthyOnExhausted;
+ }
+
+ public boolean isUnhealthyOnRestarting() {
+ return unhealthyOnRestarting;
+ }
+
+ /**
+ * Whether to mark the route as unhealthy (down) when the route failed to
initially start, and is being controlled
+ * for restarting (backoff).
+ *
+ * Setting this to true allows health checks to know about this and can
report the Camel application as DOWN.
+ *
+ * The default is false.
+ */
+ public void setUnhealthyOnRestarting(boolean unhealthyOnRestarting) {
+ this.unhealthyOnRestarting = unhealthyOnRestarting;
+ }
+
+ /**
+ * To enable using supervising route controller which allows Camel to
startup and then the controller takes care of
+ * starting the routes in a safe manner.
+ *
+ * This can be used when you want to startup Camel despite a route may
otherwise fail fast during startup and cause
+ * Camel to fail to startup as well. By delegating the route startup to
the supervising route controller then its
+ * manages the startup using a background thread. The controller allows to
be configured with various settings to
+ * attempt to restart failing routes.
+ */
+ public RouteControllerConfigurationProperties withSuperviseEnabled(boolean
superviseEnabled) {
+ this.superviseEnabled = superviseEnabled;
+ return this;
+ }
+
+ /**
+ * Initial delay in milli seconds before the route controller starts,
after CamelContext has been started.
+ */
+ public RouteControllerConfigurationProperties withInitialDelay(long
initialDelay) {
+ this.initialDelay = initialDelay;
+ return this;
+ }
+
+ /**
+ * Backoff delay in millis when restarting a route that failed to startup.
+ */
+ public RouteControllerConfigurationProperties withBackOffDelay(long
backOffDelay) {
+ this.backOffDelay = backOffDelay;
+ return this;
+ }
+
+ /**
+ * Backoff maximum delay in millis when restarting a route that failed to
startup.
+ */
+ public RouteControllerConfigurationProperties withBackOffMaxDelay(long
backOffMaxDelay) {
+ this.backOffMaxDelay = backOffMaxDelay;
+ return this;
+ }
+
+ /**
+ * Backoff maximum elapsed time in millis, after which the backoff should
be considered exhausted and no more
+ * attempts should be made.
+ */
+ public RouteControllerConfigurationProperties
withBackOffMaxElapsedTime(long backOffMaxElapsedTime) {
+ this.backOffMaxElapsedTime = backOffMaxElapsedTime;
+ return this;
+ }
+
+ /**
+ * Backoff maximum number of attempts to restart a route that failed to
startup. When this threshold has been
+ * exceeded then the controller will give up attempting to restart the
route, and the route will remain as stopped.
+ */
+ public RouteControllerConfigurationProperties withBackOffMaxAttempts(long
backOffMaxAttempts) {
+ this.backOffMaxAttempts = backOffMaxAttempts;
+ return this;
+ }
+
+ /**
+ * Backoff multiplier to use for exponential backoff. This is used to
extend the delay between restart attempts.
+ */
+ public RouteControllerConfigurationProperties withBackOffMultiplier(double
backOffMultiplier) {
+ this.backOffMultiplier = backOffMultiplier;
+ return this;
+ }
+
+ /**
+ * The number of threads used by the route controller scheduled thread
pool that are used for restarting routes. The
+ * pool uses 1 thread by default, but you can increase this to allow the
controller to concurrently attempt to
+ * restart multiple routes in case more than one route has problems
starting.
+ */
+ public RouteControllerConfigurationProperties withThreadPoolSize(int
threadPoolSize) {
+ this.threadPoolSize = threadPoolSize;
+ return this;
+ }
+
+ /**
+ * Pattern for filtering routes to be included as supervised.
+ *
+ * The pattern is matching on route id, and endpoint uri for the route.
Multiple patterns can be separated by comma.
+ *
+ * For example to include all kafka routes, you can say <tt>kafka:*</tt>.
And to include routes with specific route
+ * ids <tt>myRoute,myOtherRoute</tt>. The pattern supports wildcards and
uses the matcher from
+ * org.apache.camel.support.PatternHelper#matchPattern.
+ */
+ public RouteControllerConfigurationProperties withIncludeRoutes(String
includeRoutes) {
+ this.includeRoutes = includeRoutes;
+ return this;
+ }
+
+ /**
+ * Pattern for filtering routes to be excluded as supervised.
+ *
+ * The pattern is matching on route id, and endpoint uri for the route.
Multiple patterns can be separated by comma.
+ *
+ * For example to exclude all JMS routes, you can say <tt>jms:*</tt>. And
to exclude routes with specific route ids
+ * <tt>mySpecialRoute,myOtherSpecialRoute</tt>. The pattern supports
wildcards and uses the matcher from
+ * org.apache.camel.support.PatternHelper#matchPattern.
+ */
+ public RouteControllerConfigurationProperties withExcludeRoutes(String
excludeRoutes) {
+ this.excludeRoutes = excludeRoutes;
+ return this;
+ }
+
+ /**
+ * Whether to mark the route as unhealthy (down) when all restarting
attempts (backoff) have failed and the route is
+ * not successfully started and the route manager is giving up.
+ *
+ * Setting this to true allows health checks to know about this and can
report the Camel application as DOWN.
+ *
+ * The default is false.
+ */
+ public RouteControllerConfigurationProperties
withUnhealthyOnExhausted(boolean unhealthyOnExhausted) {
+ this.unhealthyOnExhausted = unhealthyOnExhausted;
+ return this;
+ }
+
+ /**
+ * Whether to mark the route as unhealthy (down) when the route failed to
initially start, and is being controlled
+ * for restarting (backoff).
+ *
+ * Setting this to true allows health checks to know about this and can
report the Camel application as DOWN.
+ *
+ * The default is false.
+ */
+ public RouteControllerConfigurationProperties
withUnhealthyOnRestarting(boolean unhealthyOnRestarting) {
+ this.unhealthyOnRestarting = unhealthyOnRestarting;
+ return this;
+ }
+
+}
diff --git
a/core/camel-main/src/test/java/org/apache/camel/main/MainSupervisingRouteControllerFilterFailToStartRouteTest.java
b/core/camel-main/src/test/java/org/apache/camel/main/MainSupervisingRouteControllerFilterFailToStartRouteTest.java
index 5c74d7a23e0..8c2c2548e9a 100644
---
a/core/camel-main/src/test/java/org/apache/camel/main/MainSupervisingRouteControllerFilterFailToStartRouteTest.java
+++
b/core/camel-main/src/test/java/org/apache/camel/main/MainSupervisingRouteControllerFilterFailToStartRouteTest.java
@@ -38,12 +38,12 @@ public class
MainSupervisingRouteControllerFilterFailToStartRouteTest {
// lets make a simple route
Main main = new Main();
main.configure().addRoutesBuilder(new MyRoute());
- main.configure().setRouteControllerSuperviseEnabled(true);
- main.configure().setRouteControllerBackOffDelay(250);
- main.configure().setRouteControllerBackOffMaxAttempts(3);
- main.configure().setRouteControllerInitialDelay(1000);
- main.configure().setRouteControllerThreadPoolSize(2);
- main.configure().setRouteControllerExcludeRoutes("inbox");
+ main.configure().routeControllerConfig().setSuperviseEnabled(true);
+ main.configure().routeControllerConfig().setBackOffDelay(250);
+ main.configure().routeControllerConfig().setBackOffMaxAttempts(3);
+ main.configure().routeControllerConfig().setInitialDelay(1000);
+ main.configure().routeControllerConfig().setThreadPoolSize(2);
+ main.configure().routeControllerConfig().setExcludeRoutes("inbox");
try {
main.start();
diff --git
a/core/camel-main/src/test/java/org/apache/camel/main/MainSupervisingRouteControllerTest.java
b/core/camel-main/src/test/java/org/apache/camel/main/MainSupervisingRouteControllerTest.java
index 0e1e0f1cb9d..dccbfde2329 100644
---
a/core/camel-main/src/test/java/org/apache/camel/main/MainSupervisingRouteControllerTest.java
+++
b/core/camel-main/src/test/java/org/apache/camel/main/MainSupervisingRouteControllerTest.java
@@ -41,13 +41,13 @@ public class MainSupervisingRouteControllerTest {
// lets make a simple route
Main main = new Main();
main.configure().addRoutesBuilder(new MyRoute());
- main.configure()
- .withRouteControllerSuperviseEnabled(true)
- .withRouteControllerBackOffDelay(25)
- .withRouteControllerBackOffMaxAttempts(3)
- .withRouteControllerInitialDelay(100)
- .withRouteControllerThreadPoolSize(2)
- .withRouteControllerExcludeRoutes("timer*");
+ main.configure().routeControllerConfig()
+ .withSuperviseEnabled(true)
+ .withBackOffDelay(25)
+ .withBackOffMaxAttempts(3)
+ .withInitialDelay(100)
+ .withThreadPoolSize(2)
+ .withExcludeRoutes("timer*");
main.start();
MockEndpoint mock = main.getCamelContext().getEndpoint("mock:foo",
MockEndpoint.class);
@@ -87,11 +87,11 @@ public class MainSupervisingRouteControllerTest {
// lets make a simple route
Main main = new Main();
main.configure().addRoutesBuilder(new MyRoute());
- main.configure().setRouteControllerSuperviseEnabled(true);
- main.configure().setRouteControllerBackOffDelay(25);
- main.configure().setRouteControllerBackOffMaxAttempts(10);
- main.configure().setRouteControllerInitialDelay(100);
- main.configure().setRouteControllerThreadPoolSize(2);
+ main.configure().routeControllerConfig().setSuperviseEnabled(true);
+ main.configure().routeControllerConfig().setBackOffDelay(25);
+ main.configure().routeControllerConfig().setBackOffMaxAttempts(10);
+ main.configure().routeControllerConfig().setInitialDelay(100);
+ main.configure().routeControllerConfig().setThreadPoolSize(2);
main.start();
diff --git
a/docs/user-manual/modules/ROOT/pages/camel-4x-upgrade-guide-4_4.adoc
b/docs/user-manual/modules/ROOT/pages/camel-4x-upgrade-guide-4_4.adoc
index 51cdc9b460a..732796e42da 100644
--- a/docs/user-manual/modules/ROOT/pages/camel-4x-upgrade-guide-4_4.adoc
+++ b/docs/user-manual/modules/ROOT/pages/camel-4x-upgrade-guide-4_4.adoc
@@ -15,6 +15,12 @@ The method `getCreated` is now deprecated. Access to the
time-related informatio
The `lookup` method in
`org.apache.camel.component.properties.PropertiesLookup` now has a 2nd
parameter for the default value.
+=== camel-main
+
+The route controller configuration has been moved from general main to its own
group.
+All keys started with `camel.main.routesController` should be renamed to
`camel.routecontroller.`, for example
+`camel.main.routeControllerBackOffDelay` should be renamed to
`camel.routecontroller.backOffDelay`.
+
=== camel-azure-cosmosdb
The useDefaultIdentity parameter has been removed in favor of the
credentialType parameter. Now user should select between SHARED_ACCOUNT_KEY and
AZURE_IDENTITY.
@@ -43,3 +49,12 @@ With the SHARED_ACCOUNT_KEY mode the user could explicitly
set the sharedKey par
With the AZURE_IDENTITY mode the user will be able to use the Default Azure
Credentials Chain.
With the AZURE_SAS mode the user could explicitly set the token parameter.
This is part of the effort explained in CAMEL-18590.
+
+== Camel Spring Boot
+
+=== Auto Configuration
+
+The route controller configuration has been moved from general main to its own
group.
+All keys started with `camel.main.routesController` should be renamed to
`camel.routecontroller.`, for example
+`camel.main.routeControllerBackOffDelay` should be renamed to
`camel.routecontroller.backOffDelay`.
+
diff --git a/docs/user-manual/modules/ROOT/pages/route-controller.adoc
b/docs/user-manual/modules/ROOT/pages/route-controller.adoc
index 0d3dd197f1c..3a7b0a0aed2 100644
--- a/docs/user-manual/modules/ROOT/pages/route-controller.adoc
+++ b/docs/user-manual/modules/ROOT/pages/route-controller.adoc
@@ -85,29 +85,16 @@ from `application.properties`:
[source,properties]
----
-camel.main.routeControllerSuperviseEnabled = true
+camel.routecontroller.superviseEnabled = true
# and you can configure more options
-camel.main.routeControllerBackoffDelay = 5000
-camel.main.routeControllerBackoffMaxAttempts = 3
-camel.main.routeControllerInitialDelay = 1000
-camel.main.routeControllerThreadPoolSize = 2
+camel.routecontroller.backoffDelay = 5000
+camel.routecontroller.backoffMaxAttempts = 3
+camel.routecontroller.initialDelay = 1000
+camel.routecontroller.threadPoolSize = 2
----
-And in Spring Boot:
-
-[source,properties]
-----
-camel.springboot.routeControllerSuperviseEnabled = true
-
-# and you can configure more options
-camel.springboot.routeControllerBackoffDelay = 5000
-camel.springboot.routeControllerBackoffMaxAttempts = 3
-camel.springboot.routeControllerInitialDelay = 1000
-camel.springboot.routeControllerThreadPoolSize = 2
-----
-
-And for users with XML DSL you can do as follows:
+And for users with Spring <beans> or OSGi <blueprint> XML you can do as
follows:
[source,xml]
----
@@ -144,7 +131,7 @@ You can configure the `SupervisingRouteController` using
the following options:
| ExcludeRoutes | | Pattern for filtering routes to be excluded as supervised.
The pattern is matching on route id, and endpoint uri for the route. Multiple
patterns can be separated by comma. For example to exclude all JMS routes, you
can say jms:. And to exclude routes with specific route ids
mySpecialRoute,myOtherSpecialRoute. The pattern supports wildcards and uses the
matcher from org.apache.camel.support.PatternHelper#matchPattern.
| ThreadPoolSize | `1` | The number of threads used by the route controller
scheduled thread pool that are used for restarting routes. The pool uses 1
thread by default, but you can increase this to allow the controller to
concurrently attempt to restart multiple routes in case more than one route has
problems starting.
| UnhealthyOnExhausted | `false` | Whether to mark the route as unhealthy
(down) when all restarting attempts (backoff) have failed and the route is not
successfully started and the route manager is giving up. Setting this to true
allows health checks to know about this and can report the Camel application as
DOWN.
-| routeControllerUnhealthyOnRestarting | `false` | Whether to mark the route
as unhealthy (down) when the route failed to initially start, and is being
controlled for restarting (backoff). Setting this to true allows health checks
to know about this and can report the Camel application as DOWN.
+| UnhealthyOnRestarting | `false` | Whether to mark the route as unhealthy
(down) when the route failed to initially start, and is being controlled for
restarting (backoff). Setting this to true allows health checks to know about
this and can report the Camel application as DOWN.
|=======================================================================
=== Filtering routes to fail fast
@@ -177,7 +164,7 @@ by excluding by pattern `aws*` (uri or route id)
[source,java]
-----
-camel.springboot.routeControllerExcludeRoutes = aws*
+camel.routecontroller.excludeRoutes = aws*
-----
== JMX management
diff --git
a/tooling/maven/camel-package-maven-plugin/src/main/java/org/apache/camel/maven/packaging/PrepareCamelMainMojo.java
b/tooling/maven/camel-package-maven-plugin/src/main/java/org/apache/camel/maven/packaging/PrepareCamelMainMojo.java
index 43789467da0..5c208a906b8 100644
---
a/tooling/maven/camel-package-maven-plugin/src/main/java/org/apache/camel/maven/packaging/PrepareCamelMainMojo.java
+++
b/tooling/maven/camel-package-maven-plugin/src/main/java/org/apache/camel/maven/packaging/PrepareCamelMainMojo.java
@@ -219,6 +219,8 @@ public class PrepareCamelMainMojo extends
AbstractGeneratorMojo {
prefix = "camel.ssl.";
} else if
(file.getName().contains("DebuggerConfigurationProperties")) {
prefix = "camel.debug.";
+ } else if
(file.getName().contains("RouteControllerConfigurationProperties")) {
+ prefix = "camel.routecontroller.";
} else {
prefix = "camel.main.";
}
@@ -285,6 +287,10 @@ public class PrepareCamelMainMojo extends
AbstractGeneratorMojo {
model.getOptions().addAll(data);
model.getGroups().add(new MainGroupModel(
"camel.main", "Camel Main configurations",
"org.apache.camel.main.DefaultConfigurationProperties"));
+ model.getGroups()
+ .add(new MainGroupModel(
+ "camel.routecontroller", "Camel Route Controller
configurations",
+
"org.apache.camel.main.RouteControllerConfigurationProperties"));
model.getGroups().add(new MainGroupModel(
"camel.server",
"Camel Embedded HTTP Server (only for standalone; not
Spring Boot or Quarkus) configurations",
