This is an automated email from the ASF dual-hosted git repository.
oalsafi pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git
The following commit(s) were added to refs/heads/master by this push:
new e7cb4d5 Regen
e7cb4d5 is described below
commit e7cb4d5a804c1b137b536400c3da0165ad5f12a9
Author: Omar Al-Safi <[email protected]>
AuthorDate: Tue May 5 10:26:56 2020 +0200
Regen
---
docs/components/modules/ROOT/pages/activemq-component.adoc | 8 ++++----
1 file changed, 4 insertions(+), 4 deletions(-)
diff --git a/docs/components/modules/ROOT/pages/activemq-component.adoc
b/docs/components/modules/ROOT/pages/activemq-component.adoc
index 489ef65..c761cf1 100644
--- a/docs/components/modules/ROOT/pages/activemq-component.adoc
+++ b/docs/components/modules/ROOT/pages/activemq-component.adoc
@@ -61,16 +61,14 @@ The ActiveMQ component supports 99 options, which are
listed below.
[width="100%",cols="2,5,^1,2",options="header"]
|===
| Name | Description | Default | Type
-| *brokerURL* (common) | Sets the broker URL to use to connect to ActiveMQ |
| String
+| *brokerURL* (common) | Sets the broker URL to use to connect to ActiveMQ. If
none configured then localhost:61616 is used by default (however can be
overridden by configuration from environment variables) | | String
| *clientId* (common) | Sets the JMS client ID to use. Note that this value,
if specified, must be unique and can only be used by a single JMS connection
instance. It is typically only required for durable topic subscriptions. If
using Apache ActiveMQ you may prefer to use Virtual Topics instead. | | String
-| *configuration* (common) | Configuration of ActiveMQ | | JmsConfiguration
| *connectionFactory* (common) | The connection factory to be use. A
connection factory must be configured either on the component or endpoint. | |
ConnectionFactory
| *disableReplyTo* (common) | Specifies whether Camel ignores the JMSReplyTo
header in messages. If true, Camel does not send a reply back to the
destination specified in the JMSReplyTo header. You can use this option if you
want Camel to consume from a route and you do not want Camel to automatically
send back a reply message because another component in your code handles the
reply message. You can also use this option if you want to use Camel as a proxy
between different message broker [...]
| *durableSubscriptionName* (common) | The durable subscriber name for
specifying durable topic subscriptions. The clientId option must be configured
as well. | | String
| *jmsMessageType* (common) | Allows you to force the use of a specific
javax.jms.Message implementation for sending JMS messages. Possible values are:
Bytes, Map, Object, Stream, Text. By default, Camel would determine which JMS
message type to use from the In body type. This option allows you to specify
it. The value can be one of: Bytes, Map, Object, Stream, Text | |
JmsMessageType
| *testConnectionOnStartup* (common) | Specifies whether to test the
connection on startup. This ensures that when Camel starts that all the JMS
consumers have a valid connection to the JMS broker. If a connection cannot be
granted then Camel throws an exception on startup. This ensures that Camel is
not started with failed connections. The JMS producers is tested as well. |
false | boolean
-| *trustAllPackages* (common) | Define if all Java packages are trusted or not
(for Java object JMS message types). Notice its not recommended practice to
send Java serialized objects over network. Setting this to true can expose
security risks, so use this with care. | false | boolean
-| *usePooledConnection* (common) | Enables or disables whether a
PooledConnectionFactory will be used so that when messages are sent to ActiveMQ
from outside of a message consuming thread, pooling will be used rather than
the default with the Spring JmsTemplate which will create a new connection,
session, producer for each message then close them all down again. The default
value is true. | false | boolean
+| *usePooledConnection* (common) | Enables or disables whether a
PooledConnectionFactory will be used so that when messages are sent to ActiveMQ
from outside of a message consuming thread, pooling will be used rather than
the default with the Spring JmsTemplate which will create a new connection,
session, producer for each message then close them all down again. The default
value is true. | true | boolean
| *useSingleConnection* (common) | Enables or disables whether a Spring
SingleConnectionFactory will be used so that when messages are sent to ActiveMQ
from outside of a message consuming thread, pooling will be used rather than
the default with the Spring JmsTemplate which will create a new connection,
session, producer for each message then close them all down again. The default
value is false and a pooled connection is used by default. | false | boolean
| *acknowledgementModeName* (consumer) | The JMS acknowledgement name, which
is one of: SESSION_TRANSACTED, CLIENT_ACKNOWLEDGE, AUTO_ACKNOWLEDGE,
DUPS_OK_ACKNOWLEDGE. The value can be one of: SESSION_TRANSACTED,
CLIENT_ACKNOWLEDGE, AUTO_ACKNOWLEDGE, DUPS_OK_ACKNOWLEDGE | AUTO_ACKNOWLEDGE |
String
| *asyncConsumer* (consumer) | Whether the JmsConsumer processes the Exchange
asynchronously. If enabled then the JmsConsumer may pickup the next message
from the JMS queue, while the previous message is being processed
asynchronously (by the Asynchronous Routing Engine). This means that messages
may be processed not 100% strictly in order. If disabled (as default) then the
Exchange is fully processed before the JmsConsumer will pickup the next message
from the JMS queue. Note if transac [...]
@@ -126,6 +124,7 @@ The ActiveMQ component supports 99 options, which are
listed below.
| *asyncStartListener* (advanced) | Whether to startup the JmsConsumer message
listener asynchronously, when starting a route. For example if a JmsConsumer
cannot get a connection to a remote JMS broker, then it may block while
retrying and/or failover. This will cause Camel to block while starting routes.
By setting this option to true, you will let routes startup, while the
JmsConsumer connects to the JMS broker using a dedicated thread in asynchronous
mode. If this option is used, the [...]
| *asyncStopListener* (advanced) | Whether to stop the JmsConsumer message
listener asynchronously, when stopping a route. | false | boolean
| *basicPropertyBinding* (advanced) | Whether the component should use basic
property binding (Camel 2.x) or the newer property binding with additional
capabilities | false | boolean
+| *configuration* (advanced) | To use a shared JMS configuration | |
JmsConfiguration
| *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
| *errorHandler* (advanced) | Specifies a
org.springframework.util.ErrorHandler to be invoked in case of any uncaught
exceptions thrown while processing a Message. By default these exceptions will
be logged at the WARN level, if no errorHandler has been configured. You can
configure logging level and whether stack traces should be logged using
errorHandlerLoggingLevel and errorHandlerLogStackTrace options. This makes it
much easier to configure, than having to code a custom errorHandler. [...]
| *exceptionListener* (advanced) | Specifies the JMS Exception Listener that
is to be notified of any underlying JMS exceptions. | | ExceptionListener
@@ -147,6 +146,7 @@ The ActiveMQ component supports 99 options, which are
listed below.
| *requestTimeoutCheckerInterval* (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
| *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 [...]
+| *trustAllPackages* (advanced) | Define if all Java packages are trusted or
not (for Java object JMS message types). Notice its not recommended practice to
send Java serialized objects over network. Setting this to true can expose
security risks, so use this with care. | false | boolean
| *useMessageIDAsCorrelationID* (advanced) | Specifies whether JMSMessageID
should always be used as JMSCorrelationID for InOut messages. | false | boolean
| *waitForProvisionCorrelationTo BeUpdatedCounter* (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
| *waitForProvisionCorrelationTo BeUpdatedThreadSleepingTime* (advanced) |
Interval in millis to sleep each time while waiting for provisional correlation
id to be updated. | 100 | long
