camel-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From davscl...@apache.org
Subject [3/3] camel git commit: Component docs - To allow activemq-camel to reuse docs.
Date Sat, 16 Jan 2016 12:56:04 GMT
Component docs - To allow activemq-camel to reuse docs.


Project: http://git-wip-us.apache.org/repos/asf/camel/repo
Commit: http://git-wip-us.apache.org/repos/asf/camel/commit/f1bd0be5
Tree: http://git-wip-us.apache.org/repos/asf/camel/tree/f1bd0be5
Diff: http://git-wip-us.apache.org/repos/asf/camel/diff/f1bd0be5

Branch: refs/heads/camel-2.16.x
Commit: f1bd0be5ec9681fc58fa3d422c72d61f11e62ddc
Parents: 2200e51
Author: Claus Ibsen <davsclaus@apache.org>
Authored: Sat Jan 16 13:52:21 2016 +0100
Committer: Claus Ibsen <davsclaus@apache.org>
Committed: Sat Jan 16 13:55:04 2016 +0100

----------------------------------------------------------------------
 .../camel/component/jms/JmsConfiguration.java   | 329 +++++++++++++++----
 1 file changed, 256 insertions(+), 73 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/camel/blob/f1bd0be5/components/camel-jms/src/main/java/org/apache/camel/component/jms/JmsConfiguration.java
