This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel.git
The following commit(s) were added to refs/heads/main by this push:
new 6b4b0ca2f99e CAMEL-23005: camel-core - Failover Loadbalancer should
mark stick and round robin as boolean types
6b4b0ca2f99e is described below
commit 6b4b0ca2f99e386f085459abf04808a9ce413597
Author: Claus Ibsen <[email protected]>
AuthorDate: Sat Feb 14 18:11:52 2026 +0100
CAMEL-23005: camel-core - Failover Loadbalancer should mark stick and round
robin as boolean types
---
.../camel/catalog/models/failoverLoadBalancer.json | 4 +-
.../apache/camel/catalog/schemas/camel-spring.xsd | 4 +-
.../apache/camel/catalog/schemas/camel-xml-io.xsd | 4 +-
.../eips/pages/failoverLoadBalancer-eip.adoc | 132 ++++++++++++++++++---
.../model/loadbalancer/failoverLoadBalancer.json | 4 +-
.../apache/camel/model/LoadBalanceDefinition.java | 16 ++-
.../FailoverLoadBalancerDefinition.java | 2 +
.../dsl/yaml/deserializers/ModelDeserializers.java | 4 +-
.../generated/resources/schema/camelYamlDsl.json | 10 +-
9 files changed, 147 insertions(+), 33 deletions(-)
diff --git
a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/models/failoverLoadBalancer.json
b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/models/failoverLoadBalancer.json
index e0bc89dd7add..f9b3090b6ed1 100644
---
a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/models/failoverLoadBalancer.json
+++
b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/models/failoverLoadBalancer.json
@@ -14,8 +14,8 @@
"properties": {
"id": { "index": 0, "kind": "attribute", "displayName": "Id", "group":
"common", "required": false, "type": "string", "javaType": "java.lang.String",
"deprecated": false, "autowired": false, "secret": false, "description": "The
id of this node" },
"exception": { "index": 1, "kind": "element", "displayName": "Exception",
"group": "common", "required": false, "type": "array", "javaType":
"java.util.List<java.lang.String>", "deprecated": false, "autowired": false,
"secret": false, "description": "A list of class names for specific exceptions
to monitor. If no exceptions are configured then all exceptions are monitored"
},
- "roundRobin": { "index": 2, "kind": "attribute", "displayName": "Round
Robin", "group": "common", "required": false, "type": "string", "javaType":
"java.lang.String", "deprecated": false, "autowired": false, "secret": false,
"description": "Whether or not the failover load balancer should operate in
round robin mode or not. If not, then it will always start from the first
endpoint when a new message is to be processed. In other words it restart from
the top for every message. If roun [...]
- "sticky": { "index": 3, "kind": "attribute", "displayName": "Sticky",
"group": "common", "required": false, "type": "string", "javaType":
"java.lang.String", "deprecated": false, "autowired": false, "secret": false,
"description": "Whether or not the failover load balancer should operate in
sticky mode or not. If not, then it will always start from the first endpoint
when a new message is to be processed. In other words it restart from the top
for every message. If sticky is enabled, [...]
+ "roundRobin": { "index": 2, "kind": "attribute", "displayName": "Round
Robin", "group": "common", "required": false, "type": "boolean", "javaType":
"java.lang.Boolean", "deprecated": false, "autowired": false, "secret": false,
"defaultValue": false, "description": "Whether or not the failover load
balancer should operate in round robin mode or not. If not, then it will always
start from the first endpoint when a new message is to be processed. In other
words it restart from the top f [...]
+ "sticky": { "index": 3, "kind": "attribute", "displayName": "Sticky",
"group": "common", "required": false, "type": "boolean", "javaType":
"java.lang.Boolean", "deprecated": false, "autowired": false, "secret": false,
"defaultValue": false, "description": "Whether or not the failover load
balancer should operate in sticky mode or not. If not, then it will always
start from the first endpoint when a new message is to be processed. In other
words it restart from the top for every messa [...]
"maximumFailoverAttempts": { "index": 4, "kind": "attribute",
"displayName": "Maximum Failover Attempts", "group": "common", "required":
false, "type": "string", "javaType": "java.lang.String", "deprecated": false,
"autowired": false, "secret": false, "defaultValue": "-1", "description": "A
value to indicate after X failover attempts we should exhaust (give up). Use -1
to indicate never give up and continuously try to failover. Use 0 to never
failover. And use e.g. 3 to failover at m [...]
"inheritErrorHandler": { "index": 5, "kind": "attribute", "displayName":
"Inherit Error Handler", "group": "advanced", "label": "advanced", "required":
false, "type": "boolean", "javaType": "java.lang.Boolean", "deprecated": false,
"autowired": false, "secret": false, "defaultValue": true, "description": "To
turn off Camel error handling during load balancing. By default, Camel error
handler will attempt calling a service, which means you can specify retires and
other fine-grained se [...]
}
diff --git
a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/schemas/camel-spring.xsd
b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/schemas/camel-spring.xsd
index 673fe0f77b45..296d19fddb5b 100644
---
a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/schemas/camel-spring.xsd
+++
b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/schemas/camel-spring.xsd
@@ -7261,7 +7261,7 @@ Whether or not the failover load balancer should operate
in round robin mode or
from the first endpoint when a new message is to be processed. In other words
it restart from the top for every message.
If round robin is enabled, then it keeps state and will continue with the next
endpoint in a round robin fashion. You
can also enable sticky mode together with round robin, if so then it will pick
the last known good endpoint to use when
-starting the load balancing (instead of using the next when starting).
+starting the load balancing (instead of using the next when starting). Default
value: false
]]>
</xs:documentation>
</xs:annotation>
@@ -7274,7 +7274,7 @@ Whether or not the failover load balancer should operate
in sticky mode or not.
the first endpoint when a new message is to be processed. In other words it
restart from the top for every message. If
sticky is enabled, then it keeps state and will continue with the last known
good endpoint. You can also enable sticky
mode together with round robin, if so then it will pick the last known good
endpoint to use when starting the load
-balancing (instead of using the next when starting).
+balancing (instead of using the next when starting). Default value: false
]]>
</xs:documentation>
</xs:annotation>
diff --git
a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/schemas/camel-xml-io.xsd
b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/schemas/camel-xml-io.xsd
index f64cccd199bb..aae3eba9da82 100644
---
a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/schemas/camel-xml-io.xsd
+++
b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/schemas/camel-xml-io.xsd
@@ -5934,7 +5934,7 @@ Whether or not the failover load balancer should operate
in round robin mode or
from the first endpoint when a new message is to be processed. In other words
it restart from the top for every message.
If round robin is enabled, then it keeps state and will continue with the next
endpoint in a round robin fashion. You
can also enable sticky mode together with round robin, if so then it will pick
the last known good endpoint to use when
-starting the load balancing (instead of using the next when starting).
+starting the load balancing (instead of using the next when starting). Default
value: false
]]>
</xs:documentation>
</xs:annotation>
@@ -5947,7 +5947,7 @@ Whether or not the failover load balancer should operate
in sticky mode or not.
the first endpoint when a new message is to be processed. In other words it
restart from the top for every message. If
sticky is enabled, then it keeps state and will continue with the last known
good endpoint. You can also enable sticky
mode together with round robin, if so then it will pick the last known good
endpoint to use when starting the load
-balancing (instead of using the next when starting).
+balancing (instead of using the next when starting). Default value: false
]]>
</xs:documentation>
</xs:annotation>
diff --git
a/core/camel-core-engine/src/main/docs/modules/eips/pages/failoverLoadBalancer-eip.adoc
b/core/camel-core-engine/src/main/docs/modules/eips/pages/failoverLoadBalancer-eip.adoc
index d5ff7c0c6316..8e6bfb0b8727 100644
---
a/core/camel-core-engine/src/main/docs/modules/eips/pages/failoverLoadBalancer-eip.adoc
+++
b/core/camel-core-engine/src/main/docs/modules/eips/pages/failoverLoadBalancer-eip.adoc
@@ -55,6 +55,24 @@ XML::
</route>
----
+YAML::
++
+[source,yaml]
+----
+- route:
+ from:
+ uri: direct:start
+ steps:
+ - loadBalance:
+ steps:
+ - failoverLoadBalancer: {}
+ - to:
+ uri: http:service1
+ - to:
+ uri: http:service2
+ - to:
+ uri: http:service3
+----
====
In the default mode, the fail-over load balancer will always start with the
first processor (i.e., "http:service1").
@@ -67,8 +85,13 @@ You can use the `roundRobin` mode to start again from the
beginning, which then
trying until one succeed. To prevent endless retries, then it's recommended to
set a maximum fail-over value.
-Setting this in Java DSL is not _pretty_ as there are three parameters:
+[tabs]
+====
+Java::
++
+Setting this in Java DSL is not _pretty_ as there are three parameters:
++
[source,java]
----
from("direct:start")
@@ -78,24 +101,20 @@ from("direct:start")
.to("http:service3")
.end();
----
++
+Where `10` is the maximum fail-over attempts, And `false` is a special feature
+related to inheriting error handler. The last parameter `true` is to use
round-robin mode.
-[source,java]
-----
-.failover(10, false, true)
-----
-
-Where `10` is the maximum fail over attempts, And `false` is a special feature
-related to inheriting error handler.
-The last parameter `true` is to use round-robin mode.
-
-In XML, it is straightforward as shown:
-
+XML::
++
+In XML and YAML DSL it is easier.
++
[source,xml]
----
<route>
<from uri="direct:start"/>
<loadBalance>
- <failoverLoadBalancer roundRobin="true" maximumFailoverAttempts="10"/>
+ <failoverLoadBalancer inheritErrorHandler="false" roundRobin="true"
maximumFailoverAttempts="10"/>
<to uri="http:service1"/>
<to uri="http:service2"/>
<to uri="http:service3"/>
@@ -103,6 +122,32 @@ In XML, it is straightforward as shown:
</route>
----
+YAML::
++
+In XML and YAML DSL it is easier.
++
+[source,yaml]
+----
+- route:
+ from:
+ uri: direct:start
+ steps:
+ - loadBalance:
+ steps:
+ - failoverLoadBalancer:
+ inheritErrorHandler: "false"
+ maximumFailoverAttempts: 10
+ roundRobin: "true"
+ - to:
+ uri: http:service1
+ - to:
+ uri: http:service2
+ - to:
+ uri: http:service3
+----
+====
+
+
=== Using sticky mode
The sticky mode is used for remember the last known good endpoint, so the next
exchange
@@ -136,12 +181,14 @@ NOTE: The last `true` argument is to enable sticky mode.
XML::
+
+In XML and YAML DSL it is easier.
++
[source,xml]
----
<route>
<from uri="direct:start"/>
<loadBalance>
- <failoverLoadBalancer roundRobin="true" maximumFailoverAttempts="10"
stickyMode="true"/>
+ <failoverLoadBalancer inheritErrorHandler="false" roundRobin="true"
maximumFailoverAttempts="10" stickyMode="true"/>
<to uri="http:service1"/>
<to uri="http:service2"/>
<to uri="http:service3"/>
@@ -149,6 +196,30 @@ XML::
</route>
----
+YAML::
++
+In XML and YAML DSL it is easier.
++
+[source,yaml]
+----
+- route:
+ from:
+ uri: direct:start
+ steps:
+ - loadBalance:
+ steps:
+ - failoverLoadBalancer:
+ inheritErrorHandler: "false"
+ sticky: "true"
+ maximumFailoverAttempts: 10
+ roundRobin: "true"
+ - to:
+ uri: http:service1
+ - to:
+ uri: http:service2
+ - to:
+ uri: http:service3
+----
====
=== Fail-over on specific exceptions
@@ -156,6 +227,12 @@ XML::
The fail-over load balancer can be configured to only apply for a specific set
of exceptions.
Suppose you only want to fail-over in case of `java.io.Exception` or
`HttpOperationFailedException` then you can do:
+
+[tabs]
+====
+
+Java::
++
[source,java]
----
from("direct:start")
@@ -166,8 +243,8 @@ from("direct:start")
.end();
----
-And in XML DSL:
-
+XML::
++
[source,xml]
----
<route>
@@ -183,3 +260,26 @@ And in XML DSL:
</loadBalance>
</route>
----
+
+YAML::
++
+[source,yaml]
+----
+- route:
+ from:
+ uri: direct:start
+ steps:
+ - loadBalance:
+ steps:
+ - failoverLoadBalancer:
+ exception:
+ - java.io.IOException
+ - org.apache.camel.http.base.HttpOperationFailedException
+ - to:
+ uri: http:service1
+ - to:
+ uri: http:service2
+ - to:
+ uri: http:service3
+----
+====
diff --git
a/core/camel-core-model/src/generated/resources/META-INF/org/apache/camel/model/loadbalancer/failoverLoadBalancer.json
b/core/camel-core-model/src/generated/resources/META-INF/org/apache/camel/model/loadbalancer/failoverLoadBalancer.json
index e0bc89dd7add..f9b3090b6ed1 100644
---
a/core/camel-core-model/src/generated/resources/META-INF/org/apache/camel/model/loadbalancer/failoverLoadBalancer.json
+++
b/core/camel-core-model/src/generated/resources/META-INF/org/apache/camel/model/loadbalancer/failoverLoadBalancer.json
@@ -14,8 +14,8 @@
"properties": {
"id": { "index": 0, "kind": "attribute", "displayName": "Id", "group":
"common", "required": false, "type": "string", "javaType": "java.lang.String",
"deprecated": false, "autowired": false, "secret": false, "description": "The
id of this node" },
"exception": { "index": 1, "kind": "element", "displayName": "Exception",
"group": "common", "required": false, "type": "array", "javaType":
"java.util.List<java.lang.String>", "deprecated": false, "autowired": false,
"secret": false, "description": "A list of class names for specific exceptions
to monitor. If no exceptions are configured then all exceptions are monitored"
},
- "roundRobin": { "index": 2, "kind": "attribute", "displayName": "Round
Robin", "group": "common", "required": false, "type": "string", "javaType":
"java.lang.String", "deprecated": false, "autowired": false, "secret": false,
"description": "Whether or not the failover load balancer should operate in
round robin mode or not. If not, then it will always start from the first
endpoint when a new message is to be processed. In other words it restart from
the top for every message. If roun [...]
- "sticky": { "index": 3, "kind": "attribute", "displayName": "Sticky",
"group": "common", "required": false, "type": "string", "javaType":
"java.lang.String", "deprecated": false, "autowired": false, "secret": false,
"description": "Whether or not the failover load balancer should operate in
sticky mode or not. If not, then it will always start from the first endpoint
when a new message is to be processed. In other words it restart from the top
for every message. If sticky is enabled, [...]
+ "roundRobin": { "index": 2, "kind": "attribute", "displayName": "Round
Robin", "group": "common", "required": false, "type": "boolean", "javaType":
"java.lang.Boolean", "deprecated": false, "autowired": false, "secret": false,
"defaultValue": false, "description": "Whether or not the failover load
balancer should operate in round robin mode or not. If not, then it will always
start from the first endpoint when a new message is to be processed. In other
words it restart from the top f [...]
+ "sticky": { "index": 3, "kind": "attribute", "displayName": "Sticky",
"group": "common", "required": false, "type": "boolean", "javaType":
"java.lang.Boolean", "deprecated": false, "autowired": false, "secret": false,
"defaultValue": false, "description": "Whether or not the failover load
balancer should operate in sticky mode or not. If not, then it will always
start from the first endpoint when a new message is to be processed. In other
words it restart from the top for every messa [...]
"maximumFailoverAttempts": { "index": 4, "kind": "attribute",
"displayName": "Maximum Failover Attempts", "group": "common", "required":
false, "type": "string", "javaType": "java.lang.String", "deprecated": false,
"autowired": false, "secret": false, "defaultValue": "-1", "description": "A
value to indicate after X failover attempts we should exhaust (give up). Use -1
to indicate never give up and continuously try to failover. Use 0 to never
failover. And use e.g. 3 to failover at m [...]
"inheritErrorHandler": { "index": 5, "kind": "attribute", "displayName":
"Inherit Error Handler", "group": "advanced", "label": "advanced", "required":
false, "type": "boolean", "javaType": "java.lang.Boolean", "deprecated": false,
"autowired": false, "secret": false, "defaultValue": true, "description": "To
turn off Camel error handling during load balancing. By default, Camel error
handler will attempt calling a service, which means you can specify retires and
other fine-grained se [...]
}
diff --git
a/core/camel-core-model/src/main/java/org/apache/camel/model/LoadBalanceDefinition.java
b/core/camel-core-model/src/main/java/org/apache/camel/model/LoadBalanceDefinition.java
index 1a280ce8f486..b91cd59cfc3e 100644
---
a/core/camel-core-model/src/main/java/org/apache/camel/model/LoadBalanceDefinition.java
+++
b/core/camel-core-model/src/main/java/org/apache/camel/model/LoadBalanceDefinition.java
@@ -119,7 +119,8 @@ public class LoadBalanceDefinition extends
OutputDefinition<LoadBalanceDefinitio
* @return the builder
*/
public LoadBalanceDefinition failover() {
- return failover(-1, true, false);
+ setLoadBalancerType(new FailoverLoadBalancerDefinition());
+ return this;
}
/**
@@ -131,7 +132,10 @@ public class LoadBalanceDefinition extends
OutputDefinition<LoadBalanceDefinitio
* @return the builder
*/
public LoadBalanceDefinition failover(Class<?>... exceptions) {
- return failover(-1, true, false, exceptions);
+ FailoverLoadBalancerDefinition def = new
FailoverLoadBalancerDefinition();
+ def.setExceptionTypes(Arrays.asList(exceptions));
+ setLoadBalancerType(def);
+ return this;
}
/**
@@ -148,7 +152,13 @@ public class LoadBalanceDefinition extends
OutputDefinition<LoadBalanceDefinitio
*/
public LoadBalanceDefinition failover(
int maximumFailoverAttempts, boolean inheritErrorHandler, boolean
roundRobin, Class<?>... exceptions) {
- return failover(maximumFailoverAttempts, inheritErrorHandler,
roundRobin, false, exceptions);
+ FailoverLoadBalancerDefinition def = new
FailoverLoadBalancerDefinition();
+ def.setExceptionTypes(Arrays.asList(exceptions));
+
def.setMaximumFailoverAttempts(Integer.toString(maximumFailoverAttempts));
+ def.setRoundRobin(Boolean.toString(roundRobin));
+ def.setInheritErrorHandler(inheritErrorHandler);
+ setLoadBalancerType(def);
+ return this;
}
/**
diff --git
a/core/camel-core-model/src/main/java/org/apache/camel/model/loadbalancer/FailoverLoadBalancerDefinition.java
b/core/camel-core-model/src/main/java/org/apache/camel/model/loadbalancer/FailoverLoadBalancerDefinition.java
index 4075965a28c9..51b61613838a 100644
---
a/core/camel-core-model/src/main/java/org/apache/camel/model/loadbalancer/FailoverLoadBalancerDefinition.java
+++
b/core/camel-core-model/src/main/java/org/apache/camel/model/loadbalancer/FailoverLoadBalancerDefinition.java
@@ -43,8 +43,10 @@ public class FailoverLoadBalancerDefinition extends
LoadBalancerDefinition {
@XmlElement(name = "exception")
private List<String> exceptions = new ArrayList<>();
@XmlAttribute
+ @Metadata(javaType = "java.lang.Boolean")
private String roundRobin;
@XmlAttribute
+ @Metadata(javaType = "java.lang.Boolean")
private String sticky;
@XmlAttribute
@Metadata(defaultValue = "-1")
diff --git
a/dsl/camel-yaml-dsl/camel-yaml-dsl-deserializers/src/generated/java/org/apache/camel/dsl/yaml/deserializers/ModelDeserializers.java
b/dsl/camel-yaml-dsl/camel-yaml-dsl-deserializers/src/generated/java/org/apache/camel/dsl/yaml/deserializers/ModelDeserializers.java
index 1364e05b6851..36b706cf8aa7 100644
---
a/dsl/camel-yaml-dsl/camel-yaml-dsl-deserializers/src/generated/java/org/apache/camel/dsl/yaml/deserializers/ModelDeserializers.java
+++
b/dsl/camel-yaml-dsl/camel-yaml-dsl-deserializers/src/generated/java/org/apache/camel/dsl/yaml/deserializers/ModelDeserializers.java
@@ -5684,8 +5684,8 @@ public final class ModelDeserializers extends
YamlDeserializerSupport {
@YamlProperty(name = "id", type = "string", description =
"The id of this node", displayName = "Id"),
@YamlProperty(name = "inheritErrorHandler", type =
"boolean", defaultValue = "true", description = "To turn off Camel error
handling during load balancing. By default, Camel error handler will attempt
calling a service, which means you can specify retires and other fine-grained
settings. And only when Camel error handler have failed all attempts, then this
load balancer will fail over to the next endpoint and try again. You can turn
this off, and then this load balanc [...]
@YamlProperty(name = "maximumFailoverAttempts", type =
"string", defaultValue = "-1", description = "A value to indicate after X
failover attempts we should exhaust (give up). Use -1 to indicate never give up
and continuously try to failover. Use 0 to never failover. And use e.g. 3 to
failover at most 3 times before giving up. This option can be used whether
roundRobin is enabled or not.", displayName = "Maximum Failover Attempts"),
- @YamlProperty(name = "roundRobin", type = "string",
description = "Whether or not the failover load balancer should operate in
round robin mode or not. If not, then it will always start from the first
endpoint when a new message is to be processed. In other words it restart from
the top for every message. If round robin is enabled, then it keeps state and
will continue with the next endpoint in a round robin fashion. You can also
enable sticky mode together with round [...]
- @YamlProperty(name = "sticky", type = "string",
description = "Whether or not the failover load balancer should operate in
sticky mode or not. If not, then it will always start from the first endpoint
when a new message is to be processed. In other words it restart from the top
for every message. If sticky is enabled, then it keeps state and will continue
with the last known good endpoint. You can also enable sticky mode together
with round robin, if so then it will p [...]
+ @YamlProperty(name = "roundRobin", type = "boolean",
defaultValue = "false", description = "Whether or not the failover load
balancer should operate in round robin mode or not. If not, then it will always
start from the first endpoint when a new message is to be processed. In other
words it restart from the top for every message. If round robin is enabled,
then it keeps state and will continue with the next endpoint in a round robin
fashion. You can also enable sticky [...]
+ @YamlProperty(name = "sticky", type = "boolean",
defaultValue = "false", description = "Whether or not the failover load
balancer should operate in sticky mode or not. If not, then it will always
start from the first endpoint when a new message is to be processed. In other
words it restart from the top for every message. If sticky is enabled, then it
keeps state and will continue with the last known good endpoint. You can also
enable sticky mode together with round ro [...]
}
)
public static class FailoverLoadBalancerDefinitionDeserializer extends
YamlDeserializerBase<FailoverLoadBalancerDefinition> {
diff --git
a/dsl/camel-yaml-dsl/camel-yaml-dsl/src/generated/resources/schema/camelYamlDsl.json
b/dsl/camel-yaml-dsl/camel-yaml-dsl/src/generated/resources/schema/camelYamlDsl.json
index 49c0844d0cac..5a11dc7d76b7 100644
---
a/dsl/camel-yaml-dsl/camel-yaml-dsl/src/generated/resources/schema/camelYamlDsl.json
+++
b/dsl/camel-yaml-dsl/camel-yaml-dsl/src/generated/resources/schema/camelYamlDsl.json
@@ -15400,14 +15400,16 @@
"default" : "-1"
},
"roundRobin" : {
- "type" : "string",
+ "type" : "boolean",
"title" : "Round Robin",
- "description" : "Whether or not the failover load balancer should
operate in round robin mode or not. If not, then it will always start from the
first endpoint when a new message is to be processed. In other words it restart
from the top for every message. If round robin is enabled, then it keeps state
and will continue with the next endpoint in a round robin fashion. You can also
enable sticky mode together with round robin, if so then it will pick the last
known good endpoi [...]
+ "description" : "Whether or not the failover load balancer should
operate in round robin mode or not. If not, then it will always start from the
first endpoint when a new message is to be processed. In other words it restart
from the top for every message. If round robin is enabled, then it keeps state
and will continue with the next endpoint in a round robin fashion. You can also
enable sticky mode together with round robin, if so then it will pick the last
known good endpoi [...]
+ "default" : false
},
"sticky" : {
- "type" : "string",
+ "type" : "boolean",
"title" : "Sticky",
- "description" : "Whether or not the failover load balancer should
operate in sticky mode or not. If not, then it will always start from the first
endpoint when a new message is to be processed. In other words it restart from
the top for every message. If sticky is enabled, then it keeps state and will
continue with the last known good endpoint. You can also enable sticky mode
together with round robin, if so then it will pick the last known good endpoint
to use when starting [...]
+ "description" : "Whether or not the failover load balancer should
operate in sticky mode or not. If not, then it will always start from the first
endpoint when a new message is to be processed. In other words it restart from
the top for every message. If sticky is enabled, then it keeps state and will
continue with the last known good endpoint. You can also enable sticky mode
together with round robin, if so then it will pick the last known good endpoint
to use when starting [...]
+ "default" : false
}
}
},
