CAMEL-11786: EIP docs should have same table structure as the others.
Project: http://git-wip-us.apache.org/repos/asf/camel/repo Commit: http://git-wip-us.apache.org/repos/asf/camel/commit/d486902f Tree: http://git-wip-us.apache.org/repos/asf/camel/tree/d486902f Diff: http://git-wip-us.apache.org/repos/asf/camel/diff/d486902f Branch: refs/heads/master Commit: d486902f408acfd964dcfb134143c9e98df1928f Parents: 924885e Author: Claus Ibsen <davscl...@apache.org> Authored: Wed Sep 20 10:29:49 2017 +0200 Committer: Claus Ibsen <davscl...@apache.org> Committed: Wed Sep 20 10:29:49 2017 +0200 ---------------------------------------------------------------------- .../src/main/docs/eips/aggregate-eip.adoc | 56 ++++++++--------- camel-core/src/main/docs/eips/bean-eip.adoc | 14 ++--- camel-core/src/main/docs/eips/choice-eip.adoc | 8 +-- .../src/main/docs/eips/circuitBreaker-eip.adoc | 10 +-- .../main/docs/eips/customLoadBalancer-eip.adoc | 6 +- camel-core/src/main/docs/eips/delay-eip.adoc | 10 +-- .../src/main/docs/eips/dynamicRouter-eip.adoc | 10 +-- camel-core/src/main/docs/eips/enrich-eip.adoc | 18 +++--- camel-core/src/main/docs/eips/hystrix-eip.adoc | 8 +-- .../docs/eips/hystrixConfiguration-eip.adoc | 66 ++++++++++---------- .../src/main/docs/eips/loadBalance-eip.adoc | 8 +-- camel-core/src/main/docs/eips/log-eip.adoc | 14 ++--- camel-core/src/main/docs/eips/loop-eip.adoc | 8 +-- .../src/main/docs/eips/recipientList-eip.adoc | 34 +++++----- .../src/main/docs/eips/resequence-eip.adoc | 6 +- .../src/main/docs/eips/routingSlip-eip.adoc | 10 +-- camel-core/src/main/docs/eips/sample-eip.adoc | 10 +-- .../src/main/docs/eips/serviceCall-eip.adoc | 32 +++++----- camel-core/src/main/docs/eips/sort-eip.adoc | 6 +- camel-core/src/main/docs/eips/split-eip.adoc | 28 ++++----- camel-core/src/main/docs/eips/throttle-eip.adoc | 14 ++--- .../camel/maven/packaging/UpdateReadmeMojo.java | 1 + .../maven/packaging/model/EipOptionModel.java | 57 +++++++++++++++-- .../src/main/resources/eip-options.mvel | 6 +- 24 files changed, 245 insertions(+), 195 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/camel/blob/d486902f/camel-core/src/main/docs/eips/aggregate-eip.adoc ---------------------------------------------------------------------- diff --git a/camel-core/src/main/docs/eips/aggregate-eip.adoc b/camel-core/src/main/docs/eips/aggregate-eip.adoc index e7bf61c..cb66b02 100644 --- a/camel-core/src/main/docs/eips/aggregate-eip.adoc +++ b/camel-core/src/main/docs/eips/aggregate-eip.adoc @@ -19,35 +19,35 @@ single correlation key into a single message exchange. The Aggregate EIP supports 26 options which are listed below: -[width="100%",cols="3,1m,6",options="header"] +[width="100%",cols="2,5,^1,2",options="header"] |=== -| Name | Java Type | Description -| correlationExpression | NamespaceAwareExpression | *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. -| completionPredicate | NamespaceAwareExpression | 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. -| completionTimeout | NamespaceAwareExpression | 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 runs every second you can use the completionTimeoutCheckerInterval option to configure how frequently to run the checker. 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. -| completionSize | NamespaceAwareExpression | 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. -| optimisticLockRetryPolicy | OptimisticLockRetryPolicyDefinition | Allows to configure retry settings when using optimistic locking. -| parallelProcessing | Boolean | 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. -| optimisticLocking | Boolean | Turns on using optimistic locking which requires the aggregationRepository being used is supporting this by implementing org.apache.camel.spi.OptimisticLockingAggregationRepository. -| executorServiceRef | String | 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. -| timeoutCheckerExecutorServiceRef | String | 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. -| aggregationRepositoryRef | String | Sets the custom aggregate repository to use Will by default use org.apache.camel.processor.aggregate.MemoryAggregationRepository -| strategyRef | String | 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. -| strategyMethodName | String | This option can be used to explicit declare the method name to use when using POJOs as the AggregationStrategy. -| strategyMethodAllowNull | Boolean | 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. -| completionSize | Integer | 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. -| completionInterval | Long | 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. -| completionTimeout | Long | 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 runs every second you can use the completionTimeoutCheckerInterval option to configure how frequently to run the checker. 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. -| completionTimeoutCheckerInterval | Long | 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. -| completionFromBatchConsumer | Boolean | 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 link org.apache.camel.ExchangeBATCH_COMPLETE when its complete. -| groupExchanges | Boolean | *Deprecated* Enables grouped exchanges so the aggregator will group all aggregated exchanges into a single combined Exchange holding all the aggregated exchanges in a java.util.List. -| eagerCheckCompletion | Boolean | 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. -| ignoreInvalidCorrelationKeys | Boolean | If a correlation key cannot be successfully evaluated it will be ignored by logging a DEBUG and then just ignore the incoming Exchange. -| closeCorrelationKeyOnCompletion | Integer | 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. -| discardOnCompletionTimeout | Boolean | Discards the aggregated message on completion timeout. This means on timeout the aggregated message is dropped and not sent out of the aggregator. -| forceCompletionOnStop | Boolean | Indicates to complete all current aggregated exchanges when the context is stopped -| completeAllOnStop | Boolean | 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 waiting to complete all those exchanges before its stopped when stopping CamelContext or the route using it. -| aggregateControllerRef | String | To use a org.apache.camel.processor.aggregate.AggregateController to allow external sources to control this aggregator. +| 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 +| *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 runs every second you can use the completionTimeoutCheckerInterval option to configure how frequently to run the checker. 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. | | NamespaceAware Expression +| *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. | | NamespaceAware Expression +| *optimisticLockRetryPolicy* | Allows to configure retry settings when using optimistic locking. | | OptimisticLockRetry PolicyDefinition +| *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 +| *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 +| *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 runs every second you can use the completionTimeoutCheckerInterval option to configure how frequently to run the checker. 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. | | 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 link org.apache.camel.ExchangeBATCH_COMPLETE when its complete. | false | Boolean +| *groupExchanges* | *Deprecated* Enables grouped exchanges so the aggregator will group all aggregated exchanges into a single combined Exchange holding all the aggregated exchanges in a java.util.List. | 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 +| *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 +| *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 waiting to complete all those exchanges before its stopped when stopping CamelContext or the route using it. | false | Boolean +| *aggregateControllerRef* | To use a org.apache.camel.processor.aggregate.AggregateController to allow external sources to control this aggregator. | | String |=== // eip options: END http://git-wip-us.apache.org/repos/asf/camel/blob/d486902f/camel-core/src/main/docs/eips/bean-eip.adoc ---------------------------------------------------------------------- diff --git a/camel-core/src/main/docs/eips/bean-eip.adoc b/camel-core/src/main/docs/eips/bean-eip.adoc index 1f92d2e..54d298a 100644 --- a/camel-core/src/main/docs/eips/bean-eip.adoc +++ b/camel-core/src/main/docs/eips/bean-eip.adoc @@ -18,14 +18,14 @@ the link:registry.html[Registry] The Bean EIP supports 5 options which are listed below: -[width="100%",cols="3,1m,6",options="header"] +[width="100%",cols="2,5,^1,2",options="header"] |=== -| Name | Java Type | Description -| ref | String | Sets a reference to a bean to use -| method | String | Sets the method name on the bean to use -| beanType | String | Sets the Class of the bean -| cache | Boolean | Caches the bean lookup to avoid lookup up bean on every usage. -| multiParameterArray | Boolean | *Deprecated* Whether the message body is an array type. +| Name | Description | Default | Type +| *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* | Caches the bean lookup to avoid lookup up bean on every usage. | true | Boolean +| *multiParameterArray* | *Deprecated* Whether the message body is an array type. | false | Boolean |=== // eip options: END http://git-wip-us.apache.org/repos/asf/camel/blob/d486902f/camel-core/src/main/docs/eips/choice-eip.adoc ---------------------------------------------------------------------- diff --git a/camel-core/src/main/docs/eips/choice-eip.adoc b/camel-core/src/main/docs/eips/choice-eip.adoc index e9800a6..26ab08d 100644 --- a/camel-core/src/main/docs/eips/choice-eip.adoc +++ b/camel-core/src/main/docs/eips/choice-eip.adoc @@ -14,11 +14,11 @@ image:http://www.enterpriseintegrationpatterns.com/img/ContentBasedRouter.gif[im The Choice EIP supports 2 options which are listed below: -[width="100%",cols="3,1m,6",options="header"] +[width="100%",cols="2,5,^1,2",options="header"] |=== -| Name | Java Type | Description -| whenClauses | List | Sets the when clauses -| otherwise | OtherwiseDefinition | Sets the otherwise node +| Name | Description | Default | Type +| *whenClauses* | Sets the when clauses | | List +| *otherwise* | Sets the otherwise node | | OtherwiseDefinition |=== // eip options: END http://git-wip-us.apache.org/repos/asf/camel/blob/d486902f/camel-core/src/main/docs/eips/circuitBreaker-eip.adoc ---------------------------------------------------------------------- diff --git a/camel-core/src/main/docs/eips/circuitBreaker-eip.adoc b/camel-core/src/main/docs/eips/circuitBreaker-eip.adoc index 251f5f6..afa4e8b 100644 --- a/camel-core/src/main/docs/eips/circuitBreaker-eip.adoc +++ b/camel-core/src/main/docs/eips/circuitBreaker-eip.adoc @@ -7,12 +7,12 @@ When the circuit breaker is closed, it will throw a `java.util.concurrent.Reject The Circuit Breaker EIP supports 3 options which are listed below: -[width="100%",cols="3,1m,6",options="header"] +[width="100%",cols="2,5,^1,2",options="header"] |=== -| Name | Java Type | Description -| exception | List | A list of class names for specific exceptions to monitor. If no exceptions is configured then all exceptions is monitored -| halfOpenAfter | Long | The timeout in millis to use as threshold to move state from closed to half-open or open state -| threshold | Integer | Number of previous failed messages to use as threshold to move state from closed to half-open or open state +| 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 +| *halfOpenAfter* | The timeout in millis to use as threshold to move state from closed to half-open or open state | | Long +| *threshold* | Number of previous failed messages to use as threshold to move state from closed to half-open or open state | | Integer |=== // eip options: END http://git-wip-us.apache.org/repos/asf/camel/blob/d486902f/camel-core/src/main/docs/eips/customLoadBalancer-eip.adoc ---------------------------------------------------------------------- diff --git a/camel-core/src/main/docs/eips/customLoadBalancer-eip.adoc b/camel-core/src/main/docs/eips/customLoadBalancer-eip.adoc index 96be9c7..89b2b0a 100644 --- a/camel-core/src/main/docs/eips/customLoadBalancer-eip.adoc +++ b/camel-core/src/main/docs/eips/customLoadBalancer-eip.adoc @@ -6,10 +6,10 @@ You can use a custom load balancer (eg your own implementation) also. The Custom Load Balancer EIP supports 1 options which are listed below: -[width="100%",cols="3,1m,6",options="header"] +[width="100%",cols="2,5,^1,2",options="header"] |=== -| Name | Java Type | Description -| ref | String | *Required* Refers to the custom load balancer to lookup from the registry +| Name | Description | Default | Type +| *ref* | *Required* Refers to the custom load balancer to lookup from the registry | | String |=== // eip options: END http://git-wip-us.apache.org/repos/asf/camel/blob/d486902f/camel-core/src/main/docs/eips/delay-eip.adoc ---------------------------------------------------------------------- diff --git a/camel-core/src/main/docs/eips/delay-eip.adoc b/camel-core/src/main/docs/eips/delay-eip.adoc index 799db64..e53a137 100644 --- a/camel-core/src/main/docs/eips/delay-eip.adoc +++ b/camel-core/src/main/docs/eips/delay-eip.adoc @@ -7,12 +7,12 @@ The Delayer Pattern allows you to delay the delivery of messages to some destina The Delay EIP supports 3 options which are listed below: -[width="100%",cols="3,1m,6",options="header"] +[width="100%",cols="2,5,^1,2",options="header"] |=== -| Name | Java Type | Description -| executorServiceRef | String | Refers to a custom Thread Pool if asyncDelay has been enabled. -| asyncDelayed | Boolean | Enables asynchronous delay which means the thread will noy block while delaying. -| callerRunsWhenRejected | Boolean | Whether or not the caller should run the task when it was rejected by the thread pool. Is by default true +| 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 noy block while delaying. | false | 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 |=== // eip options: END http://git-wip-us.apache.org/repos/asf/camel/blob/d486902f/camel-core/src/main/docs/eips/dynamicRouter-eip.adoc ---------------------------------------------------------------------- diff --git a/camel-core/src/main/docs/eips/dynamicRouter-eip.adoc b/camel-core/src/main/docs/eips/dynamicRouter-eip.adoc index 98a3d1d..48c0321 100644 --- a/camel-core/src/main/docs/eips/dynamicRouter-eip.adoc +++ b/camel-core/src/main/docs/eips/dynamicRouter-eip.adoc @@ -18,12 +18,12 @@ You must ensure the expression used for the `dynamicRouter` such as a bean, will The Dynamic Router EIP supports 3 options which are listed below: -[width="100%",cols="3,1m,6",options="header"] +[width="100%",cols="2,5,^1,2",options="header"] |=== -| Name | Java Type | Description -| uriDelimiter | String | Sets the uri delimiter to use -| ignoreInvalidEndpoints | Boolean | Ignore the invalidate endpoint exception when try to create a producer with that endpoint -| cacheSize | Integer | Sets the maximum size used by the org.apache.camel.impl.ProducerCache which is used to cache and reuse producers when using this recipient list when uris are reused. +| 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.impl.ProducerCache which is used to cache and reuse producers when using this recipient list when uris are reused. | | Integer |=== // eip options: END http://git-wip-us.apache.org/repos/asf/camel/blob/d486902f/camel-core/src/main/docs/eips/enrich-eip.adoc ---------------------------------------------------------------------- diff --git a/camel-core/src/main/docs/eips/enrich-eip.adoc b/camel-core/src/main/docs/eips/enrich-eip.adoc index 8f55a1e..a93e811 100644 --- a/camel-core/src/main/docs/eips/enrich-eip.adoc +++ b/camel-core/src/main/docs/eips/enrich-eip.adoc @@ -251,16 +251,16 @@ The `pollEnrich` works just as the `enrich` however as it uses a Polling Consume The Enrich EIP supports 7 options which are listed below: -[width="100%",cols="3,1m,6",options="header"] +[width="100%",cols="2,5,^1,2",options="header"] |=== -| Name | Java Type | Description -| strategyRef | String | 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. -| strategyMethodName | String | This option can be used to explicit declare the method name to use when using POJOs as the AggregationStrategy. -| strategyMethodAllowNull | Boolean | 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. -| aggregateOnException | Boolean | 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. -| shareUnitOfWork | Boolean | 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. -| cacheSize | Integer | Sets the maximum size used by the org.apache.camel.impl.ProducerCache which is used to cache and reuse producer when uris are reused. -| ignoreInvalidEndpoint | Boolean | Ignore the invalidate endpoint exception when try to create a producer with that endpoint +| 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.impl.ProducerCache which is used to cache and reuse producer when uris are reused. | | Integer +| *ignoreInvalidEndpoint* | Ignore the invalidate endpoint exception when try to create a producer with that endpoint | false | Boolean |=== // eip options: END http://git-wip-us.apache.org/repos/asf/camel/blob/d486902f/camel-core/src/main/docs/eips/hystrix-eip.adoc ---------------------------------------------------------------------- diff --git a/camel-core/src/main/docs/eips/hystrix-eip.adoc b/camel-core/src/main/docs/eips/hystrix-eip.adoc index 35f20e5..a10538a 100644 --- a/camel-core/src/main/docs/eips/hystrix-eip.adoc +++ b/camel-core/src/main/docs/eips/hystrix-eip.adoc @@ -21,11 +21,11 @@ Maven users will need to add the following dependency to their pom.xml to use th The Hystrix EIP supports 2 options which are listed below: -[width="100%",cols="3,1m,6",options="header"] +[width="100%",cols="2,5,^1,2",options="header"] |=== -| Name | Java Type | Description -| hystrixConfiguration | HystrixConfigurationDefinition | Configures the Hystrix EIP Use end when configuration is complete to return back to the Hystrix EIP. -| hystrixConfigurationRef | String | Refers to a Hystrix configuration to use for configuring the Hystrix EIP. +| Name | Description | Default | Type +| *hystrixConfiguration* | Configures the Hystrix EIP Use end when configuration is complete to return back to the Hystrix EIP. | | HystrixConfiguration Definition +| *hystrixConfigurationRef* | Refers to a Hystrix configuration to use for configuring the Hystrix EIP. | | String |=== // eip options: END http://git-wip-us.apache.org/repos/asf/camel/blob/d486902f/camel-core/src/main/docs/eips/hystrixConfiguration-eip.adoc ---------------------------------------------------------------------- diff --git a/camel-core/src/main/docs/eips/hystrixConfiguration-eip.adoc b/camel-core/src/main/docs/eips/hystrixConfiguration-eip.adoc index df65e07..3963833 100644 --- a/camel-core/src/main/docs/eips/hystrixConfiguration-eip.adoc +++ b/camel-core/src/main/docs/eips/hystrixConfiguration-eip.adoc @@ -5,39 +5,39 @@ The Hystrix Configuration EIP supports 31 options which are listed below: -[width="100%",cols="3,1m,6",options="header"] +[width="100%",cols="2,5,^1,2",options="header"] |=== -| Name | Java Type | Description -| groupKey | String | Sets the group key to use. The default value is CamelHystrix. -| threadPoolKey | String | Sets the thread pool key to use. Will by default use the same value as groupKey has been configured to use. -| circuitBreakerEnabled | Boolean | 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. -| circuitBreakerErrorThresholdPercentage | Integer | 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(). -| circuitBreakerForceClosed | Boolean | If true the HystrixCircuitBreakerallowRequest() 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. -| circuitBreakerForceOpen | Boolean | 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(); -| circuitBreakerRequestVolumeThreshold | Integer | 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. -| circuitBreakerSleepWindowInMilliseconds | Integer | The time in milliseconds after a HystrixCircuitBreaker trips open that it should wait before trying requests again. -| executionIsolationSemaphoreMaxConcurrentRequests | Integer | Number of concurrent requests permitted to HystrixCommand.run(). Requests beyond the concurrent limit will be rejected. Applicable only when executionIsolationStrategy == SEMAPHORE. -| executionIsolationStrategy | String | 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. -| executionIsolationThreadInterruptOnTimeout | Boolean | Whether the execution thread should attempt an interrupt (using link Futurecancel) when a thread times out. Applicable only when executionIsolationStrategy() == THREAD. -| executionTimeoutInMilliseconds | Integer | Time in milliseconds at which point the command will timeout and halt execution. If link 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. -| executionTimeoutEnabled | Boolean | Whether the timeout mechanism is enabled for this command -| fallbackIsolationSemaphoreMaxConcurrentRequests | Integer | Number of concurrent requests permitted to HystrixCommand.getFallback(). Requests beyond the concurrent limit will fail-fast and not attempt retrieving a fallback. -| fallbackEnabled | Boolean | Whether HystrixCommand.getFallback() should be attempted when failure occurs. -| metricsHealthSnapshotIntervalInMilliseconds | Integer | 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. -| metricsRollingPercentileBucketSize | Integer | Maximum number of values stored in each bucket of the rolling percentile. This is passed into HystrixRollingPercentile inside HystrixCommandMetrics. -| metricsRollingPercentileEnabled | Boolean | Whether percentile metrics should be captured using HystrixRollingPercentile inside HystrixCommandMetrics. -| metricsRollingPercentileWindowInMilliseconds | Integer | Duration of percentile rolling window in milliseconds. This is passed into HystrixRollingPercentile inside HystrixCommandMetrics. -| metricsRollingPercentileWindowBuckets | Integer | Number of buckets the rolling percentile window is broken into. This is passed into HystrixRollingPercentile inside HystrixCommandMetrics. -| metricsRollingStatisticalWindowInMilliseconds | Integer | 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. -| metricsRollingStatisticalWindowBuckets | Integer | Number of buckets the rolling statistical window is broken into. This is passed into HystrixRollingNumber inside HystrixCommandMetrics. -| requestLogEnabled | Boolean | Whether HystrixCommand execution and events should be logged to HystrixRequestLog. -| corePoolSize | Integer | Core thread-pool size that gets passed to link java.util.concurrent.ThreadPoolExecutorsetCorePoolSize(int) -| maximumSize | Integer | Maximum thread-pool size that gets passed to link ThreadPoolExecutorsetMaximumPoolSize(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 -| keepAliveTime | Integer | Keep-alive time in minutes that gets passed to link ThreadPoolExecutorsetKeepAliveTime(long TimeUnit) -| maxQueueSize | Integer | 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(). -| queueSizeRejectionThreshold | Integer | Queue size rejection threshold is an artificial max size at which rejections will occur even if link maxQueueSize has not been reached. This is done because the link 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. -| threadPoolRollingNumberStatisticalWindowInMilliseconds | Integer | Duration of statistical rolling window in milliseconds. This is passed into HystrixRollingNumber inside each HystrixThreadPoolMetrics instance. -| threadPoolRollingNumberStatisticalWindowBuckets | Integer | Number of buckets the rolling statistical window is broken into. This is passed into HystrixRollingNumber inside each HystrixThreadPoolMetrics instance. -| allowMaximumSizeToDivergeFromCoreSize | Boolean | Allows the configuration for maximumSize to take effect. That value can then be equal to or higher than coreSize +| 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 HystrixCircuitBreakerallowRequest() 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 +| *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 link Futurecancel) 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 link 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 link java.util.concurrent.ThreadPoolExecutorsetCorePoolSize(int) | 10 | Integer +| *maximumSize* | Maximum thread-pool size that gets passed to link ThreadPoolExecutorsetMaximumPoolSize(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 ThreadPoolExecutorsetKeepAliveTime(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 link maxQueueSize has not been reached. This is done because the link 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 |=== // eip options: END http://git-wip-us.apache.org/repos/asf/camel/blob/d486902f/camel-core/src/main/docs/eips/loadBalance-eip.adoc ---------------------------------------------------------------------- diff --git a/camel-core/src/main/docs/eips/loadBalance-eip.adoc b/camel-core/src/main/docs/eips/loadBalance-eip.adoc index 9dfe34d..4f08742 100644 --- a/camel-core/src/main/docs/eips/loadBalance-eip.adoc +++ b/camel-core/src/main/docs/eips/loadBalance-eip.adoc @@ -70,11 +70,11 @@ If you use streaming then you should enable Stream caching when using the failov The Load Balance EIP supports 2 options which are listed below: -[width="100%",cols="3,1m,6",options="header"] +[width="100%",cols="2,5,^1,2",options="header"] |=== -| Name | Java Type | Description -| loadBalancerType | LoadBalancerDefinition | *Required* The load balancer to be used -| inheritErrorHandler | Boolean | Sets whether or not to inherit the configured error handler. The default value is true. You can use this to disable using the inherited error handler for a given DSL such as a load balancer where you want to use a custom error handler strategy. +| Name | Description | Default | Type +| *loadBalancerType* | *Required* The load balancer to be used | | LoadBalancerDefinition +| *inheritErrorHandler* | Sets whether or not to inherit the configured error handler. The default value is true. You can use this to disable using the inherited error handler for a given DSL such as a load balancer where you want to use a custom error handler strategy. | false | Boolean |=== // eip options: END http://git-wip-us.apache.org/repos/asf/camel/blob/d486902f/camel-core/src/main/docs/eips/log-eip.adoc ---------------------------------------------------------------------- diff --git a/camel-core/src/main/docs/eips/log-eip.adoc b/camel-core/src/main/docs/eips/log-eip.adoc index f540c27..18cc0e9 100644 --- a/camel-core/src/main/docs/eips/log-eip.adoc +++ b/camel-core/src/main/docs/eips/log-eip.adoc @@ -12,14 +12,14 @@ Camel provides many ways to log the fact that you are processing a message. Here The Log EIP supports 5 options which are listed below: -[width="100%",cols="3,1m,6",options="header"] +[width="100%",cols="2,5,^1,2",options="header"] |=== -| Name | Java Type | Description -| message | String | *Required* Sets the log message (uses simple language) -| loggingLevel | LoggingLevel | Sets the logging level. The default value is INFO -| logName | String | Sets the name of the logger -| marker | String | To use slf4j marker -| loggerRef | String | To refer to a custom logger instance to lookup from the registry. +| 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 +| *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 |=== // eip options: END http://git-wip-us.apache.org/repos/asf/camel/blob/d486902f/camel-core/src/main/docs/eips/loop-eip.adoc ---------------------------------------------------------------------- diff --git a/camel-core/src/main/docs/eips/loop-eip.adoc b/camel-core/src/main/docs/eips/loop-eip.adoc index 7b9b423..9c604f0 100644 --- a/camel-core/src/main/docs/eips/loop-eip.adoc +++ b/camel-core/src/main/docs/eips/loop-eip.adoc @@ -13,11 +13,11 @@ Notice by default the loop uses the same exchange throughout the looping. So the The Loop EIP supports 2 options which are listed below: -[width="100%",cols="3,1m,6",options="header"] +[width="100%",cols="2,5,^1,2",options="header"] |=== -| Name | Java Type | Description -| copy | Boolean | 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. -| doWhile | Boolean | Enables the while loop that loops until the predicate evaluates to false or null. +| 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 |=== // eip options: END http://git-wip-us.apache.org/repos/asf/camel/blob/d486902f/camel-core/src/main/docs/eips/recipientList-eip.adoc ---------------------------------------------------------------------- diff --git a/camel-core/src/main/docs/eips/recipientList-eip.adoc b/camel-core/src/main/docs/eips/recipientList-eip.adoc index 49b9aec..01b7656 100644 --- a/camel-core/src/main/docs/eips/recipientList-eip.adoc +++ b/camel-core/src/main/docs/eips/recipientList-eip.adoc @@ -11,24 +11,24 @@ The recipients will receive a copy of the *same* Exchange, and Camel will execut The Recipient List EIP supports 15 options which are listed below: -[width="100%",cols="3,1m,6",options="header"] +[width="100%",cols="2,5,^1,2",options="header"] |=== -| Name | Java Type | Description -| delimiter | String | Delimiter used if the Expression returned multiple endpoints. Can be turned off using the value false. The default value is -| parallelProcessing | Boolean | 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. -| strategyRef | String | 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 -| strategyMethodName | String | This option can be used to explicit declare the method name to use when using POJOs as the AggregationStrategy. -| strategyMethodAllowNull | Boolean | 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 -| executorServiceRef | String | 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. -| stopOnException | Boolean | 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 default behavior is to not stop but continue processing till the end -| ignoreInvalidEndpoints | Boolean | Ignore the invalidate endpoint exception when try to create a producer with that endpoint -| streaming | Boolean | 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. -| timeout | Long | 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 shut down in a graceful manner may continue to run. So use this option with a bit of care. -| onPrepareRef | String | 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. -| shareUnitOfWork | Boolean | 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. -| cacheSize | Integer | Sets the maximum size used by the org.apache.camel.impl.ProducerCache which is used to cache and reuse producers when using this recipient list when uris are reused. -| parallelAggregate | Boolean | 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. -| stopOnAggregateException | Boolean | 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. +| 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 +| *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 +| *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 default behavior is to not stop but continue processing till the end | false | Boolean +| *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 shut down in a graceful manner may continue to run. So use this option with a bit of care. | 0 | Long +| *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.impl.ProducerCache which is used to cache and reuse producers when using this recipient list when uris are reused. | | Integer +| *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 |=== // eip options: END http://git-wip-us.apache.org/repos/asf/camel/blob/d486902f/camel-core/src/main/docs/eips/resequence-eip.adoc ---------------------------------------------------------------------- diff --git a/camel-core/src/main/docs/eips/resequence-eip.adoc b/camel-core/src/main/docs/eips/resequence-eip.adoc index ddde1e9..ea4600c 100644 --- a/camel-core/src/main/docs/eips/resequence-eip.adoc +++ b/camel-core/src/main/docs/eips/resequence-eip.adoc @@ -10,10 +10,10 @@ image:http://www.enterpriseintegrationpatterns.com/img/Resequencer.gif[image] The Resequence EIP supports 1 options which are listed below: -[width="100%",cols="3,1m,6",options="header"] +[width="100%",cols="2,5,^1,2",options="header"] |=== -| Name | Java Type | Description -| resequencerConfig | ResequencerConfig | To configure the resequencer in using either batch or stream configuration. Will by default use batch configuration. +| Name | Description | Default | Type +| *resequencerConfig* | To configure the resequencer in using either batch or stream configuration. Will by default use batch configuration. | | ResequencerConfig |=== // eip options: END http://git-wip-us.apache.org/repos/asf/camel/blob/d486902f/camel-core/src/main/docs/eips/routingSlip-eip.adoc ---------------------------------------------------------------------- diff --git a/camel-core/src/main/docs/eips/routingSlip-eip.adoc b/camel-core/src/main/docs/eips/routingSlip-eip.adoc index db07ffa..b40850e 100644 --- a/camel-core/src/main/docs/eips/routingSlip-eip.adoc +++ b/camel-core/src/main/docs/eips/routingSlip-eip.adoc @@ -10,12 +10,12 @@ image:http://www.enterpriseintegrationpatterns.com/img/RoutingTableSimple.gif[im The Routing Slip EIP supports 3 options which are listed below: -[width="100%",cols="3,1m,6",options="header"] +[width="100%",cols="2,5,^1,2",options="header"] |=== -| Name | Java Type | Description -| uriDelimiter | String | Sets the uri delimiter to use -| ignoreInvalidEndpoints | Boolean | Ignore the invalidate endpoint exception when try to create a producer with that endpoint -| cacheSize | Integer | Sets the maximum size used by the org.apache.camel.impl.ProducerCache which is used to cache and reuse producers when using this recipient list when uris are reused. +| 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.impl.ProducerCache which is used to cache and reuse producers when using this recipient list when uris are reused. | | Integer |=== // eip options: END http://git-wip-us.apache.org/repos/asf/camel/blob/d486902f/camel-core/src/main/docs/eips/sample-eip.adoc ---------------------------------------------------------------------- diff --git a/camel-core/src/main/docs/eips/sample-eip.adoc b/camel-core/src/main/docs/eips/sample-eip.adoc index c01ce88..c5b6afc 100644 --- a/camel-core/src/main/docs/eips/sample-eip.adoc +++ b/camel-core/src/main/docs/eips/sample-eip.adoc @@ -10,12 +10,12 @@ Will by default use a sample period of 1 seconds. The Sample EIP supports 3 options which are listed below: -[width="100%",cols="3,1m,6",options="header"] +[width="100%",cols="2,5,^1,2",options="header"] |=== -| Name | Java Type | Description -| samplePeriod | Long | Sets the sample period during which only a single Exchange will pass through. -| messageFrequency | Long | Sets the sample message count which only a single Exchange will pass through after this many received. -| units | TimeUnit | Sets the time units for the sample period defaulting to seconds. +| Name | Description | Default | Type +| *samplePeriod* | Sets the sample period during which only a single Exchange will pass through. | 1 | Long +| *messageFrequency* | Sets the sample message count which only a single Exchange will pass through after this many received. | | Long +| *units* | Sets the time units for the sample period defaulting to seconds. | SECONDS | TimeUnit |=== // eip options: END http://git-wip-us.apache.org/repos/asf/camel/blob/d486902f/camel-core/src/main/docs/eips/serviceCall-eip.adoc ---------------------------------------------------------------------- diff --git a/camel-core/src/main/docs/eips/serviceCall-eip.adoc b/camel-core/src/main/docs/eips/serviceCall-eip.adoc index df447e3..3f31d91 100644 --- a/camel-core/src/main/docs/eips/serviceCall-eip.adoc +++ b/camel-core/src/main/docs/eips/serviceCall-eip.adoc @@ -94,23 +94,23 @@ from("direct:start") The Service Call EIP supports 14 options which are listed below: -[width="100%",cols="3,1m,6",options="header"] +[width="100%",cols="2,5,^1,2",options="header"] |=== -| Name | Java Type | Description -| name | String | *Required* Sets the name of the service to use -| uri | String | The uri of the endpoint to send to. The uri can be dynamic computed using the org.apache.camel.language.simple.SimpleLanguage expression. -| component | String | The component to use. -| pattern | ExchangePattern | Sets the optional ExchangePattern used to invoke this endpoint -| configurationRef | String | Refers to a ServiceCall configuration to use -| serviceDiscoveryRef | String | Sets a reference to a custom ServiceDiscovery to use. -| serviceFilterRef | String | Sets a reference to a custom ServiceFilter to use. -| serviceChooserRef | String | Sets a reference to a custom ServiceChooser to use. -| loadBalancerRef | String | Sets a reference to a custom ServiceLoadBalancer to use. -| expressionRef | String | Set a reference to a custom Expression to use. -| serviceDiscoveryConfiguration | ServiceCallServiceDiscoveryConfiguration | *Required* Configures the ServiceDiscovery using the given configuration. -| serviceFilterConfiguration | ServiceCallServiceFilterConfiguration | *Required* Configures the ServiceFilter using the given configuration. -| loadBalancerConfiguration | ServiceCallServiceLoadBalancerConfiguration | *Required* Configures the LoadBalancer using the given configuration. -| expressionConfiguration | ServiceCallExpressionConfiguration | *Required* Configures the Expression using the given configuration. +| Name | Description | Default | Type +| *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. | http4 | String +| *pattern* | 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 |=== // eip options: END http://git-wip-us.apache.org/repos/asf/camel/blob/d486902f/camel-core/src/main/docs/eips/sort-eip.adoc ---------------------------------------------------------------------- diff --git a/camel-core/src/main/docs/eips/sort-eip.adoc b/camel-core/src/main/docs/eips/sort-eip.adoc index d697cbf..01ebde0 100644 --- a/camel-core/src/main/docs/eips/sort-eip.adoc +++ b/camel-core/src/main/docs/eips/sort-eip.adoc @@ -9,10 +9,10 @@ Sort will by default sort the body using a default comparator that handles numer The Sort EIP supports 1 options which are listed below: -[width="100%",cols="3,1m,6",options="header"] +[width="100%",cols="2,5,^1,2",options="header"] |=== -| Name | Java Type | Description -| comparatorRef | String | Sets a reference to lookup for the comparator to use for sorting +| Name | Description | Default | Type +| *comparatorRef* | Sets a reference to lookup for the comparator to use for sorting | | String |=== // eip options: END http://git-wip-us.apache.org/repos/asf/camel/blob/d486902f/camel-core/src/main/docs/eips/split-eip.adoc ---------------------------------------------------------------------- diff --git a/camel-core/src/main/docs/eips/split-eip.adoc b/camel-core/src/main/docs/eips/split-eip.adoc index c2c72a0..d2f5b62 100644 --- a/camel-core/src/main/docs/eips/split-eip.adoc +++ b/camel-core/src/main/docs/eips/split-eip.adoc @@ -10,21 +10,21 @@ You need to specify a Splitter as `split()`. In earlier versions of Camel, you n The Split EIP supports 12 options which are listed below: -[width="100%",cols="3,1m,6",options="header"] +[width="100%",cols="2,5,^1,2",options="header"] |=== -| Name | Java Type | Description -| parallelProcessing | Boolean | If enabled then processing each splitted messages occurs concurrently. Note the caller thread will still wait until all messages has been fully processed before it continues. Its only processing the sub messages from the splitter which happens concurrently. -| strategyRef | String | Sets a reference to the AggregationStrategy to be used to assemble the replies from the splitted messages into a single outgoing message from the Splitter. By default Camel will use the original incoming message to the splitter (leave it unchanged). You can also use a POJO as the AggregationStrategy -| strategyMethodName | String | This option can be used to explicit declare the method name to use when using POJOs as the AggregationStrategy. -| strategyMethodAllowNull | Boolean | 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 -| executorServiceRef | String | 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. -| streaming | Boolean | When in streaming mode then the splitter splits the original message on-demand and each splitted message is processed one by one. This reduces memory usage as the splitter do not split all the messages first but then we do not know the total size and therefore the link org.apache.camel.ExchangeSPLIT_SIZE is empty. In non-streaming mode (default) the splitter will split each message first to know the total size and then process each message one by one. This requires to keep all the splitted messages in memory and therefore requires more memory. The total size is provided in the link org.apache.camel.ExchangeSPLIT_SIZE header. The streaming mode also affects the aggregation behavior. 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 the messages was splitted. -| stopOnException | Boolean | 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 splitter will stop further processing. This is the same behavior as in pipeline which is used by the routing engine. The default behavior is to not stop but continue processing till the end -| timeout | Long | Sets a total timeout specified in millis when using parallel processing. If the Splitter hasn't been able to split and process all the sub messages within the given timeframe then the timeout triggers and the Splitter 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 a graceful manner may continue to run. So use this option with a bit of care. -| onPrepareRef | String | 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. -| shareUnitOfWork | Boolean | Shares the org.apache.camel.spi.UnitOfWork with the parent and each of the sub messages. Splitter will by default not share unit of work between the parent exchange and each splitted exchange. This means each splitted exchange has its own individual unit of work. -| parallelAggregate | Boolean | 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. -| stopOnAggregateException | Boolean | 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. +| Name | Description | Default | Type +| *parallelProcessing* | If enabled then processing each splitted messages occurs concurrently. Note the caller thread will still wait until all messages has been fully processed before it continues. Its only processing the sub messages from the splitter which happens concurrently. | false | Boolean +| *strategyRef* | Sets a reference to the AggregationStrategy to be used to assemble the replies from the splitted messages into a single outgoing message from the Splitter. By default Camel will use the original incoming message to the splitter (leave it unchanged). 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 +| *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* | When in streaming mode then the splitter splits the original message on-demand and each splitted message is processed one by one. This reduces memory usage as the splitter do not split all the messages first but then we do not know the total size and therefore the link org.apache.camel.ExchangeSPLIT_SIZE is empty. In non-streaming mode (default) the splitter will split each message first to know the total size and then process each message one by one. This requires to keep all the splitted messages in memory and therefore requires more memory. The total size is provided in the link org.apache.camel.ExchangeSPLIT_SIZE header. The streaming mode also affects the aggregation behavior. 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 the messages was splitted. | 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 splitter will stop further processing. This is the same behavior as in pipeline which is used by the routing engine. The default behavior is to not stop but continue processing till the end | false | Boolean +| *timeout* | Sets a total timeout specified in millis when using parallel processing. If the Splitter hasn't been able to split and process all the sub messages within the given timeframe then the timeout triggers and the Splitter 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 a graceful manner may continue to run. So use this option with a bit of care. | 0 | Long +| *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. Splitter will by default not share unit of work between the parent exchange and each splitted exchange. This means each splitted 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 |=== // eip options: END http://git-wip-us.apache.org/repos/asf/camel/blob/d486902f/camel-core/src/main/docs/eips/throttle-eip.adoc ---------------------------------------------------------------------- diff --git a/camel-core/src/main/docs/eips/throttle-eip.adoc b/camel-core/src/main/docs/eips/throttle-eip.adoc index 7ec0b3b..7e026ca 100644 --- a/camel-core/src/main/docs/eips/throttle-eip.adoc +++ b/camel-core/src/main/docs/eips/throttle-eip.adoc @@ -7,14 +7,14 @@ The Throttler Pattern allows you to ensure that a specific endpoint does not get The Throttle EIP supports 5 options which are listed below: -[width="100%",cols="3,1m,6",options="header"] +[width="100%",cols="2,5,^1,2",options="header"] |=== -| Name | Java Type | Description -| executorServiceRef | String | To use a custom thread pool (ScheduledExecutorService) by the throttler. -| timePeriodMillis | Long | Sets the time period during which the maximum request count is valid for -| asyncDelayed | Boolean | Enables asynchronous delay which means the thread will not block while delaying. -| callerRunsWhenRejected | Boolean | Whether or not the caller should run the task when it was rejected by the thread pool. Is by default true -| rejectExecution | Boolean | Whether or not throttler throws the ThrottlerRejectedExecutionException when the exchange exceeds the request limit Is by default false +| Name | Description | Default | Type +| *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 +| *callerRunsWhenRejected* | Whether or not the caller should run the task when it was rejected by the thread pool. Is by default true | true | Boolean +| *rejectExecution* | Whether or not throttler throws the ThrottlerRejectedExecutionException when the exchange exceeds the request limit Is by default false | false | Boolean |=== // eip options: END http://git-wip-us.apache.org/repos/asf/camel/blob/d486902f/tooling/maven/camel-package-maven-plugin/src/main/java/org/apache/camel/maven/packaging/UpdateReadmeMojo.java ---------------------------------------------------------------------- diff --git a/tooling/maven/camel-package-maven-plugin/src/main/java/org/apache/camel/maven/packaging/UpdateReadmeMojo.java b/tooling/maven/camel-package-maven-plugin/src/main/java/org/apache/camel/maven/packaging/UpdateReadmeMojo.java index a5fb2ce..7c9d48f 100644 --- a/tooling/maven/camel-package-maven-plugin/src/main/java/org/apache/camel/maven/packaging/UpdateReadmeMojo.java +++ b/tooling/maven/camel-package-maven-plugin/src/main/java/org/apache/camel/maven/packaging/UpdateReadmeMojo.java @@ -1020,6 +1020,7 @@ public class UpdateReadmeMojo extends AbstractMojo { option.setRequired(getSafeValue("required", row)); option.setDeprecated("true".equals(getSafeValue("deprecated", row))); option.setDeprecationNote(getSafeValue("deprecationNote", row)); + option.setDefaultValue(getSafeValue("defaultValue", row)); option.setDescription(getSafeValue("description", row)); option.setInput("true".equals(getSafeValue("input", row))); option.setOutput("true".equals(getSafeValue("output", row))); http://git-wip-us.apache.org/repos/asf/camel/blob/d486902f/tooling/maven/camel-package-maven-plugin/src/main/java/org/apache/camel/maven/packaging/model/EipOptionModel.java ---------------------------------------------------------------------- diff --git a/tooling/maven/camel-package-maven-plugin/src/main/java/org/apache/camel/maven/packaging/model/EipOptionModel.java b/tooling/maven/camel-package-maven-plugin/src/main/java/org/apache/camel/maven/packaging/model/EipOptionModel.java index 2e4223d..1a63750 100644 --- a/tooling/maven/camel-package-maven-plugin/src/main/java/org/apache/camel/maven/packaging/model/EipOptionModel.java +++ b/tooling/maven/camel-package-maven-plugin/src/main/java/org/apache/camel/maven/packaging/model/EipOptionModel.java @@ -16,6 +16,8 @@ */ package org.apache.camel.maven.packaging.model; +import static org.apache.camel.maven.packaging.StringHelper.wrapCamelCaseWords; + public class EipOptionModel { private String name; @@ -25,6 +27,7 @@ public class EipOptionModel { private String javaType; private String type; private String label; + private String defaultValue; private String description; private boolean deprecated; private String deprecationNote; @@ -87,6 +90,14 @@ public class EipOptionModel { this.label = label; } + public String getDefaultValue() { + return defaultValue; + } + + public void setDefaultValue(String defaultValue) { + this.defaultValue = defaultValue; + } + public String getDescription() { return description; } @@ -136,6 +147,11 @@ public class EipOptionModel { } public String getShortJavaType() { + // TODO: use watermark in the others + return getShortJavaType(40); + } + + public String getShortJavaType(int watermark) { if (javaType.startsWith("java.util.Map")) { return "Map"; } else if (javaType.startsWith("java.util.Set")) { @@ -143,12 +159,45 @@ public class EipOptionModel { } else if (javaType.startsWith("java.util.List")) { return "List"; } - int pos = javaType.lastIndexOf("."); + + String text = javaType; + + int pos = text.lastIndexOf("."); if (pos != -1) { - return javaType.substring(pos + 1); - } else { - return javaType; + text = text.substring(pos + 1); + } + + // if its some kind of java object then lets wrap it as its long + if ("object".equals(type)) { + text = wrapCamelCaseWords(text, watermark, " "); } + return text; } + + public String getShortDefaultValue(int watermark) { + if (defaultValue.isEmpty()) { + return ""; + } + String text = defaultValue; + if (text.endsWith("<T>")) { + text = text.substring(0, text.length() - 3); + } else if (text.endsWith("<T>>")) { + text = text.substring(0, text.length() - 4); + } + + // TODO: dirty hack for AUTO_ACKNOWLEDGE which we should wrap + if ("AUTO_ACKNOWLEDGE".equals(text)) { + return "AUTO_ ACKNOWLEDGE"; + } + + return text; + } + + public String getShortName(int watermark) { + String text = wrapCamelCaseWords(name, watermark, " "); + // ensure the option name starts with lower-case + return Character.toLowerCase(text.charAt(0)) + text.substring(1); + } + }