----------------------------------------------------------------------
diff --git a/components/camel-jms/src/main/java/org/apache/camel/component/jms/JmsConfiguration.java
b/components/camel-jms/src/main/java/org/apache/camel/component/jms/JmsConfiguration.java
index 510765b..c3e2877 100644
--- a/components/camel-jms/src/main/java/org/apache/camel/component/jms/JmsConfiguration.java
+++ b/components/camel-jms/src/main/java/org/apache/camel/component/jms/JmsConfiguration.java
@@ -68,151 +68,335 @@ public class JmsConfiguration implements Cloneable {
     private ConnectionFactory templateConnectionFactory;
     private ConnectionFactory listenerConnectionFactory;
     private int acknowledgementMode = -1;
-    @UriParam(defaultValue = "AUTO_ACKNOWLEDGE", enums = "SESSION_TRANSACTED,CLIENT_ACKNOWLEDGE,AUTO_ACKNOWLEDGE,DUPS_OK_ACKNOWLEDGE",
label = "consumer")
+    @UriParam(defaultValue = "AUTO_ACKNOWLEDGE", enums = "SESSION_TRANSACTED,CLIENT_ACKNOWLEDGE,AUTO_ACKNOWLEDGE,DUPS_OK_ACKNOWLEDGE",
label = "consumer",
+            description = "The JMS acknowledgement name, which is one of: SESSION_TRANSACTED,
CLIENT_ACKNOWLEDGE, AUTO_ACKNOWLEDGE, DUPS_OK_ACKNOWLEDGE")
     private String acknowledgementModeName;
     // Used to configure the spring Container
-    @UriParam(label = "advanced")
+    @UriParam(label = "advanced",
+            description = "Specifies the JMS Exception Listener that is to be notified of
any underlying JMS exceptions.")
     private ExceptionListener exceptionListener;
-    @UriParam(label = "consumer,advanced", defaultValue = "Default")
+    @UriParam(label = "consumer,advanced", defaultValue = "Default",
+            description = "The consumer type to use, which can be one of: Simple, Default,
or Custom."
+                    + " The consumer type determines which Spring JMS listener to use. Default
will use org.springframework.jms.listener.DefaultMessageListenerContainer,"
+                    + " Simple will use org.springframework.jms.listener.SimpleMessageListenerContainer."
+                    + " When Custom is specified, the MessageListenerContainerFactory defined
by the messageListenerContainerFactory option"
+                    + " will determine what org.springframework.jms.listener.AbstractMessageListenerContainer
to use.")
     private ConsumerType consumerType = ConsumerType.Default;
-    @UriParam(label = "advanced")
+    @UriParam(label = "advanced",
+            description = "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.")
     private ErrorHandler errorHandler;
-    @UriParam(defaultValue = "WARN", label = "advanced")
+    @UriParam(defaultValue = "WARN", label = "advanced",
+            description = "Allows to configure the default errorHandler logging level for
logging uncaught exceptions.")
     private LoggingLevel errorHandlerLoggingLevel = LoggingLevel.WARN;
-    @UriParam(defaultValue = "true", label = "advanced")
+    @UriParam(defaultValue = "true", label = "advanced",
+            description = "Allows to control whether stacktraces should be logged or not,
by the default errorHandler.")
     private boolean errorHandlerLogStackTrace = true;
-    @UriParam(label = "consumer", defaultValue = "true")
+    @UriParam(label = "consumer", defaultValue = "true",
+            description = "Specifies whether the consumer container should auto-startup.")
     private boolean autoStartup = true;
-    @UriParam(label = "consumer,advanced")
+    @UriParam(label = "consumer,advanced",
+            description = "Specifies whether the consumer accept messages while it is stopping."
+                    + " You may consider enabling this option, if you start and stop JMS
routes at runtime, while there are still messages"
+                    + " enqued on the queue. If this option is false, and you stop the JMS
route, then messages may be rejected,"
+                    + " and the JMS broker would have to attempt redeliveries, which yet
again may be rejected, and eventually the message"
+                    + " may be moved at a dead letter queue on the JMS broker. To avoid this
its recommended to enable this option.")
     private boolean acceptMessagesWhileStopping;
-    @UriParam
+    @UriParam(description = "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.")
     private String clientId;
-    @UriParam
+    @UriParam(description = "The durable subscriber name for specifying durable topic subscriptions.
The clientId option must be configured as well.")
     private String durableSubscriptionName;
     @Deprecated
     private boolean subscriptionDurable;
-    @UriParam(label = "consumer,advanced")
+    @UriParam(label = "consumer,advanced",
+            description = "Specifies whether the listener session should be exposed when
consuming messages.")
     private boolean exposeListenerSession = true;
     private TaskExecutor taskExecutor;
-    @UriParam(label = "advanced")
+    @UriParam(label = "advanced",
+            description = "Specifies whether to inhibit the delivery of messages published
by its own connection.")
     private boolean pubSubNoLocal;
-    @UriParam(defaultValue = "1", label = "consumer")
+    @UriParam(defaultValue = "1", label = "consumer",
+            description = "Specifies the default number of concurrent consumers when consuming
from JMS (not for request/reply over JMS)."
+                    + " See also the maxMessagesPerTask option to control dynamic scaling
up/down of threads."
+                    + " When doing request/reply over JMS then the option replyToConcurrentConsumers
is used to control number"
+                    + " of concurrent consumers on the reply message listener.")
     private int concurrentConsumers = 1;
-    @UriParam(defaultValue = "1", label = "producer")
+    @UriParam(defaultValue = "1", label = "producer",
+            description = "Specifies the default number of concurrent consumers when doing
request/reply over JMS."
+                    + " See also the maxMessagesPerTask option to control dynamic scaling
up/down of threads.")
     private int replyToConcurrentConsumers = 1;
-    @UriParam(defaultValue = "-1", label = "advanced")
+    @UriParam(defaultValue = "-1", label = "advanced",
+            description = "The number of messages per task. -1 is unlimited."
+                    + " If you use a range for concurrent consumers (eg min < max), then
this option can be used to set"
+                    + " a value to eg 100 to control how fast the consumers will shrink when
less work is required.")
     private int maxMessagesPerTask = -1;
     private int cacheLevel = -1;
-    @UriParam(defaultValue = "CACHE_AUTO", enums = "CACHE_AUTO,CACHE_CONNECTION,CACHE_CONSUMER,CACHE_NONE,CACHE_SESSION",
label = "consumer")
+    @UriParam(defaultValue = "CACHE_AUTO", enums = "CACHE_AUTO,CACHE_CONNECTION,CACHE_CONSUMER,CACHE_NONE,CACHE_SESSION",
label = "consumer",
+            description = "Sets the cache level by name for the underlying JMS resources."
+                    + " Possible values are: CACHE_AUTO, CACHE_CONNECTION, CACHE_CONSUMER,
CACHE_NONE, and CACHE_SESSION."
+                    + " The default setting is CACHE_AUTO. See the Spring documentation and
Transactions Cache Levels for more information.")
     private String cacheLevelName;
-    @UriParam(defaultValue = "5000", label = "advanced")
+    @UriParam(defaultValue = "5000", label = "advanced",
+            description = "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.")
     private long recoveryInterval = 5000;
-    @UriParam(defaultValue = "1000", label = "advanced")
+    @UriParam(defaultValue = "1000", label = "advanced",
+            description = "The timeout for receiving messages (in milliseconds).")
     private long receiveTimeout = 1000;
-    @UriParam(defaultValue = "20000", label = "producer")
+    @UriParam(defaultValue = "20000", label = "producer",
+            description = "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.")
     private long requestTimeout = 20000L;
-    @UriParam(defaultValue = "1000", label = "advanced")
+    @UriParam(defaultValue = "1000", label = "advanced",
+            description = "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.")
     private long requestTimeoutCheckerInterval = 1000L;
-    @UriParam(defaultValue = "1", label = "advanced")
+    @UriParam(defaultValue = "1", label = "advanced",
+            description = "Specifies the limit for idle executions of a receive task, not
having received any message within its execution."
+                    + " If this limit is reached, the task will shut down and leave receiving
to other executing tasks"
+                    + " (in the case of dynamic scheduling; see the maxConcurrentConsumers
setting)."
+                    + " There is additional doc available from Spring.")
     private int idleTaskExecutionLimit = 1;
-    @UriParam(defaultValue = "1", label = "advanced")
+    @UriParam(defaultValue = "1", label = "advanced",
+            description = "Specify the limit for the number of consumers that are allowed
to be idle at any given time.")
     private int idleConsumerLimit = 1;
-    @UriParam(label = "consumer")
+    @UriParam(label = "consumer",
+            description = "Specifies the maximum number of concurrent consumers when consuming
from JMS (not for request/reply over JMS)."
+                    + " See also the maxMessagesPerTask option to control dynamic scaling
up/down of threads."
+                    + " When doing request/reply over JMS then the option replyToMaxConcurrentConsumers
is used to control number"
+                    + " of concurrent consumers on the reply message listener.")
     private int maxConcurrentConsumers;
-    @UriParam(label = "producer")
+    @UriParam(label = "producer",
+            description = "Specifies the maximum number of concurrent consumers when using
request/reply over JMS."
+                    + " See also the maxMessagesPerTask option to control dynamic scaling
up/down of threads.")
     private int replyToMaxConcurrentConsumers;
     // JmsTemplate only
-    @UriParam(label = "producer", defaultValue = "false")
+    @UriParam(label = "producer", defaultValue = "false",
+            description = "Set if the deliveryMode, priority or timeToLive qualities of service
should be used when sending messages."
+                    + " This option is based on Spring's JmsTemplate. The deliveryMode, priority
and timeToLive options are applied to the current endpoint."
+                    + " This contrasts with the preserveMessageQos option, which operates
at message granularity,"
+                    + " reading QoS properties exclusively from the Camel In message headers.")
     private Boolean explicitQosEnabled;
-    @UriParam(defaultValue = "true", label = "producer")
+    @UriParam(defaultValue = "true", label = "producer",
+            description = "Specifies whether persistent delivery is used by default.")
     private boolean deliveryPersistent = true;
-    @UriParam(enums = "1,2", label = "producer")
+    @UriParam(enums = "1,2", label = "producer",
+            description = "Specifies the delivery mode to be used."
+                    + " Possibles values are those defined by javax.jms.DeliveryMode."
+                    + " NON_PERSISTENT = 1 and PERSISTENT = 2.")
     private Integer deliveryMode;
-    @UriParam(defaultValue = "true", label = "consumer")
+    @UriParam(defaultValue = "true", label = "consumer",
+            description = "Specifies whether to use persistent delivery by default for replies.")
     private boolean replyToDeliveryPersistent = true;
-    @UriParam(defaultValue = "-1", label = "producer")
+    @UriParam(defaultValue = "-1", label = "producer",
+            description = "When sending messages, specifies the time-to-live of the message
(in milliseconds).")
     private long timeToLive = -1;
-    @UriParam(label = "advanced")
+    @UriParam(label = "advanced",
+            description = "To use a custom Spring org.springframework.jms.support.converter.MessageConverter
so you can be in control how to map to/from a javax.jms.Message.")
     private MessageConverter messageConverter;
-    @UriParam(defaultValue = "true", label = "advanced")
+    @UriParam(defaultValue = "true", label = "advanced",
+            description = "Specifies whether Camel should auto map the received JMS message
to a suited payload type, such as javax.jms.TextMessage to a String etc.")
     private boolean mapJmsMessage = true;
-    @UriParam(defaultValue = "true", label = "advanced")
+    @UriParam(defaultValue = "true", label = "advanced",
+            description = "When sending, specifies whether message IDs should be added.")
     private boolean messageIdEnabled = true;
-    @UriParam(defaultValue = "true", label = "advanced")
+    @UriParam(defaultValue = "true", label = "advanced",
+            description = "Specifies whether timestamps should be enabled by default on sending
messages.")
     private boolean messageTimestampEnabled = true;
-    @UriParam(defaultValue = "" + Message.DEFAULT_PRIORITY, enums = "1,2,3,4,5,6,7,8,9",
label = "producer")
+    @UriParam(defaultValue = "" + Message.DEFAULT_PRIORITY, enums = "1,2,3,4,5,6,7,8,9",
label = "producer",
+            description = "Values greater than 1 specify the message priority when sending
(where 0 is the lowest priority and 9 is the highest)."
+                    + " The explicitQosEnabled option must also be enabled in order for this
option to have any effect.")
     private int priority = Message.DEFAULT_PRIORITY;
     // Transaction related configuration
-    @UriParam(label = "transaction")
+    @UriParam(label = "transaction",
+            description = "Specifies whether to use transacted mode")
     private boolean transacted;
+    @Deprecated
     private boolean transactedInOut;
-    @UriParam(defaultValue = "true", label = "transaction,advanced")
+    @UriParam(defaultValue = "true", label = "transaction,advanced",
+            description = "If true, Camel will create a JmsTransactionManager, if there is
no transactionManager injected when option transacted=true.")
     private boolean lazyCreateTransactionManager = true;
+    @UriParam(label = "transaction,advanced",
+            description = "The Spring transaction manager to use.")
     private PlatformTransactionManager transactionManager;
-    @UriParam(label = "transaction,advanced")
+    @UriParam(label = "transaction,advanced",
+            description = "The name of the transaction to use.")
     private String transactionName;
-    @UriParam(defaultValue = "-1", label = "transaction,advanced")
+    @UriParam(defaultValue = "-1", label = "transaction,advanced",
+            description = "The timeout value of the transaction (in seconds), if using transacted
mode.")
     private int transactionTimeout = -1;
-    @UriParam(label = "producer")
+    @UriParam(label = "producer",
+            description = "Set to true, if you want to send message using the QoS settings
specified on the message,"
+                    + " instead of the QoS settings on the JMS endpoint. The following three
headers are considered JMSPriority, JMSDeliveryMode,"
+                    + " and JMSExpiration. You can provide all or only some of them. If not
provided, Camel will fall back to use the"
+                    + " values from the endpoint instead. So, when using this option, the
headers override the values from the endpoint."
+                    + " The explicitQosEnabled option, by contrast, will only use options
set on the endpoint, and not values from the message header.")
     private boolean preserveMessageQos;
-    @UriParam
+    @UriParam(description = "If true, a producer will behave like a InOnly exchange with
the exception that JMSReplyTo header is sent out and"
+            + " not be suppressed like in the case of InOnly. Like InOnly the producer will
not wait for a reply."
+            + " A consumer with this flag will behave like InOnly. This feature can be used
to bridge InOut requests to"
+            + " another queue so that a route on the other queue will send it´s response
directly back to the original JMSReplyTo.")
     private boolean disableReplyTo;
-    @UriParam(label = "consumer,advanced")
+    @UriParam(label = "consumer,advanced",
+            description = "Enables eager loading of JMS properties as soon as a message is
loaded"
+                    + " which generally is inefficient as the JMS properties may not be required"
+                    + " but sometimes can catch early any issues with the underlying JMS
provider"
+                    + " and the use of JMS properties")
     private boolean eagerLoadingOfProperties;
     // Always make a JMS message copy when it's passed to Producer
-    @UriParam(label = "producer,advanced")
+    @UriParam(label = "producer,advanced",
+            description = "If true, Camel will always make a JMS message copy of the message
when it is passed to the producer for sending."
+                    + " Copying the message is needed in some situations, such as when a
replyToDestinationSelectorName is set"
+                    + " (incidentally, Camel will set the alwaysCopyMessage option to true,
if a replyToDestinationSelectorName is set)")
     private boolean alwaysCopyMessage;
-    @UriParam(label = "advanced")
+    @UriParam(label = "advanced",
+            description = "Specifies whether JMSMessageID should always be used as JMSCorrelationID
for InOut messages.")
     private boolean useMessageIDAsCorrelationID;
     private JmsProviderMetadata providerMetadata = new JmsProviderMetadata();
     private JmsOperations metadataJmsOperations;
-    @UriParam(label = "consumer")
+    @UriParam(label = "consumer",
+            description = "Provides an explicit ReplyTo destination, which overrides any
incoming value of Message.getJMSReplyTo().")
     private String replyTo;
-    @UriParam(label = "producer,advanced")
+    @UriParam(label = "producer,advanced",
+            description = "Sets the JMS Selector using the fixed name to be used so you can
filter out your own replies"
+                    + " from the others when using a shared queue (that is, if you are not
using a temporary reply queue).")
     private String replyToDestinationSelectorName;
-    @UriParam(label = "producer")
+    @UriParam(label = "producer",
+            description = "Provides an explicit ReplyTo destination in the JMS message, which
overrides the setting of replyTo."
+                    + " It is useful if you want to forward the message to a remote Queue
and receive the reply message from the ReplyTo destination.")
     private String replyToOverride;
-    @UriParam(label = "consumer,advanced")
+    @UriParam(label = "consumer,advanced",
+            description = "Whether a JMS consumer is allowed to send a reply message to the
same destination that the consumer is using to"
+                    + " consume from. This prevents an endless loop by consuming and sending
back the same message to itself.")
     private boolean replyToSameDestinationAllowed;
-    @UriParam(enums = "Bytes,Map,Object,Stream,Text")
+    @UriParam(enums = "Bytes,Map,Object,Stream,Text",
+            description = "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.")
     private JmsMessageType jmsMessageType;
-    @UriParam(label = "advanced", enums = "default,passthrough", javaType = "java.lang.String")
+    @UriParam(label = "advanced", enums = "default,passthrough", javaType = "java.lang.String",
+            description = "Pluggable strategy for encoding and decoding JMS keys so they
can be compliant with the JMS specification."
+                    + " Camel provides two implementations out of the box: default and passthrough."
+                    + " The default strategy will safely marshal dots and hyphens (. and
-). The passthrough strategy leaves the key as is."
+                    + " Can be used for JMS brokers which do not care whether JMS header
keys contain illegal characters."
+                    + " You can provide your own implementation of the org.apache.camel.component.jms.JmsKeyFormatStrategy"
+                    + " and refer to it using the # notation.")
     private JmsKeyFormatStrategy jmsKeyFormatStrategy;
-    @UriParam(label = "advanced")
+    @UriParam(label = "advanced",
+            description = "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 Exchange and not a regular payload.")
     private boolean transferExchange;
-    @UriParam(label = "advanced")
+    @UriParam(label = "advanced",
+            description = "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 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.")
     private boolean transferException;
-    @UriParam
+    @UriParam(description = "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.")
     private boolean testConnectionOnStartup;
-    @UriParam(label = "advanced")
+    @UriParam(label = "advanced",
+            description = "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, then beware that if
the connection could not be established,"
+                    + " then an exception is logged at WARN level, and the consumer will
not be able to receive messages;"
+                    + " You can then restart the route to retry.")
     private boolean asyncStartListener;
-    @UriParam(label = "advanced")
+    @UriParam(label = "advanced",
+            description = "Whether to stop the JmsConsumer message listener asynchronously,
when stopping a route.")
     private boolean asyncStopListener;
     // if the message is a JmsMessage and mapJmsMessage=false, force the
     // producer to send the javax.jms.Message body to the next JMS destination
-    @UriParam(label = "producer,advanced")
+    @UriParam(label = "producer,advanced",
+            description = "When using mapJmsMessage=false Camel will create a new JMS message
to send to a new JMS destination"
+                    + " if you touch the headers (get or set) during the route. Set this
option to true to force Camel to send"
+                    + " the original JMS message that was received.")
     private boolean forceSendOriginalMessage;
     // to force disabling time to live (works in both in-only or in-out mode)
-    @UriParam(label = "producer,advanced")
+    @UriParam(label = "producer,advanced",
+            description = "Use this option to force disabling time to live."
+                    + " For example when you do request/reply over JMS, then Camel will by
default use the requestTimeout value"
+                    + " as time to live on the message being sent. The problem is that the
sender and receiver systems have"
+                    + " to have their clocks synchronized, so they are in sync. This is not
always so easy to archive."
+                    + " So you can use disableTimeToLive=true to not set a time to live value
on the sent message."
+                    + " Then the message will not expire on the receiver system. See below
in section About time to live for more details.")
     private boolean disableTimeToLive;
-    @UriParam(label = "producer")
+    @UriParam(label = "producer",
+            description = "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 in a clustered environment,"
+                    + " and the fact that Shared reply queues has lower performance than
its alternatives Temporary and Exclusive.")
     private ReplyToType replyToType;
-    @UriParam(label = "consumer")
+    @UriParam(label = "consumer",
+            description = "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 transacted has been enabled, then asyncConsumer=true does
not run asynchronously, as transaction"
+                    + "  must be executed synchronously (Camel 3.0 may support async transactions).")
     private boolean asyncConsumer;
     // the cacheLevelName of reply manager
-    @UriParam(label = "producer,advanced")
+    @UriParam(label = "producer,advanced",
+            description = "Sets the cache level by name for the reply consumer when doing
request/reply over JMS."
+                    + " This option only applies when using fixed reply queues (not temporary)."
+                    + " Camel will by default use: CACHE_CONSUMER for exclusive or shared
w/ replyToSelectorName."
+                    + " And CACHE_SESSION for shared without replyToSelectorName. Some JMS
brokers such as IBM WebSphere"
+                    + " may require to set the replyToCacheLevelName=CACHE_NONE to work."
+                    + " Note: If using temporary queues then CACHE_NONE is not allowed,"
+                    + " and you must use a higher value such as CACHE_CONSUMER or CACHE_SESSION.")
     private String replyToCacheLevelName;
-    @UriParam(defaultValue = "true", label = "producer,advanced")
+    @UriParam(defaultValue = "true", label = "producer,advanced",
+            description = "Whether to allow sending messages with no body. If this option
is false and the message body is null, then an JMSException is thrown.")
     private boolean allowNullBody = true;
-    @UriParam(label = "advanced")
+    @UriParam(label = "advanced",
+            description = "Registry ID of the MessageListenerContainerFactory used to determine
what"
+                    + " org.springframework.jms.listener.AbstractMessageListenerContainer
to use to consume messages."
+                    + " Setting this will automatically set consumerType to Custom.")
     private MessageListenerContainerFactory messageListenerContainerFactory;
-    @UriParam(label = "producer,advanced")
+    @UriParam(label = "producer,advanced",
+            description = "Only applicable when sending to JMS destination using InOnly (eg
fire and forget)."
+                    + " Enabling this option will enrich the Camel Exchange with the actual
JMSMessageID"
+                    + " that was used by the JMS client when the message was sent to the
JMS destination.")
     private boolean includeSentJMSMessageID;
-    @UriParam(label = "consumer,advanced")
+    @UriParam(label = "consumer,advanced",
+            description = "Specifies what default TaskExecutor type to use in the DefaultMessageListenerContainer,"
+                    + " for both consumer endpoints and the ReplyTo consumer of producer
endpoints."
+                    + " Possible values: SimpleAsync (uses Spring's SimpleAsyncTaskExecutor)
or ThreadPool"
+                    + " (uses Spring's ThreadPoolTaskExecutor with optimal values - cached
threadpool-like)."
+                    + " If not set, it defaults to the previous behaviour, which uses a cached
thread pool"
+                    + " for consumer endpoints and SimpleAsync for reply consumers."
+                    + " The use of ThreadPool is recommended to reduce thread trash in elastic
configurations"
+                    + " with dynamically increasing and decreasing concurrent consumers.")
     private DefaultTaskExecutorType defaultTaskExecutorType;
-    @UriParam(label = "advanced")
+    @UriParam(label = "advanced",
+            description = "Whether to include all JMSXxxx properties when mapping from JMS
to Camel Message."
+                    + " Setting this to true will include properties such as JMSXAppID, and
JMSXUserID etc."
+                    + " Note: If you are using a custom headerFilterStrategy then this option
does not apply.")
     private boolean includeAllJMSXProperties;
-    @UriParam(label = "advanced")
+    @UriParam(label = "advanced",
+            description = "To use the given MessageCreatedStrategy which are invoked when
Camel creates new instances of javax.jms.Message objects when Camel is sending a JMS message.")
     private MessageCreatedStrategy messageCreatedStrategy;
 
     public JmsConfiguration() {
@@ -538,7 +722,7 @@ public class JmsConfiguration implements Cloneable {
 
     /**
      * Sets the connection factory to be used for sending messages via the
-     * {@link JmsTemplate} via {@link #createInOnlyTemplate(JmsEndpoint,boolean, String)}
+     * {@link JmsTemplate} via {@link #createInOnlyTemplate(JmsEndpoint, boolean, String)}
      */
     public void setTemplateConnectionFactory(ConnectionFactory templateConnectionFactory)
{
         this.templateConnectionFactory = templateConnectionFactory;
@@ -577,7 +761,7 @@ public class JmsConfiguration implements Cloneable {
     /**
      * 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.
-     * <p/>
+     * <p>
      * If using Apache ActiveMQ you may prefer to use Virtual Topics instead.
      */
     public void setClientId(String consumerClientId) {
@@ -704,7 +888,7 @@ public class JmsConfiguration implements Cloneable {
     /**
      * Specifies the default number of concurrent consumers when consuming from JMS (not
for request/reply over JMS).
      * See also the maxMessagesPerTask option to control dynamic scaling up/down of threads.
-     * <p/>
+     * <p>
      * When doing request/reply over JMS then the option replyToConcurrentConsumers is used
to control number
      * of concurrent consumers on the reply message listener.
      */
@@ -852,7 +1036,7 @@ public class JmsConfiguration implements Cloneable {
     /**
      * Specifies the maximum number of concurrent consumers when consuming from JMS (not
for request/reply over JMS).
      * See also the maxMessagesPerTask option to control dynamic scaling up/down of threads.
-     * <p/>
+     * <p>
      * When doing request/reply over JMS then the option replyToMaxConcurrentConsumers is
used to control number
      * of concurrent consumers on the reply message listener.
      */
@@ -903,7 +1087,7 @@ public class JmsConfiguration implements Cloneable {
     }
 
     /**
-     * Specifies the delivery mode to be used. Possible values are
+     * Specifies the delivery mode to be used.
      * Possibles values are those defined by javax.jms.DeliveryMode.
      * NON_PERSISTENT = 1 and PERSISTENT = 2.
      */
@@ -953,7 +1137,6 @@ public class JmsConfiguration implements Cloneable {
 
     /**
      * Specifies whether Camel should auto map the received JMS message to a suited payload
type, such as javax.jms.TextMessage to a String etc.
-     * See section about how mapping works below for more details.
      */
     public void setMapJmsMessage(boolean mapJmsMessage) {
         this.mapJmsMessage = mapJmsMessage;
@@ -1021,7 +1204,7 @@ public class JmsConfiguration implements Cloneable {
 
     /**
      * Should InOut operations (request reply) default to using transacted mode?
-     * <p/>
+     * <p>
      * By default this is false as you need to commit the outgoing request before you can
consume the input
      */
     @Deprecated
@@ -1295,7 +1478,7 @@ public class JmsConfiguration implements Cloneable {
 
     /**
      * Defaults the JMS cache level if none is explicitly specified.
-     * <p/>
+     * <p>
      * Will return <tt>CACHE_AUTO</tt> which will pickup and use <tt>CACHE_NONE</tt>
      * if transacted has been enabled, otherwise it will use <tt>CACHE_CONSUMER</tt>
      * which is the most efficient.


Mime
View raw message