This is an automated email from the ASF dual-hosted git repository.
djencks pushed a commit to branch issue-14698-rearrange-adocs
in repository https://gitbox.apache.org/repos/asf/camel.git
commit 13b4a1a87ad183d6d0e8d327b2d2afb4ca39c91f
Author: David Jencks <djen...@apache.org>
AuthorDate: Thu Mar 12 11:22:00 2020 -0700
tooling generated update to eip pages, from correcting expected location
---
.../docs/modules/eips/pages/aggregate-eip.adoc | 22 ++++-----
.../src/main/docs/modules/eips/pages/bean-eip.adoc | 4 +-
.../modules/eips/pages/circuitBreaker-eip.adoc | 6 +--
.../docs/modules/eips/pages/claimCheck-eip.adoc | 2 +-
.../main/docs/modules/eips/pages/delay-eip.adoc | 4 +-
.../docs/modules/eips/pages/dynamicRouter-eip.adoc | 4 +-
.../main/docs/modules/eips/pages/enrich-eip.adoc | 10 ++--
.../main/docs/modules/eips/pages/failover-eip.adoc | 6 +--
.../eips/pages/hystrixConfiguration-eip.adoc | 56 +++++++++++-----------
.../modules/eips/pages/idempotentConsumer-eip.adoc | 8 ++--
.../src/main/docs/modules/eips/pages/log-eip.adoc | 2 +-
.../src/main/docs/modules/eips/pages/loop-eip.adoc | 4 +-
.../docs/modules/eips/pages/multicast-eip.adoc | 16 +++----
.../docs/modules/eips/pages/onFallback-eip.adoc | 2 +-
.../docs/modules/eips/pages/pollEnrich-eip.adoc | 10 ++--
.../docs/modules/eips/pages/recipientList-eip.adoc | 20 ++++----
.../eips/pages/resilience4jConfiguration-eip.adoc | 18 +++++++
.../src/main/docs/modules/eips/pages/saga-eip.adoc | 8 ++--
.../docs/modules/eips/pages/serviceCall-eip.adoc | 10 ++--
.../main/docs/modules/eips/pages/sticky-eip.adoc | 2 +-
.../main/docs/modules/eips/pages/threads-eip.adoc | 4 +-
.../main/docs/modules/eips/pages/throttle-eip.adoc | 2 +-
.../src/main/docs/modules/eips/pages/to-eip.adoc | 2 +-
.../src/main/docs/modules/eips/pages/toD-eip.adoc | 4 +-
.../main/docs/modules/eips/pages/weighted-eip.adoc | 2 +-
.../main/docs/modules/eips/pages/wireTap-eip.adoc | 6 +--
26 files changed, 125 insertions(+), 109 deletions(-)
diff --git
a/core/camel-core-engine/src/main/docs/modules/eips/pages/aggregate-eip.adoc
b/core/camel-core-engine/src/main/docs/modules/eips/pages/aggregate-eip.adoc
index 923517d..077725c 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/aggregate-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/aggregate-eip.adoc
@@ -22,30 +22,30 @@ The Aggregate EIP supports 27 options which are listed
below:
[width="100%",cols="2,5,^1,2",options="header"]
|===
| Name | Description | Default | Type
-| *correlationExpression* | *Required* The expression used to calculate the
correlation key to use for aggregation. The Exchange which has the same
correlation key is aggregated together. If the correlation key could not be
evaluated an Exception is thrown. You can disable this by using the
ignoreBadCorrelationKeys option. | | NamespaceAware Expression
-| *completionPredicate* | A Predicate to indicate when an aggregated exchange
is complete. If this is not specified and the AggregationStrategy object
implements Predicate, the aggregationStrategy object will be used as the
completionPredicate. | | NamespaceAware Expression
-| *completionTimeoutExpression* | Time in millis that an aggregated exchange
should be inactive before its complete (timeout). This option can be set as
either a fixed value or using an Expression which allows you to evaluate a
timeout dynamically - will use Long as result. If both are set Camel will
fallback to use the fixed value if the Expression result was null or 0. You
cannot use this option together with completionInterval, only one of the two
can be used. By default the timeout c [...]
-| *completionSizeExpression* | Number of messages aggregated before the
aggregation is complete. This option can be set as either a fixed value or
using an Expression which allows you to evaluate a size dynamically - will use
Integer as result. If both are set Camel will fallback to use the fixed value
if the Expression result was null or 0. | | NamespaceAware Expression
-| *optimisticLockRetryPolicy* | Allows to configure retry settings when using
optimistic locking. | | OptimisticLockRetry PolicyDefinition
+| *correlationExpression* | *Required* The expression used to calculate the
correlation key to use for aggregation. The Exchange which has the same
correlation key is aggregated together. If the correlation key could not be
evaluated an Exception is thrown. You can disable this by using the
ignoreBadCorrelationKeys option. | | ExpressionSubElementDefinition
+| *completionPredicate* | A Predicate to indicate when an aggregated exchange
is complete. If this is not specified and the AggregationStrategy object
implements Predicate, the aggregationStrategy object will be used as the
completionPredicate. | | ExpressionSubElementDefinition
+| *completionTimeoutExpression* | Time in millis that an aggregated exchange
should be inactive before its complete (timeout). This option can be set as
either a fixed value or using an Expression which allows you to evaluate a
timeout dynamically - will use Long as result. If both are set Camel will
fallback to use the fixed value if the Expression result was null or 0. You
cannot use this option together with completionInterval, only one of the two
can be used. By default the timeout c [...]
+| *completionSizeExpression* | Number of messages aggregated before the
aggregation is complete. This option can be set as either a fixed value or
using an Expression which allows you to evaluate a size dynamically - will use
Integer as result. If both are set Camel will fallback to use the fixed value
if the Expression result was null or 0. | | ExpressionSubElementDefinition
+| *optimisticLockRetryPolicy* | Allows to configure retry settings when using
optimistic locking. | | OptimisticLockRetryPolicyDefinition
| *parallelProcessing* | When aggregated are completed they are being send out
of the aggregator. This option indicates whether or not Camel should use a
thread pool with multiple threads for concurrency. If no custom thread pool has
been specified then Camel creates a default pool with 10 concurrent threads. |
false | Boolean
-| *optimisticLocking* | Turns on using optimistic locking, which requires the
aggregationRepository being used, is supporting this by implementing
org.apache.camel.spi.OptimisticLockingAggregationRepository. | false | Boolean
+| *optimisticLocking* | Turns on using optimistic locking, which requires the
aggregationRepository being used, is supporting this by implementing
org.apache.camel.spi.OptimisticLockingAggregationRepository . | false | Boolean
| *executorServiceRef* | If using parallelProcessing you can specify a custom
thread pool to be used. In fact also if you are not using parallelProcessing
this custom thread pool is used to send out aggregated exchanges as well. | |
String
-| *timeoutCheckerExecutor ServiceRef* | If using either of the
completionTimeout, completionTimeoutExpression, or completionInterval options a
background thread is created to check for the completion for every aggregator.
Set this option to provide a custom thread pool to be used rather than creating
a new thread for every aggregator. | | String
-| *aggregationRepositoryRef* | Sets the custom aggregate repository to use
Will by default use
org.apache.camel.processor.aggregate.MemoryAggregationRepository | | String
+| *timeoutCheckerExecutorService Ref* | If using either of the
completionTimeout, completionTimeoutExpression, or completionInterval options a
background thread is created to check for the completion for every aggregator.
Set this option to provide a custom thread pool to be used rather than creating
a new thread for every aggregator. | | String
+| *aggregationRepositoryRef* | Sets the custom aggregate repository to use.
Will by default use
org.apache.camel.processor.aggregate.MemoryAggregationRepository | | String
| *strategyRef* | A reference to lookup the AggregationStrategy in the
Registry. Configuring an AggregationStrategy is required, and is used to merge
the incoming Exchange with the existing already merged exchanges. At first call
the oldExchange parameter is null. On subsequent invocations the oldExchange
contains the merged exchanges and newExchange is of course the new incoming
Exchange. | | String
| *strategyMethodName* | This option can be used to explicit declare the
method name to use, when using POJOs as the AggregationStrategy. | | String
| *strategyMethodAllowNull* | If this option is false then the aggregate
method is not used for the very first aggregation. If this option is true then
null values is used as the oldExchange (at the very first aggregation), when
using POJOs as the AggregationStrategy. | false | Boolean
| *completionSize* | Number of messages aggregated before the aggregation is
complete. This option can be set as either a fixed value or using an Expression
which allows you to evaluate a size dynamically - will use Integer as result.
If both are set Camel will fallback to use the fixed value if the Expression
result was null or 0. | | Integer
| *completionInterval* | A repeating period in millis by which the aggregator
will complete all current aggregated exchanges. Camel has a background task
which is triggered every period. You cannot use this option together with
completionTimeout, only one of them can be used. | | Long
| *completionTimeout* | Time in millis that an aggregated exchange should be
inactive before its complete (timeout). This option can be set as either a
fixed value or using an Expression which allows you to evaluate a timeout
dynamically - will use Long as result. If both are set Camel will fallback to
use the fixed value if the Expression result was null or 0. You cannot use this
option together with completionInterval, only one of the two can be used. By
default the timeout checker run [...]
-| *completionTimeoutChecker Interval* | Interval in millis that is used by the
background task that checks for timeouts (org.apache.camel.TimeoutMap). By
default the timeout checker runs every second. The timeout is an approximation
and there is no guarantee that the a timeout is triggered exactly after the
timeout value. It is not recommended to use very low timeout values or checker
intervals. | 1000 | Long
+| *completionTimeoutChecker Interval* | Interval in millis that is used by the
background task that checks for timeouts ( org.apache.camel.TimeoutMap ). By
default the timeout checker runs every second. The timeout is an approximation
and there is no guarantee that the a timeout is triggered exactly after the
timeout value. It is not recommended to use very low timeout values or checker
intervals. | 1000 | Long
| *completionFromBatchConsumer* | Enables the batch completion mode where we
aggregate from a org.apache.camel.BatchConsumer and aggregate the total number
of exchanges the org.apache.camel.BatchConsumer has reported as total by
checking the exchange property org.apache.camel.Exchange#BATCH_COMPLETE when
its complete. This option cannot be used together with
discardOnAggregationFailure. | false | Boolean
| *completionOnNewCorrelation Group* | Enables completion on all previous
groups when a new incoming correlation group. This can for example be used to
complete groups with same correlation keys when they are in consecutive order.
Notice when this is enabled then only 1 correlation group can be in progress as
when a new correlation group starts, then the previous groups is forced
completed. | false | Boolean
| *eagerCheckCompletion* | Use eager completion checking which means that the
completionPredicate will use the incoming Exchange. As opposed to without eager
completion checking the completionPredicate will use the aggregated Exchange. |
false | Boolean
-| *ignoreInvalidCorrelation Keys* | If a correlation key cannot be
successfully evaluated it will be ignored by logging a DEBUG and then just
ignore the incoming Exchange. | false | Boolean
+| *ignoreInvalidCorrelationKeys* | If a correlation key cannot be successfully
evaluated it will be ignored by logging a DEBUG and then just ignore the
incoming Exchange. | false | Boolean
| *closeCorrelationKeyOn Completion* | Closes a correlation key when its
complete. Any late received exchanges which has a correlation key that has been
closed, it will be defined and a ClosedCorrelationKeyException is thrown. | |
Integer
| *discardOnCompletionTimeout* | Discards the aggregated message on completion
timeout. This means on timeout the aggregated message is dropped and not sent
out of the aggregator. | false | Boolean
-| *discardOnAggregationFailure* | Discards the aggregated message when
aggregation failed (an exception was thrown from AggregationStrategy. This
means the partly aggregated message is dropped and not sent out of the
aggregator. This option cannot be used together with
completionFromBatchConsumer. | false | Boolean
+| *discardOnAggregationFailure* | Discards the aggregated message when
aggregation failed (an exception was thrown from AggregationStrategy . This
means the partly aggregated message is dropped and not sent out of the
aggregator. This option cannot be used together with
completionFromBatchConsumer. | false | Boolean
| *forceCompletionOnStop* | Indicates to complete all current aggregated
exchanges when the context is stopped | false | Boolean
| *completeAllOnStop* | Indicates to wait to complete all current and partial
(pending) aggregated exchanges when the context is stopped. This also means
that we will wait for all pending exchanges which are stored in the aggregation
repository to complete so the repository is empty before we can stop. You may
want to enable this when using the memory based aggregation repository that is
memory based only, and do not store data on disk. When this option is enabled,
then the aggregator is [...]
| *aggregateControllerRef* | To use a
org.apache.camel.processor.aggregate.AggregateController to allow external
sources to control this aggregator. | | String
diff --git
a/core/camel-core-engine/src/main/docs/modules/eips/pages/bean-eip.adoc
b/core/camel-core-engine/src/main/docs/modules/eips/pages/bean-eip.adoc
index 9b997493..6de8313 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/bean-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/bean-eip.adoc
@@ -24,8 +24,8 @@ The Bean EIP supports 5 options which are listed below:
| *ref* | Sets a reference to a bean to use | | String
| *method* | Sets the method name on the bean to use | | String
| *beanType* | Sets the Class of the bean | | String
-| *cache* | *Deprecated* Use scope option instead. | | Boolean
-| *scope* | Scope of bean. See below for more details. | Singleton | String |
+| *cache* | *Deprecated* Use singleton option instead | true | Boolean
+| *scope* | Scope of bean. When using singleton scope (default) the bean is
created or looked up only once and reused for the lifetime of the endpoint. The
bean should be thread-safe in case concurrent threads is calling the bean at
the same time. When using request scope the bean is created or looked up once
per request (exchange). This can be used if you want to store state on a bean
while processing a request and you want to call the same bean instance multiple
times while processing [...]
|===
// eip options: END
diff --git
a/core/camel-core-engine/src/main/docs/modules/eips/pages/circuitBreaker-eip.adoc
b/core/camel-core-engine/src/main/docs/modules/eips/pages/circuitBreaker-eip.adoc
index 46909dc..7c60200 100644
---
a/core/camel-core-engine/src/main/docs/modules/eips/pages/circuitBreaker-eip.adoc
+++
b/core/camel-core-engine/src/main/docs/modules/eips/pages/circuitBreaker-eip.adoc
@@ -1,5 +1,4 @@
-[[circuitBreaker-eip]]
-= CircuitBreaker EIP
+= Circuit Breaker EIP
The Circuit Breaker pattern is inspired by the real-world electrical circuit
breaker,
which is used to detect excessive current draw and fail fast to protect
electrical equipment.
@@ -57,5 +56,4 @@ And in XML DSL:
Camel provides two implementations of this pattern:
* xref:hystrix-eip.adoc[Hystrix] - Using the Netflix Hystrix implementation
-* xref:resilience4j-eip.adoc[Resilience4j] - Using the Resilience4j
implementation
-
+* xref:resilience4j-eip.adoc[Resilience4j] - Using the Resilience4j
implementation
\ No newline at end of file
diff --git
a/core/camel-core-engine/src/main/docs/modules/eips/pages/claimCheck-eip.adoc
b/core/camel-core-engine/src/main/docs/modules/eips/pages/claimCheck-eip.adoc
index c7c238b..4f0d729 100644
---
a/core/camel-core-engine/src/main/docs/modules/eips/pages/claimCheck-eip.adoc
+++
b/core/camel-core-engine/src/main/docs/modules/eips/pages/claimCheck-eip.adoc
@@ -19,7 +19,7 @@ The Claim Check EIP supports 5 options which are listed below:
[width="100%",cols="2,5,^1,2",options="header"]
|===
| Name | Description | Default | Type
-| *operation* | *Required* The claim check operation to use. The following
operations is supported: Get - Gets (does not remove) the claim check by the
given key. GetAndRemove - Gets and remove the claim check by the given key. Set
- Sets a new (will override if key already exists) claim check with the given
key. Push - Sets a new claim check on the stack (does not use key). Pop - Gets
the latest claim check from the stack (does not use key). | |
ClaimCheckOperation
+| *operation* | The claim check operation to use. The following operations is
supported: Get - Gets (does not remove) the claim check by the given key.
GetAndRemove - Gets and remove the claim check by the given key. Set - Sets a
new (will override if key already exists) claim check with the given key. Push
- Sets a new claim check on the stack (does not use key). Pop - Gets the latest
claim check from the stack (does not use key). | | ClaimCheckOperation
| *key* | To use a specific key for claim check id (for dynamic keys use
simple language syntax as the key). | | String
| *filter* | Specified a filter to control what data gets merging data back
from the claim check repository. The following syntax is supported: body - to
aggregate the message body attachments - to aggregate all the message
attachments headers - to aggregate all the message headers header:pattern - to
aggregate all the message headers that matches the pattern. The pattern uses
the following rules are applied in this order: exact match, returns true
wildcard match (pattern ends with a and [...]
| *strategyRef* | To use a custom AggregationStrategy instead of the default
implementation. Notice you cannot use both custom aggregation strategy and
configure data at the same time. | | String
diff --git
a/core/camel-core-engine/src/main/docs/modules/eips/pages/delay-eip.adoc
b/core/camel-core-engine/src/main/docs/modules/eips/pages/delay-eip.adoc
index 8b0f273..58af86a 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/delay-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/delay-eip.adoc
@@ -11,8 +11,8 @@ The Delay EIP supports 3 options which are listed below:
|===
| Name | Description | Default | Type
| *executorServiceRef* | Refers to a custom Thread Pool if asyncDelay has been
enabled. | | String
-| *asyncDelayed* | Enables asynchronous delay which means the thread will not
block while delaying. | true | Boolean
-| *callerRunsWhenRejected* | Whether or not the caller should run the task
when it was rejected by the thread pool. Is by default true | true | Boolean
+| *asyncDelayed* | Enables asynchronous delay which means the thread will not
block while delaying. | true | String
+| *callerRunsWhenRejected* | Whether or not the caller should run the task
when it was rejected by the thread pool. Is by default true | true | String
|===
// eip options: END
diff --git
a/core/camel-core-engine/src/main/docs/modules/eips/pages/dynamicRouter-eip.adoc
b/core/camel-core-engine/src/main/docs/modules/eips/pages/dynamicRouter-eip.adoc
index 70010e3..3453e72e 100644
---
a/core/camel-core-engine/src/main/docs/modules/eips/pages/dynamicRouter-eip.adoc
+++
b/core/camel-core-engine/src/main/docs/modules/eips/pages/dynamicRouter-eip.adoc
@@ -26,8 +26,8 @@ The Dynamic Router EIP supports 3 options which are listed
below:
|===
| Name | Description | Default | Type
| *uriDelimiter* | Sets the uri delimiter to use | , | String
-| *ignoreInvalidEndpoints* | Ignore the invalidate endpoint exception when try
to create a producer with that endpoint | false | Boolean
-| *cacheSize* | Sets the maximum size used by the
org.apache.camel.spi.ProducerCache which is used to cache and reuse producers
when using this dynamic router, when uris are reused. Beware that when using
dynamic endpoints then it affects how well the cache can be utilized. If each
dynamic endpoint is unique then its best to turn of caching by setting this to
-1, which allows Camel to not cache both the producers and endpoints; they are
regarded as prototype scoped and will be stopped an [...]
+| *ignoreInvalidEndpoints* | Ignore the invalidate endpoint exception when try
to create a producer with that endpoint | | String
+| *cacheSize* | Sets the maximum size used by the
org.apache.camel.spi.ProducerCache which is used to cache and reuse producers
when using this dynamic router, when uris are reused. Beware that when using
dynamic endpoints then it affects how well the cache can be utilized. If each
dynamic endpoint is unique then its best to turn of caching by setting this to
-1, which allows Camel to not cache both the producers and endpoints; they are
regarded as prototype scoped and will be stopped an [...]
|===
// eip options: END
diff --git
a/core/camel-core-engine/src/main/docs/modules/eips/pages/enrich-eip.adoc
b/core/camel-core-engine/src/main/docs/modules/eips/pages/enrich-eip.adoc
index 8f40c81..5a36c15 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/enrich-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/enrich-eip.adoc
@@ -15,11 +15,11 @@ The Enrich EIP supports 7 options which are listed below:
| Name | Description | Default | Type
| *strategyRef* | Refers to an AggregationStrategy to be used to merge the
reply from the external service, into a single outgoing message. By default
Camel will use the reply from the external service as outgoing message. | |
String
| *strategyMethodName* | This option can be used to explicit declare the
method name to use, when using POJOs as the AggregationStrategy. | | String
-| *strategyMethodAllowNull* | If this option is false then the aggregate
method is not used if there was no data to enrich. If this option is true then
null values is used as the oldExchange (when no data to enrich), when using
POJOs as the AggregationStrategy. | false | Boolean
-| *aggregateOnException* | If this option is false then the aggregate method
is not used if there was an exception thrown while trying to retrieve the data
to enrich from the resource. Setting this option to true allows end users to
control what to do if there was an exception in the aggregate method. For
example to suppress the exception or set a custom message body etc. | false |
Boolean
-| *shareUnitOfWork* | Shares the org.apache.camel.spi.UnitOfWork with the
parent and the resource exchange. Enrich will by default not share unit of work
between the parent exchange and the resource exchange. This means the resource
exchange has its own individual unit of work. | false | Boolean
-| *cacheSize* | Sets the maximum size used by the
org.apache.camel.spi.ProducerCache which is used to cache and reuse producer
when uris are reused. Beware that when using dynamic endpoints then it affects
how well the cache can be utilized. If each dynamic endpoint is unique then its
best to turn of caching by setting this to -1, which allows Camel to not cache
both the producers and endpoints; they are regarded as prototype scoped and
will be stopped and discarded after use. This reduc [...]
-| *ignoreInvalidEndpoint* | Ignore the invalidate endpoint exception when try
to create a producer with that endpoint | false | Boolean
+| *strategyMethodAllowNull* | If this option is false then the aggregate
method is not used if there was no data to enrich. If this option is true then
null values is used as the oldExchange (when no data to enrich), when using
POJOs as the AggregationStrategy. | | String
+| *aggregateOnException* | If this option is false then the aggregate method
is not used if there was an exception thrown while trying to retrieve the data
to enrich from the resource. Setting this option to true allows end users to
control what to do if there was an exception in the aggregate method. For
example to suppress the exception or set a custom message body etc. | | String
+| *shareUnitOfWork* | Shares the org.apache.camel.spi.UnitOfWork with the
parent and the resource exchange. Enrich will by default not share unit of work
between the parent exchange and the resource exchange. This means the resource
exchange has its own individual unit of work. | | String
+| *cacheSize* | Sets the maximum size used by the
org.apache.camel.spi.ProducerCache which is used to cache and reuse producer
when uris are reused. Beware that when using dynamic endpoints then it affects
how well the cache can be utilized. If each dynamic endpoint is unique then its
best to turn of caching by setting this to -1, which allows Camel to not cache
both the producers and endpoints; they are regarded as prototype scoped and
will be stopped and discarded after use. This reduc [...]
+| *ignoreInvalidEndpoint* | Ignore the invalidate endpoint exception when try
to create a producer with that endpoint | | String
|===
// eip options: END
diff --git
a/core/camel-core-engine/src/main/docs/modules/eips/pages/failover-eip.adoc
b/core/camel-core-engine/src/main/docs/modules/eips/pages/failover-eip.adoc
index e1a7711..2abcd9f 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/failover-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/failover-eip.adoc
@@ -12,9 +12,9 @@ The Failover EIP supports 4 options which are listed below:
|===
| Name | Description | Default | Type
| *exception* | A list of class names for specific exceptions to monitor. If
no exceptions is configured then all exceptions is monitored | | List
-| *roundRobin* | 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 endpoint to use wh [...]
-| *sticky* | 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 the load balanci [...]
-| *maximumFailoverAttempts* | 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. his option can be used whether or not roundRobin is
enabled or not. | -1 | Integer
+| *roundRobin* | 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 endpoint to use wh [...]
+| *sticky* | 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 the load balanci [...]
+| *maximumFailoverAttempts* | 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. his option can be used whether or not roundRobin is
enabled or not. | -1 | String
|===
// eip options: END
diff --git
a/core/camel-core-engine/src/main/docs/modules/eips/pages/hystrixConfiguration-eip.adoc
b/core/camel-core-engine/src/main/docs/modules/eips/pages/hystrixConfiguration-eip.adoc
index 877b26b..9c6bef2 100644
---
a/core/camel-core-engine/src/main/docs/modules/eips/pages/hystrixConfiguration-eip.adoc
+++
b/core/camel-core-engine/src/main/docs/modules/eips/pages/hystrixConfiguration-eip.adoc
@@ -10,34 +10,34 @@ The Hystrix Configuration EIP supports 31 options which are
listed below:
| Name | Description | Default | Type
| *groupKey* | Sets the group key to use. The default value is CamelHystrix. |
CamelHystrix | String
| *threadPoolKey* | Sets the thread pool key to use. Will by default use the
same value as groupKey has been configured to use. | CamelHystrix | String
-| *circuitBreakerEnabled* | Whether to use a HystrixCircuitBreaker or not. If
false no circuit-breaker logic will be used and all requests permitted. This is
similar in effect to circuitBreakerForceClosed() except that continues tracking
metrics and knowing whether it should be open/closed, this property results in
not even instantiating a circuit-breaker. | true | Boolean
-| *circuitBreakerError ThresholdPercentage* | Error percentage threshold (as
whole number such as 50) at which point the circuit breaker will trip open and
reject requests. It will stay tripped for the duration defined in
circuitBreakerSleepWindowInMilliseconds; The error percentage this is compared
against comes from HystrixCommandMetrics.getHealthCounts(). | 50 | Integer
-| *circuitBreakerForceClosed* | If true the
HystrixCircuitBreaker#allowRequest() will always return true to allow requests
regardless of the error percentage from
HystrixCommandMetrics.getHealthCounts(). The circuitBreakerForceOpen() property
takes precedence so if it set to true this property does nothing. | false |
Boolean
-| *circuitBreakerForceOpen* | If true the HystrixCircuitBreaker.allowRequest()
will always return false, causing the circuit to be open (tripped) and reject
all requests. This property takes precedence over circuitBreakerForceClosed();
| false | Boolean
-| *circuitBreakerRequestVolume Threshold* | Minimum number of requests in the
metricsRollingStatisticalWindowInMilliseconds() that must exist before the
HystrixCircuitBreaker will trip. If below this number the circuit will not trip
regardless of error percentage. | 20 | Integer
-| *circuitBreakerSleepWindow InMilliseconds* | The time in milliseconds after
a HystrixCircuitBreaker trips open that it should wait before trying requests
again. | 5000 | Integer
-| *executionIsolationSemaphore MaxConcurrentRequests* | Number of concurrent
requests permitted to HystrixCommand.run(). Requests beyond the concurrent
limit will be rejected. Applicable only when executionIsolationStrategy ==
SEMAPHORE. | 20 | Integer
+| *circuitBreakerEnabled* | Whether to use a HystrixCircuitBreaker or not. If
false no circuit-breaker logic will be used and all requests permitted. This is
similar in effect to circuitBreakerForceClosed() except that continues tracking
metrics and knowing whether it should be open/closed, this property results in
not even instantiating a circuit-breaker. | true | String
+| *circuitBreakerErrorThreshold Percentage* | Error percentage threshold (as
whole number such as 50) at which point the circuit breaker will trip open and
reject requests. It will stay tripped for the duration defined in
circuitBreakerSleepWindowInMilliseconds; The error percentage this is compared
against comes from HystrixCommandMetrics.getHealthCounts(). | 50 | String
+| *circuitBreakerForceClosed* | If true the
HystrixCircuitBreaker#allowRequest() will always return true to allow requests
regardless of the error percentage from
HystrixCommandMetrics.getHealthCounts(). The circuitBreakerForceOpen() property
takes precedence so if it set to true this property does nothing. | false |
String
+| *circuitBreakerForceOpen* | If true the HystrixCircuitBreaker.allowRequest()
will always return false, causing the circuit to be open (tripped) and reject
all requests. This property takes precedence over circuitBreakerForceClosed();
| false | String
+| *circuitBreakerRequestVolume Threshold* | Minimum number of requests in the
metricsRollingStatisticalWindowInMilliseconds() that must exist before the
HystrixCircuitBreaker will trip. If below this number the circuit will not trip
regardless of error percentage. | 20 | String
+| *circuitBreakerSleepWindowIn Milliseconds* | The time in milliseconds after
a HystrixCircuitBreaker trips open that it should wait before trying requests
again. | 5000 | String
+| *executionIsolationSemaphoreMax ConcurrentRequests* | Number of concurrent
requests permitted to HystrixCommand.run(). Requests beyond the concurrent
limit will be rejected. Applicable only when executionIsolationStrategy ==
SEMAPHORE. | 20 | String
| *executionIsolationStrategy* | What isolation strategy HystrixCommand.run()
will be executed with. If THREAD then it will be executed on a separate thread
and concurrent requests limited by the number of threads in the thread-pool. If
SEMAPHORE then it will be executed on the calling thread and concurrent
requests limited by the semaphore count. | THREAD | String
-| *executionIsolationThread InterruptOnTimeout* | Whether the execution thread
should attempt an interrupt (using Future#cancel) when a thread times out.
Applicable only when executionIsolationStrategy() == THREAD. | true | Boolean
-| *executionTimeoutIn Milliseconds* | Time in milliseconds at which point the
command will timeout and halt execution. If
executionIsolationThreadInterruptOnTimeout == true and the command is
thread-isolated, the executing thread will be interrupted. If the command is
semaphore-isolated and a HystrixObservableCommand, that command will get
unsubscribed. | 1000 | Integer
-| *executionTimeoutEnabled* | Whether the timeout mechanism is enabled for
this command | true | Boolean
-| *fallbackIsolationSemaphore MaxConcurrentRequests* | Number of concurrent
requests permitted to HystrixCommand.getFallback(). Requests beyond the
concurrent limit will fail-fast and not attempt retrieving a fallback. | 10 |
Integer
-| *fallbackEnabled* | Whether HystrixCommand.getFallback() should be attempted
when failure occurs. | true | Boolean
-| *metricsHealthSnapshot IntervalInMilliseconds* | Time in milliseconds to
wait between allowing health snapshots to be taken that calculate success and
error percentages and affect HystrixCircuitBreaker.isOpen() status. On
high-volume circuits the continual calculation of error percentage can become
CPU intensive thus this controls how often it is calculated. | 500 | Integer
-| *metricsRollingPercentile BucketSize* | Maximum number of values stored in
each bucket of the rolling percentile. This is passed into
HystrixRollingPercentile inside HystrixCommandMetrics. | 10 | Integer
-| *metricsRollingPercentile Enabled* | Whether percentile metrics should be
captured using HystrixRollingPercentile inside HystrixCommandMetrics. | true |
Boolean
-| *metricsRollingPercentile WindowInMilliseconds* | Duration of percentile
rolling window in milliseconds. This is passed into HystrixRollingPercentile
inside HystrixCommandMetrics. | 10000 | Integer
-| *metricsRollingPercentile WindowBuckets* | Number of buckets the rolling
percentile window is broken into. This is passed into HystrixRollingPercentile
inside HystrixCommandMetrics. | 6 | Integer
-| *metricsRollingStatistical WindowInMilliseconds* | This property sets the
duration of the statistical rolling window, in milliseconds. This is how long
metrics are kept for the thread pool. The window is divided into buckets and
rolls by those increments. | 10000 | Integer
-| *metricsRollingStatistical WindowBuckets* | Number of buckets the rolling
statistical window is broken into. This is passed into HystrixRollingNumber
inside HystrixCommandMetrics. | 10 | Integer
-| *requestLogEnabled* | Whether HystrixCommand execution and events should be
logged to HystrixRequestLog. | true | Boolean
-| *corePoolSize* | Core thread-pool size that gets passed to
java.util.concurrent.ThreadPoolExecutor#setCorePoolSize(int) | 10 | Integer
-| *maximumSize* | Maximum thread-pool size that gets passed to
ThreadPoolExecutor#setMaximumPoolSize(int). This is the maximum amount of
concurrency that can be supported without starting to reject HystrixCommands.
Please note that this setting only takes effect if you also set
allowMaximumSizeToDivergeFromCoreSize | 10 | Integer
-| *keepAliveTime* | Keep-alive time in minutes that gets passed to {link
ThreadPoolExecutor#setKeepAliveTime(long, TimeUnit)} | 1 | Integer
-| *maxQueueSize* | Max queue size that gets passed to BlockingQueue in
HystrixConcurrencyStrategy.getBlockingQueue(int) This should only affect the
instantiation of a threadpool - it is not eliglible to change a queue size on
the fly. For that, use queueSizeRejectionThreshold(). | -1 | Integer
-| *queueSizeRejectionThreshold* | Queue size rejection threshold is an
artificial max size at which rejections will occur even if maxQueueSize has not
been reached. This is done because the maxQueueSize of a BlockingQueue can not
be dynamically changed and we want to support dynamically changing the queue
size that affects rejections. This is used by HystrixCommand when queuing a
thread for execution. | 5 | Integer
-| *threadPoolRollingNumber StatisticalWindowIn Milliseconds* | Duration of
statistical rolling window in milliseconds. This is passed into
HystrixRollingNumber inside each HystrixThreadPoolMetrics instance. | 10000 |
Integer
-| *threadPoolRollingNumber StatisticalWindowBuckets* | Number of buckets the
rolling statistical window is broken into. This is passed into
HystrixRollingNumber inside each HystrixThreadPoolMetrics instance. | 10 |
Integer
-| *allowMaximumSizeToDiverge FromCoreSize* | Allows the configuration for
maximumSize to take effect. That value can then be equal to, or higher, than
coreSize | false | Boolean
+| *executionIsolationThread InterruptOnTimeout* | Whether the execution thread
should attempt an interrupt (using Future#cancel ) when a thread times out.
Applicable only when executionIsolationStrategy() == THREAD. | true | String
+| *executionTimeoutInMilliseconds* | Time in milliseconds at which point the
command will timeout and halt execution. If
executionIsolationThreadInterruptOnTimeout == true and the command is
thread-isolated, the executing thread will be interrupted. If the command is
semaphore-isolated and a HystrixObservableCommand, that command will get
unsubscribed. | 1000 | String
+| *executionTimeoutEnabled* | Whether the timeout mechanism is enabled for
this command | true | String
+| *fallbackIsolationSemaphoreMax ConcurrentRequests* | Number of concurrent
requests permitted to HystrixCommand.getFallback(). Requests beyond the
concurrent limit will fail-fast and not attempt retrieving a fallback. | 10 |
String
+| *fallbackEnabled* | Whether HystrixCommand.getFallback() should be attempted
when failure occurs. | true | String
+| *metricsHealthSnapshotInterval InMilliseconds* | Time in milliseconds to
wait between allowing health snapshots to be taken that calculate success and
error percentages and affect HystrixCircuitBreaker.isOpen() status. On
high-volume circuits the continual calculation of error percentage can become
CPU intensive thus this controls how often it is calculated. | 500 | String
+| *metricsRollingPercentileBucket Size* | Maximum number of values stored in
each bucket of the rolling percentile. This is passed into
HystrixRollingPercentile inside HystrixCommandMetrics. | 10 | String
+| *metricsRollingPercentile Enabled* | Whether percentile metrics should be
captured using HystrixRollingPercentile inside HystrixCommandMetrics. | true |
String
+| *metricsRollingPercentileWindow InMilliseconds* | Duration of percentile
rolling window in milliseconds. This is passed into HystrixRollingPercentile
inside HystrixCommandMetrics. | 10000 | String
+| *metricsRollingPercentileWindow Buckets* | Number of buckets the rolling
percentile window is broken into. This is passed into HystrixRollingPercentile
inside HystrixCommandMetrics. | 6 | String
+| *metricsRollingStatistical WindowInMilliseconds* | This property sets the
duration of the statistical rolling window, in milliseconds. This is how long
metrics are kept for the thread pool. The window is divided into buckets and
rolls by those increments. | 10000 | String
+| *metricsRollingStatistical WindowBuckets* | Number of buckets the rolling
statistical window is broken into. This is passed into HystrixRollingNumber
inside HystrixCommandMetrics. | 10 | String
+| *requestLogEnabled* | Whether HystrixCommand execution and events should be
logged to HystrixRequestLog. | true | String
+| *corePoolSize* | Core thread-pool size that gets passed to
java.util.concurrent.ThreadPoolExecutor#setCorePoolSize(int) | 10 | String
+| *maximumSize* | Maximum thread-pool size that gets passed to
ThreadPoolExecutor#setMaximumPoolSize(int) . This is the maximum amount of
concurrency that can be supported without starting to reject HystrixCommands.
Please note that this setting only takes effect if you also set
allowMaximumSizeToDivergeFromCoreSize | 10 | String
+| *keepAliveTime* | Keep-alive time in minutes that gets passed to
ThreadPoolExecutor#setKeepAliveTime(long,TimeUnit) | 1 | String
+| *maxQueueSize* | Max queue size that gets passed to BlockingQueue in
HystrixConcurrencyStrategy.getBlockingQueue(int) This should only affect the
instantiation of a threadpool - it is not eliglible to change a queue size on
the fly. For that, use queueSizeRejectionThreshold(). | -1 | String
+| *queueSizeRejectionThreshold* | Queue size rejection threshold is an
artificial max size at which rejections will occur even if maxQueueSize has not
been reached. This is done because the maxQueueSize of a BlockingQueue can not
be dynamically changed and we want to support dynamically changing the queue
size that affects rejections. This is used by HystrixCommand when queuing a
thread for execution. | 5 | String
+| *threadPoolRollingNumber StatisticalWindowIn Milliseconds* | Duration of
statistical rolling window in milliseconds. This is passed into
HystrixRollingNumber inside each HystrixThreadPoolMetrics instance. | 10000 |
String
+| *threadPoolRollingNumber StatisticalWindowBuckets* | Number of buckets the
rolling statistical window is broken into. This is passed into
HystrixRollingNumber inside each HystrixThreadPoolMetrics instance. | 10 |
String
+| *allowMaximumSizeToDivergeFrom CoreSize* | Allows the configuration for
maximumSize to take effect. That value can then be equal to, or higher, than
coreSize | false | String
|===
// eip options: END
diff --git
a/core/camel-core-engine/src/main/docs/modules/eips/pages/idempotentConsumer-eip.adoc
b/core/camel-core-engine/src/main/docs/modules/eips/pages/idempotentConsumer-eip.adoc
index 8878a5d..6835947 100644
---
a/core/camel-core-engine/src/main/docs/modules/eips/pages/idempotentConsumer-eip.adoc
+++
b/core/camel-core-engine/src/main/docs/modules/eips/pages/idempotentConsumer-eip.adoc
@@ -36,9 +36,9 @@ The Idempotent Consumer EIP supports 5 options which are
listed below:
|===
| Name | Description | Default | Type
| *messageIdRepositoryRef* | *Required* Sets the reference name of the message
id repository | | String
-| *eager* | Sets whether to eagerly add the key to the idempotent repository
or wait until the exchange is complete. Eager is default enabled. | true |
Boolean
-| *completionEager* | Sets whether to complete the idempotent consumer eager
or when the exchange is done. If this option is true to complete eager, then
the idempotent consumer will trigger its completion when the exchange reached
the end of the block of the idempotent consumer pattern. So if the exchange is
continued routed after the block ends, then whatever happens there does not
affect the state. If this option is false (default) to not complete eager, then
the idempotent consumer w [...]
-| *skipDuplicate* | Sets whether to skip duplicates or not. The default
behavior is to skip duplicates. A duplicate message would have the Exchange
property org.apache.camel.Exchange#DUPLICATE_MESSAGE set to a Boolean#TRUE
value. A none duplicate message will not have this property set. | true |
Boolean
-| *removeOnFailure* | Sets whether to remove or keep the key on failure. The
default behavior is to remove the key on failure. | true | Boolean
+| *eager* | Sets whether to eagerly add the key to the idempotent repository
or wait until the exchange is complete. Eager is default enabled. | true |
String
+| *completionEager* | Sets whether to complete the idempotent consumer eager
or when the exchange is done. If this option is true to complete eager, then
the idempotent consumer will trigger its completion when the exchange reached
the end of the block of the idempotent consumer pattern. So if the exchange is
continued routed after the block ends, then whatever happens there does not
affect the state. If this option is false (default) to not complete eager, then
the idempotent consumer w [...]
+| *skipDuplicate* | Sets whether to skip duplicates or not. The default
behavior is to skip duplicates. A duplicate message would have the Exchange
property org.apache.camel.Exchange#DUPLICATE_MESSAGE set to a Boolean#TRUE
value. A none duplicate message will not have this property set. | true | String
+| *removeOnFailure* | Sets whether to remove or keep the key on failure. The
default behavior is to remove the key on failure. | true | String
|===
// eip options: END
diff --git
a/core/camel-core-engine/src/main/docs/modules/eips/pages/log-eip.adoc
b/core/camel-core-engine/src/main/docs/modules/eips/pages/log-eip.adoc
index 91b27d7..151fd43 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/log-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/log-eip.adoc
@@ -18,7 +18,7 @@ The Log EIP supports 5 options which are listed below:
|===
| Name | Description | Default | Type
| *message* | *Required* Sets the log message (uses simple language) | |
String
-| *loggingLevel* | Sets the logging level. The default value is INFO | INFO |
LoggingLevel
+| *loggingLevel* | Sets the logging level. The default value is INFO | INFO |
String
| *logName* | Sets the name of the logger | | String
| *marker* | To use slf4j marker | | String
| *loggerRef* | To refer to a custom logger instance to lookup from the
registry. | | String
diff --git
a/core/camel-core-engine/src/main/docs/modules/eips/pages/loop-eip.adoc
b/core/camel-core-engine/src/main/docs/modules/eips/pages/loop-eip.adoc
index 088b8ff..dae1731 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/loop-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/loop-eip.adoc
@@ -17,8 +17,8 @@ The Loop EIP supports 2 options which are listed below:
[width="100%",cols="2,5,^1,2",options="header"]
|===
| Name | Description | Default | Type
-| *copy* | If the copy attribute is true, a copy of the input Exchange is used
for each iteration. That means each iteration will start from a copy of the
same message. By default loop will loop the same exchange all over, so each
iteration may have different message content. | false | Boolean
-| *doWhile* | Enables the while loop that loops until the predicate evaluates
to false or null. | false | Boolean
+| *copy* | If the copy attribute is true, a copy of the input Exchange is used
for each iteration. That means each iteration will start from a copy of the
same message. By default loop will loop the same exchange all over, so each
iteration may have different message content. | | String
+| *doWhile* | Enables the while loop that loops until the predicate evaluates
to false or null. | | String
|===
// eip options: END
diff --git
a/core/camel-core-engine/src/main/docs/modules/eips/pages/multicast-eip.adoc
b/core/camel-core-engine/src/main/docs/modules/eips/pages/multicast-eip.adoc
index 55d2d57..3363680 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/multicast-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/multicast-eip.adoc
@@ -14,18 +14,18 @@ The Multicast EIP supports 12 options which are listed
below:
[width="100%",cols="2,5,^1,2",options="header"]
|===
| Name | Description | Default | Type
-| *parallelProcessing* | If enabled then sending messages to the multicasts
occurs concurrently. Note the caller thread will still wait until all messages
has been fully processed, before it continues. Its only the sending and
processing the replies from the multicasts which happens concurrently. | false
| Boolean
+| *parallelProcessing* | If enabled then sending messages to the multicasts
occurs concurrently. Note the caller thread will still wait until all messages
has been fully processed, before it continues. Its only the sending and
processing the replies from the multicasts which happens concurrently. | |
String
| *strategyRef* | Refers to an AggregationStrategy to be used to assemble the
replies from the multicasts, into a single outgoing message from the Multicast.
By default Camel will use the last reply as the outgoing message. You can also
use a POJO as the AggregationStrategy | | String
| *strategyMethodName* | This option can be used to explicit declare the
method name to use, when using POJOs as the AggregationStrategy. | | String
-| *strategyMethodAllowNull* | If this option is false then the aggregate
method is not used if there was no data to enrich. If this option is true then
null values is used as the oldExchange (when no data to enrich), when using
POJOs as the AggregationStrategy | false | Boolean
+| *strategyMethodAllowNull* | If this option is false then the aggregate
method is not used if there was no data to enrich. If this option is true then
null values is used as the oldExchange (when no data to enrich), when using
POJOs as the AggregationStrategy | | String
| *executorServiceRef* | Refers to a custom Thread Pool to be used for
parallel processing. Notice if you set this option, then parallel processing is
automatic implied, and you do not have to enable that option as well. | |
String
-| *streaming* | If enabled then Camel will process replies out-of-order, eg in
the order they come back. If disabled, Camel will process replies in the same
order as defined by the multicast. | false | Boolean
-| *stopOnException* | Will now stop further processing if an exception or
failure occurred during processing of an org.apache.camel.Exchange and the
caused exception will be thrown. Will also stop if processing the exchange
failed (has a fault message) or an exception was thrown and handled by the
error handler (such as using onException). In all situations the multicast will
stop further processing. This is the same behavior as in pipeline, which is
used by the routing engine. The defau [...]
-| *timeout* | Sets a total timeout specified in millis, when using parallel
processing. If the Multicast hasn't been able to send and process all replies
within the given timeframe, then the timeout triggers and the Multicast breaks
out and continues. Notice if you provide a TimeoutAwareAggregationStrategy then
the timeout method is invoked before breaking out. If the timeout is reached
with running tasks still remaining, certain tasks for which it is difficult for
Camel to shut down in [...]
+| *streaming* | If enabled then Camel will process replies out-of-order, eg in
the order they come back. If disabled, Camel will process replies in the same
order as defined by the multicast. | | String
+| *stopOnException* | Will now stop further processing if an exception or
failure occurred during processing of an org.apache.camel.Exchange and the
caused exception will be thrown. Will also stop if processing the exchange
failed (has a fault message) or an exception was thrown and handled by the
error handler (such as using onException). In all situations the multicast will
stop further processing. This is the same behavior as in pipeline, which is
used by the routing engine. The defau [...]
+| *timeout* | Sets a total timeout specified in millis, when using parallel
processing. If the Multicast hasn't been able to send and process all replies
within the given timeframe, then the timeout triggers and the Multicast breaks
out and continues. Notice if you provide a TimeoutAwareAggregationStrategy then
the timeout method is invoked before breaking out. If the timeout is reached
with running tasks still remaining, certain tasks for which it is difficult for
Camel to shut down in [...]
| *onPrepareRef* | Uses the Processor when preparing the
org.apache.camel.Exchange to be send. This can be used to deep-clone messages
that should be send, or any custom logic needed before the exchange is send. |
| String
-| *shareUnitOfWork* | Shares the org.apache.camel.spi.UnitOfWork with the
parent and each of the sub messages. Multicast will by default not share unit
of work between the parent exchange and each multicasted exchange. This means
each sub exchange has its own individual unit of work. | false | Boolean
-| *parallelAggregate* | If enabled then the aggregate method on
AggregationStrategy can be called concurrently. Notice that this would require
the implementation of AggregationStrategy to be implemented as thread-safe. By
default this is false meaning that Camel synchronizes the call to the aggregate
method. Though in some use-cases this can be used to archive higher performance
when the AggregationStrategy is implemented as thread-safe. | false | Boolean
-| *stopOnAggregateException* | If enabled, unwind exceptions occurring at
aggregation time to the error handler when parallelProcessing is used.
Currently, aggregation time exceptions do not stop the route processing when
parallelProcessing is used. Enabling this option allows to work around this
behavior. The default value is false for the sake of backward compatibility. |
false | Boolean
+| *shareUnitOfWork* | Shares the org.apache.camel.spi.UnitOfWork with the
parent and each of the sub messages. Multicast will by default not share unit
of work between the parent exchange and each multicasted exchange. This means
each sub exchange has its own individual unit of work. | | String
+| *parallelAggregate* | If enabled then the aggregate method on
AggregationStrategy can be called concurrently. Notice that this would require
the implementation of AggregationStrategy to be implemented as thread-safe. By
default this is false meaning that Camel synchronizes the call to the aggregate
method. Though in some use-cases this can be used to archive higher performance
when the AggregationStrategy is implemented as thread-safe. | | String
+| *stopOnAggregateException* | If enabled, unwind exceptions occurring at
aggregation time to the error handler when parallelProcessing is used.
Currently, aggregation time exceptions do not stop the route processing when
parallelProcessing is used. Enabling this option allows to work around this
behavior. The default value is false for the sake of backward compatibility. |
| String
|===
// eip options: END
diff --git
a/core/camel-core-engine/src/main/docs/modules/eips/pages/onFallback-eip.adoc
b/core/camel-core-engine/src/main/docs/modules/eips/pages/onFallback-eip.adoc
index bc083e4..04dc958 100644
---
a/core/camel-core-engine/src/main/docs/modules/eips/pages/onFallback-eip.adoc
+++
b/core/camel-core-engine/src/main/docs/modules/eips/pages/onFallback-eip.adoc
@@ -13,7 +13,7 @@ The On Fallback EIP supports 1 options which are listed below:
[width="100%",cols="2,5,^1,2",options="header"]
|===
| Name | Description | Default | Type
-| *fallbackViaNetwork* | Whether the fallback goes over the network. If the
fallback will go over the network it is another possible point of failure and
so it also needs to be wrapped by a HystrixCommand. It is important to execute
the fallback command on a separate thread-pool, otherwise if the main command
were to become latent and fill the thread-pool this would prevent the fallback
from running if the two commands share the same pool. | false | Boolean
+| *fallbackViaNetwork* | Whether the fallback goes over the network. If the
fallback will go over the network it is another possible point of failure and
so it also needs to be wrapped by a HystrixCommand. It is important to execute
the fallback command on a separate thread-pool, otherwise if the main command
were to become latent and fill the thread-pool this would prevent the fallback
from running if the two commands share the same pool. | false | String
|===
// eip options: END
diff --git
a/core/camel-core-engine/src/main/docs/modules/eips/pages/pollEnrich-eip.adoc
b/core/camel-core-engine/src/main/docs/modules/eips/pages/pollEnrich-eip.adoc
index 87d74c0..ebd5c87 100644
---
a/core/camel-core-engine/src/main/docs/modules/eips/pages/pollEnrich-eip.adoc
+++
b/core/camel-core-engine/src/main/docs/modules/eips/pages/pollEnrich-eip.adoc
@@ -39,13 +39,13 @@ The Poll Enrich EIP supports 7 options which are listed
below:
[width="100%",cols="2,5,^1,2",options="header"]
|===
| Name | Description | Default | Type
-| *timeout* | Timeout in millis when polling from the external service. The
timeout has influence about the poll enrich behavior. It basically operations
in three different modes: negative value - Waits until a message is available
and then returns it. Warning that this method could block indefinitely if no
messages are available. 0 - Attempts to receive a message exchange immediately
without waiting and returning null if a message exchange is not available yet.
positive value - Attempts [...]
+| *timeout* | Timeout in millis when polling from the external service. The
timeout has influence about the poll enrich behavior. It basically operations
in three different modes: negative value - Waits until a message is available
and then returns it. Warning that this method could block indefinitely if no
messages are available. 0 - Attempts to receive a message exchange immediately
without waiting and returning null if a message exchange is not available yet.
positive value - Attempts [...]
| *strategyRef* | Refers to an AggregationStrategy to be used to merge the
reply from the external service, into a single outgoing message. By default
Camel will use the reply from the external service as outgoing message. | |
String
| *strategyMethodName* | This option can be used to explicit declare the
method name to use, when using POJOs as the AggregationStrategy. | | String
-| *strategyMethodAllowNull* | If this option is false then the aggregate
method is not used if there was no data to enrich. If this option is true then
null values is used as the oldExchange (when no data to enrich), when using
POJOs as the AggregationStrategy. | false | Boolean
-| *aggregateOnException* | If this option is false then the aggregate method
is not used if there was an exception thrown while trying to retrieve the data
to enrich from the resource. Setting this option to true allows end users to
control what to do if there was an exception in the aggregate method. For
example to suppress the exception or set a custom message body etc. | false |
Boolean
-| *cacheSize* | Sets the maximum size used by the
org.apache.camel.spi.ConsumerCache which is used to cache and reuse consumers
when uris are reused. Beware that when using dynamic endpoints then it affects
how well the cache can be utilized. If each dynamic endpoint is unique then its
best to turn of caching by setting this to -1, which allows Camel to not cache
both the producers and endpoints; they are regarded as prototype scoped and
will be stopped and discarded after use. This redu [...]
-| *ignoreInvalidEndpoint* | Ignore the invalidate endpoint exception when try
to create a producer with that endpoint | false | Boolean
+| *strategyMethodAllowNull* | If this option is false then the aggregate
method is not used if there was no data to enrich. If this option is true then
null values is used as the oldExchange (when no data to enrich), when using
POJOs as the AggregationStrategy. | | String
+| *aggregateOnException* | If this option is false then the aggregate method
is not used if there was an exception thrown while trying to retrieve the data
to enrich from the resource. Setting this option to true allows end users to
control what to do if there was an exception in the aggregate method. For
example to suppress the exception or set a custom message body etc. | | String
+| *cacheSize* | Sets the maximum size used by the
org.apache.camel.spi.ConsumerCache which is used to cache and reuse consumers
when uris are reused. Beware that when using dynamic endpoints then it affects
how well the cache can be utilized. If each dynamic endpoint is unique then its
best to turn of caching by setting this to -1, which allows Camel to not cache
both the producers and endpoints; they are regarded as prototype scoped and
will be stopped and discarded after use. This redu [...]
+| *ignoreInvalidEndpoint* | Ignore the invalidate endpoint exception when try
to create a producer with that endpoint | | String
|===
// eip options: END
diff --git
a/core/camel-core-engine/src/main/docs/modules/eips/pages/recipientList-eip.adoc
b/core/camel-core-engine/src/main/docs/modules/eips/pages/recipientList-eip.adoc
index 0c91120..7c477c6 100644
---
a/core/camel-core-engine/src/main/docs/modules/eips/pages/recipientList-eip.adoc
+++
b/core/camel-core-engine/src/main/docs/modules/eips/pages/recipientList-eip.adoc
@@ -17,20 +17,20 @@ The Recipient List EIP supports 15 options which are listed
below:
|===
| Name | Description | Default | Type
| *delimiter* | Delimiter used if the Expression returned multiple endpoints.
Can be turned off using the value false. The default value is , | , | String
-| *parallelProcessing* | If enabled then sending messages to the recipients
occurs concurrently. Note the caller thread will still wait until all messages
has been fully processed, before it continues. Its only the sending and
processing the replies from the recipients which happens concurrently. | false
| Boolean
+| *parallelProcessing* | If enabled then sending messages to the recipients
occurs concurrently. Note the caller thread will still wait until all messages
has been fully processed, before it continues. Its only the sending and
processing the replies from the recipients which happens concurrently. | |
String
| *strategyRef* | Sets a reference to the AggregationStrategy to be used to
assemble the replies from the recipients, into a single outgoing message from
the RecipientList. By default Camel will use the last reply as the outgoing
message. You can also use a POJO as the AggregationStrategy | | String
| *strategyMethodName* | This option can be used to explicit declare the
method name to use, when using POJOs as the AggregationStrategy. | | String
-| *strategyMethodAllowNull* | If this option is false then the aggregate
method is not used if there was no data to enrich. If this option is true then
null values is used as the oldExchange (when no data to enrich), when using
POJOs as the AggregationStrategy | false | Boolean
+| *strategyMethodAllowNull* | If this option is false then the aggregate
method is not used if there was no data to enrich. If this option is true then
null values is used as the oldExchange (when no data to enrich), when using
POJOs as the AggregationStrategy | | String
| *executorServiceRef* | Refers to a custom Thread Pool to be used for
parallel processing. Notice if you set this option, then parallel processing is
automatic implied, and you do not have to enable that option as well. | |
String
-| *stopOnException* | Will now stop further processing if an exception or
failure occurred during processing of an org.apache.camel.Exchange and the
caused exception will be thrown. Will also stop if processing the exchange
failed (has a fault message) or an exception was thrown and handled by the
error handler (such as using onException). In all situations the recipient list
will stop further processing. This is the same behavior as in pipeline, which
is used by the routing engine. The [...]
-| *ignoreInvalidEndpoints* | Ignore the invalidate endpoint exception when try
to create a producer with that endpoint | false | Boolean
-| *streaming* | If enabled then Camel will process replies out-of-order, eg in
the order they come back. If disabled, Camel will process replies in the same
order as defined by the recipient list. | false | Boolean
-| *timeout* | Sets a total timeout specified in millis, when using parallel
processing. If the Recipient List hasn't been able to send and process all
replies within the given timeframe, then the timeout triggers and the Recipient
List breaks out and continues. Notice if you provide a
TimeoutAwareAggregationStrategy then the timeout method is invoked before
breaking out. If the timeout is reached with running tasks still remaining,
certain tasks for which it is difficult for Camel to shu [...]
+| *stopOnException* | Will now stop further processing if an exception or
failure occurred during processing of an org.apache.camel.Exchange and the
caused exception will be thrown. Will also stop if processing the exchange
failed (has a fault message) or an exception was thrown and handled by the
error handler (such as using onException). In all situations the recipient list
will stop further processing. This is the same behavior as in pipeline, which
is used by the routing engine. The [...]
+| *ignoreInvalidEndpoints* | Ignore the invalidate endpoint exception when try
to create a producer with that endpoint | | String
+| *streaming* | If enabled then Camel will process replies out-of-order, eg in
the order they come back. If disabled, Camel will process replies in the same
order as defined by the recipient list. | | String
+| *timeout* | Sets a total timeout specified in millis, when using parallel
processing. If the Recipient List hasn't been able to send and process all
replies within the given timeframe, then the timeout triggers and the Recipient
List breaks out and continues. Notice if you provide a
TimeoutAwareAggregationStrategy then the timeout method is invoked before
breaking out. If the timeout is reached with running tasks still remaining,
certain tasks for which it is difficult for Camel to shu [...]
| *onPrepareRef* | Uses the Processor when preparing the
org.apache.camel.Exchange to be send. This can be used to deep-clone messages
that should be send, or any custom logic needed before the exchange is send. |
| String
-| *shareUnitOfWork* | Shares the org.apache.camel.spi.UnitOfWork with the
parent and each of the sub messages. Recipient List will by default not share
unit of work between the parent exchange and each recipient exchange. This
means each sub exchange has its own individual unit of work. | false | Boolean
-| *cacheSize* | Sets the maximum size used by the
org.apache.camel.spi.ProducerCache which is used to cache and reuse producers
when using this recipient list, when uris are reused. Beware that when using
dynamic endpoints then it affects how well the cache can be utilized. If each
dynamic endpoint is unique then its best to turn of caching by setting this to
-1, which allows Camel to not cache both the producers and endpoints; they are
regarded as prototype scoped and will be stopped an [...]
-| *parallelAggregate* | If enabled then the aggregate method on
AggregationStrategy can be called concurrently. Notice that this would require
the implementation of AggregationStrategy to be implemented as thread-safe. By
default this is false meaning that Camel synchronizes the call to the aggregate
method. Though in some use-cases this can be used to archive higher performance
when the AggregationStrategy is implemented as thread-safe. | false | Boolean
-| *stopOnAggregateException* | If enabled, unwind exceptions occurring at
aggregation time to the error handler when parallelProcessing is used.
Currently, aggregation time exceptions do not stop the route processing when
parallelProcessing is used. Enabling this option allows to work around this
behavior. The default value is false for the sake of backward compatibility. |
false | Boolean
+| *shareUnitOfWork* | Shares the org.apache.camel.spi.UnitOfWork with the
parent and each of the sub messages. Recipient List will by default not share
unit of work between the parent exchange and each recipient exchange. This
means each sub exchange has its own individual unit of work. | | String
+| *cacheSize* | Sets the maximum size used by the
org.apache.camel.spi.ProducerCache which is used to cache and reuse producers
when using this recipient list, when uris are reused. Beware that when using
dynamic endpoints then it affects how well the cache can be utilized. If each
dynamic endpoint is unique then its best to turn of caching by setting this to
-1, which allows Camel to not cache both the producers and endpoints; they are
regarded as prototype scoped and will be stopped an [...]
+| *parallelAggregate* | If enabled then the aggregate method on
AggregationStrategy can be called concurrently. Notice that this would require
the implementation of AggregationStrategy to be implemented as thread-safe. By
default this is false meaning that Camel synchronizes the call to the aggregate
method. Though in some use-cases this can be used to archive higher performance
when the AggregationStrategy is implemented as thread-safe. | | String
+| *stopOnAggregateException* | If enabled, unwind exceptions occurring at
aggregation time to the error handler when parallelProcessing is used.
Currently, aggregation time exceptions do not stop the route processing when
parallelProcessing is used. Enabling this option allows to work around this
behavior. The default value is false for the sake of backward compatibility. |
| String
|===
// eip options: END
diff --git
a/core/camel-core-engine/src/main/docs/modules/eips/pages/resilience4jConfiguration-eip.adoc
b/core/camel-core-engine/src/main/docs/modules/eips/pages/resilience4jConfiguration-eip.adoc
index 77f40f9..397fd62 100644
---
a/core/camel-core-engine/src/main/docs/modules/eips/pages/resilience4jConfiguration-eip.adoc
+++
b/core/camel-core-engine/src/main/docs/modules/eips/pages/resilience4jConfiguration-eip.adoc
@@ -3,4 +3,22 @@
// eip options: START
+The Resilience4j Configuration EIP supports 12 options which are listed below:
+
+[width="100%",cols="2,5,^1,2",options="header"]
+|===
+| Name | Description | Default | Type
+| *circuitBreakerRef* | Refers to an existing
io.github.resilience4j.circuitbreaker.CircuitBreaker instance to lookup and use
from the registry. When using this, then any other circuit breaker options are
not in use. | | String
+| *configRef* | Refers to an existing
io.github.resilience4j.circuitbreaker.CircuitBreakerConfig instance to lookup
and use from the registry. | | String
+| *failureRateThreshold* | Configures the failure rate threshold in
percentage. If the failure rate is equal or greater than the threshold the
CircuitBreaker transitions to open and starts short-circuiting calls. The
threshold must be greater than 0 and not greater than 100. Default value is 50
percentage. | 50 | Float
+| *permittedNumberOfCallsInHalf OpenState* | Configures the number of
permitted calls when the CircuitBreaker is half open. The size must be greater
than 0. Default size is 10. | 10 | Integer
+| *slidingWindowSize* | Configures the size of the sliding window which is
used to record the outcome of calls when the CircuitBreaker is closed.
slidingWindowSize configures the size of the sliding window. Sliding window can
either be count-based or time-based. If slidingWindowType is COUNT_BASED, the
last slidingWindowSize calls are recorded and aggregated. If slidingWindowType
is TIME_BASED, the calls of the last slidingWindowSize seconds are recorded and
aggregated. The slidingWindow [...]
+| *slidingWindowType* | Configures the type of the sliding window which is
used to record the outcome of calls when the CircuitBreaker is closed. Sliding
window can either be count-based or time-based. If slidingWindowType is
COUNT_BASED, the last slidingWindowSize calls are recorded and aggregated. If
slidingWindowType is TIME_BASED, the calls of the last slidingWindowSize
seconds are recorded and aggregated. Default slidingWindowType is COUNT_BASED.
| COUNT_BASED | String
+| *minimumNumberOfCalls* | Configures configures the minimum number of calls
which are required (per sliding window period) before the CircuitBreaker can
calculate the error rate. For example, if minimumNumberOfCalls is 10, then at
least 10 calls must be recorded, before the failure rate can be calculated. If
only 9 calls have been recorded the CircuitBreaker will not transition to open
even if all 9 calls have failed. Default minimumNumberOfCalls is 100 | 100 |
Integer
+| *writableStackTraceEnabled* | Enables writable stack traces. When set to
false, Exception.getStackTrace returns a zero length array. This may be used to
reduce log spam when the circuit breaker is open as the cause of the exceptions
is already known (the circuit breaker is short-circuiting calls). | true |
Boolean
+| *waitDurationInOpenState* | Configures the wait duration (in seconds) which
specifies how long the CircuitBreaker should stay open, before it switches to
half open. Default value is 60 seconds. | 60 | Integer
+| *automaticTransitionFromOpenTo HalfOpenEnabled* | Enables automatic
transition from OPEN to HALF_OPEN state once the waitDurationInOpenState has
passed. | false | Boolean
+| *slowCallRateThreshold* | Configures a threshold in percentage. The
CircuitBreaker considers a call as slow when the call duration is greater than
slowCallDurationThreshold(Duration. When the percentage of slow calls is equal
or greater the threshold, the CircuitBreaker transitions to open and starts
short-circuiting calls. The threshold must be greater than 0 and not greater
than 100. Default value is 100 percentage which means that all recorded calls
must be slower than slowCallDurat [...]
+| *slowCallDurationThreshold* | Configures the duration threshold (seconds)
above which calls are considered as slow and increase the slow calls
percentage. Default value is 60 seconds. | 60 | Integer
+|===
// eip options: END
diff --git
a/core/camel-core-engine/src/main/docs/modules/eips/pages/saga-eip.adoc
b/core/camel-core-engine/src/main/docs/modules/eips/pages/saga-eip.adoc
index 0b2b49d..e217b8d 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/saga-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/saga-eip.adoc
@@ -21,7 +21,7 @@ with the purpose of restoring the status that was present
before the flow execut
Compensating actions can be declared in Camel routes using the Java or XML DSL
and will be invoked by Camel only when needed (if the saga is cancelled due to
an error).
// eip options: START
-The Saga EIP supports 6 options which are listed below:
+The Saga EIP supports 7 options which are listed below:
[width="100%",cols="2,5,^1,2",options="header"]
|===
@@ -29,10 +29,10 @@ The Saga EIP supports 6 options which are listed below:
| *propagation* | Set the Saga propagation mode (REQUIRED, REQUIRES_NEW,
MANDATORY, SUPPORTS, NOT_SUPPORTED, NEVER). | REQUIRED | SagaPropagation
| *completionMode* | Determine how the saga should be considered complete.
When set to AUTO, the saga is completed when the exchange that initiates the
saga is processed successfully, or compensated when it completes exceptionally.
When set to MANUAL, the user must complete or compensate the saga using the
saga:complete or saga:compensate endpoints. | AUTO | SagaCompletionMode
| *timeoutInMilliseconds* | Set the maximum amount of time for the Saga. After
the timeout is expired, the saga will be compensated automatically (unless a
different decision has been taken in the meantime). | | Long
-| *compensation* | The compensation endpoint URI that must be called to
compensate all changes done in the route. The route corresponding to the
compensation URI must perform compensation and complete without error. If
errors occur during compensation, the saga service may call again the
compensation URI to retry. | | SagaActionUri Definition
-| *completion* | The completion endpoint URI that will be called when the Saga
is completed successfully. The route corresponding to the completion URI must
perform completion tasks and terminate without error. If errors occur during
completion, the saga service may call again the completion URI to retry. | |
SagaActionUri Definition
+| *compensation* | The compensation endpoint URI that must be called to
compensate all changes done in the route. The route corresponding to the
compensation URI must perform compensation and complete without error. If
errors occur during compensation, the saga service may call again the
compensation URI to retry. | | SagaActionUriDefinition
+| *completion* | The completion endpoint URI that will be called when the Saga
is completed successfully. The route corresponding to the completion URI must
perform completion tasks and terminate without error. If errors occur during
completion, the saga service may call again the completion URI to retry. | |
SagaActionUriDefinition
| *option* | Allows to save properties of the current exchange in order to
re-use them in a compensation/completion callback route. Options are usually
helpful e.g. to store and retrieve identifiers of objects that should be
deleted in compensating actions. Option values will be transformed into input
headers of the compensation/completion exchange. | | List
-| *sagaServiceRef* | Refers to the id to lookup in the registry for the
specific CamelSagaService to use. | | String
+| *sagaServiceRef* | Refers to the id to lookup in the registry for the
specific CamelSagaService to use. | | String
|===
// eip options: END
diff --git
a/core/camel-core-engine/src/main/docs/modules/eips/pages/serviceCall-eip.adoc
b/core/camel-core-engine/src/main/docs/modules/eips/pages/serviceCall-eip.adoc
index aece528..b38db15 100644
---
a/core/camel-core-engine/src/main/docs/modules/eips/pages/serviceCall-eip.adoc
+++
b/core/camel-core-engine/src/main/docs/modules/eips/pages/serviceCall-eip.adoc
@@ -100,17 +100,17 @@ The Service Call EIP supports 14 options which are listed
below:
| *name* | *Required* Sets the name of the service to use | | String
| *uri* | The uri of the endpoint to send to. The uri can be dynamic computed
using the org.apache.camel.language.simple.SimpleLanguage expression. | |
String
| *component* | The component to use. | http | String
-| *pattern* | Sets the optional ExchangePattern used to invoke this endpoint |
| ExchangePattern
+| *pattern* | *Required* Sets the optional ExchangePattern used to invoke this
endpoint | | ExchangePattern
| *configurationRef* | Refers to a ServiceCall configuration to use | | String
| *serviceDiscoveryRef* | Sets a reference to a custom ServiceDiscovery to
use. | | String
| *serviceFilterRef* | Sets a reference to a custom ServiceFilter to use. | |
String
| *serviceChooserRef* | Sets a reference to a custom ServiceChooser to use. |
| String
| *loadBalancerRef* | Sets a reference to a custom ServiceLoadBalancer to use.
| | String
| *expressionRef* | Set a reference to a custom Expression to use. | | String
-| *serviceDiscovery Configuration* | *Required* Configures the
ServiceDiscovery using the given configuration. | | ServiceCallService
DiscoveryConfiguration
-| *serviceFilterConfiguration* | *Required* Configures the ServiceFilter using
the given configuration. | | ServiceCallService FilterConfiguration
-| *loadBalancerConfiguration* | *Required* Configures the LoadBalancer using
the given configuration. | | ServiceCallServiceLoad BalancerConfiguration
-| *expressionConfiguration* | *Required* Configures the Expression using the
given configuration. | | ServiceCallExpression Configuration
+| *serviceDiscoveryConfiguration* | *Required* Configures the ServiceDiscovery
using the given configuration. | | ServiceCallServiceDiscoveryConfiguration
+| *serviceFilterConfiguration* | *Required* Configures the ServiceFilter using
the given configuration. | | ServiceCallServiceFilterConfiguration
+| *loadBalancerConfiguration* | *Required* Configures the LoadBalancer using
the given configuration. | | ServiceCallServiceLoadBalancerConfiguration
+| *expressionConfiguration* | *Required* Configures the Expression using the
given configuration. | | ServiceCallExpressionConfiguration
|===
// eip options: END
diff --git
a/core/camel-core-engine/src/main/docs/modules/eips/pages/sticky-eip.adoc
b/core/camel-core-engine/src/main/docs/modules/eips/pages/sticky-eip.adoc
index cd04f97..5e1910c 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/sticky-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/sticky-eip.adoc
@@ -11,7 +11,7 @@ The Sticky EIP supports 1 options which are listed below:
[width="100%",cols="2,5,^1,2",options="header"]
|===
| Name | Description | Default | Type
-| *correlationExpression* | *Required* The correlation expression to use to
calculate the correlation key | | NamespaceAware Expression
+| *correlationExpression* | *Required* The correlation expression to use to
calculate the correlation key | | ExpressionSubElementDefinition
|===
// eip options: END
diff --git
a/core/camel-core-engine/src/main/docs/modules/eips/pages/threads-eip.adoc
b/core/camel-core-engine/src/main/docs/modules/eips/pages/threads-eip.adoc
index a12c023..b415dcf 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/threads-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/threads-eip.adoc
@@ -18,8 +18,8 @@ The Threads EIP supports 10 options which are listed below:
| *maxQueueSize* | Sets the maximum number of tasks in the work queue. Use -1
or Integer.MAX_VALUE for an unbounded queue | | Integer
| *allowCoreThreadTimeOut* | Whether idle core threads is allowed to timeout
and therefore can shrink the pool size below the core pool size Is by default
false | false | Boolean
| *threadName* | Sets the thread name to use. | Threads | String
-| *rejectedPolicy* | Sets the handler for tasks which cannot be executed by
the thread pool. | | ThreadPoolRejected Policy
-| *callerRunsWhenRejected* | Whether or not to use as caller runs as fallback
when a task is rejected being added to the thread pool (when its full). This is
only used as fallback if no rejectedPolicy has been configured, or the thread
pool has no configured rejection handler. Is by default true | true | Boolean
+| *rejectedPolicy* | Sets the handler for tasks which cannot be executed by
the thread pool. | | ThreadPoolRejectedPolicy
+| *callerRunsWhenRejected* | Whether or not to use as caller runs as fallback
when a task is rejected being added to the thread pool (when its full). This is
only used as fallback if no rejectedPolicy has been configured, or the thread
pool has no configured rejection handler. Is by default true | true | String
|===
// eip options: END
diff --git
a/core/camel-core-engine/src/main/docs/modules/eips/pages/throttle-eip.adoc
b/core/camel-core-engine/src/main/docs/modules/eips/pages/throttle-eip.adoc
index 7d6c8d7..6d1a6b1 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/throttle-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/throttle-eip.adoc
@@ -11,7 +11,7 @@ The Throttle EIP supports 6 options which are listed below:
[width="100%",cols="2,5,^1,2",options="header"]
|===
| Name | Description | Default | Type
-| *correlationExpression* | The expression used to calculate the correlation
key to use for throttle grouping. The Exchange which has the same correlation
key is throttled together. | | NamespaceAware Expression
+| *correlationExpression* | The expression used to calculate the correlation
key to use for throttle grouping. The Exchange which has the same correlation
key is throttled together. | | ExpressionSubElementDefinition
| *executorServiceRef* | To use a custom thread pool
(ScheduledExecutorService) by the throttler. | | String
| *timePeriodMillis* | Sets the time period during which the maximum request
count is valid for | 1000 | Long
| *asyncDelayed* | Enables asynchronous delay which means the thread will not
block while delaying. | false | Boolean
diff --git
a/core/camel-core-engine/src/main/docs/modules/eips/pages/to-eip.adoc
b/core/camel-core-engine/src/main/docs/modules/eips/pages/to-eip.adoc
index fb1c22c..f9ceb03 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/to-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/to-eip.adoc
@@ -19,7 +19,7 @@ The To EIP supports 2 options which are listed below:
|===
| Name | Description | Default | Type
| *uri* | *Required* Sets the uri of the endpoint to send to. | | String
-| *pattern* | Sets the optional ExchangePattern used to invoke this endpoint |
| ExchangePattern
+| *pattern* | Sets the optional ExchangePattern used to invoke this endpoint |
| String
|===
// eip options: END
diff --git
a/core/camel-core-engine/src/main/docs/modules/eips/pages/toD-eip.adoc
b/core/camel-core-engine/src/main/docs/modules/eips/pages/toD-eip.adoc
index a52be0d..2b9aca7 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/toD-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/toD-eip.adoc
@@ -17,9 +17,9 @@ The To D EIP supports 5 options which are listed below:
| Name | Description | Default | Type
| *uri* | *Required* The uri of the endpoint to send to. The uri can be
dynamic computed using the org.apache.camel.language.simple.SimpleLanguage
expression. | | String
| *pattern* | Sets the optional ExchangePattern used to invoke this endpoint |
| ExchangePattern
-| *cacheSize* | Sets the maximum size used by the
org.apache.camel.spi.ConsumerCache which is used to cache and reuse producers.
| | Integer
+| *cacheSize* | Sets the maximum size used by the
org.apache.camel.spi.ProducerCache which is used to cache and reuse producers
when using this recipient list, when uris are reused. Beware that when using
dynamic endpoints then it affects how well the cache can be utilized. If each
dynamic endpoint is unique then its best to turn of caching by setting this to
-1, which allows Camel to not cache both the producers and endpoints; they are
regarded as prototype scoped and will be stopped an [...]
| *ignoreInvalidEndpoint* | Ignore the invalidate endpoint exception when try
to create a producer with that endpoint | false | Boolean
-| *allowOptimisedComponents* | Whether to allow components to optimise toD if
they are org.apache.camel.spi.SendDynamicAware. | true | Boolean
+| *allowOptimisedComponents* | Whether to allow components to optimise toD if
they are org.apache.camel.spi.SendDynamicAware . | true | Boolean
|===
// eip options: END
diff --git
a/core/camel-core-engine/src/main/docs/modules/eips/pages/weighted-eip.adoc
b/core/camel-core-engine/src/main/docs/modules/eips/pages/weighted-eip.adoc
index ced6732..f3cf276 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/weighted-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/weighted-eip.adoc
@@ -11,7 +11,7 @@ The Weighted EIP supports 3 options which are listed below:
[width="100%",cols="2,5,^1,2",options="header"]
|===
| Name | Description | Default | Type
-| *roundRobin* | To enable round robin mode. By default the weighted
distribution mode is used. The default value is false. | false | Boolean
+| *roundRobin* | To enable round robin mode. By default the weighted
distribution mode is used. The default value is false. | | String
| *distributionRatio* | *Required* The distribution ratio is a delimited
String consisting on integer weights separated by delimiters for example 2,3,5.
The distributionRatio must match the number of endpoints and/or processors
specified in the load balancer list. | | String
| *distributionRatioDelimiter* | Delimiter used to specify the distribution
ratio. The default value is , | , | String
|===
diff --git
a/core/camel-core-engine/src/main/docs/modules/eips/pages/wireTap-eip.adoc
b/core/camel-core-engine/src/main/docs/modules/eips/pages/wireTap-eip.adoc
index 7082de2..1aabcae 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/wireTap-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/wireTap-eip.adoc
@@ -26,16 +26,16 @@ The Wire Tap EIP supports 11 options which are listed below:
|===
| Name | Description | Default | Type
| *processorRef* | Reference to a Processor to use for creating a new body as
the message to use for wire tapping | | String
-| *body* | Uses the expression for creating a new body as the message to use
for wire tapping | | NamespaceAware Expression
+| *body* | Uses the expression for creating a new body as the message to use
for wire tapping | | ExpressionSubElementDefinition
| *executorServiceRef* | Uses a custom thread pool | | String
| *copy* | Uses a copy of the original exchange | true | Boolean
| *dynamicUri* | Whether the uri is dynamic or static. If the uri is dynamic
then the simple language is used to evaluate a dynamic uri to use as the
wire-tap destination, for each incoming message. This works similar to how the
toD EIP pattern works. If static then the uri is used as-is as the wire-tap
destination. | true | Boolean
| *onPrepareRef* | Uses the Processor when preparing the
org.apache.camel.Exchange to be send. This can be used to deep-clone messages
that should be send, or any custom logic needed before the exchange is send. |
| String
| *uri* | *Required* The uri of the endpoint to send to. The uri can be
dynamic computed using the org.apache.camel.language.simple.SimpleLanguage
expression. | | String
| *pattern* | Sets the optional ExchangePattern used to invoke this endpoint |
| ExchangePattern
-| *cacheSize* | Sets the maximum size used by the
org.apache.camel.spi.ProducerCache which is used to cache and reuse producers
when using this dynamic router, when uris are reused. Beware that when using
dynamic endpoints then it affects how well the cache can be utilized. If each
dynamic endpoint is unique then its best to turn of caching by setting this to
-1, which allows Camel to not cache both the producers and endpoints; they are
regarded as prototype scoped and will be stopped an [...]
+| *cacheSize* | Sets the maximum size used by the
org.apache.camel.spi.ProducerCache which is used to cache and reuse producers
when using this recipient list, when uris are reused. Beware that when using
dynamic endpoints then it affects how well the cache can be utilized. If each
dynamic endpoint is unique then its best to turn of caching by setting this to
-1, which allows Camel to not cache both the producers and endpoints; they are
regarded as prototype scoped and will be stopped an [...]
| *ignoreInvalidEndpoint* | Ignore the invalidate endpoint exception when try
to create a producer with that endpoint | false | Boolean
-| *allowOptimisedComponents* | Whether to allow components to optimise toD if
they are org.apache.camel.spi.SendDynamicAware. | true | Boolean
+| *allowOptimisedComponents* | Whether to allow components to optimise toD if
they are org.apache.camel.spi.SendDynamicAware . | true | Boolean
|===
// eip options: END
