This is an automated email from the ASF dual-hosted git repository.
acosentino pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git
commit 84773805a40cc0c5f9e7be65d9f3bb232f5a4ba0
Author: Andrea Cosentino <anco...@gmail.com>
AuthorDate: Wed Aug 7 15:09:37 2019 +0200
Super Regen!
---
.../src/main/docs/activemq-component.adoc | 2 +-
.../camel-amqp/src/main/docs/amqp-component.adoc | 8 +--
.../camel-jms/src/main/docs/jms-component.adoc | 6 +--
.../src/main/docs/salesforce-component.adoc | 4 +-
.../endpoint/dsl/AMQPEndpointBuilderFactory.java | 60 +++++++++++++++++++---
.../modules/ROOT/pages/activemq-component.adoc | 8 +--
.../modules/ROOT/pages/amqp-component.adoc | 8 +--
.../modules/ROOT/pages/jms-component.adoc | 12 ++---
.../modules/ROOT/pages/rest-component.adoc | 1 -
.../modules/ROOT/pages/salesforce-component.adoc | 8 ++-
.../springboot/AMQPComponentConfiguration.java | 5 +-
11 files changed, 89 insertions(+), 33 deletions(-)
diff --git a/components/camel-activemq/src/main/docs/activemq-component.adoc
b/components/camel-activemq/src/main/docs/activemq-component.adoc
index f357782..9fd81ea 100644
--- a/components/camel-activemq/src/main/docs/activemq-component.adoc
+++ b/components/camel-activemq/src/main/docs/activemq-component.adoc
@@ -363,7 +363,7 @@ The component supports 86 options, which are listed below.
| *camel.component.activemq.transaction-manager* | The Spring transaction
manager to use. The option is a
org.springframework.transaction.PlatformTransactionManager type. | | String
| *camel.component.activemq.transaction-name* | The name of the transaction to
use. | | String
| *camel.component.activemq.transaction-timeout* | The timeout value of the
transaction (in seconds), if using transacted mode. | -1 | Integer
-| *camel.component.activemq.transfer-exception* | If enabled and you are using
Request Reply messaging (InOut) and an Exchange failed on the consumer side,
then the caused Exception will be send back in response as a
javax.jms.ObjectMessage. If the client is Camel, the returned Exception is
rethrown. This allows you to use Camel JMS as a bridge in your routing - for
example, using persistent queues to enable robust routing. Notice that if you
also have transferExchange enabled, this opti [...]
+| *camel.component.activemq.transfer-exception* | If enabled and you are using
Request Reply messaging (InOut) and an Exchange failed on the consumer side,
then the caused Exception will be send back in response as a
javax.jms.ObjectMessage. If the client is Camel, the returned Exception is
rethrown. This allows you to use Camel JMS as a bridge in your routing - for
example, using persistent queues to enable robust routing. Notice that if you
also have transferExchange enabled, this opti [...]
| *camel.component.activemq.transfer-exchange* | You can transfer the exchange
over the wire instead of just the body and headers. The following fields are
transferred: In body, Out body, Fault body, In headers, Out headers, Fault
headers, exchange properties, exchange exception. This requires that the
objects are serializable. Camel will exclude any non-serializable objects and
log it at WARN level. You must enable this option on both the producer and
consumer side, so Camel knows the p [...]
| *camel.component.activemq.trust-all-packages* | Define if all packages are
trusted or not | false | Boolean
| *camel.component.activemq.use-message-i-d-as-correlation-i-d* | Specifies
whether JMSMessageID should always be used as JMSCorrelationID for InOut
messages. | false | Boolean
diff --git a/components/camel-amqp/src/main/docs/amqp-component.adoc
b/components/camel-amqp/src/main/docs/amqp-component.adoc
index 9abe610..f0c6f43 100644
--- a/components/camel-amqp/src/main/docs/amqp-component.adoc
+++ b/components/camel-amqp/src/main/docs/amqp-component.adoc
@@ -98,7 +98,7 @@ The AMQP component supports 80 options, which are listed
below.
| *requestTimeout* (producer) | The timeout for waiting for a reply when using
the InOut Exchange Pattern (in milliseconds). The default is 20 seconds. You
can include the header CamelJmsRequestTimeout to override this endpoint
configured timeout value, and thus have per message individual timeout values.
See also the requestTimeoutCheckerInterval option. | 20000 | long
| *requestTimeoutChecker Interval* (advanced) | Configures how often Camel
should check for timed out Exchanges when doing request/reply over JMS. By
default Camel checks once per second. But if you must react faster when a
timeout occurs, then you can lower this interval, to check more frequently. The
timeout is determined by the option requestTimeout. | 1000 | long
| *transferExchange* (advanced) | You can transfer the exchange over the wire
instead of just the body and headers. The following fields are transferred: In
body, Out body, Fault body, In headers, Out headers, Fault headers, exchange
properties, exchange exception. This requires that the objects are
serializable. Camel will exclude any non-serializable objects and log it at
WARN level. You must enable this option on both the producer and consumer side,
so Camel knows the payloads is an E [...]
-| *transferException* (advanced) | If enabled and you are using Request Reply
messaging (InOut) and an Exchange failed on the consumer side, then the caused
Exception will be send back in response as a javax.jms.ObjectMessage. If the
client is Camel, the returned Exception is rethrown. This allows you to use
Camel JMS as a bridge in your routing - for example, using persistent queues to
enable robust routing. Notice that if you also have transferExchange enabled,
this option takes preced [...]
+| *transferException* (advanced) | If enabled and you are using Request Reply
messaging (InOut) and an Exchange failed on the consumer side, then the caused
Exception will be send back in response as a javax.jms.ObjectMessage. If the
client is Camel, the returned Exception is rethrown. This allows you to use
Camel JMS as a bridge in your routing - for example, using persistent queues to
enable robust routing. Notice that if you also have transferExchange enabled,
this option takes preced [...]
| *jmsOperations* (advanced) | Allows you to use your own implementation of
the org.springframework.jms.core.JmsOperations interface. Camel uses
JmsTemplate as default. Can be used for testing purpose, but not used much as
stated in the spring API docs. | | JmsOperations
| *destinationResolver* (advanced) | A pluggable
org.springframework.jms.support.destination.DestinationResolver that allows you
to use your own resolver (for example, to lookup the real destination in a JNDI
registry). | | DestinationResolver
| *replyToType* (producer) | Allows for explicitly specifying which kind of
strategy to use for replyTo queues when doing request/reply over JMS. Possible
values are: Temporary, Shared, or Exclusive. By default Camel will use
temporary queues. However if replyTo has been configured, then Shared is used
by default. This option allows you to use exclusive queues instead of shared
ones. See Camel JMS documentation for more details, and especially the notes
about the implications if running [...]
@@ -236,8 +236,8 @@ with the following path and query parameters:
| *recoveryInterval* (advanced) | Specifies the interval between recovery
attempts, i.e. when a connection is being refreshed, in milliseconds. The
default is 5000 ms, that is, 5 seconds. | 5000 | long
| *requestTimeoutChecker Interval* (advanced) | Configures how often Camel
should check for timed out Exchanges when doing request/reply over JMS. By
default Camel checks once per second. But if you must react faster when a
timeout occurs, then you can lower this interval, to check more frequently. The
timeout is determined by the option requestTimeout. | 1000 | long
| *synchronous* (advanced) | Sets whether synchronous processing should be
strictly used, or Camel is allowed to use asynchronous processing (if
supported). | false | boolean
-| *transferException* (advanced) | If enabled and you are using Request Reply
messaging (InOut) and an Exchange failed on the consumer side, then the caused
Exception will be send back in response as a javax.jms.ObjectMessage. If the
client is Camel, the returned Exception is rethrown. This allows you to use
Camel JMS as a bridge in your routing - for example, using persistent queues to
enable robust routing. Notice that if you also have transferExchange enabled,
this option takes preced [...]
-| *transferExchange* (advanced) | You can transfer the exchange over the wire
instead of just the body and headers. The following fields are transferred: In
body, Out body, Fault body, In headers, Out headers, Fault headers, exchange
properties, exchange exception. This requires that the objects are
serializable. Camel will exclude any non-serializable objects and log it at
WARN level. You must enable this option on both the producer and consumer side,
so Camel knows the payloads is an E [...]
+| *transferException* (advanced) | If enabled and you are using Request Reply
messaging (InOut) and an Exchange failed on the consumer side, then the caused
Exception will be send back in response as a javax.jms.ObjectMessage. If the
client is Camel, the returned Exception is rethrown. This allows you to use
Camel JMS as a bridge in your routing - for example, using persistent queues to
enable robust routing. Notice that if you also have transferExchange enabled,
this option takes preced [...]
+| *transferExchange* (advanced) | You can transfer the exchange over the wire
instead of just the body and headers. The following fields are transferred: In
body, Out body, Fault body, In headers, Out headers, Fault headers, exchange
properties, exchange exception. This requires that the objects are
serializable. Camel will exclude any non-serializable objects and log it at
WARN level. You must enable this option on both the producer and consumer side,
so Camel knows the payloads is an E [...]
| *useMessageIDAsCorrelation ID* (advanced) | Specifies whether JMSMessageID
should always be used as JMSCorrelationID for InOut messages. | false | boolean
| *waitForProvisionCorrelation ToBeUpdatedCounter* (advanced) | Number of
times to wait for provisional correlation id to be updated to the actual
correlation id when doing request/reply over JMS and when the option
useMessageIDAsCorrelationID is enabled. | 50 | int
| *waitForProvisionCorrelation ToBeUpdatedThreadSleeping Time* (advanced) |
Interval in millis to sleep each time while waiting for provisional correlation
id to be updated. | 100 | long
@@ -350,7 +350,7 @@ The component supports 81 options, which are listed below.
| *camel.component.amqp.transaction-manager* | The Spring transaction manager
to use. The option is a
org.springframework.transaction.PlatformTransactionManager type. | | String
| *camel.component.amqp.transaction-name* | The name of the transaction to
use. | | String
| *camel.component.amqp.transaction-timeout* | The timeout value of the
transaction (in seconds), if using transacted mode. | -1 | Integer
-| *camel.component.amqp.transfer-exception* | If enabled and you are using
Request Reply messaging (InOut) and an Exchange failed on the consumer side,
then the caused Exception will be send back in response as a
javax.jms.ObjectMessage. If the client is Camel, the returned Exception is
rethrown. This allows you to use Camel JMS as a bridge in your routing - for
example, using persistent queues to enable robust routing. Notice that if you
also have transferExchange enabled, this option t [...]
+| *camel.component.amqp.transfer-exception* | If enabled and you are using
Request Reply messaging (InOut) and an Exchange failed on the consumer side,
then the caused Exception will be send back in response as a
javax.jms.ObjectMessage. If the client is Camel, the returned Exception is
rethrown. This allows you to use Camel JMS as a bridge in your routing - for
example, using persistent queues to enable robust routing. Notice that if you
also have transferExchange enabled, this option t [...]
| *camel.component.amqp.transfer-exchange* | You can transfer the exchange
over the wire instead of just the body and headers. The following fields are
transferred: In body, Out body, Fault body, In headers, Out headers, Fault
headers, exchange properties, exchange exception. This requires that the
objects are serializable. Camel will exclude any non-serializable objects and
log it at WARN level. You must enable this option on both the producer and
consumer side, so Camel knows the paylo [...]
| *camel.component.amqp.use-message-i-d-as-correlation-i-d* | Specifies
whether JMSMessageID should always be used as JMSCorrelationID for InOut
messages. | false | Boolean
| *camel.component.amqp.username* | Username to use with the
ConnectionFactory. You can also configure username/password directly on the
ConnectionFactory. | | String
diff --git a/components/camel-jms/src/main/docs/jms-component.adoc
b/components/camel-jms/src/main/docs/jms-component.adoc
index 0bdd271..4a9a7b6 100644
--- a/components/camel-jms/src/main/docs/jms-component.adoc
+++ b/components/camel-jms/src/main/docs/jms-component.adoc
@@ -541,8 +541,8 @@ The component supports 169 options, which are listed below.
| *camel.component.jms.configuration.transaction-manager* | The Spring
transaction manager to use. | | PlatformTransaction Manager
| *camel.component.jms.configuration.transaction-name* | The name of the
transaction to use. | | String
| *camel.component.jms.configuration.transaction-timeout* | The timeout value
of the transaction (in seconds), if using transacted mode. | -1 | Integer
-| *camel.component.jms.configuration.transfer-exception* | If enabled and you
are using Request Reply messaging (InOut) and an Exchange failed on the
consumer side, then the caused Exception will be send back in response as a
javax.jms.ObjectMessage. If the client is Camel, the returned Exception is
rethrown. This allows you to use Camel JMS as a bridge in your routing - for
example, using persistent queues to enable robust routing. Notice that if you
also have transferExchange enabled, [...]
-| *camel.component.jms.configuration.transfer-exchange* | You can transfer the
exchange over the wire instead of just the body and headers. The following
fields are transferred: In body, Out body, Fault body, In headers, Out headers,
Fault headers, exchange properties, exchange exception. This requires that the
objects are serializable. Camel will exclude any non-serializable objects and
log it at WARN level. You must enable this option on both the producer and
consumer side, so Camel kn [...]
+| *camel.component.jms.configuration.transfer-exception* | If enabled and you
are using Request Reply messaging (InOut) and an Exchange failed on the
consumer side, then the caused Exception will be send back in response as a
javax.jms.ObjectMessage. If the client is Camel, the returned Exception is
rethrown. This allows you to use Camel JMS as a bridge in your routing - for
example, using persistent queues to enable robust routing. Notice that if you
also have transferExchange enabled, [...]
+| *camel.component.jms.configuration.transfer-exchange* | You can transfer the
exchange over the wire instead of just the body and headers. The following
fields are transferred: In body, Out body, Fault body, In headers, Out headers,
Fault headers, exchange properties, exchange exception. This requires that the
objects are serializable. Camel will exclude any non-serializable objects and
log it at WARN level. You must enable this option on both the producer and
consumer side, so Camel kn [...]
| *camel.component.jms.configuration.use-message-i-d-as-correlation-i-d* |
Specifies whether JMSMessageID should always be used as JMSCorrelationID for
InOut messages. | false | Boolean
| *camel.component.jms.configuration.username* | Username to use with the
ConnectionFactory. You can also configure username/password directly on the
ConnectionFactory. | | String
|
*camel.component.jms.configuration.wait-for-provision-correlation-to-be-updated-counter*
| Number of times to wait for provisional correlation id to be updated to the
actual correlation id when doing request/reply over JMS and when the option
useMessageIDAsCorrelationID is enabled. | 50 | Integer
@@ -605,7 +605,7 @@ The component supports 169 options, which are listed below.
| *camel.component.jms.transaction-manager* | The Spring transaction manager
to use. The option is a
org.springframework.transaction.PlatformTransactionManager type. | | String
| *camel.component.jms.transaction-name* | The name of the transaction to use.
| | String
| *camel.component.jms.transaction-timeout* | The timeout value of the
transaction (in seconds), if using transacted mode. | -1 | Integer
-| *camel.component.jms.transfer-exception* | If enabled and you are using
Request Reply messaging (InOut) and an Exchange failed on the consumer side,
then the caused Exception will be send back in response as a
javax.jms.ObjectMessage. If the client is Camel, the returned Exception is
rethrown. This allows you to use Camel JMS as a bridge in your routing - for
example, using persistent queues to enable robust routing. Notice that if you
also have transferExchange enabled, this option ta [...]
+| *camel.component.jms.transfer-exception* | If enabled and you are using
Request Reply messaging (InOut) and an Exchange failed on the consumer side,
then the caused Exception will be send back in response as a
javax.jms.ObjectMessage. If the client is Camel, the returned Exception is
rethrown. This allows you to use Camel JMS as a bridge in your routing - for
example, using persistent queues to enable robust routing. Notice that if you
also have transferExchange enabled, this option ta [...]
| *camel.component.jms.transfer-exchange* | You can transfer the exchange over
the wire instead of just the body and headers. The following fields are
transferred: In body, Out body, Fault body, In headers, Out headers, Fault
headers, exchange properties, exchange exception. This requires that the
objects are serializable. Camel will exclude any non-serializable objects and
log it at WARN level. You must enable this option on both the producer and
consumer side, so Camel knows the payloa [...]
| *camel.component.jms.use-message-i-d-as-correlation-i-d* | Specifies whether
JMSMessageID should always be used as JMSCorrelationID for InOut messages. |
false | Boolean
| *camel.component.jms.username* | Username to use with the ConnectionFactory.
You can also configure username/password directly on the ConnectionFactory. |
| String
diff --git
a/components/camel-salesforce/camel-salesforce-component/src/main/docs/salesforce-component.adoc
b/components/camel-salesforce/camel-salesforce-component/src/main/docs/salesforce-component.adoc
index 4091fc8..510c479 100644
---
a/components/camel-salesforce/camel-salesforce-component/src/main/docs/salesforce-component.adoc
+++
b/components/camel-salesforce/camel-salesforce-component/src/main/docs/salesforce-component.adoc
@@ -760,7 +760,7 @@ When using Spring Boot make sure to use the following Maven
dependency to have s
----
-The component supports 86 options, which are listed below.
+The component supports 88 options, which are listed below.
@@ -819,6 +819,8 @@ The component supports 86 options, which are listed below.
| *camel.component.salesforce.config.serialize-nulls* | Should the NULL values
of given DTO be serialized with empty (NULL) values. This affects only JSON
data format. | false | Boolean
| *camel.component.salesforce.config.update-topic* | Whether to update an
existing Push Topic when using the Streaming API, defaults to false | false |
Boolean
| *camel.component.salesforce.enabled* | Enable salesforce component | true |
Boolean
+| *camel.component.salesforce.http-client-connection-timeout* | Connection
timeout used by the HttpClient when connecting to the Salesforce server. |
60000 | Long
+| *camel.component.salesforce.http-client-idle-timeout* | Timeout used by the
HttpClient when waiting for response from the Salesforce server. | 10000 | Long
| *camel.component.salesforce.http-client-properties* | Used to set any
properties that can be configured on the underlying HTTP client. Have a look at
properties of SalesforceHttpClient and the Jetty HttpClient for all available
options. | | Map
| *camel.component.salesforce.http-proxy-auth-uri* | Used in authentication
against the HTTP proxy server, needs to match the URI of the proxy server in
order for the httpProxyUsername and httpProxyPassword to be used for
authentication. | | String
| *camel.component.salesforce.http-proxy-excluded-addresses* | A list of
addresses for which HTTP proxy server should not be used. | | Set
diff --git
a/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/AMQPEndpointBuilderFactory.java
b/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/AMQPEndpointBuilderFactory.java
index fd25f75..4700246 100644
---
a/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/AMQPEndpointBuilderFactory.java
+++
b/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/AMQPEndpointBuilderFactory.java
@@ -1758,6 +1758,10 @@ public interface AMQPEndpointBuilderFactory {
* exception is required to be serializable. The original Exception on
* the consumer side can be wrapped in an outer exception such as
* org.apache.camel.RuntimeCamelException when returned to the
producer.
+ * Use this with caution as the data is using Java Object serialization
+ * and requires the received to be able to deserialize the data at
Class
+ * level, which forces a strong coupling between the producers and
+ * consumer!.
*
* The option is a: <code>boolean</code> type.
*
@@ -1779,6 +1783,10 @@ public interface AMQPEndpointBuilderFactory {
* exception is required to be serializable. The original Exception on
* the consumer side can be wrapped in an outer exception such as
* org.apache.camel.RuntimeCamelException when returned to the
producer.
+ * Use this with caution as the data is using Java Object serialization
+ * and requires the received to be able to deserialize the data at
Class
+ * level, which forces a strong coupling between the producers and
+ * consumer!.
*
* The option will be converted to a <code>boolean</code> type.
*
@@ -1797,7 +1805,11 @@ public interface AMQPEndpointBuilderFactory {
* serializable. Camel will exclude any non-serializable objects and
log
* it at WARN level. You must enable this option on both the producer
* and consumer side, so Camel knows the payloads is an Exchange and
not
- * a regular payload.
+ * a regular payload. Use this with caution as the data is using Java
+ * Object serialization and requires the received to be able to
+ * deserialize the data at Class level, which forces a strong coupling
+ * between the producers and consumer having to use compatible Camel
+ * versions!.
*
* The option is a: <code>boolean</code> type.
*
@@ -1816,7 +1828,11 @@ public interface AMQPEndpointBuilderFactory {
* serializable. Camel will exclude any non-serializable objects and
log
* it at WARN level. You must enable this option on both the producer
* and consumer side, so Camel knows the payloads is an Exchange and
not
- * a regular payload.
+ * a regular payload. Use this with caution as the data is using Java
+ * Object serialization and requires the received to be able to
+ * deserialize the data at Class level, which forces a strong coupling
+ * between the producers and consumer having to use compatible Camel
+ * versions!.
*
* The option will be converted to a <code>boolean</code> type.
*
@@ -3646,6 +3662,10 @@ public interface AMQPEndpointBuilderFactory {
* exception is required to be serializable. The original Exception on
* the consumer side can be wrapped in an outer exception such as
* org.apache.camel.RuntimeCamelException when returned to the
producer.
+ * Use this with caution as the data is using Java Object serialization
+ * and requires the received to be able to deserialize the data at
Class
+ * level, which forces a strong coupling between the producers and
+ * consumer!.
*
* The option is a: <code>boolean</code> type.
*
@@ -3667,6 +3687,10 @@ public interface AMQPEndpointBuilderFactory {
* exception is required to be serializable. The original Exception on
* the consumer side can be wrapped in an outer exception such as
* org.apache.camel.RuntimeCamelException when returned to the
producer.
+ * Use this with caution as the data is using Java Object serialization
+ * and requires the received to be able to deserialize the data at
Class
+ * level, which forces a strong coupling between the producers and
+ * consumer!.
*
* The option will be converted to a <code>boolean</code> type.
*
@@ -3685,7 +3709,11 @@ public interface AMQPEndpointBuilderFactory {
* serializable. Camel will exclude any non-serializable objects and
log
* it at WARN level. You must enable this option on both the producer
* and consumer side, so Camel knows the payloads is an Exchange and
not
- * a regular payload.
+ * a regular payload. Use this with caution as the data is using Java
+ * Object serialization and requires the received to be able to
+ * deserialize the data at Class level, which forces a strong coupling
+ * between the producers and consumer having to use compatible Camel
+ * versions!.
*
* The option is a: <code>boolean</code> type.
*
@@ -3704,7 +3732,11 @@ public interface AMQPEndpointBuilderFactory {
* serializable. Camel will exclude any non-serializable objects and
log
* it at WARN level. You must enable this option on both the producer
* and consumer side, so Camel knows the payloads is an Exchange and
not
- * a regular payload.
+ * a regular payload. Use this with caution as the data is using Java
+ * Object serialization and requires the received to be able to
+ * deserialize the data at Class level, which forces a strong coupling
+ * between the producers and consumer having to use compatible Camel
+ * versions!.
*
* The option will be converted to a <code>boolean</code> type.
*
@@ -4844,6 +4876,10 @@ public interface AMQPEndpointBuilderFactory {
* exception is required to be serializable. The original Exception on
* the consumer side can be wrapped in an outer exception such as
* org.apache.camel.RuntimeCamelException when returned to the
producer.
+ * Use this with caution as the data is using Java Object serialization
+ * and requires the received to be able to deserialize the data at
Class
+ * level, which forces a strong coupling between the producers and
+ * consumer!.
*
* The option is a: <code>boolean</code> type.
*
@@ -4865,6 +4901,10 @@ public interface AMQPEndpointBuilderFactory {
* exception is required to be serializable. The original Exception on
* the consumer side can be wrapped in an outer exception such as
* org.apache.camel.RuntimeCamelException when returned to the
producer.
+ * Use this with caution as the data is using Java Object serialization
+ * and requires the received to be able to deserialize the data at
Class
+ * level, which forces a strong coupling between the producers and
+ * consumer!.
*
* The option will be converted to a <code>boolean</code> type.
*
@@ -4883,7 +4923,11 @@ public interface AMQPEndpointBuilderFactory {
* serializable. Camel will exclude any non-serializable objects and
log
* it at WARN level. You must enable this option on both the producer
* and consumer side, so Camel knows the payloads is an Exchange and
not
- * a regular payload.
+ * a regular payload. Use this with caution as the data is using Java
+ * Object serialization and requires the received to be able to
+ * deserialize the data at Class level, which forces a strong coupling
+ * between the producers and consumer having to use compatible Camel
+ * versions!.
*
* The option is a: <code>boolean</code> type.
*
@@ -4902,7 +4946,11 @@ public interface AMQPEndpointBuilderFactory {
* serializable. Camel will exclude any non-serializable objects and
log
* it at WARN level. You must enable this option on both the producer
* and consumer side, so Camel knows the payloads is an Exchange and
not
- * a regular payload.
+ * a regular payload. Use this with caution as the data is using Java
+ * Object serialization and requires the received to be able to
+ * deserialize the data at Class level, which forces a strong coupling
+ * between the producers and consumer having to use compatible Camel
+ * versions!.
*
* The option will be converted to a <code>boolean</code> type.
*
diff --git a/docs/components/modules/ROOT/pages/activemq-component.adoc
b/docs/components/modules/ROOT/pages/activemq-component.adoc
index ab5fc9a..9fd81ea 100644
--- a/docs/components/modules/ROOT/pages/activemq-component.adoc
+++ b/docs/components/modules/ROOT/pages/activemq-component.adoc
@@ -111,7 +111,7 @@ The ActiveMQ component supports 85 options, which are
listed below.
| *requestTimeout* (producer) | The timeout for waiting for a reply when using
the InOut Exchange Pattern (in milliseconds). The default is 20 seconds. You
can include the header CamelJmsRequestTimeout to override this endpoint
configured timeout value, and thus have per message individual timeout values.
See also the requestTimeoutCheckerInterval option. | 20000 | long
| *requestTimeoutChecker Interval* (advanced) | Configures how often Camel
should check for timed out Exchanges when doing request/reply over JMS. By
default Camel checks once per second. But if you must react faster when a
timeout occurs, then you can lower this interval, to check more frequently. The
timeout is determined by the option requestTimeout. | 1000 | long
| *transferExchange* (advanced) | You can transfer the exchange over the wire
instead of just the body and headers. The following fields are transferred: In
body, Out body, Fault body, In headers, Out headers, Fault headers, exchange
properties, exchange exception. This requires that the objects are
serializable. Camel will exclude any non-serializable objects and log it at
WARN level. You must enable this option on both the producer and consumer side,
so Camel knows the payloads is an E [...]
-| *transferException* (advanced) | If enabled and you are using Request Reply
messaging (InOut) and an Exchange failed on the consumer side, then the caused
Exception will be send back in response as a javax.jms.ObjectMessage. If the
client is Camel, the returned Exception is rethrown. This allows you to use
Camel JMS as a bridge in your routing - for example, using persistent queues to
enable robust routing. Notice that if you also have transferExchange enabled,
this option takes preced [...]
+| *transferException* (advanced) | If enabled and you are using Request Reply
messaging (InOut) and an Exchange failed on the consumer side, then the caused
Exception will be send back in response as a javax.jms.ObjectMessage. If the
client is Camel, the returned Exception is rethrown. This allows you to use
Camel JMS as a bridge in your routing - for example, using persistent queues to
enable robust routing. Notice that if you also have transferExchange enabled,
this option takes preced [...]
| *jmsOperations* (advanced) | Allows you to use your own implementation of
the org.springframework.jms.core.JmsOperations interface. Camel uses
JmsTemplate as default. Can be used for testing purpose, but not used much as
stated in the spring API docs. | | JmsOperations
| *destinationResolver* (advanced) | A pluggable
org.springframework.jms.support.destination.DestinationResolver that allows you
to use your own resolver (for example, to lookup the real destination in a JNDI
registry). | | DestinationResolver
| *replyToType* (producer) | Allows for explicitly specifying which kind of
strategy to use for replyTo queues when doing request/reply over JMS. Possible
values are: Temporary, Shared, or Exclusive. By default Camel will use
temporary queues. However if replyTo has been configured, then Shared is used
by default. This option allows you to use exclusive queues instead of shared
ones. See Camel JMS documentation for more details, and especially the notes
about the implications if running [...]
@@ -246,8 +246,8 @@ with the following path and query parameters:
| *recoveryInterval* (advanced) | Specifies the interval between recovery
attempts, i.e. when a connection is being refreshed, in milliseconds. The
default is 5000 ms, that is, 5 seconds. | 5000 | long
| *requestTimeoutChecker Interval* (advanced) | Configures how often Camel
should check for timed out Exchanges when doing request/reply over JMS. By
default Camel checks once per second. But if you must react faster when a
timeout occurs, then you can lower this interval, to check more frequently. The
timeout is determined by the option requestTimeout. | 1000 | long
| *synchronous* (advanced) | Sets whether synchronous processing should be
strictly used, or Camel is allowed to use asynchronous processing (if
supported). | false | boolean
-| *transferException* (advanced) | If enabled and you are using Request Reply
messaging (InOut) and an Exchange failed on the consumer side, then the caused
Exception will be send back in response as a javax.jms.ObjectMessage. If the
client is Camel, the returned Exception is rethrown. This allows you to use
Camel JMS as a bridge in your routing - for example, using persistent queues to
enable robust routing. Notice that if you also have transferExchange enabled,
this option takes preced [...]
-| *transferExchange* (advanced) | You can transfer the exchange over the wire
instead of just the body and headers. The following fields are transferred: In
body, Out body, Fault body, In headers, Out headers, Fault headers, exchange
properties, exchange exception. This requires that the objects are
serializable. Camel will exclude any non-serializable objects and log it at
WARN level. You must enable this option on both the producer and consumer side,
so Camel knows the payloads is an E [...]
+| *transferException* (advanced) | If enabled and you are using Request Reply
messaging (InOut) and an Exchange failed on the consumer side, then the caused
Exception will be send back in response as a javax.jms.ObjectMessage. If the
client is Camel, the returned Exception is rethrown. This allows you to use
Camel JMS as a bridge in your routing - for example, using persistent queues to
enable robust routing. Notice that if you also have transferExchange enabled,
this option takes preced [...]
+| *transferExchange* (advanced) | You can transfer the exchange over the wire
instead of just the body and headers. The following fields are transferred: In
body, Out body, Fault body, In headers, Out headers, Fault headers, exchange
properties, exchange exception. This requires that the objects are
serializable. Camel will exclude any non-serializable objects and log it at
WARN level. You must enable this option on both the producer and consumer side,
so Camel knows the payloads is an E [...]
| *useMessageIDAsCorrelation ID* (advanced) | Specifies whether JMSMessageID
should always be used as JMSCorrelationID for InOut messages. | false | boolean
| *waitForProvisionCorrelation ToBeUpdatedCounter* (advanced) | Number of
times to wait for provisional correlation id to be updated to the actual
correlation id when doing request/reply over JMS and when the option
useMessageIDAsCorrelationID is enabled. | 50 | int
| *waitForProvisionCorrelation ToBeUpdatedThreadSleeping Time* (advanced) |
Interval in millis to sleep each time while waiting for provisional correlation
id to be updated. | 100 | long
@@ -363,7 +363,7 @@ The component supports 86 options, which are listed below.
| *camel.component.activemq.transaction-manager* | The Spring transaction
manager to use. The option is a
org.springframework.transaction.PlatformTransactionManager type. | | String
| *camel.component.activemq.transaction-name* | The name of the transaction to
use. | | String
| *camel.component.activemq.transaction-timeout* | The timeout value of the
transaction (in seconds), if using transacted mode. | -1 | Integer
-| *camel.component.activemq.transfer-exception* | If enabled and you are using
Request Reply messaging (InOut) and an Exchange failed on the consumer side,
then the caused Exception will be send back in response as a
javax.jms.ObjectMessage. If the client is Camel, the returned Exception is
rethrown. This allows you to use Camel JMS as a bridge in your routing - for
example, using persistent queues to enable robust routing. Notice that if you
also have transferExchange enabled, this opti [...]
+| *camel.component.activemq.transfer-exception* | If enabled and you are using
Request Reply messaging (InOut) and an Exchange failed on the consumer side,
then the caused Exception will be send back in response as a
javax.jms.ObjectMessage. If the client is Camel, the returned Exception is
rethrown. This allows you to use Camel JMS as a bridge in your routing - for
example, using persistent queues to enable robust routing. Notice that if you
also have transferExchange enabled, this opti [...]
| *camel.component.activemq.transfer-exchange* | You can transfer the exchange
over the wire instead of just the body and headers. The following fields are
transferred: In body, Out body, Fault body, In headers, Out headers, Fault
headers, exchange properties, exchange exception. This requires that the
objects are serializable. Camel will exclude any non-serializable objects and
log it at WARN level. You must enable this option on both the producer and
consumer side, so Camel knows the p [...]
| *camel.component.activemq.trust-all-packages* | Define if all packages are
trusted or not | false | Boolean
| *camel.component.activemq.use-message-i-d-as-correlation-i-d* | Specifies
whether JMSMessageID should always be used as JMSCorrelationID for InOut
messages. | false | Boolean
diff --git a/docs/components/modules/ROOT/pages/amqp-component.adoc
b/docs/components/modules/ROOT/pages/amqp-component.adoc
index 9abe610..f0c6f43 100644
--- a/docs/components/modules/ROOT/pages/amqp-component.adoc
+++ b/docs/components/modules/ROOT/pages/amqp-component.adoc
@@ -98,7 +98,7 @@ The AMQP component supports 80 options, which are listed
below.
| *requestTimeout* (producer) | The timeout for waiting for a reply when using
the InOut Exchange Pattern (in milliseconds). The default is 20 seconds. You
can include the header CamelJmsRequestTimeout to override this endpoint
configured timeout value, and thus have per message individual timeout values.
See also the requestTimeoutCheckerInterval option. | 20000 | long
| *requestTimeoutChecker Interval* (advanced) | Configures how often Camel
should check for timed out Exchanges when doing request/reply over JMS. By
default Camel checks once per second. But if you must react faster when a
timeout occurs, then you can lower this interval, to check more frequently. The
timeout is determined by the option requestTimeout. | 1000 | long
| *transferExchange* (advanced) | You can transfer the exchange over the wire
instead of just the body and headers. The following fields are transferred: In
body, Out body, Fault body, In headers, Out headers, Fault headers, exchange
properties, exchange exception. This requires that the objects are
serializable. Camel will exclude any non-serializable objects and log it at
WARN level. You must enable this option on both the producer and consumer side,
so Camel knows the payloads is an E [...]
-| *transferException* (advanced) | If enabled and you are using Request Reply
messaging (InOut) and an Exchange failed on the consumer side, then the caused
Exception will be send back in response as a javax.jms.ObjectMessage. If the
client is Camel, the returned Exception is rethrown. This allows you to use
Camel JMS as a bridge in your routing - for example, using persistent queues to
enable robust routing. Notice that if you also have transferExchange enabled,
this option takes preced [...]
+| *transferException* (advanced) | If enabled and you are using Request Reply
messaging (InOut) and an Exchange failed on the consumer side, then the caused
Exception will be send back in response as a javax.jms.ObjectMessage. If the
client is Camel, the returned Exception is rethrown. This allows you to use
Camel JMS as a bridge in your routing - for example, using persistent queues to
enable robust routing. Notice that if you also have transferExchange enabled,
this option takes preced [...]
| *jmsOperations* (advanced) | Allows you to use your own implementation of
the org.springframework.jms.core.JmsOperations interface. Camel uses
JmsTemplate as default. Can be used for testing purpose, but not used much as
stated in the spring API docs. | | JmsOperations
| *destinationResolver* (advanced) | A pluggable
org.springframework.jms.support.destination.DestinationResolver that allows you
to use your own resolver (for example, to lookup the real destination in a JNDI
registry). | | DestinationResolver
| *replyToType* (producer) | Allows for explicitly specifying which kind of
strategy to use for replyTo queues when doing request/reply over JMS. Possible
values are: Temporary, Shared, or Exclusive. By default Camel will use
temporary queues. However if replyTo has been configured, then Shared is used
by default. This option allows you to use exclusive queues instead of shared
ones. See Camel JMS documentation for more details, and especially the notes
about the implications if running [...]
@@ -236,8 +236,8 @@ with the following path and query parameters:
| *recoveryInterval* (advanced) | Specifies the interval between recovery
attempts, i.e. when a connection is being refreshed, in milliseconds. The
default is 5000 ms, that is, 5 seconds. | 5000 | long
| *requestTimeoutChecker Interval* (advanced) | Configures how often Camel
should check for timed out Exchanges when doing request/reply over JMS. By
default Camel checks once per second. But if you must react faster when a
timeout occurs, then you can lower this interval, to check more frequently. The
timeout is determined by the option requestTimeout. | 1000 | long
| *synchronous* (advanced) | Sets whether synchronous processing should be
strictly used, or Camel is allowed to use asynchronous processing (if
supported). | false | boolean
-| *transferException* (advanced) | If enabled and you are using Request Reply
messaging (InOut) and an Exchange failed on the consumer side, then the caused
Exception will be send back in response as a javax.jms.ObjectMessage. If the
client is Camel, the returned Exception is rethrown. This allows you to use
Camel JMS as a bridge in your routing - for example, using persistent queues to
enable robust routing. Notice that if you also have transferExchange enabled,
this option takes preced [...]
-| *transferExchange* (advanced) | You can transfer the exchange over the wire
instead of just the body and headers. The following fields are transferred: In
body, Out body, Fault body, In headers, Out headers, Fault headers, exchange
properties, exchange exception. This requires that the objects are
serializable. Camel will exclude any non-serializable objects and log it at
WARN level. You must enable this option on both the producer and consumer side,
so Camel knows the payloads is an E [...]
+| *transferException* (advanced) | If enabled and you are using Request Reply
messaging (InOut) and an Exchange failed on the consumer side, then the caused
Exception will be send back in response as a javax.jms.ObjectMessage. If the
client is Camel, the returned Exception is rethrown. This allows you to use
Camel JMS as a bridge in your routing - for example, using persistent queues to
enable robust routing. Notice that if you also have transferExchange enabled,
this option takes preced [...]
+| *transferExchange* (advanced) | You can transfer the exchange over the wire
instead of just the body and headers. The following fields are transferred: In
body, Out body, Fault body, In headers, Out headers, Fault headers, exchange
properties, exchange exception. This requires that the objects are
serializable. Camel will exclude any non-serializable objects and log it at
WARN level. You must enable this option on both the producer and consumer side,
so Camel knows the payloads is an E [...]
| *useMessageIDAsCorrelation ID* (advanced) | Specifies whether JMSMessageID
should always be used as JMSCorrelationID for InOut messages. | false | boolean
| *waitForProvisionCorrelation ToBeUpdatedCounter* (advanced) | Number of
times to wait for provisional correlation id to be updated to the actual
correlation id when doing request/reply over JMS and when the option
useMessageIDAsCorrelationID is enabled. | 50 | int
| *waitForProvisionCorrelation ToBeUpdatedThreadSleeping Time* (advanced) |
Interval in millis to sleep each time while waiting for provisional correlation
id to be updated. | 100 | long
@@ -350,7 +350,7 @@ The component supports 81 options, which are listed below.
| *camel.component.amqp.transaction-manager* | The Spring transaction manager
to use. The option is a
org.springframework.transaction.PlatformTransactionManager type. | | String
| *camel.component.amqp.transaction-name* | The name of the transaction to
use. | | String
| *camel.component.amqp.transaction-timeout* | The timeout value of the
transaction (in seconds), if using transacted mode. | -1 | Integer
-| *camel.component.amqp.transfer-exception* | If enabled and you are using
Request Reply messaging (InOut) and an Exchange failed on the consumer side,
then the caused Exception will be send back in response as a
javax.jms.ObjectMessage. If the client is Camel, the returned Exception is
rethrown. This allows you to use Camel JMS as a bridge in your routing - for
example, using persistent queues to enable robust routing. Notice that if you
also have transferExchange enabled, this option t [...]
+| *camel.component.amqp.transfer-exception* | If enabled and you are using
Request Reply messaging (InOut) and an Exchange failed on the consumer side,
then the caused Exception will be send back in response as a
javax.jms.ObjectMessage. If the client is Camel, the returned Exception is
rethrown. This allows you to use Camel JMS as a bridge in your routing - for
example, using persistent queues to enable robust routing. Notice that if you
also have transferExchange enabled, this option t [...]
| *camel.component.amqp.transfer-exchange* | You can transfer the exchange
over the wire instead of just the body and headers. The following fields are
transferred: In body, Out body, Fault body, In headers, Out headers, Fault
headers, exchange properties, exchange exception. This requires that the
objects are serializable. Camel will exclude any non-serializable objects and
log it at WARN level. You must enable this option on both the producer and
consumer side, so Camel knows the paylo [...]
| *camel.component.amqp.use-message-i-d-as-correlation-i-d* | Specifies
whether JMSMessageID should always be used as JMSCorrelationID for InOut
messages. | false | Boolean
| *camel.component.amqp.username* | Username to use with the
ConnectionFactory. You can also configure username/password directly on the
ConnectionFactory. | | String
diff --git a/docs/components/modules/ROOT/pages/jms-component.adoc
b/docs/components/modules/ROOT/pages/jms-component.adoc
index 95ee60a..4a9a7b6 100644
--- a/docs/components/modules/ROOT/pages/jms-component.adoc
+++ b/docs/components/modules/ROOT/pages/jms-component.adoc
@@ -254,7 +254,7 @@ The JMS component supports 80 options, which are listed
below.
| *requestTimeout* (producer) | The timeout for waiting for a reply when using
the InOut Exchange Pattern (in milliseconds). The default is 20 seconds. You
can include the header CamelJmsRequestTimeout to override this endpoint
configured timeout value, and thus have per message individual timeout values.
See also the requestTimeoutCheckerInterval option. | 20000 | long
| *requestTimeoutChecker Interval* (advanced) | Configures how often Camel
should check for timed out Exchanges when doing request/reply over JMS. By
default Camel checks once per second. But if you must react faster when a
timeout occurs, then you can lower this interval, to check more frequently. The
timeout is determined by the option requestTimeout. | 1000 | long
| *transferExchange* (advanced) | You can transfer the exchange over the wire
instead of just the body and headers. The following fields are transferred: In
body, Out body, Fault body, In headers, Out headers, Fault headers, exchange
properties, exchange exception. This requires that the objects are
serializable. Camel will exclude any non-serializable objects and log it at
WARN level. You must enable this option on both the producer and consumer side,
so Camel knows the payloads is an E [...]
-| *transferException* (advanced) | If enabled and you are using Request Reply
messaging (InOut) and an Exchange failed on the consumer side, then the caused
Exception will be send back in response as a javax.jms.ObjectMessage. If the
client is Camel, the returned Exception is rethrown. This allows you to use
Camel JMS as a bridge in your routing - for example, using persistent queues to
enable robust routing. Notice that if you also have transferExchange enabled,
this option takes preced [...]
+| *transferException* (advanced) | If enabled and you are using Request Reply
messaging (InOut) and an Exchange failed on the consumer side, then the caused
Exception will be send back in response as a javax.jms.ObjectMessage. If the
client is Camel, the returned Exception is rethrown. This allows you to use
Camel JMS as a bridge in your routing - for example, using persistent queues to
enable robust routing. Notice that if you also have transferExchange enabled,
this option takes preced [...]
| *jmsOperations* (advanced) | Allows you to use your own implementation of
the org.springframework.jms.core.JmsOperations interface. Camel uses
JmsTemplate as default. Can be used for testing purpose, but not used much as
stated in the spring API docs. | | JmsOperations
| *destinationResolver* (advanced) | A pluggable
org.springframework.jms.support.destination.DestinationResolver that allows you
to use your own resolver (for example, to lookup the real destination in a JNDI
registry). | | DestinationResolver
| *replyToType* (producer) | Allows for explicitly specifying which kind of
strategy to use for replyTo queues when doing request/reply over JMS. Possible
values are: Temporary, Shared, or Exclusive. By default Camel will use
temporary queues. However if replyTo has been configured, then Shared is used
by default. This option allows you to use exclusive queues instead of shared
ones. See Camel JMS documentation for more details, and especially the notes
about the implications if running [...]
@@ -403,8 +403,8 @@ with the following path and query parameters:
| *recoveryInterval* (advanced) | Specifies the interval between recovery
attempts, i.e. when a connection is being refreshed, in milliseconds. The
default is 5000 ms, that is, 5 seconds. | 5000 | long
| *requestTimeoutChecker Interval* (advanced) | Configures how often Camel
should check for timed out Exchanges when doing request/reply over JMS. By
default Camel checks once per second. But if you must react faster when a
timeout occurs, then you can lower this interval, to check more frequently. The
timeout is determined by the option requestTimeout. | 1000 | long
| *synchronous* (advanced) | Sets whether synchronous processing should be
strictly used, or Camel is allowed to use asynchronous processing (if
supported). | false | boolean
-| *transferException* (advanced) | If enabled and you are using Request Reply
messaging (InOut) and an Exchange failed on the consumer side, then the caused
Exception will be send back in response as a javax.jms.ObjectMessage. If the
client is Camel, the returned Exception is rethrown. This allows you to use
Camel JMS as a bridge in your routing - for example, using persistent queues to
enable robust routing. Notice that if you also have transferExchange enabled,
this option takes preced [...]
-| *transferExchange* (advanced) | You can transfer the exchange over the wire
instead of just the body and headers. The following fields are transferred: In
body, Out body, Fault body, In headers, Out headers, Fault headers, exchange
properties, exchange exception. This requires that the objects are
serializable. Camel will exclude any non-serializable objects and log it at
WARN level. You must enable this option on both the producer and consumer side,
so Camel knows the payloads is an E [...]
+| *transferException* (advanced) | If enabled and you are using Request Reply
messaging (InOut) and an Exchange failed on the consumer side, then the caused
Exception will be send back in response as a javax.jms.ObjectMessage. If the
client is Camel, the returned Exception is rethrown. This allows you to use
Camel JMS as a bridge in your routing - for example, using persistent queues to
enable robust routing. Notice that if you also have transferExchange enabled,
this option takes preced [...]
+| *transferExchange* (advanced) | You can transfer the exchange over the wire
instead of just the body and headers. The following fields are transferred: In
body, Out body, Fault body, In headers, Out headers, Fault headers, exchange
properties, exchange exception. This requires that the objects are
serializable. Camel will exclude any non-serializable objects and log it at
WARN level. You must enable this option on both the producer and consumer side,
so Camel knows the payloads is an E [...]
| *useMessageIDAsCorrelation ID* (advanced) | Specifies whether JMSMessageID
should always be used as JMSCorrelationID for InOut messages. | false | boolean
| *waitForProvisionCorrelation ToBeUpdatedCounter* (advanced) | Number of
times to wait for provisional correlation id to be updated to the actual
correlation id when doing request/reply over JMS and when the option
useMessageIDAsCorrelationID is enabled. | 50 | int
| *waitForProvisionCorrelation ToBeUpdatedThreadSleeping Time* (advanced) |
Interval in millis to sleep each time while waiting for provisional correlation
id to be updated. | 100 | long
@@ -541,8 +541,8 @@ The component supports 169 options, which are listed below.
| *camel.component.jms.configuration.transaction-manager* | The Spring
transaction manager to use. | | PlatformTransaction Manager
| *camel.component.jms.configuration.transaction-name* | The name of the
transaction to use. | | String
| *camel.component.jms.configuration.transaction-timeout* | The timeout value
of the transaction (in seconds), if using transacted mode. | -1 | Integer
-| *camel.component.jms.configuration.transfer-exception* | If enabled and you
are using Request Reply messaging (InOut) and an Exchange failed on the
consumer side, then the caused Exception will be send back in response as a
javax.jms.ObjectMessage. If the client is Camel, the returned Exception is
rethrown. This allows you to use Camel JMS as a bridge in your routing - for
example, using persistent queues to enable robust routing. Notice that if you
also have transferExchange enabled, [...]
-| *camel.component.jms.configuration.transfer-exchange* | You can transfer the
exchange over the wire instead of just the body and headers. The following
fields are transferred: In body, Out body, Fault body, In headers, Out headers,
Fault headers, exchange properties, exchange exception. This requires that the
objects are serializable. Camel will exclude any non-serializable objects and
log it at WARN level. You must enable this option on both the producer and
consumer side, so Camel kn [...]
+| *camel.component.jms.configuration.transfer-exception* | If enabled and you
are using Request Reply messaging (InOut) and an Exchange failed on the
consumer side, then the caused Exception will be send back in response as a
javax.jms.ObjectMessage. If the client is Camel, the returned Exception is
rethrown. This allows you to use Camel JMS as a bridge in your routing - for
example, using persistent queues to enable robust routing. Notice that if you
also have transferExchange enabled, [...]
+| *camel.component.jms.configuration.transfer-exchange* | You can transfer the
exchange over the wire instead of just the body and headers. The following
fields are transferred: In body, Out body, Fault body, In headers, Out headers,
Fault headers, exchange properties, exchange exception. This requires that the
objects are serializable. Camel will exclude any non-serializable objects and
log it at WARN level. You must enable this option on both the producer and
consumer side, so Camel kn [...]
| *camel.component.jms.configuration.use-message-i-d-as-correlation-i-d* |
Specifies whether JMSMessageID should always be used as JMSCorrelationID for
InOut messages. | false | Boolean
| *camel.component.jms.configuration.username* | Username to use with the
ConnectionFactory. You can also configure username/password directly on the
ConnectionFactory. | | String
|
*camel.component.jms.configuration.wait-for-provision-correlation-to-be-updated-counter*
| Number of times to wait for provisional correlation id to be updated to the
actual correlation id when doing request/reply over JMS and when the option
useMessageIDAsCorrelationID is enabled. | 50 | Integer
@@ -605,7 +605,7 @@ The component supports 169 options, which are listed below.
| *camel.component.jms.transaction-manager* | The Spring transaction manager
to use. The option is a
org.springframework.transaction.PlatformTransactionManager type. | | String
| *camel.component.jms.transaction-name* | The name of the transaction to use.
| | String
| *camel.component.jms.transaction-timeout* | The timeout value of the
transaction (in seconds), if using transacted mode. | -1 | Integer
-| *camel.component.jms.transfer-exception* | If enabled and you are using
Request Reply messaging (InOut) and an Exchange failed on the consumer side,
then the caused Exception will be send back in response as a
javax.jms.ObjectMessage. If the client is Camel, the returned Exception is
rethrown. This allows you to use Camel JMS as a bridge in your routing - for
example, using persistent queues to enable robust routing. Notice that if you
also have transferExchange enabled, this option ta [...]
+| *camel.component.jms.transfer-exception* | If enabled and you are using
Request Reply messaging (InOut) and an Exchange failed on the consumer side,
then the caused Exception will be send back in response as a
javax.jms.ObjectMessage. If the client is Camel, the returned Exception is
rethrown. This allows you to use Camel JMS as a bridge in your routing - for
example, using persistent queues to enable robust routing. Notice that if you
also have transferExchange enabled, this option ta [...]
| *camel.component.jms.transfer-exchange* | You can transfer the exchange over
the wire instead of just the body and headers. The following fields are
transferred: In body, Out body, Fault body, In headers, Out headers, Fault
headers, exchange properties, exchange exception. This requires that the
objects are serializable. Camel will exclude any non-serializable objects and
log it at WARN level. You must enable this option on both the producer and
consumer side, so Camel knows the payloa [...]
| *camel.component.jms.use-message-i-d-as-correlation-i-d* | Specifies whether
JMSMessageID should always be used as JMSCorrelationID for InOut messages. |
false | Boolean
| *camel.component.jms.username* | Username to use with the ConnectionFactory.
You can also configure username/password directly on the ConnectionFactory. |
| String
diff --git a/docs/components/modules/ROOT/pages/rest-component.adoc
b/docs/components/modules/ROOT/pages/rest-component.adoc
index 46d150b..6c31c4c 100644
--- a/docs/components/modules/ROOT/pages/rest-component.adoc
+++ b/docs/components/modules/ROOT/pages/rest-component.adoc
@@ -123,7 +123,6 @@ The component supports 8 options, which are listed below.
The following components support rest consumer (Rest DSL):
* camel-coap
-* camel-netty-http
* camel-netty4-http
* camel-jetty
* camel-restlet
diff --git a/docs/components/modules/ROOT/pages/salesforce-component.adoc
b/docs/components/modules/ROOT/pages/salesforce-component.adoc
index aa0f9fe..510c479 100644
--- a/docs/components/modules/ROOT/pages/salesforce-component.adoc
+++ b/docs/components/modules/ROOT/pages/salesforce-component.adoc
@@ -619,7 +619,7 @@ for details on how to generate the DTO.
// component options: START
-The Salesforce component supports 30 options, which are listed below.
+The Salesforce component supports 32 options, which are listed below.
@@ -642,6 +642,8 @@ The Salesforce component supports 30 options, which are
listed below.
| *longPollingTransport Properties* (common) | Used to set any properties that
can be configured on the LongPollingTransport used by the BayeuxClient (CometD)
used by the streaming api | | Map
| *sslContextParameters* (security) | SSL parameters to use, see
SSLContextParameters class for all available options. | | SSLContextParameters
| *useGlobalSslContext Parameters* (security) | Enable usage of global SSL
context parameters | false | boolean
+| *httpClientIdleTimeout* (common) | Timeout used by the HttpClient when
waiting for response from the Salesforce server. | 10000 | long
+| *httpClientConnection Timeout* (common) | Connection timeout used by the
HttpClient when connecting to the Salesforce server. | 60000 | long
| *httpProxyHost* (proxy) | Hostname of the HTTP proxy server to use. | |
String
| *httpProxyPort* (proxy) | Port number of the HTTP proxy server to use. | |
Integer
| *httpProxyUsername* (security) | Username to use to authenticate against the
HTTP proxy server. | | String
@@ -758,7 +760,7 @@ When using Spring Boot make sure to use the following Maven
dependency to have s
----
-The component supports 86 options, which are listed below.
+The component supports 88 options, which are listed below.
@@ -817,6 +819,8 @@ The component supports 86 options, which are listed below.
| *camel.component.salesforce.config.serialize-nulls* | Should the NULL values
of given DTO be serialized with empty (NULL) values. This affects only JSON
data format. | false | Boolean
| *camel.component.salesforce.config.update-topic* | Whether to update an
existing Push Topic when using the Streaming API, defaults to false | false |
Boolean
| *camel.component.salesforce.enabled* | Enable salesforce component | true |
Boolean
+| *camel.component.salesforce.http-client-connection-timeout* | Connection
timeout used by the HttpClient when connecting to the Salesforce server. |
60000 | Long
+| *camel.component.salesforce.http-client-idle-timeout* | Timeout used by the
HttpClient when waiting for response from the Salesforce server. | 10000 | Long
| *camel.component.salesforce.http-client-properties* | Used to set any
properties that can be configured on the underlying HTTP client. Have a look at
properties of SalesforceHttpClient and the Jetty HttpClient for all available
options. | | Map
| *camel.component.salesforce.http-proxy-auth-uri* | Used in authentication
against the HTTP proxy server, needs to match the URI of the proxy server in
order for the httpProxyUsername and httpProxyPassword to be used for
authentication. | | String
| *camel.component.salesforce.http-proxy-excluded-addresses* | A list of
addresses for which HTTP proxy server should not be used. | | Set
diff --git
a/platforms/spring-boot/components-starter/camel-amqp-starter/src/main/java/org/apache/camel/component/amqp/springboot/AMQPComponentConfiguration.java
b/platforms/spring-boot/components-starter/camel-amqp-starter/src/main/java/org/apache/camel/component/amqp/springboot/AMQPComponentConfiguration.java
index 2d7397f..4f1f463 100644
---
a/platforms/spring-boot/components-starter/camel-amqp-starter/src/main/java/org/apache/camel/component/amqp/springboot/AMQPComponentConfiguration.java
+++
b/platforms/spring-boot/components-starter/camel-amqp-starter/src/main/java/org/apache/camel/component/amqp/springboot/AMQPComponentConfiguration.java
@@ -407,7 +407,10 @@ public class AMQPComponentConfiguration
* enabled, this option takes precedence. The caught exception is required
* to be serializable. The original Exception on the consumer side can be
* wrapped in an outer exception such as
- * org.apache.camel.RuntimeCamelException when returned to the producer.
+ * org.apache.camel.RuntimeCamelException when returned to the producer.
Use
+ * this with caution as the data is using Java Object serialization and
+ * requires the received to be able to deserialize the data at Class level,
+ * which forces a strong coupling between the producers and consumer!
*/
private Boolean transferException = false;
/**
