This is an automated email from the ASF dual-hosted git repository.
acosentino pushed a commit to branch camel-master
in repository https://gitbox.apache.org/repos/asf/camel-kafka-connector.git
The following commit(s) were added to refs/heads/camel-master by this push:
new a50dd04 [create-pull-request] automated change
a50dd04 is described below
commit a50dd04bf0ba575f3fa992500fa6cf45801f0172
Author: github-actions[bot]
<41898282+github-actions[bot]@users.noreply.github.com>
AuthorDate: Fri Jan 22 04:11:29 2021 +0000
[create-pull-request] automated change
---
.../connectors/camel-activemq-source.json | 12 +
.../resources/connectors/camel-amqp-source.json | 12 +
.../resources/connectors/camel-jms-source.json | 12 +
.../connectors/camel-paho-mqtt5-sink.json | 406 ++++++++++++++++++++
.../connectors/camel-paho-mqtt5-source.json | 423 +++++++++++++++++++++
.../generated/resources/camel-activemq-source.json | 12 +
.../camel-activemq-kafka-source-connector.adoc | 4 +-
.../CamelActivemqSourceConnectorConfig.java | 8 +
.../src/generated/resources/camel-amqp-source.json | 12 +
.../docs/camel-amqp-kafka-source-connector.adoc | 4 +-
.../amqp/CamelAmqpSourceConnectorConfig.java | 8 +
.../src/generated/resources/camel-jms-source.json | 12 +
.../docs/camel-jms-kafka-source-connector.adoc | 4 +-
.../jms/CamelJmsSourceConnectorConfig.java | 8 +
.../camel-activemq-kafka-source-connector.adoc | 4 +-
.../camel-amqp-kafka-source-connector.adoc | 4 +-
.../camel-jms-kafka-source-connector.adoc | 4 +-
17 files changed, 943 insertions(+), 6 deletions(-)
diff --git
a/camel-kafka-connector-catalog/src/generated/resources/connectors/camel-activemq-source.json
b/camel-kafka-connector-catalog/src/generated/resources/connectors/camel-activemq-source.json
index f6095f0..5104a3d 100644
---
a/camel-kafka-connector-catalog/src/generated/resources/connectors/camel-activemq-source.json
+++
b/camel-kafka-connector-catalog/src/generated/resources/connectors/camel-activemq-source.json
@@ -92,6 +92,12 @@
"DUPS_OK_ACKNOWLEDGE"
]
},
+ "camel.source.endpoint.artemisConsumerPriority": {
+ "name": "camel.source.endpoint.artemisConsumerPriority",
+ "description": "Consumer priorities allow you to ensure
that high priority consumers receive messages while they are active. Normally,
active consumers connected to a queue receive messages from it in a round-robin
fashion. When consumer priorities are in use, messages are delivered
round-robin if multiple active consumers exist with the same high priority.
Messages will only going to lower priority consumers when the high priority
consumers do not have credit available to consume the [...]
+ "priority": "MEDIUM",
+ "required": "false"
+ },
"camel.source.endpoint.asyncConsumer": {
"name": "camel.source.endpoint.asyncConsumer",
"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 [...]
@@ -616,6 +622,12 @@
"DUPS_OK_ACKNOWLEDGE"
]
},
+ "camel.component.activemq.artemisConsumerPriority": {
+ "name":
"camel.component.activemq.artemisConsumerPriority",
+ "description": "Consumer priorities allow you to ensure
that high priority consumers receive messages while they are active. Normally,
active consumers connected to a queue receive messages from it in a round-robin
fashion. When consumer priorities are in use, messages are delivered
round-robin if multiple active consumers exist with the same high priority.
Messages will only going to lower priority consumers when the high priority
consumers do not have credit available to consume the [...]
+ "priority": "MEDIUM",
+ "required": "false"
+ },
"camel.component.activemq.asyncConsumer": {
"name": "camel.component.activemq.asyncConsumer",
"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 [...]
diff --git
a/camel-kafka-connector-catalog/src/generated/resources/connectors/camel-amqp-source.json
b/camel-kafka-connector-catalog/src/generated/resources/connectors/camel-amqp-source.json
index 6b15fbb..31bc079 100644
---
a/camel-kafka-connector-catalog/src/generated/resources/connectors/camel-amqp-source.json
+++
b/camel-kafka-connector-catalog/src/generated/resources/connectors/camel-amqp-source.json
@@ -92,6 +92,12 @@
"DUPS_OK_ACKNOWLEDGE"
]
},
+ "camel.source.endpoint.artemisConsumerPriority": {
+ "name": "camel.source.endpoint.artemisConsumerPriority",
+ "description": "Consumer priorities allow you to ensure
that high priority consumers receive messages while they are active. Normally,
active consumers connected to a queue receive messages from it in a round-robin
fashion. When consumer priorities are in use, messages are delivered
round-robin if multiple active consumers exist with the same high priority.
Messages will only going to lower priority consumers when the high priority
consumers do not have credit available to consume the [...]
+ "priority": "MEDIUM",
+ "required": "false"
+ },
"camel.source.endpoint.asyncConsumer": {
"name": "camel.source.endpoint.asyncConsumer",
"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 [...]
@@ -603,6 +609,12 @@
"DUPS_OK_ACKNOWLEDGE"
]
},
+ "camel.component.amqp.artemisConsumerPriority": {
+ "name": "camel.component.amqp.artemisConsumerPriority",
+ "description": "Consumer priorities allow you to ensure
that high priority consumers receive messages while they are active. Normally,
active consumers connected to a queue receive messages from it in a round-robin
fashion. When consumer priorities are in use, messages are delivered
round-robin if multiple active consumers exist with the same high priority.
Messages will only going to lower priority consumers when the high priority
consumers do not have credit available to consume the [...]
+ "priority": "MEDIUM",
+ "required": "false"
+ },
"camel.component.amqp.asyncConsumer": {
"name": "camel.component.amqp.asyncConsumer",
"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 [...]
diff --git
a/camel-kafka-connector-catalog/src/generated/resources/connectors/camel-jms-source.json
b/camel-kafka-connector-catalog/src/generated/resources/connectors/camel-jms-source.json
index f6099b7..c0ae5ed 100644
---
a/camel-kafka-connector-catalog/src/generated/resources/connectors/camel-jms-source.json
+++
b/camel-kafka-connector-catalog/src/generated/resources/connectors/camel-jms-source.json
@@ -92,6 +92,12 @@
"DUPS_OK_ACKNOWLEDGE"
]
},
+ "camel.source.endpoint.artemisConsumerPriority": {
+ "name": "camel.source.endpoint.artemisConsumerPriority",
+ "description": "Consumer priorities allow you to ensure
that high priority consumers receive messages while they are active. Normally,
active consumers connected to a queue receive messages from it in a round-robin
fashion. When consumer priorities are in use, messages are delivered
round-robin if multiple active consumers exist with the same high priority.
Messages will only going to lower priority consumers when the high priority
consumers do not have credit available to consume the [...]
+ "priority": "MEDIUM",
+ "required": "false"
+ },
"camel.source.endpoint.asyncConsumer": {
"name": "camel.source.endpoint.asyncConsumer",
"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 [...]
@@ -596,6 +602,12 @@
"DUPS_OK_ACKNOWLEDGE"
]
},
+ "camel.component.jms.artemisConsumerPriority": {
+ "name": "camel.component.jms.artemisConsumerPriority",
+ "description": "Consumer priorities allow you to ensure
that high priority consumers receive messages while they are active. Normally,
active consumers connected to a queue receive messages from it in a round-robin
fashion. When consumer priorities are in use, messages are delivered
round-robin if multiple active consumers exist with the same high priority.
Messages will only going to lower priority consumers when the high priority
consumers do not have credit available to consume the [...]
+ "priority": "MEDIUM",
+ "required": "false"
+ },
"camel.component.jms.asyncConsumer": {
"name": "camel.component.jms.asyncConsumer",
"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 [...]
diff --git
a/camel-kafka-connector-catalog/src/generated/resources/connectors/camel-paho-mqtt5-sink.json
b/camel-kafka-connector-catalog/src/generated/resources/connectors/camel-paho-mqtt5-sink.json
new file mode 100644
index 0000000..22d8376
--- /dev/null
+++
b/camel-kafka-connector-catalog/src/generated/resources/connectors/camel-paho-mqtt5-sink.json
@@ -0,0 +1,406 @@
+{
+ "connector": {
+ "class":
"org.apache.camel.kafkaconnector.pahomqtt5.CamelPahomqtt5SinkConnector",
+ "artifactId": "camel-paho-mqtt5-kafka-connector",
+ "groupId": "org.apache.camel.kafkaconnector",
+ "id": "camel-paho-mqtt5-sink",
+ "type": "sink",
+ "version": "0.8.0-SNAPSHOT",
+ "description": "Communicate with MQTT message brokers using
Eclipse Paho MQTT v5 Client."
+ },
+ "properties": {
+ "camel.sink.path.topic": {
+ "name": "camel.sink.path.topic",
+ "description": "Name of the topic",
+ "priority": "HIGH",
+ "required": "true"
+ },
+ "camel.sink.endpoint.automaticReconnect": {
+ "name": "camel.sink.endpoint.automaticReconnect",
+ "description": "Sets whether the client will
automatically attempt to reconnect to the server if the connection is lost. If
set to false, the client will not attempt to automatically reconnect to the
server in the event that the connection is lost. If set to true, in the event
that the connection is lost, the client will attempt to reconnect to the
server. It will initially wait 1 second before it attempts to reconnect, for
every failed reconnect attempt, the delay will double until i [...]
+ "defaultValue": "true",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.sink.endpoint.brokerUrl": {
+ "name": "camel.sink.endpoint.brokerUrl",
+ "description": "The URL of the MQTT broker.",
+ "defaultValue": "\"tcp:\/\/localhost:1883\"",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.sink.endpoint.cleanStart": {
+ "name": "camel.sink.endpoint.cleanStart",
+ "description": "Sets whether the client and server
should remember state across restarts and reconnects. If set to false both the
client and server will maintain state across restarts of the client, the server
and the connection. As state is maintained: Message delivery will be reliable
meeting the specified QOS even if the client, server or connection are
restarted. The server will treat a subscription as durable. If set to true the
client and server will not maintain state across re [...]
+ "defaultValue": "true",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.sink.endpoint.clientId": {
+ "name": "camel.sink.endpoint.clientId",
+ "description": "MQTT client identifier. The identifier
must be unique.",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.sink.endpoint.connectionTimeout": {
+ "name": "camel.sink.endpoint.connectionTimeout",
+ "description": "Sets the connection timeout value. This
value, measured in seconds, defines the maximum time interval the client will
wait for the network connection to the MQTT server to be established. The
default timeout is 30 seconds. A value of 0 disables timeout processing meaning
the client will wait until the network connection is made successfully or
fails.",
+ "defaultValue": "30",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.sink.endpoint.filePersistenceDirectory": {
+ "name": "camel.sink.endpoint.filePersistenceDirectory",
+ "description": "Base directory used by file
persistence. Will by default use user directory.",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.sink.endpoint.keepAliveInterval": {
+ "name": "camel.sink.endpoint.keepAliveInterval",
+ "description": "Sets the keep alive interval. This
value, measured in seconds, defines the maximum time interval between messages
sent or received. It enables the client to detect if the server is no longer
available, without having to wait for the TCP\/IP timeout. The client will
ensure that at least one message travels across the network within each keep
alive period. In the absence of a data-related message during the time period,
the client sends a very small ping message, which t [...]
+ "defaultValue": "60",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.sink.endpoint.maxReconnectDelay": {
+ "name": "camel.sink.endpoint.maxReconnectDelay",
+ "description": "Get the maximum time (in millis) to
wait between reconnects",
+ "defaultValue": "128000",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.sink.endpoint.persistence": {
+ "name": "camel.sink.endpoint.persistence",
+ "description": "Client persistence to be used - memory
or file. One of: [FILE] [MEMORY]",
+ "defaultValue": "\"MEMORY\"",
+ "priority": "MEDIUM",
+ "required": "false",
+ "enum": [
+ "FILE",
+ "MEMORY"
+ ]
+ },
+ "camel.sink.endpoint.qos": {
+ "name": "camel.sink.endpoint.qos",
+ "description": "Client quality of service level (0-2).",
+ "defaultValue": "2",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.sink.endpoint.receiveMaximum": {
+ "name": "camel.sink.endpoint.receiveMaximum",
+ "description": "Sets the Receive Maximum. This value
represents the limit of QoS 1 and QoS 2 publications that the client is willing
to process concurrently. There is no mechanism to limit the number of QoS 0
publications that the Server might try to send. The default value is 65535",
+ "defaultValue": "65535",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.sink.endpoint.retained": {
+ "name": "camel.sink.endpoint.retained",
+ "description": "Retain option",
+ "defaultValue": "false",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.sink.endpoint.serverURIs": {
+ "name": "camel.sink.endpoint.serverURIs",
+ "description": "Set a list of one or more serverURIs
the client may connect to. Multiple servers can be separated by comma. Each
serverURI specifies the address of a server that the client may connect to. Two
types of connection are supported tcp:\/\/ for a TCP connection and ssl:\/\/
for a TCP connection secured by SSL\/TLS. For example: tcp:\/\/localhost:1883
ssl:\/\/localhost:8883 If the port is not specified, it will default to 1883
for tcp:\/\/ URIs, and 8883 for ssl:\/\/ URIs. I [...]
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.sink.endpoint.willMqttProperties": {
+ "name": "camel.sink.endpoint.willMqttProperties",
+ "description": "Sets the Last Will and Testament (LWT)
for the connection. In the event that this client unexpectedly loses its
connection to the server, the server will publish a message to itself using the
supplied details. The MQTT properties set for the message.",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.sink.endpoint.willPayload": {
+ "name": "camel.sink.endpoint.willPayload",
+ "description": "Sets the Last Will and Testament (LWT)
for the connection. In the event that this client unexpectedly loses its
connection to the server, the server will publish a message to itself using the
supplied details. The byte payload for the message.",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.sink.endpoint.willQos": {
+ "name": "camel.sink.endpoint.willQos",
+ "description": "Sets the Last Will and Testament (LWT)
for the connection. In the event that this client unexpectedly loses its
connection to the server, the server will publish a message to itself using the
supplied details. The quality of service to publish the message at (0, 1 or
2).",
+ "defaultValue": "1",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.sink.endpoint.willRetained": {
+ "name": "camel.sink.endpoint.willRetained",
+ "description": "Sets the Last Will and Testament (LWT)
for the connection. In the event that this client unexpectedly loses its
connection to the server, the server will publish a message to itself using the
supplied details. Whether or not the message should be retained.",
+ "defaultValue": "false",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.sink.endpoint.willTopic": {
+ "name": "camel.sink.endpoint.willTopic",
+ "description": "Sets the Last Will and Testament (LWT)
for the connection. In the event that this client unexpectedly loses its
connection to the server, the server will publish a message to itself using the
supplied details. The topic to publish to.",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.sink.endpoint.lazyStartProducer": {
+ "name": "camel.sink.endpoint.lazyStartProducer",
+ "description": "Whether the producer should be started
lazy (on the first message). By starting lazy you can use this to allow
CamelContext and routes to startup in situations where a producer may otherwise
fail during starting and cause the route to fail being started. By deferring
this startup to be lazy then the startup failure can be handled during routing
messages via Camel's routing error handlers. Beware that when the first message
is processed then creating and starting the pr [...]
+ "defaultValue": "false",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.sink.endpoint.client": {
+ "name": "camel.sink.endpoint.client",
+ "description": "To use an existing mqtt client",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.sink.endpoint.customWebSocketHeaders": {
+ "name": "camel.sink.endpoint.customWebSocketHeaders",
+ "description": "Sets the Custom WebSocket Headers for
the WebSocket Connection.",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.sink.endpoint.executorServiceTimeout": {
+ "name": "camel.sink.endpoint.executorServiceTimeout",
+ "description": "Set the time in seconds that the
executor service should wait when terminating before forcefully terminating. It
is not recommended to change this value unless you are absolutely sure that you
need to.",
+ "defaultValue": "1",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.sink.endpoint.httpsHostnameVerificationEnabled": {
+ "name":
"camel.sink.endpoint.httpsHostnameVerificationEnabled",
+ "description": "Whether SSL HostnameVerifier is enabled
or not. The default value is true.",
+ "defaultValue": "true",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.sink.endpoint.password": {
+ "name": "camel.sink.endpoint.password",
+ "description": "Password to be used for authentication
against the MQTT broker",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.sink.endpoint.socketFactory": {
+ "name": "camel.sink.endpoint.socketFactory",
+ "description": "Sets the SocketFactory to use. This
allows an application to apply its own policies around the creation of network
sockets. If using an SSL connection, an SSLSocketFactory can be used to supply
application-specific security settings.",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.sink.endpoint.sslClientProps": {
+ "name": "camel.sink.endpoint.sslClientProps",
+ "description": "Sets the SSL properties for the
connection. Note that these properties are only valid if an implementation of
the Java Secure Socket Extensions (JSSE) is available. These properties are not
used if a custom SocketFactory has been set. The following properties can be
used: com.ibm.ssl.protocol One of: SSL, SSLv3, TLS, TLSv1, SSL_TLS.
com.ibm.ssl.contextProvider Underlying JSSE provider. For example IBMJSSE2 or
SunJSSE com.ibm.ssl.keyStore The name of the file that conta [...]
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.sink.endpoint.sslHostnameVerifier": {
+ "name": "camel.sink.endpoint.sslHostnameVerifier",
+ "description": "Sets the HostnameVerifier for the SSL
connection. Note that it will be used after handshake on a connection and you
should do actions by yourself when hostname is verified error. There is no
default HostnameVerifier",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.sink.endpoint.userName": {
+ "name": "camel.sink.endpoint.userName",
+ "description": "Username to be used for authentication
against the MQTT broker",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.automaticReconnect": {
+ "name": "camel.component.paho-mqtt5.automaticReconnect",
+ "description": "Sets whether the client will
automatically attempt to reconnect to the server if the connection is lost. If
set to false, the client will not attempt to automatically reconnect to the
server in the event that the connection is lost. If set to true, in the event
that the connection is lost, the client will attempt to reconnect to the
server. It will initially wait 1 second before it attempts to reconnect, for
every failed reconnect attempt, the delay will double until i [...]
+ "defaultValue": "true",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.brokerUrl": {
+ "name": "camel.component.paho-mqtt5.brokerUrl",
+ "description": "The URL of the MQTT broker.",
+ "defaultValue": "\"tcp:\/\/localhost:1883\"",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.cleanStart": {
+ "name": "camel.component.paho-mqtt5.cleanStart",
+ "description": "Sets whether the client and server
should remember state across restarts and reconnects. If set to false both the
client and server will maintain state across restarts of the client, the server
and the connection. As state is maintained: Message delivery will be reliable
meeting the specified QOS even if the client, server or connection are
restarted. The server will treat a subscription as durable. If set to true the
client and server will not maintain state across re [...]
+ "defaultValue": "true",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.clientId": {
+ "name": "camel.component.paho-mqtt5.clientId",
+ "description": "MQTT client identifier. The identifier
must be unique.",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.configuration": {
+ "name": "camel.component.paho-mqtt5.configuration",
+ "description": "To use the shared Paho configuration",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.connectionTimeout": {
+ "name": "camel.component.paho-mqtt5.connectionTimeout",
+ "description": "Sets the connection timeout value. This
value, measured in seconds, defines the maximum time interval the client will
wait for the network connection to the MQTT server to be established. The
default timeout is 30 seconds. A value of 0 disables timeout processing meaning
the client will wait until the network connection is made successfully or
fails.",
+ "defaultValue": "30",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.filePersistenceDirectory": {
+ "name":
"camel.component.paho-mqtt5.filePersistenceDirectory",
+ "description": "Base directory used by file
persistence. Will by default use user directory.",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.keepAliveInterval": {
+ "name": "camel.component.paho-mqtt5.keepAliveInterval",
+ "description": "Sets the keep alive interval. This
value, measured in seconds, defines the maximum time interval between messages
sent or received. It enables the client to detect if the server is no longer
available, without having to wait for the TCP\/IP timeout. The client will
ensure that at least one message travels across the network within each keep
alive period. In the absence of a data-related message during the time period,
the client sends a very small ping message, which t [...]
+ "defaultValue": "60",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.maxReconnectDelay": {
+ "name": "camel.component.paho-mqtt5.maxReconnectDelay",
+ "description": "Get the maximum time (in millis) to
wait between reconnects",
+ "defaultValue": "128000",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.persistence": {
+ "name": "camel.component.paho-mqtt5.persistence",
+ "description": "Client persistence to be used - memory
or file. One of: [FILE] [MEMORY]",
+ "defaultValue": "\"MEMORY\"",
+ "priority": "MEDIUM",
+ "required": "false",
+ "enum": [
+ "FILE",
+ "MEMORY"
+ ]
+ },
+ "camel.component.paho-mqtt5.qos": {
+ "name": "camel.component.paho-mqtt5.qos",
+ "description": "Client quality of service level (0-2).",
+ "defaultValue": "2",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.receiveMaximum": {
+ "name": "camel.component.paho-mqtt5.receiveMaximum",
+ "description": "Sets the Receive Maximum. This value
represents the limit of QoS 1 and QoS 2 publications that the client is willing
to process concurrently. There is no mechanism to limit the number of QoS 0
publications that the Server might try to send. The default value is 65535",
+ "defaultValue": "65535",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.retained": {
+ "name": "camel.component.paho-mqtt5.retained",
+ "description": "Retain option",
+ "defaultValue": "false",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.serverURIs": {
+ "name": "camel.component.paho-mqtt5.serverURIs",
+ "description": "Set a list of one or more serverURIs
the client may connect to. Multiple servers can be separated by comma. Each
serverURI specifies the address of a server that the client may connect to. Two
types of connection are supported tcp:\/\/ for a TCP connection and ssl:\/\/
for a TCP connection secured by SSL\/TLS. For example: tcp:\/\/localhost:1883
ssl:\/\/localhost:8883 If the port is not specified, it will default to 1883
for tcp:\/\/ URIs, and 8883 for ssl:\/\/ URIs. I [...]
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.willMqttProperties": {
+ "name": "camel.component.paho-mqtt5.willMqttProperties",
+ "description": "Sets the Last Will and Testament (LWT)
for the connection. In the event that this client unexpectedly loses its
connection to the server, the server will publish a message to itself using the
supplied details. The MQTT properties set for the message.",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.willPayload": {
+ "name": "camel.component.paho-mqtt5.willPayload",
+ "description": "Sets the Last Will and Testament (LWT)
for the connection. In the event that this client unexpectedly loses its
connection to the server, the server will publish a message to itself using the
supplied details. The byte payload for the message.",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.willQos": {
+ "name": "camel.component.paho-mqtt5.willQos",
+ "description": "Sets the Last Will and Testament (LWT)
for the connection. In the event that this client unexpectedly loses its
connection to the server, the server will publish a message to itself using the
supplied details. The quality of service to publish the message at (0, 1 or
2).",
+ "defaultValue": "1",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.willRetained": {
+ "name": "camel.component.paho-mqtt5.willRetained",
+ "description": "Sets the Last Will and Testament (LWT)
for the connection. In the event that this client unexpectedly loses its
connection to the server, the server will publish a message to itself using the
supplied details. Whether or not the message should be retained.",
+ "defaultValue": "false",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.willTopic": {
+ "name": "camel.component.paho-mqtt5.willTopic",
+ "description": "Sets the Last Will and Testament (LWT)
for the connection. In the event that this client unexpectedly loses its
connection to the server, the server will publish a message to itself using the
supplied details. The topic to publish to.",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.lazyStartProducer": {
+ "name": "camel.component.paho-mqtt5.lazyStartProducer",
+ "description": "Whether the producer should be started
lazy (on the first message). By starting lazy you can use this to allow
CamelContext and routes to startup in situations where a producer may otherwise
fail during starting and cause the route to fail being started. By deferring
this startup to be lazy then the startup failure can be handled during routing
messages via Camel's routing error handlers. Beware that when the first message
is processed then creating and starting the pr [...]
+ "defaultValue": "false",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.autowiredEnabled": {
+ "name": "camel.component.paho-mqtt5.autowiredEnabled",
+ "description": "Whether autowiring is enabled. This is
used for automatic autowiring options (the option must be marked as autowired)
by looking up in the registry to find if there is a single instance of matching
type, which then gets configured on the component. This can be used for
automatic configuring JDBC data sources, JMS connection factories, AWS Clients,
etc.",
+ "defaultValue": "true",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.client": {
+ "name": "camel.component.paho-mqtt5.client",
+ "description": "To use a shared Paho client",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.customWebSocketHeaders": {
+ "name":
"camel.component.paho-mqtt5.customWebSocketHeaders",
+ "description": "Sets the Custom WebSocket Headers for
the WebSocket Connection.",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.executorServiceTimeout": {
+ "name":
"camel.component.paho-mqtt5.executorServiceTimeout",
+ "description": "Set the time in seconds that the
executor service should wait when terminating before forcefully terminating. It
is not recommended to change this value unless you are absolutely sure that you
need to.",
+ "defaultValue": "1",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.httpsHostnameVerificationEnabled": {
+ "name":
"camel.component.paho-mqtt5.httpsHostnameVerificationEnabled",
+ "description": "Whether SSL HostnameVerifier is enabled
or not. The default value is true.",
+ "defaultValue": "true",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.password": {
+ "name": "camel.component.paho-mqtt5.password",
+ "description": "Password to be used for authentication
against the MQTT broker",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.socketFactory": {
+ "name": "camel.component.paho-mqtt5.socketFactory",
+ "description": "Sets the SocketFactory to use. This
allows an application to apply its own policies around the creation of network
sockets. If using an SSL connection, an SSLSocketFactory can be used to supply
application-specific security settings.",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.sslClientProps": {
+ "name": "camel.component.paho-mqtt5.sslClientProps",
+ "description": "Sets the SSL properties for the
connection. Note that these properties are only valid if an implementation of
the Java Secure Socket Extensions (JSSE) is available. These properties are not
used if a custom SocketFactory has been set. The following properties can be
used: com.ibm.ssl.protocol One of: SSL, SSLv3, TLS, TLSv1, SSL_TLS.
com.ibm.ssl.contextProvider Underlying JSSE provider. For example IBMJSSE2 or
SunJSSE com.ibm.ssl.keyStore The name of the file that conta [...]
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.sslHostnameVerifier": {
+ "name":
"camel.component.paho-mqtt5.sslHostnameVerifier",
+ "description": "Sets the HostnameVerifier for the SSL
connection. Note that it will be used after handshake on a connection and you
should do actions by yourself when hostname is verified error. There is no
default HostnameVerifier",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.userName": {
+ "name": "camel.component.paho-mqtt5.userName",
+ "description": "Username to be used for authentication
against the MQTT broker",
+ "priority": "MEDIUM",
+ "required": "false"
+ }
+ }
+}
diff --git
a/camel-kafka-connector-catalog/src/generated/resources/connectors/camel-paho-mqtt5-source.json
b/camel-kafka-connector-catalog/src/generated/resources/connectors/camel-paho-mqtt5-source.json
new file mode 100644
index 0000000..8f35276
--- /dev/null
+++
b/camel-kafka-connector-catalog/src/generated/resources/connectors/camel-paho-mqtt5-source.json
@@ -0,0 +1,423 @@
+{
+ "connector": {
+ "class":
"org.apache.camel.kafkaconnector.pahomqtt5.CamelPahomqtt5SourceConnector",
+ "artifactId": "camel-paho-mqtt5-kafka-connector",
+ "groupId": "org.apache.camel.kafkaconnector",
+ "id": "camel-paho-mqtt5-source",
+ "type": "source",
+ "version": "0.8.0-SNAPSHOT",
+ "description": "Communicate with MQTT message brokers using
Eclipse Paho MQTT v5 Client."
+ },
+ "properties": {
+ "camel.source.path.topic": {
+ "name": "camel.source.path.topic",
+ "description": "Name of the topic",
+ "priority": "HIGH",
+ "required": "true"
+ },
+ "camel.source.endpoint.automaticReconnect": {
+ "name": "camel.source.endpoint.automaticReconnect",
+ "description": "Sets whether the client will
automatically attempt to reconnect to the server if the connection is lost. If
set to false, the client will not attempt to automatically reconnect to the
server in the event that the connection is lost. If set to true, in the event
that the connection is lost, the client will attempt to reconnect to the
server. It will initially wait 1 second before it attempts to reconnect, for
every failed reconnect attempt, the delay will double until i [...]
+ "defaultValue": "true",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.source.endpoint.brokerUrl": {
+ "name": "camel.source.endpoint.brokerUrl",
+ "description": "The URL of the MQTT broker.",
+ "defaultValue": "\"tcp:\/\/localhost:1883\"",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.source.endpoint.cleanStart": {
+ "name": "camel.source.endpoint.cleanStart",
+ "description": "Sets whether the client and server
should remember state across restarts and reconnects. If set to false both the
client and server will maintain state across restarts of the client, the server
and the connection. As state is maintained: Message delivery will be reliable
meeting the specified QOS even if the client, server or connection are
restarted. The server will treat a subscription as durable. If set to true the
client and server will not maintain state across re [...]
+ "defaultValue": "true",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.source.endpoint.clientId": {
+ "name": "camel.source.endpoint.clientId",
+ "description": "MQTT client identifier. The identifier
must be unique.",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.source.endpoint.connectionTimeout": {
+ "name": "camel.source.endpoint.connectionTimeout",
+ "description": "Sets the connection timeout value. This
value, measured in seconds, defines the maximum time interval the client will
wait for the network connection to the MQTT server to be established. The
default timeout is 30 seconds. A value of 0 disables timeout processing meaning
the client will wait until the network connection is made successfully or
fails.",
+ "defaultValue": "30",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.source.endpoint.filePersistenceDirectory": {
+ "name":
"camel.source.endpoint.filePersistenceDirectory",
+ "description": "Base directory used by file
persistence. Will by default use user directory.",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.source.endpoint.keepAliveInterval": {
+ "name": "camel.source.endpoint.keepAliveInterval",
+ "description": "Sets the keep alive interval. This
value, measured in seconds, defines the maximum time interval between messages
sent or received. It enables the client to detect if the server is no longer
available, without having to wait for the TCP\/IP timeout. The client will
ensure that at least one message travels across the network within each keep
alive period. In the absence of a data-related message during the time period,
the client sends a very small ping message, which t [...]
+ "defaultValue": "60",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.source.endpoint.maxReconnectDelay": {
+ "name": "camel.source.endpoint.maxReconnectDelay",
+ "description": "Get the maximum time (in millis) to
wait between reconnects",
+ "defaultValue": "128000",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.source.endpoint.persistence": {
+ "name": "camel.source.endpoint.persistence",
+ "description": "Client persistence to be used - memory
or file. One of: [FILE] [MEMORY]",
+ "defaultValue": "\"MEMORY\"",
+ "priority": "MEDIUM",
+ "required": "false",
+ "enum": [
+ "FILE",
+ "MEMORY"
+ ]
+ },
+ "camel.source.endpoint.qos": {
+ "name": "camel.source.endpoint.qos",
+ "description": "Client quality of service level (0-2).",
+ "defaultValue": "2",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.source.endpoint.receiveMaximum": {
+ "name": "camel.source.endpoint.receiveMaximum",
+ "description": "Sets the Receive Maximum. This value
represents the limit of QoS 1 and QoS 2 publications that the client is willing
to process concurrently. There is no mechanism to limit the number of QoS 0
publications that the Server might try to send. The default value is 65535",
+ "defaultValue": "65535",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.source.endpoint.retained": {
+ "name": "camel.source.endpoint.retained",
+ "description": "Retain option",
+ "defaultValue": "false",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.source.endpoint.serverURIs": {
+ "name": "camel.source.endpoint.serverURIs",
+ "description": "Set a list of one or more serverURIs
the client may connect to. Multiple servers can be separated by comma. Each
serverURI specifies the address of a server that the client may connect to. Two
types of connection are supported tcp:\/\/ for a TCP connection and ssl:\/\/
for a TCP connection secured by SSL\/TLS. For example: tcp:\/\/localhost:1883
ssl:\/\/localhost:8883 If the port is not specified, it will default to 1883
for tcp:\/\/ URIs, and 8883 for ssl:\/\/ URIs. I [...]
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.source.endpoint.willMqttProperties": {
+ "name": "camel.source.endpoint.willMqttProperties",
+ "description": "Sets the Last Will and Testament (LWT)
for the connection. In the event that this client unexpectedly loses its
connection to the server, the server will publish a message to itself using the
supplied details. The MQTT properties set for the message.",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.source.endpoint.willPayload": {
+ "name": "camel.source.endpoint.willPayload",
+ "description": "Sets the Last Will and Testament (LWT)
for the connection. In the event that this client unexpectedly loses its
connection to the server, the server will publish a message to itself using the
supplied details. The byte payload for the message.",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.source.endpoint.willQos": {
+ "name": "camel.source.endpoint.willQos",
+ "description": "Sets the Last Will and Testament (LWT)
for the connection. In the event that this client unexpectedly loses its
connection to the server, the server will publish a message to itself using the
supplied details. The quality of service to publish the message at (0, 1 or
2).",
+ "defaultValue": "1",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.source.endpoint.willRetained": {
+ "name": "camel.source.endpoint.willRetained",
+ "description": "Sets the Last Will and Testament (LWT)
for the connection. In the event that this client unexpectedly loses its
connection to the server, the server will publish a message to itself using the
supplied details. Whether or not the message should be retained.",
+ "defaultValue": "false",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.source.endpoint.willTopic": {
+ "name": "camel.source.endpoint.willTopic",
+ "description": "Sets the Last Will and Testament (LWT)
for the connection. In the event that this client unexpectedly loses its
connection to the server, the server will publish a message to itself using the
supplied details. The topic to publish to.",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.source.endpoint.bridgeErrorHandler": {
+ "name": "camel.source.endpoint.bridgeErrorHandler",
+ "description": "Allows for bridging the consumer to the
Camel routing Error Handler, which mean any exceptions occurred while the
consumer is trying to pickup incoming messages, or the likes, will now be
processed as a message and handled by the routing Error Handler. By default the
consumer will use the org.apache.camel.spi.ExceptionHandler to deal with
exceptions, that will be logged at WARN or ERROR level and ignored.",
+ "defaultValue": "false",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.source.endpoint.exceptionHandler": {
+ "name": "camel.source.endpoint.exceptionHandler",
+ "description": "To let the consumer use a custom
ExceptionHandler. Notice if the option bridgeErrorHandler is enabled then this
option is not in use. By default the consumer will deal with exceptions, that
will be logged at WARN or ERROR level and ignored.",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.source.endpoint.exchangePattern": {
+ "name": "camel.source.endpoint.exchangePattern",
+ "description": "Sets the exchange pattern when the
consumer creates an exchange. One of: [InOnly] [InOut] [InOptionalOut]",
+ "priority": "MEDIUM",
+ "required": "false",
+ "enum": [
+ "InOnly",
+ "InOut",
+ "InOptionalOut"
+ ]
+ },
+ "camel.source.endpoint.client": {
+ "name": "camel.source.endpoint.client",
+ "description": "To use an existing mqtt client",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.source.endpoint.customWebSocketHeaders": {
+ "name": "camel.source.endpoint.customWebSocketHeaders",
+ "description": "Sets the Custom WebSocket Headers for
the WebSocket Connection.",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.source.endpoint.executorServiceTimeout": {
+ "name": "camel.source.endpoint.executorServiceTimeout",
+ "description": "Set the time in seconds that the
executor service should wait when terminating before forcefully terminating. It
is not recommended to change this value unless you are absolutely sure that you
need to.",
+ "defaultValue": "1",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.source.endpoint.httpsHostnameVerificationEnabled": {
+ "name":
"camel.source.endpoint.httpsHostnameVerificationEnabled",
+ "description": "Whether SSL HostnameVerifier is enabled
or not. The default value is true.",
+ "defaultValue": "true",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.source.endpoint.password": {
+ "name": "camel.source.endpoint.password",
+ "description": "Password to be used for authentication
against the MQTT broker",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.source.endpoint.socketFactory": {
+ "name": "camel.source.endpoint.socketFactory",
+ "description": "Sets the SocketFactory to use. This
allows an application to apply its own policies around the creation of network
sockets. If using an SSL connection, an SSLSocketFactory can be used to supply
application-specific security settings.",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.source.endpoint.sslClientProps": {
+ "name": "camel.source.endpoint.sslClientProps",
+ "description": "Sets the SSL properties for the
connection. Note that these properties are only valid if an implementation of
the Java Secure Socket Extensions (JSSE) is available. These properties are not
used if a custom SocketFactory has been set. The following properties can be
used: com.ibm.ssl.protocol One of: SSL, SSLv3, TLS, TLSv1, SSL_TLS.
com.ibm.ssl.contextProvider Underlying JSSE provider. For example IBMJSSE2 or
SunJSSE com.ibm.ssl.keyStore The name of the file that conta [...]
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.source.endpoint.sslHostnameVerifier": {
+ "name": "camel.source.endpoint.sslHostnameVerifier",
+ "description": "Sets the HostnameVerifier for the SSL
connection. Note that it will be used after handshake on a connection and you
should do actions by yourself when hostname is verified error. There is no
default HostnameVerifier",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.source.endpoint.userName": {
+ "name": "camel.source.endpoint.userName",
+ "description": "Username to be used for authentication
against the MQTT broker",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.automaticReconnect": {
+ "name": "camel.component.paho-mqtt5.automaticReconnect",
+ "description": "Sets whether the client will
automatically attempt to reconnect to the server if the connection is lost. If
set to false, the client will not attempt to automatically reconnect to the
server in the event that the connection is lost. If set to true, in the event
that the connection is lost, the client will attempt to reconnect to the
server. It will initially wait 1 second before it attempts to reconnect, for
every failed reconnect attempt, the delay will double until i [...]
+ "defaultValue": "true",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.brokerUrl": {
+ "name": "camel.component.paho-mqtt5.brokerUrl",
+ "description": "The URL of the MQTT broker.",
+ "defaultValue": "\"tcp:\/\/localhost:1883\"",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.cleanStart": {
+ "name": "camel.component.paho-mqtt5.cleanStart",
+ "description": "Sets whether the client and server
should remember state across restarts and reconnects. If set to false both the
client and server will maintain state across restarts of the client, the server
and the connection. As state is maintained: Message delivery will be reliable
meeting the specified QOS even if the client, server or connection are
restarted. The server will treat a subscription as durable. If set to true the
client and server will not maintain state across re [...]
+ "defaultValue": "true",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.clientId": {
+ "name": "camel.component.paho-mqtt5.clientId",
+ "description": "MQTT client identifier. The identifier
must be unique.",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.configuration": {
+ "name": "camel.component.paho-mqtt5.configuration",
+ "description": "To use the shared Paho configuration",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.connectionTimeout": {
+ "name": "camel.component.paho-mqtt5.connectionTimeout",
+ "description": "Sets the connection timeout value. This
value, measured in seconds, defines the maximum time interval the client will
wait for the network connection to the MQTT server to be established. The
default timeout is 30 seconds. A value of 0 disables timeout processing meaning
the client will wait until the network connection is made successfully or
fails.",
+ "defaultValue": "30",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.filePersistenceDirectory": {
+ "name":
"camel.component.paho-mqtt5.filePersistenceDirectory",
+ "description": "Base directory used by file
persistence. Will by default use user directory.",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.keepAliveInterval": {
+ "name": "camel.component.paho-mqtt5.keepAliveInterval",
+ "description": "Sets the keep alive interval. This
value, measured in seconds, defines the maximum time interval between messages
sent or received. It enables the client to detect if the server is no longer
available, without having to wait for the TCP\/IP timeout. The client will
ensure that at least one message travels across the network within each keep
alive period. In the absence of a data-related message during the time period,
the client sends a very small ping message, which t [...]
+ "defaultValue": "60",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.maxReconnectDelay": {
+ "name": "camel.component.paho-mqtt5.maxReconnectDelay",
+ "description": "Get the maximum time (in millis) to
wait between reconnects",
+ "defaultValue": "128000",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.persistence": {
+ "name": "camel.component.paho-mqtt5.persistence",
+ "description": "Client persistence to be used - memory
or file. One of: [FILE] [MEMORY]",
+ "defaultValue": "\"MEMORY\"",
+ "priority": "MEDIUM",
+ "required": "false",
+ "enum": [
+ "FILE",
+ "MEMORY"
+ ]
+ },
+ "camel.component.paho-mqtt5.qos": {
+ "name": "camel.component.paho-mqtt5.qos",
+ "description": "Client quality of service level (0-2).",
+ "defaultValue": "2",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.receiveMaximum": {
+ "name": "camel.component.paho-mqtt5.receiveMaximum",
+ "description": "Sets the Receive Maximum. This value
represents the limit of QoS 1 and QoS 2 publications that the client is willing
to process concurrently. There is no mechanism to limit the number of QoS 0
publications that the Server might try to send. The default value is 65535",
+ "defaultValue": "65535",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.retained": {
+ "name": "camel.component.paho-mqtt5.retained",
+ "description": "Retain option",
+ "defaultValue": "false",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.serverURIs": {
+ "name": "camel.component.paho-mqtt5.serverURIs",
+ "description": "Set a list of one or more serverURIs
the client may connect to. Multiple servers can be separated by comma. Each
serverURI specifies the address of a server that the client may connect to. Two
types of connection are supported tcp:\/\/ for a TCP connection and ssl:\/\/
for a TCP connection secured by SSL\/TLS. For example: tcp:\/\/localhost:1883
ssl:\/\/localhost:8883 If the port is not specified, it will default to 1883
for tcp:\/\/ URIs, and 8883 for ssl:\/\/ URIs. I [...]
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.willMqttProperties": {
+ "name": "camel.component.paho-mqtt5.willMqttProperties",
+ "description": "Sets the Last Will and Testament (LWT)
for the connection. In the event that this client unexpectedly loses its
connection to the server, the server will publish a message to itself using the
supplied details. The MQTT properties set for the message.",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.willPayload": {
+ "name": "camel.component.paho-mqtt5.willPayload",
+ "description": "Sets the Last Will and Testament (LWT)
for the connection. In the event that this client unexpectedly loses its
connection to the server, the server will publish a message to itself using the
supplied details. The byte payload for the message.",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.willQos": {
+ "name": "camel.component.paho-mqtt5.willQos",
+ "description": "Sets the Last Will and Testament (LWT)
for the connection. In the event that this client unexpectedly loses its
connection to the server, the server will publish a message to itself using the
supplied details. The quality of service to publish the message at (0, 1 or
2).",
+ "defaultValue": "1",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.willRetained": {
+ "name": "camel.component.paho-mqtt5.willRetained",
+ "description": "Sets the Last Will and Testament (LWT)
for the connection. In the event that this client unexpectedly loses its
connection to the server, the server will publish a message to itself using the
supplied details. Whether or not the message should be retained.",
+ "defaultValue": "false",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.willTopic": {
+ "name": "camel.component.paho-mqtt5.willTopic",
+ "description": "Sets the Last Will and Testament (LWT)
for the connection. In the event that this client unexpectedly loses its
connection to the server, the server will publish a message to itself using the
supplied details. The topic to publish to.",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.bridgeErrorHandler": {
+ "name": "camel.component.paho-mqtt5.bridgeErrorHandler",
+ "description": "Allows for bridging the consumer to the
Camel routing Error Handler, which mean any exceptions occurred while the
consumer is trying to pickup incoming messages, or the likes, will now be
processed as a message and handled by the routing Error Handler. By default the
consumer will use the org.apache.camel.spi.ExceptionHandler to deal with
exceptions, that will be logged at WARN or ERROR level and ignored.",
+ "defaultValue": "false",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.autowiredEnabled": {
+ "name": "camel.component.paho-mqtt5.autowiredEnabled",
+ "description": "Whether autowiring is enabled. This is
used for automatic autowiring options (the option must be marked as autowired)
by looking up in the registry to find if there is a single instance of matching
type, which then gets configured on the component. This can be used for
automatic configuring JDBC data sources, JMS connection factories, AWS Clients,
etc.",
+ "defaultValue": "true",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.client": {
+ "name": "camel.component.paho-mqtt5.client",
+ "description": "To use a shared Paho client",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.customWebSocketHeaders": {
+ "name":
"camel.component.paho-mqtt5.customWebSocketHeaders",
+ "description": "Sets the Custom WebSocket Headers for
the WebSocket Connection.",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.executorServiceTimeout": {
+ "name":
"camel.component.paho-mqtt5.executorServiceTimeout",
+ "description": "Set the time in seconds that the
executor service should wait when terminating before forcefully terminating. It
is not recommended to change this value unless you are absolutely sure that you
need to.",
+ "defaultValue": "1",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.httpsHostnameVerificationEnabled": {
+ "name":
"camel.component.paho-mqtt5.httpsHostnameVerificationEnabled",
+ "description": "Whether SSL HostnameVerifier is enabled
or not. The default value is true.",
+ "defaultValue": "true",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.password": {
+ "name": "camel.component.paho-mqtt5.password",
+ "description": "Password to be used for authentication
against the MQTT broker",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.socketFactory": {
+ "name": "camel.component.paho-mqtt5.socketFactory",
+ "description": "Sets the SocketFactory to use. This
allows an application to apply its own policies around the creation of network
sockets. If using an SSL connection, an SSLSocketFactory can be used to supply
application-specific security settings.",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.sslClientProps": {
+ "name": "camel.component.paho-mqtt5.sslClientProps",
+ "description": "Sets the SSL properties for the
connection. Note that these properties are only valid if an implementation of
the Java Secure Socket Extensions (JSSE) is available. These properties are not
used if a custom SocketFactory has been set. The following properties can be
used: com.ibm.ssl.protocol One of: SSL, SSLv3, TLS, TLSv1, SSL_TLS.
com.ibm.ssl.contextProvider Underlying JSSE provider. For example IBMJSSE2 or
SunJSSE com.ibm.ssl.keyStore The name of the file that conta [...]
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.sslHostnameVerifier": {
+ "name":
"camel.component.paho-mqtt5.sslHostnameVerifier",
+ "description": "Sets the HostnameVerifier for the SSL
connection. Note that it will be used after handshake on a connection and you
should do actions by yourself when hostname is verified error. There is no
default HostnameVerifier",
+ "priority": "MEDIUM",
+ "required": "false"
+ },
+ "camel.component.paho-mqtt5.userName": {
+ "name": "camel.component.paho-mqtt5.userName",
+ "description": "Username to be used for authentication
against the MQTT broker",
+ "priority": "MEDIUM",
+ "required": "false"
+ }
+ }
+}
diff --git
a/connectors/camel-activemq-kafka-connector/src/generated/resources/camel-activemq-source.json
b/connectors/camel-activemq-kafka-connector/src/generated/resources/camel-activemq-source.json
index f6095f0..5104a3d 100644
---
a/connectors/camel-activemq-kafka-connector/src/generated/resources/camel-activemq-source.json
+++
b/connectors/camel-activemq-kafka-connector/src/generated/resources/camel-activemq-source.json
@@ -92,6 +92,12 @@
"DUPS_OK_ACKNOWLEDGE"
]
},
+ "camel.source.endpoint.artemisConsumerPriority": {
+ "name": "camel.source.endpoint.artemisConsumerPriority",
+ "description": "Consumer priorities allow you to ensure
that high priority consumers receive messages while they are active. Normally,
active consumers connected to a queue receive messages from it in a round-robin
fashion. When consumer priorities are in use, messages are delivered
round-robin if multiple active consumers exist with the same high priority.
Messages will only going to lower priority consumers when the high priority
consumers do not have credit available to consume the [...]
+ "priority": "MEDIUM",
+ "required": "false"
+ },
"camel.source.endpoint.asyncConsumer": {
"name": "camel.source.endpoint.asyncConsumer",
"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 [...]
@@ -616,6 +622,12 @@
"DUPS_OK_ACKNOWLEDGE"
]
},
+ "camel.component.activemq.artemisConsumerPriority": {
+ "name":
"camel.component.activemq.artemisConsumerPriority",
+ "description": "Consumer priorities allow you to ensure
that high priority consumers receive messages while they are active. Normally,
active consumers connected to a queue receive messages from it in a round-robin
fashion. When consumer priorities are in use, messages are delivered
round-robin if multiple active consumers exist with the same high priority.
Messages will only going to lower priority consumers when the high priority
consumers do not have credit available to consume the [...]
+ "priority": "MEDIUM",
+ "required": "false"
+ },
"camel.component.activemq.asyncConsumer": {
"name": "camel.component.activemq.asyncConsumer",
"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 [...]
diff --git
a/connectors/camel-activemq-kafka-connector/src/main/docs/camel-activemq-kafka-source-connector.adoc
b/connectors/camel-activemq-kafka-connector/src/main/docs/camel-activemq-kafka-source-connector.adoc
index 354e0bd..f4ee729 100644
---
a/connectors/camel-activemq-kafka-connector/src/main/docs/camel-activemq-kafka-source-connector.adoc
+++
b/connectors/camel-activemq-kafka-connector/src/main/docs/camel-activemq-kafka-source-connector.adoc
@@ -22,7 +22,7 @@
connector.class=org.apache.camel.kafkaconnector.activemq.CamelActivemqSourceConn
----
-The camel-activemq source connector supports 147 options, which are listed
below.
+The camel-activemq source connector supports 149 options, which are listed
below.
@@ -39,6 +39,7 @@ The camel-activemq source connector supports 147 options,
which are listed below
| *camel.source.endpoint.replyTo* | Provides an explicit ReplyTo destination
(overrides any incoming value of Message.getJMSReplyTo() in consumer). | null |
false | MEDIUM
| *camel.source.endpoint.testConnectionOnStartup* | 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 | false | MEDIUM
| *camel.source.endpoint.acknowledgementModeName* | The JMS acknowledgement
name, which is one of: SESSION_TRANSACTED, CLIENT_ACKNOWLEDGE,
AUTO_ACKNOWLEDGE, DUPS_OK_ACKNOWLEDGE One of: [SESSION_TRANSACTED]
[CLIENT_ACKNOWLEDGE] [AUTO_ACKNOWLEDGE] [DUPS_OK_ACKNOWLEDGE] |
"AUTO_ACKNOWLEDGE" | false | MEDIUM
+| *camel.source.endpoint.artemisConsumerPriority* | Consumer priorities allow
you to ensure that high priority consumers receive messages while they are
active. Normally, active consumers connected to a queue receive messages from
it in a round-robin fashion. When consumer priorities are in use, messages are
delivered round-robin if multiple active consumers exist with the same high
priority. Messages will only going to lower priority consumers when the high
priority consumers do not hav [...]
| *camel.source.endpoint.asyncConsumer* | 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 [...]
| *camel.source.endpoint.autoStartup* | Specifies whether the consumer
container should auto-startup. | true | false | MEDIUM
| *camel.source.endpoint.cacheLevel* | Sets the cache level by ID for the
underlying JMS resources. See cacheLevelName option for more details. | null |
false | MEDIUM
@@ -111,6 +112,7 @@ The camel-activemq source connector supports 147 options,
which are listed below
| *camel.component.activemq.usePooledConnection* | 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 | false | MEDIUM
| *camel.component.activemq.useSingleConnection* | 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
| false | MEDIUM
| *camel.component.activemq.acknowledgementModeName* | The JMS acknowledgement
name, which is one of: SESSION_TRANSACTED, CLIENT_ACKNOWLEDGE,
AUTO_ACKNOWLEDGE, DUPS_OK_ACKNOWLEDGE One of: [SESSION_TRANSACTED]
[CLIENT_ACKNOWLEDGE] [AUTO_ACKNOWLEDGE] [DUPS_OK_ACKNOWLEDGE] |
"AUTO_ACKNOWLEDGE" | false | MEDIUM
+| *camel.component.activemq.artemisConsumerPriority* | Consumer priorities
allow you to ensure that high priority consumers receive messages while they
are active. Normally, active consumers connected to a queue receive messages
from it in a round-robin fashion. When consumer priorities are in use, messages
are delivered round-robin if multiple active consumers exist with the same high
priority. Messages will only going to lower priority consumers when the high
priority consumers do not [...]
| *camel.component.activemq.asyncConsumer* | 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. N [...]
| *camel.component.activemq.autoStartup* | Specifies whether the consumer
container should auto-startup. | true | false | MEDIUM
| *camel.component.activemq.cacheLevel* | Sets the cache level by ID for the
underlying JMS resources. See cacheLevelName option for more details. | null |
false | MEDIUM
diff --git
a/connectors/camel-activemq-kafka-connector/src/main/java/org/apache/camel/kafkaconnector/activemq/CamelActivemqSourceConnectorConfig.java
b/connectors/camel-activemq-kafka-connector/src/main/java/org/apache/camel/kafkaconnector/activemq/CamelActivemqSourceConnectorConfig.java
index 9a8b655..ef0c241 100644
---
a/connectors/camel-activemq-kafka-connector/src/main/java/org/apache/camel/kafkaconnector/activemq/CamelActivemqSourceConnectorConfig.java
+++
b/connectors/camel-activemq-kafka-connector/src/main/java/org/apache/camel/kafkaconnector/activemq/CamelActivemqSourceConnectorConfig.java
@@ -56,6 +56,9 @@ public class CamelActivemqSourceConnectorConfig
public static final String
CAMEL_SOURCE_ACTIVEMQ_ENDPOINT_ACKNOWLEDGEMENT_MODE_NAME_CONF =
"camel.source.endpoint.acknowledgementModeName";
public static final String
CAMEL_SOURCE_ACTIVEMQ_ENDPOINT_ACKNOWLEDGEMENT_MODE_NAME_DOC = "The JMS
acknowledgement name, which is one of: SESSION_TRANSACTED, CLIENT_ACKNOWLEDGE,
AUTO_ACKNOWLEDGE, DUPS_OK_ACKNOWLEDGE One of: [SESSION_TRANSACTED]
[CLIENT_ACKNOWLEDGE] [AUTO_ACKNOWLEDGE] [DUPS_OK_ACKNOWLEDGE]";
public static final String
CAMEL_SOURCE_ACTIVEMQ_ENDPOINT_ACKNOWLEDGEMENT_MODE_NAME_DEFAULT =
"AUTO_ACKNOWLEDGE";
+ public static final String
CAMEL_SOURCE_ACTIVEMQ_ENDPOINT_ARTEMIS_CONSUMER_PRIORITY_CONF =
"camel.source.endpoint.artemisConsumerPriority";
+ public static final String
CAMEL_SOURCE_ACTIVEMQ_ENDPOINT_ARTEMIS_CONSUMER_PRIORITY_DOC = "Consumer
priorities allow you to ensure that high priority consumers receive messages
while they are active. Normally, active consumers connected to a queue receive
messages from it in a round-robin fashion. When consumer priorities are in use,
messages are delivered round-robin if multiple active consumers exist with the
same high priority. Messages will only going to lower priority consumers [...]
+ public static final Integer
CAMEL_SOURCE_ACTIVEMQ_ENDPOINT_ARTEMIS_CONSUMER_PRIORITY_DEFAULT = null;
public static final String
CAMEL_SOURCE_ACTIVEMQ_ENDPOINT_ASYNC_CONSUMER_CONF =
"camel.source.endpoint.asyncConsumer";
public static final String
CAMEL_SOURCE_ACTIVEMQ_ENDPOINT_ASYNC_CONSUMER_DOC = "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 [...]
public static final Boolean
CAMEL_SOURCE_ACTIVEMQ_ENDPOINT_ASYNC_CONSUMER_DEFAULT = false;
@@ -272,6 +275,9 @@ public class CamelActivemqSourceConnectorConfig
public static final String
CAMEL_SOURCE_ACTIVEMQ_COMPONENT_ACKNOWLEDGEMENT_MODE_NAME_CONF =
"camel.component.activemq.acknowledgementModeName";
public static final String
CAMEL_SOURCE_ACTIVEMQ_COMPONENT_ACKNOWLEDGEMENT_MODE_NAME_DOC = "The JMS
acknowledgement name, which is one of: SESSION_TRANSACTED, CLIENT_ACKNOWLEDGE,
AUTO_ACKNOWLEDGE, DUPS_OK_ACKNOWLEDGE One of: [SESSION_TRANSACTED]
[CLIENT_ACKNOWLEDGE] [AUTO_ACKNOWLEDGE] [DUPS_OK_ACKNOWLEDGE]";
public static final String
CAMEL_SOURCE_ACTIVEMQ_COMPONENT_ACKNOWLEDGEMENT_MODE_NAME_DEFAULT =
"AUTO_ACKNOWLEDGE";
+ public static final String
CAMEL_SOURCE_ACTIVEMQ_COMPONENT_ARTEMIS_CONSUMER_PRIORITY_CONF =
"camel.component.activemq.artemisConsumerPriority";
+ public static final String
CAMEL_SOURCE_ACTIVEMQ_COMPONENT_ARTEMIS_CONSUMER_PRIORITY_DOC = "Consumer
priorities allow you to ensure that high priority consumers receive messages
while they are active. Normally, active consumers connected to a queue receive
messages from it in a round-robin fashion. When consumer priorities are in use,
messages are delivered round-robin if multiple active consumers exist with the
same high priority. Messages will only going to lower priority consumers [...]
+ public static final Integer
CAMEL_SOURCE_ACTIVEMQ_COMPONENT_ARTEMIS_CONSUMER_PRIORITY_DEFAULT = null;
public static final String
CAMEL_SOURCE_ACTIVEMQ_COMPONENT_ASYNC_CONSUMER_CONF =
"camel.component.activemq.asyncConsumer";
public static final String
CAMEL_SOURCE_ACTIVEMQ_COMPONENT_ASYNC_CONSUMER_DOC = "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 picku [...]
public static final Boolean
CAMEL_SOURCE_ACTIVEMQ_COMPONENT_ASYNC_CONSUMER_DEFAULT = false;
@@ -490,6 +496,7 @@ public class CamelActivemqSourceConnectorConfig
conf.define(CAMEL_SOURCE_ACTIVEMQ_ENDPOINT_REPLY_TO_CONF,
ConfigDef.Type.STRING, CAMEL_SOURCE_ACTIVEMQ_ENDPOINT_REPLY_TO_DEFAULT,
ConfigDef.Importance.MEDIUM, CAMEL_SOURCE_ACTIVEMQ_ENDPOINT_REPLY_TO_DOC);
conf.define(CAMEL_SOURCE_ACTIVEMQ_ENDPOINT_TEST_CONNECTION_ON_STARTUP_CONF,
ConfigDef.Type.BOOLEAN,
CAMEL_SOURCE_ACTIVEMQ_ENDPOINT_TEST_CONNECTION_ON_STARTUP_DEFAULT,
ConfigDef.Importance.MEDIUM,
CAMEL_SOURCE_ACTIVEMQ_ENDPOINT_TEST_CONNECTION_ON_STARTUP_DOC);
conf.define(CAMEL_SOURCE_ACTIVEMQ_ENDPOINT_ACKNOWLEDGEMENT_MODE_NAME_CONF,
ConfigDef.Type.STRING,
CAMEL_SOURCE_ACTIVEMQ_ENDPOINT_ACKNOWLEDGEMENT_MODE_NAME_DEFAULT,
ConfigDef.Importance.MEDIUM,
CAMEL_SOURCE_ACTIVEMQ_ENDPOINT_ACKNOWLEDGEMENT_MODE_NAME_DOC);
+
conf.define(CAMEL_SOURCE_ACTIVEMQ_ENDPOINT_ARTEMIS_CONSUMER_PRIORITY_CONF,
ConfigDef.Type.INT,
CAMEL_SOURCE_ACTIVEMQ_ENDPOINT_ARTEMIS_CONSUMER_PRIORITY_DEFAULT,
ConfigDef.Importance.MEDIUM,
CAMEL_SOURCE_ACTIVEMQ_ENDPOINT_ARTEMIS_CONSUMER_PRIORITY_DOC);
conf.define(CAMEL_SOURCE_ACTIVEMQ_ENDPOINT_ASYNC_CONSUMER_CONF,
ConfigDef.Type.BOOLEAN, CAMEL_SOURCE_ACTIVEMQ_ENDPOINT_ASYNC_CONSUMER_DEFAULT,
ConfigDef.Importance.MEDIUM, CAMEL_SOURCE_ACTIVEMQ_ENDPOINT_ASYNC_CONSUMER_DOC);
conf.define(CAMEL_SOURCE_ACTIVEMQ_ENDPOINT_AUTO_STARTUP_CONF,
ConfigDef.Type.BOOLEAN, CAMEL_SOURCE_ACTIVEMQ_ENDPOINT_AUTO_STARTUP_DEFAULT,
ConfigDef.Importance.MEDIUM, CAMEL_SOURCE_ACTIVEMQ_ENDPOINT_AUTO_STARTUP_DOC);
conf.define(CAMEL_SOURCE_ACTIVEMQ_ENDPOINT_CACHE_LEVEL_CONF,
ConfigDef.Type.INT, CAMEL_SOURCE_ACTIVEMQ_ENDPOINT_CACHE_LEVEL_DEFAULT,
ConfigDef.Importance.MEDIUM, CAMEL_SOURCE_ACTIVEMQ_ENDPOINT_CACHE_LEVEL_DOC);
@@ -562,6 +569,7 @@ public class CamelActivemqSourceConnectorConfig
conf.define(CAMEL_SOURCE_ACTIVEMQ_COMPONENT_USE_POOLED_CONNECTION_CONF,
ConfigDef.Type.BOOLEAN,
CAMEL_SOURCE_ACTIVEMQ_COMPONENT_USE_POOLED_CONNECTION_DEFAULT,
ConfigDef.Importance.MEDIUM,
CAMEL_SOURCE_ACTIVEMQ_COMPONENT_USE_POOLED_CONNECTION_DOC);
conf.define(CAMEL_SOURCE_ACTIVEMQ_COMPONENT_USE_SINGLE_CONNECTION_CONF,
ConfigDef.Type.BOOLEAN,
CAMEL_SOURCE_ACTIVEMQ_COMPONENT_USE_SINGLE_CONNECTION_DEFAULT,
ConfigDef.Importance.MEDIUM,
CAMEL_SOURCE_ACTIVEMQ_COMPONENT_USE_SINGLE_CONNECTION_DOC);
conf.define(CAMEL_SOURCE_ACTIVEMQ_COMPONENT_ACKNOWLEDGEMENT_MODE_NAME_CONF,
ConfigDef.Type.STRING,
CAMEL_SOURCE_ACTIVEMQ_COMPONENT_ACKNOWLEDGEMENT_MODE_NAME_DEFAULT,
ConfigDef.Importance.MEDIUM,
CAMEL_SOURCE_ACTIVEMQ_COMPONENT_ACKNOWLEDGEMENT_MODE_NAME_DOC);
+
conf.define(CAMEL_SOURCE_ACTIVEMQ_COMPONENT_ARTEMIS_CONSUMER_PRIORITY_CONF,
ConfigDef.Type.INT,
CAMEL_SOURCE_ACTIVEMQ_COMPONENT_ARTEMIS_CONSUMER_PRIORITY_DEFAULT,
ConfigDef.Importance.MEDIUM,
CAMEL_SOURCE_ACTIVEMQ_COMPONENT_ARTEMIS_CONSUMER_PRIORITY_DOC);
conf.define(CAMEL_SOURCE_ACTIVEMQ_COMPONENT_ASYNC_CONSUMER_CONF,
ConfigDef.Type.BOOLEAN, CAMEL_SOURCE_ACTIVEMQ_COMPONENT_ASYNC_CONSUMER_DEFAULT,
ConfigDef.Importance.MEDIUM,
CAMEL_SOURCE_ACTIVEMQ_COMPONENT_ASYNC_CONSUMER_DOC);
conf.define(CAMEL_SOURCE_ACTIVEMQ_COMPONENT_AUTO_STARTUP_CONF,
ConfigDef.Type.BOOLEAN, CAMEL_SOURCE_ACTIVEMQ_COMPONENT_AUTO_STARTUP_DEFAULT,
ConfigDef.Importance.MEDIUM, CAMEL_SOURCE_ACTIVEMQ_COMPONENT_AUTO_STARTUP_DOC);
conf.define(CAMEL_SOURCE_ACTIVEMQ_COMPONENT_CACHE_LEVEL_CONF,
ConfigDef.Type.INT, CAMEL_SOURCE_ACTIVEMQ_COMPONENT_CACHE_LEVEL_DEFAULT,
ConfigDef.Importance.MEDIUM, CAMEL_SOURCE_ACTIVEMQ_COMPONENT_CACHE_LEVEL_DOC);
diff --git
a/connectors/camel-amqp-kafka-connector/src/generated/resources/camel-amqp-source.json
b/connectors/camel-amqp-kafka-connector/src/generated/resources/camel-amqp-source.json
index 6b15fbb..31bc079 100644
---
a/connectors/camel-amqp-kafka-connector/src/generated/resources/camel-amqp-source.json
+++
b/connectors/camel-amqp-kafka-connector/src/generated/resources/camel-amqp-source.json
@@ -92,6 +92,12 @@
"DUPS_OK_ACKNOWLEDGE"
]
},
+ "camel.source.endpoint.artemisConsumerPriority": {
+ "name": "camel.source.endpoint.artemisConsumerPriority",
+ "description": "Consumer priorities allow you to ensure
that high priority consumers receive messages while they are active. Normally,
active consumers connected to a queue receive messages from it in a round-robin
fashion. When consumer priorities are in use, messages are delivered
round-robin if multiple active consumers exist with the same high priority.
Messages will only going to lower priority consumers when the high priority
consumers do not have credit available to consume the [...]
+ "priority": "MEDIUM",
+ "required": "false"
+ },
"camel.source.endpoint.asyncConsumer": {
"name": "camel.source.endpoint.asyncConsumer",
"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 [...]
@@ -603,6 +609,12 @@
"DUPS_OK_ACKNOWLEDGE"
]
},
+ "camel.component.amqp.artemisConsumerPriority": {
+ "name": "camel.component.amqp.artemisConsumerPriority",
+ "description": "Consumer priorities allow you to ensure
that high priority consumers receive messages while they are active. Normally,
active consumers connected to a queue receive messages from it in a round-robin
fashion. When consumer priorities are in use, messages are delivered
round-robin if multiple active consumers exist with the same high priority.
Messages will only going to lower priority consumers when the high priority
consumers do not have credit available to consume the [...]
+ "priority": "MEDIUM",
+ "required": "false"
+ },
"camel.component.amqp.asyncConsumer": {
"name": "camel.component.amqp.asyncConsumer",
"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 [...]
diff --git
a/connectors/camel-amqp-kafka-connector/src/main/docs/camel-amqp-kafka-source-connector.adoc
b/connectors/camel-amqp-kafka-connector/src/main/docs/camel-amqp-kafka-source-connector.adoc
index bf772f3..119793a 100644
---
a/connectors/camel-amqp-kafka-connector/src/main/docs/camel-amqp-kafka-source-connector.adoc
+++
b/connectors/camel-amqp-kafka-connector/src/main/docs/camel-amqp-kafka-source-connector.adoc
@@ -22,7 +22,7 @@
connector.class=org.apache.camel.kafkaconnector.amqp.CamelAmqpSourceConnector
----
-The camel-amqp source connector supports 144 options, which are listed below.
+The camel-amqp source connector supports 146 options, which are listed below.
@@ -39,6 +39,7 @@ The camel-amqp source connector supports 144 options, which
are listed below.
| *camel.source.endpoint.replyTo* | Provides an explicit ReplyTo destination
(overrides any incoming value of Message.getJMSReplyTo() in consumer). | null |
false | MEDIUM
| *camel.source.endpoint.testConnectionOnStartup* | 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 | false | MEDIUM
| *camel.source.endpoint.acknowledgementModeName* | The JMS acknowledgement
name, which is one of: SESSION_TRANSACTED, CLIENT_ACKNOWLEDGE,
AUTO_ACKNOWLEDGE, DUPS_OK_ACKNOWLEDGE One of: [SESSION_TRANSACTED]
[CLIENT_ACKNOWLEDGE] [AUTO_ACKNOWLEDGE] [DUPS_OK_ACKNOWLEDGE] |
"AUTO_ACKNOWLEDGE" | false | MEDIUM
+| *camel.source.endpoint.artemisConsumerPriority* | Consumer priorities allow
you to ensure that high priority consumers receive messages while they are
active. Normally, active consumers connected to a queue receive messages from
it in a round-robin fashion. When consumer priorities are in use, messages are
delivered round-robin if multiple active consumers exist with the same high
priority. Messages will only going to lower priority consumers when the high
priority consumers do not hav [...]
| *camel.source.endpoint.asyncConsumer* | 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 [...]
| *camel.source.endpoint.autoStartup* | Specifies whether the consumer
container should auto-startup. | true | false | MEDIUM
| *camel.source.endpoint.cacheLevel* | Sets the cache level by ID for the
underlying JMS resources. See cacheLevelName option for more details. | null |
false | MEDIUM
@@ -109,6 +110,7 @@ The camel-amqp source connector supports 144 options, which
are listed below.
| *camel.component.amqp.replyTo* | Provides an explicit ReplyTo destination
(overrides any incoming value of Message.getJMSReplyTo() in consumer). | null |
false | MEDIUM
| *camel.component.amqp.testConnectionOnStartup* | 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 | false | MEDIUM
| *camel.component.amqp.acknowledgementModeName* | The JMS acknowledgement
name, which is one of: SESSION_TRANSACTED, CLIENT_ACKNOWLEDGE,
AUTO_ACKNOWLEDGE, DUPS_OK_ACKNOWLEDGE One of: [SESSION_TRANSACTED]
[CLIENT_ACKNOWLEDGE] [AUTO_ACKNOWLEDGE] [DUPS_OK_ACKNOWLEDGE] |
"AUTO_ACKNOWLEDGE" | false | MEDIUM
+| *camel.component.amqp.artemisConsumerPriority* | Consumer priorities allow
you to ensure that high priority consumers receive messages while they are
active. Normally, active consumers connected to a queue receive messages from
it in a round-robin fashion. When consumer priorities are in use, messages are
delivered round-robin if multiple active consumers exist with the same high
priority. Messages will only going to lower priority consumers when the high
priority consumers do not have [...]
| *camel.component.amqp.asyncConsumer* | 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 [...]
| *camel.component.amqp.autoStartup* | Specifies whether the consumer
container should auto-startup. | true | false | MEDIUM
| *camel.component.amqp.cacheLevel* | Sets the cache level by ID for the
underlying JMS resources. See cacheLevelName option for more details. | null |
false | MEDIUM
diff --git
a/connectors/camel-amqp-kafka-connector/src/main/java/org/apache/camel/kafkaconnector/amqp/CamelAmqpSourceConnectorConfig.java
b/connectors/camel-amqp-kafka-connector/src/main/java/org/apache/camel/kafkaconnector/amqp/CamelAmqpSourceConnectorConfig.java
index bc960b2..1d8e319 100644
---
a/connectors/camel-amqp-kafka-connector/src/main/java/org/apache/camel/kafkaconnector/amqp/CamelAmqpSourceConnectorConfig.java
+++
b/connectors/camel-amqp-kafka-connector/src/main/java/org/apache/camel/kafkaconnector/amqp/CamelAmqpSourceConnectorConfig.java
@@ -56,6 +56,9 @@ public class CamelAmqpSourceConnectorConfig
public static final String
CAMEL_SOURCE_AMQP_ENDPOINT_ACKNOWLEDGEMENT_MODE_NAME_CONF =
"camel.source.endpoint.acknowledgementModeName";
public static final String
CAMEL_SOURCE_AMQP_ENDPOINT_ACKNOWLEDGEMENT_MODE_NAME_DOC = "The JMS
acknowledgement name, which is one of: SESSION_TRANSACTED, CLIENT_ACKNOWLEDGE,
AUTO_ACKNOWLEDGE, DUPS_OK_ACKNOWLEDGE One of: [SESSION_TRANSACTED]
[CLIENT_ACKNOWLEDGE] [AUTO_ACKNOWLEDGE] [DUPS_OK_ACKNOWLEDGE]";
public static final String
CAMEL_SOURCE_AMQP_ENDPOINT_ACKNOWLEDGEMENT_MODE_NAME_DEFAULT =
"AUTO_ACKNOWLEDGE";
+ public static final String
CAMEL_SOURCE_AMQP_ENDPOINT_ARTEMIS_CONSUMER_PRIORITY_CONF =
"camel.source.endpoint.artemisConsumerPriority";
+ public static final String
CAMEL_SOURCE_AMQP_ENDPOINT_ARTEMIS_CONSUMER_PRIORITY_DOC = "Consumer priorities
allow you to ensure that high priority consumers receive messages while they
are active. Normally, active consumers connected to a queue receive messages
from it in a round-robin fashion. When consumer priorities are in use, messages
are delivered round-robin if multiple active consumers exist with the same high
priority. Messages will only going to lower priority consumers when [...]
+ public static final Integer
CAMEL_SOURCE_AMQP_ENDPOINT_ARTEMIS_CONSUMER_PRIORITY_DEFAULT = null;
public static final String CAMEL_SOURCE_AMQP_ENDPOINT_ASYNC_CONSUMER_CONF
= "camel.source.endpoint.asyncConsumer";
public static final String CAMEL_SOURCE_AMQP_ENDPOINT_ASYNC_CONSUMER_DOC =
"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 [...]
public static final Boolean
CAMEL_SOURCE_AMQP_ENDPOINT_ASYNC_CONSUMER_DEFAULT = false;
@@ -266,6 +269,9 @@ public class CamelAmqpSourceConnectorConfig
public static final String
CAMEL_SOURCE_AMQP_COMPONENT_ACKNOWLEDGEMENT_MODE_NAME_CONF =
"camel.component.amqp.acknowledgementModeName";
public static final String
CAMEL_SOURCE_AMQP_COMPONENT_ACKNOWLEDGEMENT_MODE_NAME_DOC = "The JMS
acknowledgement name, which is one of: SESSION_TRANSACTED, CLIENT_ACKNOWLEDGE,
AUTO_ACKNOWLEDGE, DUPS_OK_ACKNOWLEDGE One of: [SESSION_TRANSACTED]
[CLIENT_ACKNOWLEDGE] [AUTO_ACKNOWLEDGE] [DUPS_OK_ACKNOWLEDGE]";
public static final String
CAMEL_SOURCE_AMQP_COMPONENT_ACKNOWLEDGEMENT_MODE_NAME_DEFAULT =
"AUTO_ACKNOWLEDGE";
+ public static final String
CAMEL_SOURCE_AMQP_COMPONENT_ARTEMIS_CONSUMER_PRIORITY_CONF =
"camel.component.amqp.artemisConsumerPriority";
+ public static final String
CAMEL_SOURCE_AMQP_COMPONENT_ARTEMIS_CONSUMER_PRIORITY_DOC = "Consumer
priorities allow you to ensure that high priority consumers receive messages
while they are active. Normally, active consumers connected to a queue receive
messages from it in a round-robin fashion. When consumer priorities are in use,
messages are delivered round-robin if multiple active consumers exist with the
same high priority. Messages will only going to lower priority consumers whe
[...]
+ public static final Integer
CAMEL_SOURCE_AMQP_COMPONENT_ARTEMIS_CONSUMER_PRIORITY_DEFAULT = null;
public static final String CAMEL_SOURCE_AMQP_COMPONENT_ASYNC_CONSUMER_CONF
= "camel.component.amqp.asyncConsumer";
public static final String CAMEL_SOURCE_AMQP_COMPONENT_ASYNC_CONSUMER_DOC
= "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 th [...]
public static final Boolean
CAMEL_SOURCE_AMQP_COMPONENT_ASYNC_CONSUMER_DEFAULT = false;
@@ -481,6 +487,7 @@ public class CamelAmqpSourceConnectorConfig
conf.define(CAMEL_SOURCE_AMQP_ENDPOINT_REPLY_TO_CONF,
ConfigDef.Type.STRING, CAMEL_SOURCE_AMQP_ENDPOINT_REPLY_TO_DEFAULT,
ConfigDef.Importance.MEDIUM, CAMEL_SOURCE_AMQP_ENDPOINT_REPLY_TO_DOC);
conf.define(CAMEL_SOURCE_AMQP_ENDPOINT_TEST_CONNECTION_ON_STARTUP_CONF,
ConfigDef.Type.BOOLEAN,
CAMEL_SOURCE_AMQP_ENDPOINT_TEST_CONNECTION_ON_STARTUP_DEFAULT,
ConfigDef.Importance.MEDIUM,
CAMEL_SOURCE_AMQP_ENDPOINT_TEST_CONNECTION_ON_STARTUP_DOC);
conf.define(CAMEL_SOURCE_AMQP_ENDPOINT_ACKNOWLEDGEMENT_MODE_NAME_CONF,
ConfigDef.Type.STRING,
CAMEL_SOURCE_AMQP_ENDPOINT_ACKNOWLEDGEMENT_MODE_NAME_DEFAULT,
ConfigDef.Importance.MEDIUM,
CAMEL_SOURCE_AMQP_ENDPOINT_ACKNOWLEDGEMENT_MODE_NAME_DOC);
+ conf.define(CAMEL_SOURCE_AMQP_ENDPOINT_ARTEMIS_CONSUMER_PRIORITY_CONF,
ConfigDef.Type.INT,
CAMEL_SOURCE_AMQP_ENDPOINT_ARTEMIS_CONSUMER_PRIORITY_DEFAULT,
ConfigDef.Importance.MEDIUM,
CAMEL_SOURCE_AMQP_ENDPOINT_ARTEMIS_CONSUMER_PRIORITY_DOC);
conf.define(CAMEL_SOURCE_AMQP_ENDPOINT_ASYNC_CONSUMER_CONF,
ConfigDef.Type.BOOLEAN, CAMEL_SOURCE_AMQP_ENDPOINT_ASYNC_CONSUMER_DEFAULT,
ConfigDef.Importance.MEDIUM, CAMEL_SOURCE_AMQP_ENDPOINT_ASYNC_CONSUMER_DOC);
conf.define(CAMEL_SOURCE_AMQP_ENDPOINT_AUTO_STARTUP_CONF,
ConfigDef.Type.BOOLEAN, CAMEL_SOURCE_AMQP_ENDPOINT_AUTO_STARTUP_DEFAULT,
ConfigDef.Importance.MEDIUM, CAMEL_SOURCE_AMQP_ENDPOINT_AUTO_STARTUP_DOC);
conf.define(CAMEL_SOURCE_AMQP_ENDPOINT_CACHE_LEVEL_CONF,
ConfigDef.Type.INT, CAMEL_SOURCE_AMQP_ENDPOINT_CACHE_LEVEL_DEFAULT,
ConfigDef.Importance.MEDIUM, CAMEL_SOURCE_AMQP_ENDPOINT_CACHE_LEVEL_DOC);
@@ -551,6 +558,7 @@ public class CamelAmqpSourceConnectorConfig
conf.define(CAMEL_SOURCE_AMQP_COMPONENT_REPLY_TO_CONF,
ConfigDef.Type.STRING, CAMEL_SOURCE_AMQP_COMPONENT_REPLY_TO_DEFAULT,
ConfigDef.Importance.MEDIUM, CAMEL_SOURCE_AMQP_COMPONENT_REPLY_TO_DOC);
conf.define(CAMEL_SOURCE_AMQP_COMPONENT_TEST_CONNECTION_ON_STARTUP_CONF,
ConfigDef.Type.BOOLEAN,
CAMEL_SOURCE_AMQP_COMPONENT_TEST_CONNECTION_ON_STARTUP_DEFAULT,
ConfigDef.Importance.MEDIUM,
CAMEL_SOURCE_AMQP_COMPONENT_TEST_CONNECTION_ON_STARTUP_DOC);
conf.define(CAMEL_SOURCE_AMQP_COMPONENT_ACKNOWLEDGEMENT_MODE_NAME_CONF,
ConfigDef.Type.STRING,
CAMEL_SOURCE_AMQP_COMPONENT_ACKNOWLEDGEMENT_MODE_NAME_DEFAULT,
ConfigDef.Importance.MEDIUM,
CAMEL_SOURCE_AMQP_COMPONENT_ACKNOWLEDGEMENT_MODE_NAME_DOC);
+
conf.define(CAMEL_SOURCE_AMQP_COMPONENT_ARTEMIS_CONSUMER_PRIORITY_CONF,
ConfigDef.Type.INT,
CAMEL_SOURCE_AMQP_COMPONENT_ARTEMIS_CONSUMER_PRIORITY_DEFAULT,
ConfigDef.Importance.MEDIUM,
CAMEL_SOURCE_AMQP_COMPONENT_ARTEMIS_CONSUMER_PRIORITY_DOC);
conf.define(CAMEL_SOURCE_AMQP_COMPONENT_ASYNC_CONSUMER_CONF,
ConfigDef.Type.BOOLEAN, CAMEL_SOURCE_AMQP_COMPONENT_ASYNC_CONSUMER_DEFAULT,
ConfigDef.Importance.MEDIUM, CAMEL_SOURCE_AMQP_COMPONENT_ASYNC_CONSUMER_DOC);
conf.define(CAMEL_SOURCE_AMQP_COMPONENT_AUTO_STARTUP_CONF,
ConfigDef.Type.BOOLEAN, CAMEL_SOURCE_AMQP_COMPONENT_AUTO_STARTUP_DEFAULT,
ConfigDef.Importance.MEDIUM, CAMEL_SOURCE_AMQP_COMPONENT_AUTO_STARTUP_DOC);
conf.define(CAMEL_SOURCE_AMQP_COMPONENT_CACHE_LEVEL_CONF,
ConfigDef.Type.INT, CAMEL_SOURCE_AMQP_COMPONENT_CACHE_LEVEL_DEFAULT,
ConfigDef.Importance.MEDIUM, CAMEL_SOURCE_AMQP_COMPONENT_CACHE_LEVEL_DOC);
diff --git
a/connectors/camel-jms-kafka-connector/src/generated/resources/camel-jms-source.json
b/connectors/camel-jms-kafka-connector/src/generated/resources/camel-jms-source.json
index f6099b7..c0ae5ed 100644
---
a/connectors/camel-jms-kafka-connector/src/generated/resources/camel-jms-source.json
+++
b/connectors/camel-jms-kafka-connector/src/generated/resources/camel-jms-source.json
@@ -92,6 +92,12 @@
"DUPS_OK_ACKNOWLEDGE"
]
},
+ "camel.source.endpoint.artemisConsumerPriority": {
+ "name": "camel.source.endpoint.artemisConsumerPriority",
+ "description": "Consumer priorities allow you to ensure
that high priority consumers receive messages while they are active. Normally,
active consumers connected to a queue receive messages from it in a round-robin
fashion. When consumer priorities are in use, messages are delivered
round-robin if multiple active consumers exist with the same high priority.
Messages will only going to lower priority consumers when the high priority
consumers do not have credit available to consume the [...]
+ "priority": "MEDIUM",
+ "required": "false"
+ },
"camel.source.endpoint.asyncConsumer": {
"name": "camel.source.endpoint.asyncConsumer",
"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 [...]
@@ -596,6 +602,12 @@
"DUPS_OK_ACKNOWLEDGE"
]
},
+ "camel.component.jms.artemisConsumerPriority": {
+ "name": "camel.component.jms.artemisConsumerPriority",
+ "description": "Consumer priorities allow you to ensure
that high priority consumers receive messages while they are active. Normally,
active consumers connected to a queue receive messages from it in a round-robin
fashion. When consumer priorities are in use, messages are delivered
round-robin if multiple active consumers exist with the same high priority.
Messages will only going to lower priority consumers when the high priority
consumers do not have credit available to consume the [...]
+ "priority": "MEDIUM",
+ "required": "false"
+ },
"camel.component.jms.asyncConsumer": {
"name": "camel.component.jms.asyncConsumer",
"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 [...]
diff --git
a/connectors/camel-jms-kafka-connector/src/main/docs/camel-jms-kafka-source-connector.adoc
b/connectors/camel-jms-kafka-connector/src/main/docs/camel-jms-kafka-source-connector.adoc
index b9fe151..f369cc0 100644
---
a/connectors/camel-jms-kafka-connector/src/main/docs/camel-jms-kafka-source-connector.adoc
+++
b/connectors/camel-jms-kafka-connector/src/main/docs/camel-jms-kafka-source-connector.adoc
@@ -22,7 +22,7 @@
connector.class=org.apache.camel.kafkaconnector.jms.CamelJmsSourceConnector
----
-The camel-jms source connector supports 143 options, which are listed below.
+The camel-jms source connector supports 145 options, which are listed below.
@@ -39,6 +39,7 @@ The camel-jms source connector supports 143 options, which
are listed below.
| *camel.source.endpoint.replyTo* | Provides an explicit ReplyTo destination
(overrides any incoming value of Message.getJMSReplyTo() in consumer). | null |
false | MEDIUM
| *camel.source.endpoint.testConnectionOnStartup* | 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 | false | MEDIUM
| *camel.source.endpoint.acknowledgementModeName* | The JMS acknowledgement
name, which is one of: SESSION_TRANSACTED, CLIENT_ACKNOWLEDGE,
AUTO_ACKNOWLEDGE, DUPS_OK_ACKNOWLEDGE One of: [SESSION_TRANSACTED]
[CLIENT_ACKNOWLEDGE] [AUTO_ACKNOWLEDGE] [DUPS_OK_ACKNOWLEDGE] |
"AUTO_ACKNOWLEDGE" | false | MEDIUM
+| *camel.source.endpoint.artemisConsumerPriority* | Consumer priorities allow
you to ensure that high priority consumers receive messages while they are
active. Normally, active consumers connected to a queue receive messages from
it in a round-robin fashion. When consumer priorities are in use, messages are
delivered round-robin if multiple active consumers exist with the same high
priority. Messages will only going to lower priority consumers when the high
priority consumers do not hav [...]
| *camel.source.endpoint.asyncConsumer* | 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 [...]
| *camel.source.endpoint.autoStartup* | Specifies whether the consumer
container should auto-startup. | true | false | MEDIUM
| *camel.source.endpoint.cacheLevel* | Sets the cache level by ID for the
underlying JMS resources. See cacheLevelName option for more details. | null |
false | MEDIUM
@@ -108,6 +109,7 @@ The camel-jms source connector supports 143 options, which
are listed below.
| *camel.component.jms.replyTo* | Provides an explicit ReplyTo destination
(overrides any incoming value of Message.getJMSReplyTo() in consumer). | null |
false | MEDIUM
| *camel.component.jms.testConnectionOnStartup* | 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 | false | MEDIUM
| *camel.component.jms.acknowledgementModeName* | The JMS acknowledgement
name, which is one of: SESSION_TRANSACTED, CLIENT_ACKNOWLEDGE,
AUTO_ACKNOWLEDGE, DUPS_OK_ACKNOWLEDGE One of: [SESSION_TRANSACTED]
[CLIENT_ACKNOWLEDGE] [AUTO_ACKNOWLEDGE] [DUPS_OK_ACKNOWLEDGE] |
"AUTO_ACKNOWLEDGE" | false | MEDIUM
+| *camel.component.jms.artemisConsumerPriority* | Consumer priorities allow
you to ensure that high priority consumers receive messages while they are
active. Normally, active consumers connected to a queue receive messages from
it in a round-robin fashion. When consumer priorities are in use, messages are
delivered round-robin if multiple active consumers exist with the same high
priority. Messages will only going to lower priority consumers when the high
priority consumers do not have [...]
| *camel.component.jms.asyncConsumer* | 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 i [...]
| *camel.component.jms.autoStartup* | Specifies whether the consumer container
should auto-startup. | true | false | MEDIUM
| *camel.component.jms.cacheLevel* | Sets the cache level by ID for the
underlying JMS resources. See cacheLevelName option for more details. | null |
false | MEDIUM
diff --git
a/connectors/camel-jms-kafka-connector/src/main/java/org/apache/camel/kafkaconnector/jms/CamelJmsSourceConnectorConfig.java
b/connectors/camel-jms-kafka-connector/src/main/java/org/apache/camel/kafkaconnector/jms/CamelJmsSourceConnectorConfig.java
index 7268ce0..223b0f2 100644
---
a/connectors/camel-jms-kafka-connector/src/main/java/org/apache/camel/kafkaconnector/jms/CamelJmsSourceConnectorConfig.java
+++
b/connectors/camel-jms-kafka-connector/src/main/java/org/apache/camel/kafkaconnector/jms/CamelJmsSourceConnectorConfig.java
@@ -54,6 +54,9 @@ public class CamelJmsSourceConnectorConfig extends
CamelSourceConnectorConfig {
public static final String
CAMEL_SOURCE_JMS_ENDPOINT_ACKNOWLEDGEMENT_MODE_NAME_CONF =
"camel.source.endpoint.acknowledgementModeName";
public static final String
CAMEL_SOURCE_JMS_ENDPOINT_ACKNOWLEDGEMENT_MODE_NAME_DOC = "The JMS
acknowledgement name, which is one of: SESSION_TRANSACTED, CLIENT_ACKNOWLEDGE,
AUTO_ACKNOWLEDGE, DUPS_OK_ACKNOWLEDGE One of: [SESSION_TRANSACTED]
[CLIENT_ACKNOWLEDGE] [AUTO_ACKNOWLEDGE] [DUPS_OK_ACKNOWLEDGE]";
public static final String
CAMEL_SOURCE_JMS_ENDPOINT_ACKNOWLEDGEMENT_MODE_NAME_DEFAULT =
"AUTO_ACKNOWLEDGE";
+ public static final String
CAMEL_SOURCE_JMS_ENDPOINT_ARTEMIS_CONSUMER_PRIORITY_CONF =
"camel.source.endpoint.artemisConsumerPriority";
+ public static final String
CAMEL_SOURCE_JMS_ENDPOINT_ARTEMIS_CONSUMER_PRIORITY_DOC = "Consumer priorities
allow you to ensure that high priority consumers receive messages while they
are active. Normally, active consumers connected to a queue receive messages
from it in a round-robin fashion. When consumer priorities are in use, messages
are delivered round-robin if multiple active consumers exist with the same high
priority. Messages will only going to lower priority consumers when [...]
+ public static final Integer
CAMEL_SOURCE_JMS_ENDPOINT_ARTEMIS_CONSUMER_PRIORITY_DEFAULT = null;
public static final String CAMEL_SOURCE_JMS_ENDPOINT_ASYNC_CONSUMER_CONF =
"camel.source.endpoint.asyncConsumer";
public static final String CAMEL_SOURCE_JMS_ENDPOINT_ASYNC_CONSUMER_DOC =
"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 [...]
public static final Boolean
CAMEL_SOURCE_JMS_ENDPOINT_ASYNC_CONSUMER_DEFAULT = false;
@@ -261,6 +264,9 @@ public class CamelJmsSourceConnectorConfig extends
CamelSourceConnectorConfig {
public static final String
CAMEL_SOURCE_JMS_COMPONENT_ACKNOWLEDGEMENT_MODE_NAME_CONF =
"camel.component.jms.acknowledgementModeName";
public static final String
CAMEL_SOURCE_JMS_COMPONENT_ACKNOWLEDGEMENT_MODE_NAME_DOC = "The JMS
acknowledgement name, which is one of: SESSION_TRANSACTED, CLIENT_ACKNOWLEDGE,
AUTO_ACKNOWLEDGE, DUPS_OK_ACKNOWLEDGE One of: [SESSION_TRANSACTED]
[CLIENT_ACKNOWLEDGE] [AUTO_ACKNOWLEDGE] [DUPS_OK_ACKNOWLEDGE]";
public static final String
CAMEL_SOURCE_JMS_COMPONENT_ACKNOWLEDGEMENT_MODE_NAME_DEFAULT =
"AUTO_ACKNOWLEDGE";
+ public static final String
CAMEL_SOURCE_JMS_COMPONENT_ARTEMIS_CONSUMER_PRIORITY_CONF =
"camel.component.jms.artemisConsumerPriority";
+ public static final String
CAMEL_SOURCE_JMS_COMPONENT_ARTEMIS_CONSUMER_PRIORITY_DOC = "Consumer priorities
allow you to ensure that high priority consumers receive messages while they
are active. Normally, active consumers connected to a queue receive messages
from it in a round-robin fashion. When consumer priorities are in use, messages
are delivered round-robin if multiple active consumers exist with the same high
priority. Messages will only going to lower priority consumers when [...]
+ public static final Integer
CAMEL_SOURCE_JMS_COMPONENT_ARTEMIS_CONSUMER_PRIORITY_DEFAULT = null;
public static final String CAMEL_SOURCE_JMS_COMPONENT_ASYNC_CONSUMER_CONF
= "camel.component.jms.asyncConsumer";
public static final String CAMEL_SOURCE_JMS_COMPONENT_ASYNC_CONSUMER_DOC =
"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 [...]
public static final Boolean
CAMEL_SOURCE_JMS_COMPONENT_ASYNC_CONSUMER_DEFAULT = false;
@@ -476,6 +482,7 @@ public class CamelJmsSourceConnectorConfig extends
CamelSourceConnectorConfig {
conf.define(CAMEL_SOURCE_JMS_ENDPOINT_REPLY_TO_CONF,
ConfigDef.Type.STRING, CAMEL_SOURCE_JMS_ENDPOINT_REPLY_TO_DEFAULT,
ConfigDef.Importance.MEDIUM, CAMEL_SOURCE_JMS_ENDPOINT_REPLY_TO_DOC);
conf.define(CAMEL_SOURCE_JMS_ENDPOINT_TEST_CONNECTION_ON_STARTUP_CONF,
ConfigDef.Type.BOOLEAN,
CAMEL_SOURCE_JMS_ENDPOINT_TEST_CONNECTION_ON_STARTUP_DEFAULT,
ConfigDef.Importance.MEDIUM,
CAMEL_SOURCE_JMS_ENDPOINT_TEST_CONNECTION_ON_STARTUP_DOC);
conf.define(CAMEL_SOURCE_JMS_ENDPOINT_ACKNOWLEDGEMENT_MODE_NAME_CONF,
ConfigDef.Type.STRING,
CAMEL_SOURCE_JMS_ENDPOINT_ACKNOWLEDGEMENT_MODE_NAME_DEFAULT,
ConfigDef.Importance.MEDIUM,
CAMEL_SOURCE_JMS_ENDPOINT_ACKNOWLEDGEMENT_MODE_NAME_DOC);
+ conf.define(CAMEL_SOURCE_JMS_ENDPOINT_ARTEMIS_CONSUMER_PRIORITY_CONF,
ConfigDef.Type.INT,
CAMEL_SOURCE_JMS_ENDPOINT_ARTEMIS_CONSUMER_PRIORITY_DEFAULT,
ConfigDef.Importance.MEDIUM,
CAMEL_SOURCE_JMS_ENDPOINT_ARTEMIS_CONSUMER_PRIORITY_DOC);
conf.define(CAMEL_SOURCE_JMS_ENDPOINT_ASYNC_CONSUMER_CONF,
ConfigDef.Type.BOOLEAN, CAMEL_SOURCE_JMS_ENDPOINT_ASYNC_CONSUMER_DEFAULT,
ConfigDef.Importance.MEDIUM, CAMEL_SOURCE_JMS_ENDPOINT_ASYNC_CONSUMER_DOC);
conf.define(CAMEL_SOURCE_JMS_ENDPOINT_AUTO_STARTUP_CONF,
ConfigDef.Type.BOOLEAN, CAMEL_SOURCE_JMS_ENDPOINT_AUTO_STARTUP_DEFAULT,
ConfigDef.Importance.MEDIUM, CAMEL_SOURCE_JMS_ENDPOINT_AUTO_STARTUP_DOC);
conf.define(CAMEL_SOURCE_JMS_ENDPOINT_CACHE_LEVEL_CONF,
ConfigDef.Type.INT, CAMEL_SOURCE_JMS_ENDPOINT_CACHE_LEVEL_DEFAULT,
ConfigDef.Importance.MEDIUM, CAMEL_SOURCE_JMS_ENDPOINT_CACHE_LEVEL_DOC);
@@ -545,6 +552,7 @@ public class CamelJmsSourceConnectorConfig extends
CamelSourceConnectorConfig {
conf.define(CAMEL_SOURCE_JMS_COMPONENT_REPLY_TO_CONF,
ConfigDef.Type.STRING, CAMEL_SOURCE_JMS_COMPONENT_REPLY_TO_DEFAULT,
ConfigDef.Importance.MEDIUM, CAMEL_SOURCE_JMS_COMPONENT_REPLY_TO_DOC);
conf.define(CAMEL_SOURCE_JMS_COMPONENT_TEST_CONNECTION_ON_STARTUP_CONF,
ConfigDef.Type.BOOLEAN,
CAMEL_SOURCE_JMS_COMPONENT_TEST_CONNECTION_ON_STARTUP_DEFAULT,
ConfigDef.Importance.MEDIUM,
CAMEL_SOURCE_JMS_COMPONENT_TEST_CONNECTION_ON_STARTUP_DOC);
conf.define(CAMEL_SOURCE_JMS_COMPONENT_ACKNOWLEDGEMENT_MODE_NAME_CONF,
ConfigDef.Type.STRING,
CAMEL_SOURCE_JMS_COMPONENT_ACKNOWLEDGEMENT_MODE_NAME_DEFAULT,
ConfigDef.Importance.MEDIUM,
CAMEL_SOURCE_JMS_COMPONENT_ACKNOWLEDGEMENT_MODE_NAME_DOC);
+ conf.define(CAMEL_SOURCE_JMS_COMPONENT_ARTEMIS_CONSUMER_PRIORITY_CONF,
ConfigDef.Type.INT,
CAMEL_SOURCE_JMS_COMPONENT_ARTEMIS_CONSUMER_PRIORITY_DEFAULT,
ConfigDef.Importance.MEDIUM,
CAMEL_SOURCE_JMS_COMPONENT_ARTEMIS_CONSUMER_PRIORITY_DOC);
conf.define(CAMEL_SOURCE_JMS_COMPONENT_ASYNC_CONSUMER_CONF,
ConfigDef.Type.BOOLEAN, CAMEL_SOURCE_JMS_COMPONENT_ASYNC_CONSUMER_DEFAULT,
ConfigDef.Importance.MEDIUM, CAMEL_SOURCE_JMS_COMPONENT_ASYNC_CONSUMER_DOC);
conf.define(CAMEL_SOURCE_JMS_COMPONENT_AUTO_STARTUP_CONF,
ConfigDef.Type.BOOLEAN, CAMEL_SOURCE_JMS_COMPONENT_AUTO_STARTUP_DEFAULT,
ConfigDef.Importance.MEDIUM, CAMEL_SOURCE_JMS_COMPONENT_AUTO_STARTUP_DOC);
conf.define(CAMEL_SOURCE_JMS_COMPONENT_CACHE_LEVEL_CONF,
ConfigDef.Type.INT, CAMEL_SOURCE_JMS_COMPONENT_CACHE_LEVEL_DEFAULT,
ConfigDef.Importance.MEDIUM, CAMEL_SOURCE_JMS_COMPONENT_CACHE_LEVEL_DOC);
diff --git
a/docs/modules/ROOT/pages/connectors/camel-activemq-kafka-source-connector.adoc
b/docs/modules/ROOT/pages/connectors/camel-activemq-kafka-source-connector.adoc
index 354e0bd..f4ee729 100644
---
a/docs/modules/ROOT/pages/connectors/camel-activemq-kafka-source-connector.adoc
+++
b/docs/modules/ROOT/pages/connectors/camel-activemq-kafka-source-connector.adoc
@@ -22,7 +22,7 @@
connector.class=org.apache.camel.kafkaconnector.activemq.CamelActivemqSourceConn
----
-The camel-activemq source connector supports 147 options, which are listed
below.
+The camel-activemq source connector supports 149 options, which are listed
below.
@@ -39,6 +39,7 @@ The camel-activemq source connector supports 147 options,
which are listed below
| *camel.source.endpoint.replyTo* | Provides an explicit ReplyTo destination
(overrides any incoming value of Message.getJMSReplyTo() in consumer). | null |
false | MEDIUM
| *camel.source.endpoint.testConnectionOnStartup* | 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 | false | MEDIUM
| *camel.source.endpoint.acknowledgementModeName* | The JMS acknowledgement
name, which is one of: SESSION_TRANSACTED, CLIENT_ACKNOWLEDGE,
AUTO_ACKNOWLEDGE, DUPS_OK_ACKNOWLEDGE One of: [SESSION_TRANSACTED]
[CLIENT_ACKNOWLEDGE] [AUTO_ACKNOWLEDGE] [DUPS_OK_ACKNOWLEDGE] |
"AUTO_ACKNOWLEDGE" | false | MEDIUM
+| *camel.source.endpoint.artemisConsumerPriority* | Consumer priorities allow
you to ensure that high priority consumers receive messages while they are
active. Normally, active consumers connected to a queue receive messages from
it in a round-robin fashion. When consumer priorities are in use, messages are
delivered round-robin if multiple active consumers exist with the same high
priority. Messages will only going to lower priority consumers when the high
priority consumers do not hav [...]
| *camel.source.endpoint.asyncConsumer* | 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 [...]
| *camel.source.endpoint.autoStartup* | Specifies whether the consumer
container should auto-startup. | true | false | MEDIUM
| *camel.source.endpoint.cacheLevel* | Sets the cache level by ID for the
underlying JMS resources. See cacheLevelName option for more details. | null |
false | MEDIUM
@@ -111,6 +112,7 @@ The camel-activemq source connector supports 147 options,
which are listed below
| *camel.component.activemq.usePooledConnection* | 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 | false | MEDIUM
| *camel.component.activemq.useSingleConnection* | 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
| false | MEDIUM
| *camel.component.activemq.acknowledgementModeName* | The JMS acknowledgement
name, which is one of: SESSION_TRANSACTED, CLIENT_ACKNOWLEDGE,
AUTO_ACKNOWLEDGE, DUPS_OK_ACKNOWLEDGE One of: [SESSION_TRANSACTED]
[CLIENT_ACKNOWLEDGE] [AUTO_ACKNOWLEDGE] [DUPS_OK_ACKNOWLEDGE] |
"AUTO_ACKNOWLEDGE" | false | MEDIUM
+| *camel.component.activemq.artemisConsumerPriority* | Consumer priorities
allow you to ensure that high priority consumers receive messages while they
are active. Normally, active consumers connected to a queue receive messages
from it in a round-robin fashion. When consumer priorities are in use, messages
are delivered round-robin if multiple active consumers exist with the same high
priority. Messages will only going to lower priority consumers when the high
priority consumers do not [...]
| *camel.component.activemq.asyncConsumer* | 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. N [...]
| *camel.component.activemq.autoStartup* | Specifies whether the consumer
container should auto-startup. | true | false | MEDIUM
| *camel.component.activemq.cacheLevel* | Sets the cache level by ID for the
underlying JMS resources. See cacheLevelName option for more details. | null |
false | MEDIUM
diff --git
a/docs/modules/ROOT/pages/connectors/camel-amqp-kafka-source-connector.adoc
b/docs/modules/ROOT/pages/connectors/camel-amqp-kafka-source-connector.adoc
index bf772f3..119793a 100644
--- a/docs/modules/ROOT/pages/connectors/camel-amqp-kafka-source-connector.adoc
+++ b/docs/modules/ROOT/pages/connectors/camel-amqp-kafka-source-connector.adoc
@@ -22,7 +22,7 @@
connector.class=org.apache.camel.kafkaconnector.amqp.CamelAmqpSourceConnector
----
-The camel-amqp source connector supports 144 options, which are listed below.
+The camel-amqp source connector supports 146 options, which are listed below.
@@ -39,6 +39,7 @@ The camel-amqp source connector supports 144 options, which
are listed below.
| *camel.source.endpoint.replyTo* | Provides an explicit ReplyTo destination
(overrides any incoming value of Message.getJMSReplyTo() in consumer). | null |
false | MEDIUM
| *camel.source.endpoint.testConnectionOnStartup* | 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 | false | MEDIUM
| *camel.source.endpoint.acknowledgementModeName* | The JMS acknowledgement
name, which is one of: SESSION_TRANSACTED, CLIENT_ACKNOWLEDGE,
AUTO_ACKNOWLEDGE, DUPS_OK_ACKNOWLEDGE One of: [SESSION_TRANSACTED]
[CLIENT_ACKNOWLEDGE] [AUTO_ACKNOWLEDGE] [DUPS_OK_ACKNOWLEDGE] |
"AUTO_ACKNOWLEDGE" | false | MEDIUM
+| *camel.source.endpoint.artemisConsumerPriority* | Consumer priorities allow
you to ensure that high priority consumers receive messages while they are
active. Normally, active consumers connected to a queue receive messages from
it in a round-robin fashion. When consumer priorities are in use, messages are
delivered round-robin if multiple active consumers exist with the same high
priority. Messages will only going to lower priority consumers when the high
priority consumers do not hav [...]
| *camel.source.endpoint.asyncConsumer* | 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 [...]
| *camel.source.endpoint.autoStartup* | Specifies whether the consumer
container should auto-startup. | true | false | MEDIUM
| *camel.source.endpoint.cacheLevel* | Sets the cache level by ID for the
underlying JMS resources. See cacheLevelName option for more details. | null |
false | MEDIUM
@@ -109,6 +110,7 @@ The camel-amqp source connector supports 144 options, which
are listed below.
| *camel.component.amqp.replyTo* | Provides an explicit ReplyTo destination
(overrides any incoming value of Message.getJMSReplyTo() in consumer). | null |
false | MEDIUM
| *camel.component.amqp.testConnectionOnStartup* | 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 | false | MEDIUM
| *camel.component.amqp.acknowledgementModeName* | The JMS acknowledgement
name, which is one of: SESSION_TRANSACTED, CLIENT_ACKNOWLEDGE,
AUTO_ACKNOWLEDGE, DUPS_OK_ACKNOWLEDGE One of: [SESSION_TRANSACTED]
[CLIENT_ACKNOWLEDGE] [AUTO_ACKNOWLEDGE] [DUPS_OK_ACKNOWLEDGE] |
"AUTO_ACKNOWLEDGE" | false | MEDIUM
+| *camel.component.amqp.artemisConsumerPriority* | Consumer priorities allow
you to ensure that high priority consumers receive messages while they are
active. Normally, active consumers connected to a queue receive messages from
it in a round-robin fashion. When consumer priorities are in use, messages are
delivered round-robin if multiple active consumers exist with the same high
priority. Messages will only going to lower priority consumers when the high
priority consumers do not have [...]
| *camel.component.amqp.asyncConsumer* | 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 [...]
| *camel.component.amqp.autoStartup* | Specifies whether the consumer
container should auto-startup. | true | false | MEDIUM
| *camel.component.amqp.cacheLevel* | Sets the cache level by ID for the
underlying JMS resources. See cacheLevelName option for more details. | null |
false | MEDIUM
diff --git
a/docs/modules/ROOT/pages/connectors/camel-jms-kafka-source-connector.adoc
b/docs/modules/ROOT/pages/connectors/camel-jms-kafka-source-connector.adoc
index b9fe151..f369cc0 100644
--- a/docs/modules/ROOT/pages/connectors/camel-jms-kafka-source-connector.adoc
+++ b/docs/modules/ROOT/pages/connectors/camel-jms-kafka-source-connector.adoc
@@ -22,7 +22,7 @@
connector.class=org.apache.camel.kafkaconnector.jms.CamelJmsSourceConnector
----
-The camel-jms source connector supports 143 options, which are listed below.
+The camel-jms source connector supports 145 options, which are listed below.
@@ -39,6 +39,7 @@ The camel-jms source connector supports 143 options, which
are listed below.
| *camel.source.endpoint.replyTo* | Provides an explicit ReplyTo destination
(overrides any incoming value of Message.getJMSReplyTo() in consumer). | null |
false | MEDIUM
| *camel.source.endpoint.testConnectionOnStartup* | 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 | false | MEDIUM
| *camel.source.endpoint.acknowledgementModeName* | The JMS acknowledgement
name, which is one of: SESSION_TRANSACTED, CLIENT_ACKNOWLEDGE,
AUTO_ACKNOWLEDGE, DUPS_OK_ACKNOWLEDGE One of: [SESSION_TRANSACTED]
[CLIENT_ACKNOWLEDGE] [AUTO_ACKNOWLEDGE] [DUPS_OK_ACKNOWLEDGE] |
"AUTO_ACKNOWLEDGE" | false | MEDIUM
+| *camel.source.endpoint.artemisConsumerPriority* | Consumer priorities allow
you to ensure that high priority consumers receive messages while they are
active. Normally, active consumers connected to a queue receive messages from
it in a round-robin fashion. When consumer priorities are in use, messages are
delivered round-robin if multiple active consumers exist with the same high
priority. Messages will only going to lower priority consumers when the high
priority consumers do not hav [...]
| *camel.source.endpoint.asyncConsumer* | 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 [...]
| *camel.source.endpoint.autoStartup* | Specifies whether the consumer
container should auto-startup. | true | false | MEDIUM
| *camel.source.endpoint.cacheLevel* | Sets the cache level by ID for the
underlying JMS resources. See cacheLevelName option for more details. | null |
false | MEDIUM
@@ -108,6 +109,7 @@ The camel-jms source connector supports 143 options, which
are listed below.
| *camel.component.jms.replyTo* | Provides an explicit ReplyTo destination
(overrides any incoming value of Message.getJMSReplyTo() in consumer). | null |
false | MEDIUM
| *camel.component.jms.testConnectionOnStartup* | 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 | false | MEDIUM
| *camel.component.jms.acknowledgementModeName* | The JMS acknowledgement
name, which is one of: SESSION_TRANSACTED, CLIENT_ACKNOWLEDGE,
AUTO_ACKNOWLEDGE, DUPS_OK_ACKNOWLEDGE One of: [SESSION_TRANSACTED]
[CLIENT_ACKNOWLEDGE] [AUTO_ACKNOWLEDGE] [DUPS_OK_ACKNOWLEDGE] |
"AUTO_ACKNOWLEDGE" | false | MEDIUM
+| *camel.component.jms.artemisConsumerPriority* | Consumer priorities allow
you to ensure that high priority consumers receive messages while they are
active. Normally, active consumers connected to a queue receive messages from
it in a round-robin fashion. When consumer priorities are in use, messages are
delivered round-robin if multiple active consumers exist with the same high
priority. Messages will only going to lower priority consumers when the high
priority consumers do not have [...]
| *camel.component.jms.asyncConsumer* | 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 i [...]
| *camel.component.jms.autoStartup* | Specifies whether the consumer container
should auto-startup. | true | false | MEDIUM
| *camel.component.jms.cacheLevel* | Sets the cache level by ID for the
underlying JMS resources. See cacheLevelName option for more details. | null |
false | MEDIUM
