You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@camel.apache.org by da...@apache.org on 2021/08/05 14:01:31 UTC
[camel] 07/17: CAMEL-16844: component docs - prepare for regen
tables with better titles
This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel.git
commit 1bd781f935dac469be8b89d4b5251e54448ee167
Author: Claus Ibsen <cl...@gmail.com>
AuthorDate: Thu Aug 5 12:56:37 2021 +0200
CAMEL-16844: component docs - prepare for regen tables with better titles
---
.../camel-jbpm/src/main/docs/jbpm-component.adoc | 114 ++-------
.../src/main/docs/jcache-component.adoc | 129 ++--------
.../src/main/docs/jclouds-component.adoc | 70 +-----
.../camel-jcr/src/main/docs/jcr-component.adoc | 72 +-----
.../camel-jdbc/src/main/docs/jdbc-component.adoc | 71 +-----
.../camel-jetty/src/main/docs/jetty-component.adoc | 120 ---------
.../src/main/docs/jgroups-raft-component.adoc | 47 ----
.../src/main/docs/jgroups-component.adoc | 58 -----
.../camel-jing/src/main/docs/jing-component.adoc | 47 ----
.../camel-jira/src/main/docs/jira-component.adoc | 74 +-----
.../camel-jms/src/main/docs/jms-component.adoc | 267 ---------------------
.../camel-jmx/src/main/docs/jmx-component.adoc | 66 -----
.../camel-jolt/src/main/docs/jolt-component.adoc | 63 -----
.../camel-jooq/src/main/docs/jooq-component.adoc | 69 +-----
.../camel-jpa/src/main/docs/jpa-component.adoc | 106 --------
.../camel-jsch/src/main/docs/scp-component.adoc | 81 -------
.../camel-jslt/src/main/docs/jslt-component.adoc | 61 +----
.../src/main/docs/json-validator-component.adoc | 54 +----
.../src/main/docs/jsonata-component.adoc | 55 -----
.../camel-jt400/src/main/docs/jt400-component.adoc | 88 +------
.../camel-kafka/src/main/docs/kafka-component.adoc | 261 +-------------------
.../src/main/docs/kamelet-reify-component.adoc | 47 ----
.../src/main/docs/kamelet-component.adoc | 60 +----
.../docs/kubernetes-config-maps-component.adoc | 61 -----
.../kubernetes-custom-resources-component.adoc | 77 +-----
.../docs/kubernetes-deployments-component.adoc | 80 +-----
.../src/main/docs/kubernetes-hpa-component.adoc | 80 +-----
.../src/main/docs/kubernetes-job-component.adoc | 86 +------
.../main/docs/kubernetes-namespaces-component.adoc | 81 +------
.../src/main/docs/kubernetes-nodes-component.adoc | 79 +-----
...rnetes-persistent-volumes-claims-component.adoc | 64 +----
.../kubernetes-persistent-volumes-component.adoc | 64 +----
.../src/main/docs/kubernetes-pods-component.adoc | 79 +-----
...bernetes-replication-controllers-component.adoc | 79 +-----
.../docs/kubernetes-resources-quota-component.adoc | 64 +----
.../main/docs/kubernetes-secrets-component.adoc | 64 +----
.../kubernetes-service-accounts-component.adoc | 62 +----
.../main/docs/kubernetes-services-component.adoc | 78 +-----
.../docs/openshift-build-configs-component.adoc | 64 +----
.../src/main/docs/openshift-builds-component.adoc | 65 +----
.../camel-kudu/src/main/docs/kudu-component.adoc | 75 +-----
41 files changed, 81 insertions(+), 3301 deletions(-)
diff --git a/components/camel-jbpm/src/main/docs/jbpm-component.adoc b/components/camel-jbpm/src/main/docs/jbpm-component.adoc
index e673224..7f1d0a5 100644
--- a/components/camel-jbpm/src/main/docs/jbpm-component.adoc
+++ b/components/camel-jbpm/src/main/docs/jbpm-component.adoc
@@ -29,21 +29,26 @@ for this component:
</dependency>
------------------------------------------------------------------------------------
-== Consumer
-
-jBPM Consumer allows to attach routes to
-
-* ProcessEventListeners
-* TaskEventListners
-* CaseEventListeners
== URI format
-[source,java]
---------------------------------------------
jbpm::events:type:[classifier][?options]
---------------------------------------------
+// component options: START
+// component options: END
+// endpoint options: START
+// endpoint options: END
+
+== Consumer
+
+jBPM Consumer allows to attach routes to
+
+* ProcessEventListeners
+* TaskEventListners
+* CaseEventListeners
+
=== Path Parameters (3 parameters):
@@ -74,10 +79,9 @@ discovered and Camel Context for given KJAR will be created.
Create file name `global-camel-routes` in the root of the class path of KIE Server. It will be automatically found and registered
on every KJAR deployed to KIE Server.
+Example `camel-routes.xml` file that can be placed in the KJAR
-Example camel-routes.xml file that can be placed in the KJAR
-
-[source, xml]
+[source,xml]
----
<routes xmlns="http://camel.apache.org/schema/spring">
@@ -109,11 +113,9 @@ To make use of camel-jbpm component in a KIE Server it is as simple as just addi
then start KIE Server and you will see once booted following information in logs
-[source, plain]
----
Camel KIE Server extension has been successfully registered as server extension
....
-
Route: tasks started and consuming from: jbpm://events:task:test?deploymentId=form-rendering_1.0.0
Total 2 routes, of which 2 are started
Apache Camel 2.23.0-SNAPSHOT (CamelContext: KIE Server Camel context for container evaluation_1.0.0) started in 0.378 seconds
@@ -136,96 +138,10 @@ jBPM (KIE Server).
== URI format
-[source,java]
---------------------------------------------
jbpm::hostName[:port][/resourceUri][?options]
---------------------------------------------
-== URI Options
-
-
-// component options: START
-The JBPM component supports 3 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *lazyStartProducer* (producer) | 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 [...]
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-|===
-// component options: END
-
-
-
-
-
-// endpoint options: START
-The JBPM endpoint is configured using URI syntax:
-
-----
-jbpm:connectionURL
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (2 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *connectionURL* | *Required* The URL to the jBPM server. | | URL
-| *eventListenerType* | Sets the event listener type to attach to | | String
-|===
-
-
-=== Query Parameters (31 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *attachmentId* (common) | attachId to use when retrieving attachments | | Long
-| *contentId* (common) | contentId to use when retrieving attachments | | Long
-| *deploymentId* (common) | *Required* The id of the deployment | | String
-| *emitterSendItems* (common) | Sets if event produced by emitter should be sent as single items or complete collection | | Boolean
-| *event* (common) | the data associated with this event when signalEvent operation is performed | | Object
-| *eventType* (common) | the type of event to use when signalEvent operation is performed | | String
-| *identifier* (common) | identifier the global identifier | | String
-| *maxNumber* (common) | the maximum number of rules that should be fired | | Integer
-| *page* (common) | The page to use when retrieving user tasks | | Integer
-| *pageSize* (common) | The page size to use when retrieving user tasks | | Integer
-| *processId* (common) | the id of the process that should be acted upon | | String
-| *processInstanceId* (common) | the id of the process instance | | Long
-| *targetUserId* (common) | The targetUserId used when delegating a task | | String
-| *task* (common) | The task instance to use with task operations | | Task
-| *taskId* (common) | the id of the task | | Long
-| *timeout* (common) | A timeout value | | Integer
-| *userId* (common) | userId to use with task operations | | String
-| *value* (common) | the value to assign to the global identifier | | Object
-| *workItemId* (common) | the id of the work item | | Long
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *exceptionHandler* (consumer) | 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. | | ExceptionHandler
-| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut | | ExchangePattern
-| *synchronous* (consumer) | Sets whether synchronous processing should be strictly used | false | boolean
-| *lazyStartProducer* (producer) | 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 [...]
-| *operation* (producer) | The operation to perform | startProcess | String
-| *entities* (advanced) | The potentialOwners when nominateTask operation is performed | | List
-| *extraJaxbClasses* (advanced) | To load additional classes when working with XML | | Class[]
-| *parameters* (advanced) | the variables that should be set for various operations | | Map
-| *statuses* (filter) | The list of status to use when filtering tasks | | List
-| *password* (security) | Password for authentication | | String
-| *userName* (security) | Username for authentication | | String
-|===
-// endpoint options: END
-
-
-
-
-
== Message Headers
[width="100%",cols="10%,10%,10%,70%",options="header",]
diff --git a/components/camel-jcache/src/main/docs/jcache-component.adoc b/components/camel-jcache/src/main/docs/jcache-component.adoc
index 39b2ed4..900eb46 100644
--- a/components/camel-jcache/src/main/docs/jcache-component.adoc
+++ b/components/camel-jcache/src/main/docs/jcache-component.adoc
@@ -16,113 +16,37 @@ The JCache component enables you to perform caching operations using JSR107/JCac
== URI Format
-[source,java]
----------------------------
jcache:cacheName[?options]
----------------------------
-== URI Options
-
-// endpoint options: START
-The JCache endpoint is configured using URI syntax:
-
-----
-jcache:cacheName
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (1 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *cacheName* | *Required* The name of the cache | | String
-|===
-
-
-=== Query Parameters (23 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *cacheConfiguration* (common) | A Configuration for the Cache | | Configuration
-| *cacheConfigurationProperties* (common) | The Properties for the javax.cache.spi.CachingProvider to create the CacheManager | | Properties
-| *cachingProvider* (common) | The fully qualified class name of the javax.cache.spi.CachingProvider | | String
-| *configurationUri* (common) | An implementation specific URI for the CacheManager | | String
-| *managementEnabled* (common) | Whether management gathering is enabled | false | boolean
-| *readThrough* (common) | If read-through caching should be used | false | boolean
-| *statisticsEnabled* (common) | Whether statistics gathering is enabled | false | boolean
-| *storeByValue* (common) | If cache should use store-by-value or store-by-reference semantics | true | boolean
-| *writeThrough* (common) | If write-through caching should be used | false | boolean
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *filteredEvents* (consumer) | Events a consumer should filter (multiple events can be separated by comma). If using filteredEvents option, then eventFilters one will be ignored. There are 4 enums and the value can be one of: CREATED, UPDATED, REMOVED, EXPIRED | | String
-| *oldValueRequired* (consumer) | if the old value is required for events | false | boolean
-| *synchronous* (consumer) | if the event listener should block the thread causing the event | false | boolean
-| *eventFilters* (consumer) | The CacheEntryEventFilter. If using eventFilters option, then filteredEvents one will be ignored | | List
-| *exceptionHandler* (consumer) | 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. | | ExceptionHandler
-| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut | | ExchangePattern
-| *action* (producer) | To configure using a cache operation by default. If an operation in the message header, then the operation from the header takes precedence. | | String
-| *lazyStartProducer* (producer) | 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 [...]
-| *cacheLoaderFactory* (advanced) | The CacheLoader factory | | Factory
-| *cacheWriterFactory* (advanced) | The CacheWriter factory | | Factory
-| *createCacheIfNotExists* (advanced) | Configure if a cache need to be created if it does exist or can't be pre-configured. | true | boolean
-| *expiryPolicyFactory* (advanced) | The ExpiryPolicy factory | | Factory
-| *lookupProviders* (advanced) | Configure if a camel-cache should try to find implementations of jcache api in runtimes like OSGi. | false | boolean
-|===
-// endpoint options: END
-
-
-
-
-
-
-
-
-
// component options: START
-The JCache component supports 8 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *cacheConfiguration* (common) | A Configuration for the Cache | | Configuration
-| *cacheConfigurationProperties* (common) | Properties to configure jcache | | Map
-| *cacheConfigurationProperties{zwsp}Ref* (common) | References to an existing Properties or Map to lookup in the registry to use for configuring jcache. | | String
-| *cachingProvider* (common) | The fully qualified class name of the javax.cache.spi.CachingProvider | | String
-| *configurationUri* (common) | An implementation specific URI for the CacheManager | | String
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *lazyStartProducer* (producer) | 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 [...]
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-|===
// component options: END
+// endpoint options: START
+// endpoint options: END
== JCache Policy
The JCachePolicy is an interceptor around a route that caches the "result of the route" - the message body - after the route is completed.
- If next time the route is called with a "similar" Exchange, the cached value is used on the Exchange instead of executing the route.
- The policy uses the JSR107/JCache API of a cache implementation, so it's required to add one (e.g. Hazelcast, Ehcache) to the classpath.
+If next time the route is called with a "similar" Exchange, the cached value is used on the Exchange instead of executing the route.
+The policy uses the JSR107/JCache API of a cache implementation, so it's required to add one (e.g. Hazelcast, Ehcache) to the classpath.
The policy takes a _key_ value from the received Exchange to get or store values in the cache. By default the _key_ is the message body.
- For example if the route - having a JCachePolicy - receives an Exchange with a String body "fruit" and the body at the
- end of the route is "apple", it stores a _key/value_ pair "fruit=apple" in the cache. If next time another Exchange arrives
- with a body "fruit", the value "apple" is taken from the cache instead of letting the route process the Exchange.
+For example if the route - having a JCachePolicy - receives an Exchange with a String body "fruit" and the body at the
+end of the route is "apple", it stores a _key/value_ pair "fruit=apple" in the cache. If next time another Exchange arrives
+with a body "fruit", the value "apple" is taken from the cache instead of letting the route process the Exchange.
So by default the message body at the beginning of the route is the cache _key_ and the body at the end is the stored _value_.
- It's possible to use something else as _key_ by setting a Camel Expression via _.setKeyExpression()_
- that will be used to determine the key.
+It's possible to use something else as _key_ by setting a Camel Expression via _.setKeyExpression()_
+that will be used to determine the key.
The policy needs a JCache Cache. It can be set directly by _.setCache()_ or the policy will try to get or create the Cache
- based on the other parameters set.
+based on the other parameters set.
Similar caching solution is available for example in Spring using the @Cacheable annotation.
-== JCachePolicy Fields
+== JCachePolicy Fields
[width="100%",cols="2,5,3,2",options="header"]
|===
@@ -137,13 +61,11 @@ Similar caching solution is available for example in Spring using the @Cacheable
== How to determine cache to use?
-
== Set cache
The cache used by the policy can be set directly. This means you have to configure the cache yourself and get a JCache Cache object,
- but this gives the most flexibility. For example it can be setup in the config xml of the cache provider (Hazelcast, EhCache, ...)
- and used here. Or it's possible to use the standard Caching API as below:
-
+but this gives the most flexibility. For example it can be setup in the config xml of the cache provider (Hazelcast, EhCache, ...)
+and used here. Or it's possible to use the standard Caching API as below:
[source,java]
----------------------------
@@ -165,8 +87,8 @@ from("direct:get-orders")
== Set cacheManager
If the _cache_ is not set, the policy will try to lookup or create the cache automatically.
- If the _cacheManager_ is set on the policy, it will try to get cache with the set _cacheName_ (routeId by default) from the CacheManager.
- If the cache does not exist it will create a new one using the _cacheConfiguration_ (new MutableConfiguration by default).
+If the _cacheManager_ is set on the policy, it will try to get cache with the set _cacheName_ (routeId by default) from the CacheManager.
+If the cache does not exist it will create a new one using the _cacheConfiguration_ (new MutableConfiguration by default).
[source,java]
----------------------------
@@ -217,12 +139,12 @@ The _.log()_ at the beginning and at the end of the route is always called, but
== KeyExpression
By default the policy uses the received Exchange body as _key_, so the default expression is like _simple("$\{body})_.
- We can set a different Camel Expression as _keyExpression_ which will be evaluated to determine the key.
- For example if we try to find an _order_ by an _orderId_ which is in the message headers,
- set _header("orderId")_ (or _simple("${header.orderId})_ as _keyExpression_.
+We can set a different Camel Expression as _keyExpression_ which will be evaluated to determine the key.
+For example if we try to find an _order_ by an _orderId_ which is in the message headers,
+set _header("orderId")_ (or _simple("${header.orderId})_ as _keyExpression_.
The expression is evaluated only once at the beginning of the route to determine the _key_. If nothing was found in cache,
- this _key_ is used to store the _value_ in cache at the end of the route.
+this _key_ is used to store the _value_ in cache at the end of the route.
[source,java]
----------------------------
@@ -247,7 +169,7 @@ from("direct:get-orders")
== Use JCachePolicy in an XML route
In Camel XML DSL we need a named reference to the JCachePolicy instance (registered in CamelContext or simply in Spring).
- We have to wrap the route between <policy>...</policy> tags after <from>.
+We have to wrap the route between <policy>...</policy> tags after <from>.
[source,xml]
----------------------------
@@ -286,7 +208,7 @@ See this example when only a part of the route is wrapped:
== Define CachePolicy in Spring
It's more convenient to create a JCachePolicy in Java especially within a RouteBuilder using the Camel DSL expressions,
- but see this example to define it in a Spring XML:
+but see this example to define it in a Spring XML:
[source,xml]
----------------------------
@@ -303,7 +225,7 @@ It's more convenient to create a JCachePolicy in Java especially within a RouteB
== Create Cache from XML
It's not strictly speaking related to Camel XML DSL, but JCache providers usually have a way to configure the cache in an XML file.
- For example with Hazelcast you can add a _hazelcast.xml_ to classpath to configure the cache "spring" used in the example above.
+For example with Hazelcast you can add a _hazelcast.xml_ to classpath to configure the cache "spring" used in the example above.
[source,xml]
----------------------------
@@ -322,16 +244,15 @@ It's not strictly speaking related to Camel XML DSL, but JCache providers usuall
</hazelcast>
----------------------------
-
== Special scenarios and error handling
If the Cache used by the policy is closed (can be done dynamically), the whole caching functionality is skipped,
- the route will be executed every time.
+the route will be executed every time.
If the determined _key_ is _null_, nothing is looked up or stored in cache.
In case of an exception during the route, the error handled is called as always. If the exception gets _handled()_,
- the policy stores the Exchange body, otherwise nothing is added to the cache.
- If an exception happens during evaluating the keyExpression, the routing fails, the error handler is called as normally.
+the policy stores the Exchange body, otherwise nothing is added to the cache.
+If an exception happens during evaluating the keyExpression, the routing fails, the error handler is called as normally.
include::{page-component-version}@camel-spring-boot::page$jcache-starter.adoc[]
diff --git a/components/camel-jclouds/src/main/docs/jclouds-component.adoc b/components/camel-jclouds/src/main/docs/jclouds-component.adoc
index 7805371..eff41d8 100644
--- a/components/camel-jclouds/src/main/docs/jclouds-component.adoc
+++ b/components/camel-jclouds/src/main/docs/jclouds-component.adoc
@@ -94,7 +94,6 @@ each endpoint is specified by passing the provider inside the URI.
== Jclouds Options
-[source,java]
-----------------------------------------
jclouds:blobstore:[provider id][?options]
jclouds:compute:[provider id][?options]
@@ -106,77 +105,13 @@ target service (_e.g. aws-s3 or aws_ec2_).
You can append query options to the URI in the following format,
`?option=value&option=value&...`
-== Blobstore URI Options
-
-
-
// component options: START
-The JClouds component supports 5 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *blobStores* (common) | To use the given BlobStore which must be configured when using blobstore. | | List
-| *computeServices* (common) | To use the given ComputeService which must be configured when use compute. | | List
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *lazyStartProducer* (producer) | 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 [...]
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-|===
// component options: END
-
-
-
-
-
-
// endpoint options: START
-The JClouds endpoint is configured using URI syntax:
-
-----
-jclouds:command:providerId
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (2 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *command* | *Required* What command to execute such as blobstore or compute. There are 2 enums and the value can be one of: blobstore, compute | | JcloudsCommand
-| *providerId* | *Required* The name of the cloud provider that provides the target service (e.g. aws-s3 or aws_ec2). | | String
-|===
-
-
-=== Query Parameters (15 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *exceptionHandler* (consumer) | 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. | | ExceptionHandler
-| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut | | ExchangePattern
-| *lazyStartProducer* (producer) | 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 [...]
-| *blobName* (blobstore) | The name of the blob. | | String
-| *container* (blobstore) | The name of the blob container. | | String
-| *directory* (blobstore) | An optional directory name to use | | String
-| *group* (compute) | The group that will be assigned to the newly created node. Values depend on the actual cloud provider. | | String
-| *hardwareId* (compute) | The hardware that will be used for creating a node. Values depend on the actual cloud provider. | | String
-| *imageId* (compute) | The imageId that will be used for creating a node. Values depend on the actual cloud provider. | | String
-| *locationId* (compute) | The location that will be used for creating a node. Values depend on the actual cloud provider. | | String
-| *nodeId* (compute) | The id of the node that will run the script or destroyed. | | String
-| *nodeState* (compute) | To filter by node status to only select running nodes etc. There are 6 enums and the value can be one of: PENDING, TERMINATED, SUSPENDED, RUNNING, ERROR, UNRECOGNIZED | | String
-| *operation* (compute) | Specifies the type of operation that will be performed to the blobstore. | | String
-| *user* (compute) | The user on the target node that will run the script. | | String
-|===
// endpoint options: END
-
+== Usage
You can have as many of these options as you like.
@@ -188,9 +123,6 @@ jclouds:blobstore:aws-s3?operation=CamelJcloudsGet&container=mycontainer&blobNam
For producer endpoint you can override all of the above URI options by
passing the appropriate headers to the message.
-
-
-
=== Message Headers for blobstore
[width="100%",cols="10%,90%",options="header",]
diff --git a/components/camel-jcr/src/main/docs/jcr-component.adoc b/components/camel-jcr/src/main/docs/jcr-component.adoc
index c256c7e..8746d88 100644
--- a/components/camel-jcr/src/main/docs/jcr-component.adoc
+++ b/components/camel-jcr/src/main/docs/jcr-component.adoc
@@ -17,10 +17,13 @@ compliant content repository (for example,
http://jackrabbit.apache.org/[Apache Jackrabbit]) with its producer, or
register an EventListener with the consumer.
+You can use consumer as an EventListener in
+JCR or a producer to read a node by identifier.
+
Maven users will need to add the following dependency to their `pom.xml`
for this component:
-[source,java]
+[source,xml]
------------------------------------------------------------
<dependency>
<groupId>org.apache.camel</groupId>
@@ -32,82 +35,17 @@ for this component:
== URI format
-[source,java]
-------------------------------------------
jcr://user:password@repository/path/to/node
-------------------------------------------
-*Consumer added*
-
-You can use consumer as an EventListener in
-JCR or a producer to read a node by identifier.
-
-== Usage
-
The `repository` element of the URI is used to look up the JCR
`Repository` object in the Camel context registry.
-=== JCR Options
-
// component options: START
-The JCR component supports 3 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *lazyStartProducer* (producer) | 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 [...]
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-|===
// component options: END
-
-
-
-
// endpoint options: START
-The JCR endpoint is configured using URI syntax:
-
-----
-jcr:host/base
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (2 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *host* | *Required* Name of the javax.jcr.Repository to lookup from the Camel registry to be used. | | String
-| *base* | Get the base node when accessing the repository | | String
-|===
-
-
-=== Query Parameters (14 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *deep* (common) | When isDeep is true, events whose associated parent node is at absPath or within its subgraph are received. | false | boolean
-| *eventTypes* (common) | eventTypes (a combination of one or more event types encoded as a bit mask value such as javax.jcr.observation.Event.NODE_ADDED, javax.jcr.observation.Event.NODE_REMOVED, etc.). | | int
-| *nodeTypeNames* (common) | When a comma separated nodeTypeName list string is set, only events whose associated parent node has one of the node types (or a subtype of one of the node types) in this list will be received. | | String
-| *noLocal* (common) | If noLocal is true, then events generated by the session through which the listener was registered are ignored. Otherwise, they are not ignored. | false | boolean
-| *password* (common) | Password for login | | String
-| *sessionLiveCheckInterval* (common) | Interval in milliseconds to wait before each session live checking The default value is 60000 ms. | 60000 | long
-| *sessionLiveCheckIntervalOn{zwsp}Start* (common) | Interval in milliseconds to wait before the first session live checking. The default value is 3000 ms. | 3000 | long
-| *username* (common) | Username for login | | String
-| *uuids* (common) | When a comma separated uuid list string is set, only events whose associated parent node has one of the identifiers in the comma separated uuid list will be received. | | String
-| *workspaceName* (common) | The workspace to access. If it's not specified then the default one will be used | | String
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *exceptionHandler* (consumer) | 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. | | ExceptionHandler
-| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut | | ExchangePattern
-| *lazyStartProducer* (producer) | 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 [...]
-|===
// endpoint options: END
== Example
@@ -124,8 +62,6 @@ from("direct:a").setHeader(JcrConstants.JCR_NODE_NAME, constant("node"))
.to("jcr://user:pass@repository/home/test");
------------------------------------------------------------------------
-
-
The following code will register an EventListener under the path
import-application/inbox for Event.NODE_ADDED and Event.NODE_REMOVED
events (event types 1 and 2, both masked as 3) and listening deep for
diff --git a/components/camel-jdbc/src/main/docs/jdbc-component.adoc b/components/camel-jdbc/src/main/docs/jdbc-component.adoc
index 1964978..b4a5fd7 100644
--- a/components/camel-jdbc/src/main/docs/jdbc-component.adoc
+++ b/components/camel-jdbc/src/main/docs/jdbc-component.adoc
@@ -39,78 +39,14 @@ means that you cannot use the JDBC component in a `from()` statement.
== URI format
-[source,text]
----
jdbc:dataSourceName[?options]
----
-This component only supports producer endpoints.
-
-You can append query options to the URI in the following format,
-`?option=value&option=value&...`
-
-== Options
// component options: START
-The JDBC component supports 4 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *dataSource* (producer) | To use the DataSource instance instead of looking up the data source by name from the registry. | | DataSource
-| *lazyStartProducer* (producer) | 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 [...]
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-| *connectionStrategy* (advanced) | To use a custom strategy for working with connections. Do not use a custom strategy when using the spring-jdbc component because a special Spring ConnectionStrategy is used by default to support Spring Transactions. | | ConnectionStrategy
-|===
// component options: END
-
-
-
-
-
-
// endpoint options: START
-The JDBC endpoint is configured using URI syntax:
-
-----
-jdbc:dataSourceName
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (1 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *dataSourceName* | *Required* Name of DataSource to lookup in the Registry. If the name is dataSource or default, then Camel will attempt to lookup a default DataSource from the registry, meaning if there is a only one instance of DataSource found, then this DataSource will be used. | | String
-|===
-
-
-=== Query Parameters (14 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *allowNamedParameters* (producer) | Whether to allow using named parameters in the queries. | true | boolean
-| *lazyStartProducer* (producer) | 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 [...]
-| *outputClass* (producer) | Specify the full package and class name to use as conversion when outputType=SelectOne or SelectList. | | String
-| *outputType* (producer) | Determines the output the producer should use. There are 3 enums and the value can be one of: SelectOne, SelectList, StreamList | SelectList | JdbcOutputType
-| *parameters* (producer) | Optional parameters to the java.sql.Statement. For example to set maxRows, fetchSize etc. | | Map
-| *readSize* (producer) | The default maximum number of rows that can be read by a polling query. The default value is 0. | | int
-| *resetAutoCommit* (producer) | Camel will set the autoCommit on the JDBC connection to be false, commit the change after executed the statement and reset the autoCommit flag of the connection at the end, if the resetAutoCommit is true. If the JDBC connection doesn't support to reset the autoCommit flag, you can set the resetAutoCommit flag to be false, and Camel will not try to reset the autoCommit flag. When used with XA transactions you most likely need to set it to false so that the [...]
-| *transacted* (producer) | Whether transactions are in use. | false | boolean
-| *useGetBytesForBlob* (producer) | To read BLOB columns as bytes instead of string data. This may be needed for certain databases such as Oracle where you must read BLOB columns as bytes. | false | boolean
-| *useHeadersAsParameters* (producer) | Set this option to true to use the prepareStatementStrategy with named parameters. This allows to define queries with named placeholders, and use headers with the dynamic values for the query placeholders. | false | boolean
-| *useJDBC4ColumnNameAndLabel{zwsp}Semantics* (producer) | Sets whether to use JDBC 4 or JDBC 3.0 or older semantic when retrieving column name. JDBC 4.0 uses columnLabel to get the column name where as JDBC 3.0 uses both columnName or columnLabel. Unfortunately JDBC drivers behave differently so you can use this option to work out issues around your JDBC driver if you get problem using this component This option is default true. | true | boolean
-| *beanRowMapper* (advanced) | To use a custom org.apache.camel.component.jdbc.BeanRowMapper when using outputClass. The default implementation will lower case the row names and skip underscores, and dashes. For example CUST_ID is mapped as custId. | | BeanRowMapper
-| *connectionStrategy* (advanced) | To use a custom strategy for working with connections. Do not use a custom strategy when using the spring-jdbc component because a special Spring ConnectionStrategy is used by default to support Spring Transactions. | | ConnectionStrategy
-| *prepareStatementStrategy* (advanced) | Allows the plugin to use a custom org.apache.camel.component.jdbc.JdbcPrepareStatementStrategy to control preparation of the query and prepared statement. | | JdbcPrepareStatementStrategy
-|===
// endpoint options: END
@@ -151,8 +87,6 @@ type.
== Generated keys
-*Since Camel 2.10*
-
If you insert data using SQL INSERT, then the RDBMS may support auto
generated keys. You can instruct the xref:jdbc-component.adoc[JDBC] producer to
return the generated keys in headers. +
@@ -164,8 +98,6 @@ Using generated keys does not work with together with named parameters.
== Using named parameters
-*Since Camel 2.12*
-
In the given route below, we want to get all the projects from the
projects table. Notice the SQL query has 2 named parameters, :?lic and
:?min. +
@@ -268,7 +200,8 @@ With spring xml:
<simple>insert into test '${body[value]}'</simple>
</setBody>
<to uri="jdbc:DataStore"/>
- </route>
+ </route>
+</camelContext>
----
We create an endpoint, add the SQL query to the body of the IN message,
diff --git a/components/camel-jetty/src/main/docs/jetty-component.adoc b/components/camel-jetty/src/main/docs/jetty-component.adoc
index f13311d..1020311 100644
--- a/components/camel-jetty/src/main/docs/jetty-component.adoc
+++ b/components/camel-jetty/src/main/docs/jetty-component.adoc
@@ -43,134 +43,16 @@ for this component:
== URI format
-[source,text]
----
jetty:http://hostname[:port][/resourceUri][?options]
----
-You can append query options to the URI in the following format,
-`?option=value&option=value&...`
-
-== Options
-
-
-
-
-
// component options: START
-The Jetty component supports 32 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *continuationTimeout* (consumer) | Allows to set a timeout in millis when using Jetty as consumer (server). By default Jetty uses 30000. You can use a value of = 0 to never expire. If a timeout occurs then the request will be expired and Jetty will return back a http error 503 to the client. This option is only in use when using Jetty with the Asynchronous Routing Engine. | 30000 | Long
-| *enableJmx* (consumer) | If this option is true, Jetty JMX support will be enabled for this endpoint. | false | boolean
-| *maxThreads* (consumer) | To set a value for maximum number of threads in server thread pool. Notice that both a min and max size must be configured. | | Integer
-| *minThreads* (consumer) | To set a value for minimum number of threads in server thread pool. Notice that both a min and max size must be configured. | | Integer
-| *requestBufferSize* (consumer) | Allows to configure a custom value of the request buffer size on the Jetty connectors. | | Integer
-| *requestHeaderSize* (consumer) | Allows to configure a custom value of the request header size on the Jetty connectors. | | Integer
-| *responseBufferSize* (consumer) | Allows to configure a custom value of the response buffer size on the Jetty connectors. | | Integer
-| *responseHeaderSize* (consumer) | Allows to configure a custom value of the response header size on the Jetty connectors. | | Integer
-| *sendServerVersion* (consumer) | If the option is true, jetty will send the server header with the jetty version information to the client which sends the request. NOTE please make sure there is no any other camel-jetty endpoint is share the same port, otherwise this option may not work as expected. | true | boolean
-| *useContinuation* (consumer) | Whether or not to use Jetty continuations for the Jetty Server. | true | boolean
-| *useXForwardedForHeader* (consumer) | To use the X-Forwarded-For header in HttpServletRequest.getRemoteAddr. | false | boolean
-| *threadPool* (consumer) | To use a custom thread pool for the server. This option should only be used in special circumstances. | | ThreadPool
-| *allowJavaSerializedObject* (advanced) | Whether to allow java serialization when a request uses context-type=application/x-java-serialized-object. This is by default turned off. If you enable this then be aware that Java will deserialize the incoming data from the request to Java and that can be a potential security risk. | false | boolean
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-| *errorHandler* (advanced) | This option is used to set the ErrorHandler that Jetty server uses. | | ErrorHandler
-| *httpBinding* (advanced) | Not to be used - use JettyHttpBinding instead. | | HttpBinding
-| *httpConfiguration* (advanced) | Jetty component does not use HttpConfiguration. | | HttpConfiguration
-| *jettyHttpBinding* (advanced) | To use a custom org.apache.camel.component.jetty.JettyHttpBinding, which are used to customize how a response should be written for the producer. | | JettyHttpBinding
-| *mbContainer* (advanced) | To use a existing configured org.eclipse.jetty.jmx.MBeanContainer if JMX is enabled that Jetty uses for registering mbeans. | | MBeanContainer
-| *headerFilterStrategy* (filter) | To use a custom org.apache.camel.spi.HeaderFilterStrategy to filter header to and from Camel message. | | HeaderFilterStrategy
-| *proxyHost* (proxy) | To use a http proxy to configure the hostname. | | String
-| *proxyPort* (proxy) | To use a http proxy to configure the port number. | | Integer
-| *keystore* (security) | Specifies the location of the Java keystore file, which contains the Jetty server's own X.509 certificate in a key entry. | | String
-| *socketConnectorProperties* (security) | A map which contains general HTTP connector properties. Uses the same principle as sslSocketConnectorProperties. | | Map
-| *socketConnectors* (security) | A map which contains per port number specific HTTP connectors. Uses the same principle as sslSocketConnectors. | | Map
-| *sslContextParameters* (security) | To configure security using SSLContextParameters | | SSLContextParameters
-| *sslKeyPassword* (security) | The key password, which is used to access the certificate's key entry in the keystore (this is the same password that is supplied to the keystore command's -keypass option). | | String
-| *sslPassword* (security) | The ssl password, which is required to access the keystore file (this is the same password that is supplied to the keystore command's -storepass option). | | String
-| *sslSocketConnectorProperties* (security) | A map which contains general SSL connector properties. | | Map
-| *sslSocketConnectors* (security) | A map which contains per port number specific SSL connectors. | | Map
-| *useGlobalSslContextParameters* (security) | Enable usage of global SSL context parameters | false | boolean
-|===
// component options: END
-
-
-
-
-
-
-
-
-
// endpoint options: START
-The Jetty endpoint is configured using URI syntax:
-
-----
-jetty:httpUri
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (1 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *httpUri* | *Required* The url of the HTTP endpoint to call. | | URI
-|===
-
-
-=== Query Parameters (32 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *chunked* (consumer) | If this option is false the Servlet will disable the HTTP streaming and set the content-length header on the response | true | boolean
-| *disableStreamCache* (common) | Determines whether or not the raw input stream from Servlet is cached or not (Camel will read the stream into a in memory/overflow to file, Stream caching) cache. By default Camel will cache the Servlet input stream to support reading it multiple times to ensure it Camel can retrieve all data from the stream. However you can set this option to true when you for example need to access the raw stream, such as streaming it directly to a file or other persis [...]
-| *headerFilterStrategy* (common) | To use a custom HeaderFilterStrategy to filter header to and from Camel message. | | HeaderFilterStrategy
-| *httpBinding* (common) | To use a custom HttpBinding to control the mapping between Camel message and HttpClient. | | HttpBinding
-| *async* (consumer) | Configure the consumer to work in async mode | false | boolean
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *continuationTimeout* (consumer) | Allows to set a timeout in millis when using Jetty as consumer (server). By default Jetty uses 30000. You can use a value of = 0 to never expire. If a timeout occurs then the request will be expired and Jetty will return back a http error 503 to the client. This option is only in use when using Jetty with the Asynchronous Routing Engine. | 30000 | Long
-| *enableCORS* (consumer) | If the option is true, Jetty server will setup the CrossOriginFilter which supports the CORS out of box. | false | boolean
-| *enableJmx* (consumer) | If this option is true, Jetty JMX support will be enabled for this endpoint. See Jetty JMX support for more details. | false | boolean
-| *enableMultipartFilter* (consumer) | Whether org.apache.camel.component.jetty.MultiPartFilter is enabled or not. You should set this value to false when bridging endpoints, to ensure multipart requests is proxied/bridged as well. | false | boolean
-| *httpMethodRestrict* (consumer) | Used to only allow consuming if the HttpMethod matches, such as GET/POST/PUT etc. Multiple methods can be specified separated by comma. | | String
-| *matchOnUriPrefix* (consumer) | Whether or not the consumer should try to find a target consumer by matching the URI prefix if no exact match is found. | false | boolean
-| *muteException* (consumer) | If enabled and an Exchange failed processing on the consumer side the response's body won't contain the exception's stack trace. | false | boolean
-| *responseBufferSize* (consumer) | To use a custom buffer size on the javax.servlet.ServletResponse. | | Integer
-| *sendDateHeader* (consumer) | If the option is true, jetty server will send the date header to the client which sends the request. NOTE please make sure there is no any other camel-jetty endpoint is share the same port, otherwise this option may not work as expected. | false | boolean
-| *sendServerVersion* (consumer) | If the option is true, jetty will send the server header with the jetty version information to the client which sends the request. NOTE please make sure there is no any other camel-jetty endpoint is share the same port, otherwise this option may not work as expected. | true | boolean
-| *sessionSupport* (consumer) | Specifies whether to enable the session manager on the server side of Jetty. | false | boolean
-| *transferException* (consumer) | If enabled and an Exchange failed processing on the consumer side, and if the caused Exception was send back serialized in the response as a application/x-java-serialized-object content type. On the producer side the exception will be deserialized and thrown as is, instead of the HttpOperationFailedException. The caused exception is required to be serialized. This is by default turned off. If you enable this then be aware that Java will deserialize the [...]
-| *useContinuation* (consumer) | Whether or not to use Jetty continuations for the Jetty Server. | | Boolean
-| *eagerCheckContentAvailable* (consumer) | Whether to eager check whether the HTTP requests has content if the content-length header is 0 or not present. This can be turned on in case HTTP clients do not send streamed data. | false | boolean
-| *exceptionHandler* (consumer) | 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. | | ExceptionHandler
-| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut | | ExchangePattern
-| *filterInitParameters* (consumer) | Configuration of the filter init parameters. These parameters will be applied to the filter list before starting the jetty server. | | Map
-| *filters* (consumer) | Allows using a custom filters which is putted into a list and can be find in the Registry. Multiple values can be separated by comma. | | List
-| *handlers* (consumer) | Specifies a comma-delimited set of Handler instances to lookup in your Registry. These handlers are added to the Jetty servlet context (for example, to add security). Important: You can not use different handlers with different Jetty endpoints using the same port number. The handlers is associated to the port number. If you need different handlers, then use different port numbers. | | List
-| *mapHttpMessageBody* (consumer) | If this option is true then IN exchange Body of the exchange will be mapped to HTTP body. Setting this to false will avoid the HTTP mapping. | true | boolean
-| *mapHttpMessageFormUrlEncoded{zwsp}Body* (consumer) | If this option is true then IN exchange Form Encoded body of the exchange will be mapped to HTTP. Setting this to false will avoid the HTTP Form Encoded body mapping. | true | boolean
-| *mapHttpMessageHeaders* (consumer) | If this option is true then IN exchange Headers of the exchange will be mapped to HTTP headers. Setting this to false will avoid the HTTP Headers mapping. | true | boolean
-| *multipartFilter* (consumer) | Allows using a custom multipart filter. Note: setting multipartFilterRef forces the value of enableMultipartFilter to true. | | Filter
-| *optionsEnabled* (consumer) | Specifies whether to enable HTTP OPTIONS for this Servlet consumer. By default OPTIONS is turned off. | false | boolean
-| *traceEnabled* (consumer) | Specifies whether to enable HTTP TRACE for this Servlet consumer. By default TRACE is turned off. | false | boolean
-| *sslContextParameters* (security) | To configure security using SSLContextParameters | | SSLContextParameters
-|===
// endpoint options: END
-
-
== Message Headers
Camel uses the same message headers as the xref:http-component.adoc[HTTP]
@@ -651,7 +533,6 @@ Blueprint based definition of basic authentication (based on Jetty 9):
The roles.properties files contains
-[source,text]
----
username1=password1,rolename1
username2=password2,rolename1
@@ -659,7 +540,6 @@ username2=password2,rolename1
This file is located in the etc folder and will be reloaded when changed. The endpoint
-[source,text]
----
http://0.0.0.0/path
----
diff --git a/components/camel-jgroups-raft/src/main/docs/jgroups-raft-component.adoc b/components/camel-jgroups-raft/src/main/docs/jgroups-raft-component.adoc
index 6299dce..e74f766 100644
--- a/components/camel-jgroups-raft/src/main/docs/jgroups-raft-component.adoc
+++ b/components/camel-jgroups-raft/src/main/docs/jgroups-raft-component.adoc
@@ -30,7 +30,6 @@ for this component.
== URI format
-[source,java]
-----------------------------
jgroups-raft:clusterName[?options]
-----------------------------
@@ -41,54 +40,8 @@ component should connect to.
== Options
// component options: START
-The JGroups raft component supports 7 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *channelProperties* (common) | Specifies configuration properties of the RaftHandle JChannel used by the endpoint (ignored if raftHandle ref is provided). | raft.xml | String
-| *raftHandle* (common) | RaftHandle to use. | | RaftHandle
-| *raftId* (common) | *Required* Unique raftId to use. | | String
-| *stateMachine* (common) | StateMachine to use. | NopStateMachine | StateMachine
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *lazyStartProducer* (producer) | 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 [...]
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-|===
// component options: END
-
// endpoint options: START
-The JGroups raft endpoint is configured using URI syntax:
-
-----
-jgroups-raft:clusterName
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (1 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *clusterName* | *Required* The name of the JGroupsraft cluster the component should connect to. | | String
-|===
-
-
-=== Query Parameters (5 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *enableRoleChangeEvents* (consumer) | If set to true, the consumer endpoint will receive roleChange event as well (not just connecting and/or using the state machine). By default it is set to false. | false | boolean
-| *exceptionHandler* (consumer) | 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. | | ExceptionHandler
-| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut | | ExchangePattern
-| *lazyStartProducer* (producer) | 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 [...]
-|===
// endpoint options: END
diff --git a/components/camel-jgroups/src/main/docs/jgroups-component.adoc b/components/camel-jgroups/src/main/docs/jgroups-component.adoc
index 1e0069b..5224bd4 100644
--- a/components/camel-jgroups/src/main/docs/jgroups-component.adoc
+++ b/components/camel-jgroups/src/main/docs/jgroups-component.adoc
@@ -31,7 +31,6 @@ for this component.
== URI format
-[source,java]
-----------------------------
jgroups:clusterName[?options]
-----------------------------
@@ -39,70 +38,13 @@ jgroups:clusterName[?options]
Where *clusterName* represents the name of the JGroups cluster the
component should connect to.
-== Options
-
-
-
// component options: START
-The JGroups component supports 6 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *channel* (common) | Channel to use | | JChannel
-| *channelProperties* (common) | Specifies configuration properties of the JChannel used by the endpoint. | | String
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *enableViewMessages* (consumer) | If set to true, the consumer endpoint will receive org.jgroups.View messages as well (not only org.jgroups.Message instances). By default only regular messages are consumed by the endpoint. | false | boolean
-| *lazyStartProducer* (producer) | 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 [...]
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-|===
// component options: END
-
-
-
-
-
-
// endpoint options: START
-The JGroups endpoint is configured using URI syntax:
-
-----
-jgroups:clusterName
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (1 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *clusterName* | *Required* The name of the JGroups cluster the component should connect to. | | String
-|===
-
-
-=== Query Parameters (6 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *channelProperties* (common) | Specifies configuration properties of the JChannel used by the endpoint. | | String
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *enableViewMessages* (consumer) | If set to true, the consumer endpoint will receive org.jgroups.View messages as well (not only org.jgroups.Message instances). By default only regular messages are consumed by the endpoint. | false | boolean
-| *exceptionHandler* (consumer) | 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. | | ExceptionHandler
-| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut | | ExchangePattern
-| *lazyStartProducer* (producer) | 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 [...]
-|===
// endpoint options: END
-
-
== Headers
[width="100%",cols="10%,10%,70%",options="header",]
diff --git a/components/camel-jing/src/main/docs/jing-component.adoc b/components/camel-jing/src/main/docs/jing-component.adoc
index 8b27456..c73a715 100644
--- a/components/camel-jing/src/main/docs/jing-component.adoc
+++ b/components/camel-jing/src/main/docs/jing-component.adoc
@@ -38,7 +38,6 @@ syntax.
== URI format
-[source,text]
------------------------------
jing:someLocalOrRemoteResource
------------------------------
@@ -46,58 +45,12 @@ jing:someLocalOrRemoteResource
The component uses jing as name, and you can use the
option compactSyntax to turn on either RNG or RNC mode.
-== Options
-
// component options: START
-The Jing component supports 2 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *lazyStartProducer* (producer) | 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 [...]
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-|===
// component options: END
-
-
-
-
// endpoint options: START
-The Jing endpoint is configured using URI syntax:
-
-----
-jing:resourceUri
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (1 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *resourceUri* | *Required* URL to a local resource on the classpath or a full URL to a remote resource or resource on the file system which contains the schema to validate against. | | String
-|===
-
-
-=== Query Parameters (2 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *compactSyntax* (producer) | Whether to validate using RelaxNG compact syntax or not. By default this is false for using RelaxNG XML Syntax (rng) And true is for using RelaxNG Compact Syntax (rnc) | false | boolean
-| *lazyStartProducer* (producer) | 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 [...]
-|===
// endpoint options: END
-
-
-
== Example
The following example shows how to configure a route from the endpoint *direct:start* which
diff --git a/components/camel-jira/src/main/docs/jira-component.adoc b/components/camel-jira/src/main/docs/jira-component.adoc
index e25adca..f661306 100644
--- a/components/camel-jira/src/main/docs/jira-component.adoc
+++ b/components/camel-jira/src/main/docs/jira-component.adoc
@@ -42,37 +42,10 @@ for this component:
== URI format
-[source,text]
-------------------------
jira://type[?options]
-------------------------
-== JIRA Options
-
-
-// component options: START
-The Jira component supports 12 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *delay* (common) | Time in milliseconds to elapse for the next poll. | 6000 | Integer
-| *jiraUrl* (common) | *Required* The Jira server url, example: \http://my_jira.com:8081 | | String
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *lazyStartProducer* (producer) | 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 [...]
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-| *configuration* (advanced) | To use a shared base jira configuration. | | JiraConfiguration
-| *accessToken* (security) | (OAuth only) The access token generated by the Jira server. | | String
-| *consumerKey* (security) | (OAuth only) The consumer key from Jira settings. | | String
-| *password* (security) | (Basic authentication only) The password to authenticate to the Jira server. Use only if username basic authentication is used. | | String
-| *privateKey* (security) | (OAuth only) The private key generated by the client to encrypt the conversation to the server. | | String
-| *username* (security) | (Basic authentication only) The username to authenticate to the Jira server. Use only if OAuth is not enabled on the Jira server. Do not set the username and OAuth token parameter, if they are both set, the username basic authentication takes precedence. | | String
-| *verificationCode* (security) | (OAuth only) The verification code from Jira generated in the first step of the authorization proccess. | | String
-|===
-// component options: END
-
The Jira type accepts the following operations:
For consumers:
@@ -93,52 +66,12 @@ For producers:
As Jira is fully customizable, you must assure the fields IDs exists for the project and workflow, as they can change between different Jira servers.
+// component options: START
+// component options: END
// endpoint options: START
-The Jira endpoint is configured using URI syntax:
-
-----
-jira:type
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (1 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *type* | *Required* Operation to perform. Consumers: NewIssues, NewComments. Producers: AddIssue, AttachFile, DeleteIssue, TransitionIssue, UpdateIssue, Watchers. See this class javadoc description for more information. There are 14 enums and the value can be one of: ADDCOMMENT, ADDISSUE, ATTACH, DELETEISSUE, NEWISSUES, NEWCOMMENTS, WATCHUPDATES, UPDATEISSUE, TRANSITIONISSUE, WATCHERS, ADDISSUELINK, ADDWORKLOG, FETCHISSUE, FETCHCOMMENTS | | JiraType
-|===
-
-
-=== Query Parameters (16 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *delay* (common) | Time in milliseconds to elapse for the next poll. | 6000 | Integer
-| *jiraUrl* (common) | *Required* The Jira server url, example: \http://my_jira.com:8081 | | String
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *jql* (consumer) | JQL is the query language from JIRA which allows you to retrieve the data you want. For example jql=project=MyProject Where MyProject is the product key in Jira. It is important to use the RAW() and set the JQL inside it to prevent camel parsing it, example: RAW(project in (MYP, COM) AND resolution = Unresolved) | | String
-| *maxResults* (consumer) | Max number of issues to search for | 50 | Integer
-| *sendOnlyUpdatedField* (consumer) | Indicator for sending only changed fields in exchange body or issue object. By default consumer sends only changed fields. | true | boolean
-| *watchedFields* (consumer) | Comma separated list of fields to watch for changes. Status,Priority are the defaults. | Status,Priority | String
-| *exceptionHandler* (consumer) | 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. | | ExceptionHandler
-| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut | | ExchangePattern
-| *lazyStartProducer* (producer) | 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 [...]
-| *accessToken* (security) | (OAuth only) The access token generated by the Jira server. | | String
-| *consumerKey* (security) | (OAuth only) The consumer key from Jira settings. | | String
-| *password* (security) | (Basic authentication only) The password to authenticate to the Jira server. Use only if username basic authentication is used. | | String
-| *privateKey* (security) | (OAuth only) The private key generated by the client to encrypt the conversation to the server. | | String
-| *username* (security) | (Basic authentication only) The username to authenticate to the Jira server. Use only if OAuth is not enabled on the Jira server. Do not set the username and OAuth token parameter, if they are both set, the username basic authentication takes precedence. | | String
-| *verificationCode* (security) | (OAuth only) The verification code from Jira generated in the first step of the authorization proccess. | | String
-|===
// endpoint options: END
-
== Client Factory
You can bind the `JiraRestClientFactory` with name *JiraRestClientFactory* in the registry to have it automatically set in the Jira endpoint.
@@ -172,7 +105,6 @@ flexible and powerful.
At the bare minimum, the consumers will require the following:
-[source,text]
--------------------------------------------------------------
jira://[type]?[required options]&jql=project=[project key]
--------------------------------------------------------------
@@ -194,7 +126,6 @@ comments" custom field -- use '"Number of comments" > 0' in your query.
Also try to minimize based on state (status=Open), increase the polling
delay, etc. Example:
-[source,text]
----------------------------------------------------------------------------------------------------------------------------------------------
jira://[type]?[required options]&jql=RAW(project=[project key] AND status in (Open, \"Coding In Progress\") AND \"Number of comments\">0)"
----------------------------------------------------------------------------------------------------------------------------------------------
@@ -270,6 +201,7 @@ Required:
* `IssueWatchersRemove`: A list of strings with the usernames to remove from the watcher list.
== WatchUpdates (consumer)
+
* `watchedFields` Comma separated list of fields to watch for changes i.e `Status,Priority,Assignee,Components` etc.
* `sendOnlyUpdatedField` By default only changed field is send as the body.
diff --git a/components/camel-jms/src/main/docs/jms-component.adoc b/components/camel-jms/src/main/docs/jms-component.adoc
index ab8da2b..08826dd 100644
--- a/components/camel-jms/src/main/docs/jms-component.adoc
+++ b/components/camel-jms/src/main/docs/jms-component.adoc
@@ -163,8 +163,6 @@ Camel consume the message
* Hyphen is replaced by `_HYPHEN_` and the replacement is reversed when
Camel consumes the message
-== Options
-
You can configure many different properties on the JMS endpoint, which
map to properties on the `JMSConfiguration` object.
@@ -177,268 +175,13 @@ uses for sending and receiving messages. So you can get more information
about these properties by consulting the relevant Spring documentation.
====
-=== Component options
-
-
-
-
-
-
-
// component options: START
-The JMS component supports 98 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *clientId* (common) | Sets the JMS client ID to use. Note that this value, if specified, must be unique and can only be used by a single JMS connection instance. It is typically only required for durable topic subscriptions. If using Apache ActiveMQ you may prefer to use Virtual Topics instead. | | String
-| *connectionFactory* (common) | The connection factory to be use. A connection factory must be configured either on the component or endpoint. | | ConnectionFactory
-| *disableReplyTo* (common) | Specifies whether Camel ignores the JMSReplyTo header in messages. If true, Camel does not send a reply back to the destination specified in the JMSReplyTo header. You can use this option if you want Camel to consume from a route and you do not want Camel to automatically send back a reply message because another component in your code handles the reply message. You can also use this option if you want to use Camel as a proxy between different message broker [...]
-| *durableSubscriptionName* (common) | The durable subscriber name for specifying durable topic subscriptions. The clientId option must be configured as well. | | String
-| *jmsMessageType* (common) | Allows you to force the use of a specific javax.jms.Message implementation for sending JMS messages. Possible values are: Bytes, Map, Object, Stream, Text. By default, Camel would determine which JMS message type to use from the In body type. This option allows you to specify it. There are 5 enums and the value can be one of: Bytes, Map, Object, Stream, Text | | JmsMessageType
-| *replyTo* (common) | Provides an explicit ReplyTo destination (overrides any incoming value of Message.getJMSReplyTo() in consumer). | | String
-| *testConnectionOnStartup* (common) | Specifies whether to test the connection on startup. This ensures that when Camel starts that all the JMS consumers have a valid connection to the JMS broker. If a connection cannot be granted then Camel throws an exception on startup. This ensures that Camel is not started with failed connections. The JMS producers is tested as well. | false | boolean
-| *acknowledgementModeName* (consumer) | The JMS acknowledgement name, which is one of: SESSION_TRANSACTED, CLIENT_ACKNOWLEDGE, AUTO_ACKNOWLEDGE, DUPS_OK_ACKNOWLEDGE. There are 4 enums and the value can be one of: SESSION_TRANSACTED, CLIENT_ACKNOWLEDGE, AUTO_ACKNOWLEDGE, DUPS_OK_ACKNOWLEDGE | AUTO_ACKNOWLEDGE | String
-| *artemisConsumerPriority* (consumer) | 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 av [...]
-| *asyncConsumer* (consumer) | Whether the JmsConsumer processes the Exchange asynchronously. If enabled then the JmsConsumer may pickup the next message from the JMS queue, while the previous message is being processed asynchronously (by the Asynchronous Routing Engine). This means that messages may be processed not 100% strictly in order. If disabled (as default) then the Exchange is fully processed before the JmsConsumer will pickup the next message from the JMS queue. Note if transac [...]
-| *autoStartup* (consumer) | Specifies whether the consumer container should auto-startup. | true | boolean
-| *cacheLevel* (consumer) | Sets the cache level by ID for the underlying JMS resources. See cacheLevelName option for more details. | | int
-| *cacheLevelName* (consumer) | Sets the cache level by name for the underlying JMS resources. Possible values are: CACHE_AUTO, CACHE_CONNECTION, CACHE_CONSUMER, CACHE_NONE, and CACHE_SESSION. The default setting is CACHE_AUTO. See the Spring documentation and Transactions Cache Levels for more information. There are 5 enums and the value can be one of: CACHE_AUTO, CACHE_CONNECTION, CACHE_CONSUMER, CACHE_NONE, CACHE_SESSION | CACHE_AUTO | String
-| *concurrentConsumers* (consumer) | Specifies the default number of concurrent consumers when consuming from JMS (not for request/reply over JMS). See also the maxMessagesPerTask option to control dynamic scaling up/down of threads. When doing request/reply over JMS then the option replyToConcurrentConsumers is used to control number of concurrent consumers on the reply message listener. | 1 | int
-| *maxConcurrentConsumers* (consumer) | Specifies the maximum number of concurrent consumers when consuming from JMS (not for request/reply over JMS). See also the maxMessagesPerTask option to control dynamic scaling up/down of threads. When doing request/reply over JMS then the option replyToMaxConcurrentConsumers is used to control number of concurrent consumers on the reply message listener. | | int
-| *replyToDeliveryPersistent* (consumer) | Specifies whether to use persistent delivery by default for replies. | true | boolean
-| *selector* (consumer) | Sets the JMS selector to use | | String
-| *subscriptionDurable* (consumer) | Set whether to make the subscription durable. The durable subscription name to be used can be specified through the subscriptionName property. Default is false. Set this to true to register a durable subscription, typically in combination with a subscriptionName value (unless your message listener class name is good enough as subscription name). Only makes sense when listening to a topic (pub-sub domain), therefore this method switches the pubSubDomai [...]
-| *subscriptionName* (consumer) | Set the name of a subscription to create. To be applied in case of a topic (pub-sub domain) with a shared or durable subscription. The subscription name needs to be unique within this client's JMS client id. Default is the class name of the specified message listener. Note: Only 1 concurrent consumer (which is the default of this message listener container) is allowed for each subscription, except for a shared subscription (which requires JMS 2.0). | | String
-| *subscriptionShared* (consumer) | Set whether to make the subscription shared. The shared subscription name to be used can be specified through the subscriptionName property. Default is false. Set this to true to register a shared subscription, typically in combination with a subscriptionName value (unless your message listener class name is good enough as subscription name). Note that shared subscriptions may also be durable, so this flag can (and often will) be combined with subscrip [...]
-| *acceptMessagesWhileStopping* (consumer) | Specifies whether the consumer accept messages while it is stopping. You may consider enabling this option, if you start and stop JMS routes at runtime, while there are still messages enqueued on the queue. If this option is false, and you stop the JMS route, then messages may be rejected, and the JMS broker would have to attempt redeliveries, which yet again may be rejected, and eventually the message may be moved at a dead letter queue on th [...]
-| *allowReplyManagerQuickStop* (consumer) | Whether the DefaultMessageListenerContainer used in the reply managers for request-reply messaging allow the DefaultMessageListenerContainer.runningAllowed flag to quick stop in case JmsConfiguration#isAcceptMessagesWhileStopping is enabled, and org.apache.camel.CamelContext is currently being stopped. This quick stop ability is enabled by default in the regular JMS consumers but to enable for reply managers you must enable this flag. | false | [...]
-| *consumerType* (consumer) | The consumer type to use, which can be one of: Simple, Default, or Custom. The consumer type determines which Spring JMS listener to use. Default will use org.springframework.jms.listener.DefaultMessageListenerContainer, Simple will use org.springframework.jms.listener.SimpleMessageListenerContainer. When Custom is specified, the MessageListenerContainerFactory defined by the messageListenerContainerFactory option will determine what org.springframework.jms. [...]
-| *defaultTaskExecutorType* (consumer) | Specifies what default TaskExecutor type to use in the DefaultMessageListenerContainer, for both consumer endpoints and the ReplyTo consumer of producer endpoints. Possible values: SimpleAsync (uses Spring's SimpleAsyncTaskExecutor) or ThreadPool (uses Spring's ThreadPoolTaskExecutor with optimal values - cached threadpool-like). If not set, it defaults to the previous behaviour, which uses a cached thread pool for consumer endpoints and SimpleAsy [...]
-| *eagerLoadingOfProperties* (consumer) | Enables eager loading of JMS properties and payload as soon as a message is loaded which generally is inefficient as the JMS properties may not be required but sometimes can catch early any issues with the underlying JMS provider and the use of JMS properties. See also the option eagerPoisonBody. | false | boolean
-| *eagerPoisonBody* (consumer) | If eagerLoadingOfProperties is enabled and the JMS message payload (JMS body or JMS properties) is poison (cannot be read/mapped), then set this text as the message body instead so the message can be processed (the cause of the poison are already stored as exception on the Exchange). This can be turned off by setting eagerPoisonBody=false. See also the option eagerLoadingOfProperties. | Poison JMS message due to ${exception.message} | String
-| *exposeListenerSession* (consumer) | Specifies whether the listener session should be exposed when consuming messages. | false | boolean
-| *replyToSameDestinationAllowed* (consumer) | Whether a JMS consumer is allowed to send a reply message to the same destination that the consumer is using to consume from. This prevents an endless loop by consuming and sending back the same message to itself. | false | boolean
-| *taskExecutor* (consumer) | Allows you to specify a custom task executor for consuming messages. | | TaskExecutor
-| *deliveryDelay* (producer) | Sets delivery delay to use for send calls for JMS. This option requires JMS 2.0 compliant broker. | -1 | long
-| *deliveryMode* (producer) | Specifies the delivery mode to be used. Possible values are those defined by javax.jms.DeliveryMode. NON_PERSISTENT = 1 and PERSISTENT = 2. There are 2 enums and the value can be one of: 1, 2 | | Integer
-| *deliveryPersistent* (producer) | Specifies whether persistent delivery is used by default. | true | boolean
-| *explicitQosEnabled* (producer) | Set if the deliveryMode, priority or timeToLive qualities of service should be used when sending messages. This option is based on Spring's JmsTemplate. The deliveryMode, priority and timeToLive options are applied to the current endpoint. This contrasts with the preserveMessageQos option, which operates at message granularity, reading QoS properties exclusively from the Camel In message headers. | false | Boolean
-| *formatDateHeadersToIso8601* (producer) | Sets whether JMS date properties should be formatted according to the ISO 8601 standard. | false | boolean
-| *lazyStartProducer* (producer) | 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 [...]
-| *preserveMessageQos* (producer) | Set to true, if you want to send message using the QoS settings specified on the message, instead of the QoS settings on the JMS endpoint. The following three headers are considered JMSPriority, JMSDeliveryMode, and JMSExpiration. You can provide all or only some of them. If not provided, Camel will fall back to use the values from the endpoint instead. So, when using this option, the headers override the values from the endpoint. The explicitQosEnable [...]
-| *priority* (producer) | Values greater than 1 specify the message priority when sending (where 1 is the lowest priority and 9 is the highest). The explicitQosEnabled option must also be enabled in order for this option to have any effect. There are 9 enums and the value can be one of: 1, 2, 3, 4, 5, 6, 7, 8, 9 | 4 | int
-| *replyToConcurrentConsumers* (producer) | Specifies the default number of concurrent consumers when doing request/reply over JMS. See also the maxMessagesPerTask option to control dynamic scaling up/down of threads. | 1 | int
-| *replyToMaxConcurrentConsumers* (producer) | Specifies the maximum number of concurrent consumers when using request/reply over JMS. See also the maxMessagesPerTask option to control dynamic scaling up/down of threads. | | int
-| *replyToOnTimeoutMaxConcurrent{zwsp}Consumers* (producer) | Specifies the maximum number of concurrent consumers for continue routing when timeout occurred when using request/reply over JMS. | 1 | int
-| *replyToOverride* (producer) | Provides an explicit ReplyTo destination in the JMS message, which overrides the setting of replyTo. It is useful if you want to forward the message to a remote Queue and receive the reply message from the ReplyTo destination. | | String
-| *replyToType* (producer) | Allows for explicitly specifying which kind of strategy to use for replyTo queues when doing request/reply over JMS. Possible values are: Temporary, Shared, or Exclusive. By default Camel will use temporary queues. However if replyTo has been configured, then Shared is used by default. This option allows you to use exclusive queues instead of shared ones. See Camel JMS documentation for more details, and especially the notes about the implications if running [...]
-| *requestTimeout* (producer) | The timeout for waiting for a reply when using the InOut Exchange Pattern (in milliseconds). The default is 20 seconds. You can include the header CamelJmsRequestTimeout to override this endpoint configured timeout value, and thus have per message individual timeout values. See also the requestTimeoutCheckerInterval option. | 20000 | long
-| *timeToLive* (producer) | When sending messages, specifies the time-to-live of the message (in milliseconds). | -1 | long
-| *allowAdditionalHeaders* (producer) | This option is used to allow additional headers which may have values that are invalid according to JMS specification. For example some message systems such as WMQ do this with header names using prefix JMS_IBM_MQMD_ containing values with byte array or other invalid types. You can specify multiple header names separated by comma, and use as suffix for wildcard matching. | | String
-| *allowNullBody* (producer) | Whether to allow sending messages with no body. If this option is false and the message body is null, then an JMSException is thrown. | true | boolean
-| *alwaysCopyMessage* (producer) | If true, Camel will always make a JMS message copy of the message when it is passed to the producer for sending. Copying the message is needed in some situations, such as when a replyToDestinationSelectorName is set (incidentally, Camel will set the alwaysCopyMessage option to true, if a replyToDestinationSelectorName is set) | false | boolean
-| *correlationProperty* (producer) | When using InOut exchange pattern use this JMS property instead of JMSCorrelationID JMS property to correlate messages. If set messages will be correlated solely on the value of this property JMSCorrelationID property will be ignored and not set by Camel. | | String
-| *disableTimeToLive* (producer) | Use this option to force disabling time to live. For example when you do request/reply over JMS, then Camel will by default use the requestTimeout value as time to live on the message being sent. The problem is that the sender and receiver systems have to have their clocks synchronized, so they are in sync. This is not always so easy to archive. So you can use disableTimeToLive=true to not set a time to live value on the sent message. Then the message w [...]
-| *forceSendOriginalMessage* (producer) | When using mapJmsMessage=false Camel will create a new JMS message to send to a new JMS destination if you touch the headers (get or set) during the route. Set this option to true to force Camel to send the original JMS message that was received. | false | boolean
-| *includeSentJMSMessageID* (producer) | Only applicable when sending to JMS destination using InOnly (eg fire and forget). Enabling this option will enrich the Camel Exchange with the actual JMSMessageID that was used by the JMS client when the message was sent to the JMS destination. | false | boolean
-| *replyToCacheLevelName* (producer) | Sets the cache level by name for the reply consumer when doing request/reply over JMS. This option only applies when using fixed reply queues (not temporary). Camel will by default use: CACHE_CONSUMER for exclusive or shared w/ replyToSelectorName. And CACHE_SESSION for shared without replyToSelectorName. Some JMS brokers such as IBM WebSphere may require to set the replyToCacheLevelName=CACHE_NONE to work. Note: If using temporary queues then CACHE [...]
-| *replyToDestinationSelectorName* (producer) | Sets the JMS Selector using the fixed name to be used so you can filter out your own replies from the others when using a shared queue (that is, if you are not using a temporary reply queue). | | String
-| *streamMessageTypeEnabled* (producer) | Sets whether StreamMessage type is enabled or not. Message payloads of streaming kind such as files, InputStream, etc will either by sent as BytesMessage or StreamMessage. This option controls which kind will be used. By default BytesMessage is used which enforces the entire message payload to be read into memory. By enabling this option the message payload is read into memory in chunks and each chunk is then written to the StreamMessage until no [...]
-| *allowAutoWiredConnection{zwsp}Factory* (advanced) | Whether to auto-discover ConnectionFactory from the registry, if no connection factory has been configured. If only one instance of ConnectionFactory is found then it will be used. This is enabled by default. | true | boolean
-| *allowAutoWiredDestination{zwsp}Resolver* (advanced) | Whether to auto-discover DestinationResolver from the registry, if no destination resolver has been configured. If only one instance of DestinationResolver is found then it will be used. This is enabled by default. | true | boolean
-| *allowSerializedHeaders* (advanced) | Controls whether or not to include serialized headers. Applies only when transferExchange is true. This requires that the objects are serializable. Camel will exclude any non-serializable objects and log it at WARN level. | false | boolean
-| *artemisStreamingEnabled* (advanced) | Whether optimizing for Apache Artemis streaming mode. | true | boolean
-| *asyncStartListener* (advanced) | Whether to startup the JmsConsumer message listener asynchronously, when starting a route. For example if a JmsConsumer cannot get a connection to a remote JMS broker, then it may block while retrying and/or failover. This will cause Camel to block while starting routes. By setting this option to true, you will let routes startup, while the JmsConsumer connects to the JMS broker using a dedicated thread in asynchronous mode. If this option is used, the [...]
-| *asyncStopListener* (advanced) | Whether to stop the JmsConsumer message listener asynchronously, when stopping a route. | false | boolean
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-| *configuration* (advanced) | To use a shared JMS configuration | | JmsConfiguration
-| *destinationResolver* (advanced) | A pluggable org.springframework.jms.support.destination.DestinationResolver that allows you to use your own resolver (for example, to lookup the real destination in a JNDI registry). | | DestinationResolver
-| *errorHandler* (advanced) | Specifies a org.springframework.util.ErrorHandler to be invoked in case of any uncaught exceptions thrown while processing a Message. By default these exceptions will be logged at the WARN level, if no errorHandler has been configured. You can configure logging level and whether stack traces should be logged using errorHandlerLoggingLevel and errorHandlerLogStackTrace options. This makes it much easier to configure, than having to code a custom errorHandler. [...]
-| *exceptionListener* (advanced) | Specifies the JMS Exception Listener that is to be notified of any underlying JMS exceptions. | | ExceptionListener
-| *idleConsumerLimit* (advanced) | Specify the limit for the number of consumers that are allowed to be idle at any given time. | 1 | int
-| *idleTaskExecutionLimit* (advanced) | Specifies the limit for idle executions of a receive task, not having received any message within its execution. If this limit is reached, the task will shut down and leave receiving to other executing tasks (in the case of dynamic scheduling; see the maxConcurrentConsumers setting). There is additional doc available from Spring. | 1 | int
-| *includeAllJMSXProperties* (advanced) | Whether to include all JMSXxxx properties when mapping from JMS to Camel Message. Setting this to true will include properties such as JMSXAppID, and JMSXUserID etc. Note: If you are using a custom headerFilterStrategy then this option does not apply. | false | boolean
-| *jmsKeyFormatStrategy* (advanced) | Pluggable strategy for encoding and decoding JMS keys so they can be compliant with the JMS specification. Camel provides two implementations out of the box: default and passthrough. The default strategy will safely marshal dots and hyphens (. and -). The passthrough strategy leaves the key as is. Can be used for JMS brokers which do not care whether JMS header keys contain illegal characters. You can provide your own implementation of the org.apache [...]
-| *mapJmsMessage* (advanced) | Specifies whether Camel should auto map the received JMS message to a suited payload type, such as javax.jms.TextMessage to a String etc. | true | boolean
-| *maxMessagesPerTask* (advanced) | The number of messages per task. -1 is unlimited. If you use a range for concurrent consumers (eg min max), then this option can be used to set a value to eg 100 to control how fast the consumers will shrink when less work is required. | -1 | int
-| *messageConverter* (advanced) | To use a custom Spring org.springframework.jms.support.converter.MessageConverter so you can be in control how to map to/from a javax.jms.Message. | | MessageConverter
-| *messageCreatedStrategy* (advanced) | To use the given MessageCreatedStrategy which are invoked when Camel creates new instances of javax.jms.Message objects when Camel is sending a JMS message. | | MessageCreatedStrategy
-| *messageIdEnabled* (advanced) | When sending, specifies whether message IDs should be added. This is just an hint to the JMS broker. If the JMS provider accepts this hint, these messages must have the message ID set to null; if the provider ignores the hint, the message ID must be set to its normal unique value. | true | boolean
-| *messageListenerContainer{zwsp}Factory* (advanced) | Registry ID of the MessageListenerContainerFactory used to determine what org.springframework.jms.listener.AbstractMessageListenerContainer to use to consume messages. Setting this will automatically set consumerType to Custom. | | MessageListenerContainerFactory
-| *messageTimestampEnabled* (advanced) | Specifies whether timestamps should be enabled by default on sending messages. This is just an hint to the JMS broker. If the JMS provider accepts this hint, these messages must have the timestamp set to zero; if the provider ignores the hint the timestamp must be set to its normal value. | true | boolean
-| *pubSubNoLocal* (advanced) | Specifies whether to inhibit the delivery of messages published by its own connection. | false | boolean
-| *queueBrowseStrategy* (advanced) | To use a custom QueueBrowseStrategy when browsing queues | | QueueBrowseStrategy
-| *receiveTimeout* (advanced) | The timeout for receiving messages (in milliseconds). | 1000 | long
-| *recoveryInterval* (advanced) | Specifies the interval between recovery attempts, i.e. when a connection is being refreshed, in milliseconds. The default is 5000 ms, that is, 5 seconds. | 5000 | long
-| *requestTimeoutCheckerInterval* (advanced) | Configures how often Camel should check for timed out Exchanges when doing request/reply over JMS. By default Camel checks once per second. But if you must react faster when a timeout occurs, then you can lower this interval, to check more frequently. The timeout is determined by the option requestTimeout. | 1000 | long
-| *synchronous* (advanced) | Sets whether synchronous processing should be strictly used | false | boolean
-| *transferException* (advanced) | If enabled and you are using Request Reply messaging (InOut) and an Exchange failed on the consumer side, then the caused Exception will be send back in response as a javax.jms.ObjectMessage. If the client is Camel, the returned Exception is rethrown. This allows you to use Camel JMS as a bridge in your routing - for example, using persistent queues to enable robust routing. Notice that if you also have transferExchange enabled, this option takes preced [...]
-| *transferExchange* (advanced) | You can transfer the exchange over the wire instead of just the body and headers. The following fields are transferred: In body, Out body, Fault body, In headers, Out headers, Fault headers, exchange properties, exchange exception. This requires that the objects are serializable. Camel will exclude any non-serializable objects and log it at WARN level. You must enable this option on both the producer and consumer side, so Camel knows the payloads is an E [...]
-| *useMessageIDAsCorrelationID* (advanced) | Specifies whether JMSMessageID should always be used as JMSCorrelationID for InOut messages. | false | boolean
-| *waitForProvisionCorrelationTo{zwsp}BeUpdatedCounter* (advanced) | Number of times to wait for provisional correlation id to be updated to the actual correlation id when doing request/reply over JMS and when the option useMessageIDAsCorrelationID is enabled. | 50 | int
-| *waitForProvisionCorrelationTo{zwsp}BeUpdatedThreadSleepingTime* (advanced) | Interval in millis to sleep each time while waiting for provisional correlation id to be updated. | 100 | long
-| *headerFilterStrategy* (filter) | To use a custom org.apache.camel.spi.HeaderFilterStrategy to filter header to and from Camel message. | | HeaderFilterStrategy
-| *errorHandlerLoggingLevel* (logging) | Allows to configure the default errorHandler logging level for logging uncaught exceptions. There are 6 enums and the value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | WARN | LoggingLevel
-| *errorHandlerLogStackTrace* (logging) | Allows to control whether stacktraces should be logged or not, by the default errorHandler. | true | boolean
-| *password* (security) | Password to use with the ConnectionFactory. You can also configure username/password directly on the ConnectionFactory. | | String
-| *username* (security) | Username to use with the ConnectionFactory. You can also configure username/password directly on the ConnectionFactory. | | String
-| *transacted* (transaction) | Specifies whether to use transacted mode | false | boolean
-| *transactedInOut* (transaction) | Specifies whether InOut operations (request reply) default to using transacted mode If this flag is set to true, then Spring JmsTemplate will have sessionTransacted set to true, and the acknowledgeMode as transacted on the JmsTemplate used for InOut operations. Note from Spring JMS: that within a JTA transaction, the parameters passed to createQueue, createTopic methods are not taken into account. Depending on the Java EE transaction context, the conta [...]
-| *lazyCreateTransactionManager* (transaction) | If true, Camel will create a JmsTransactionManager, if there is no transactionManager injected when option transacted=true. | true | boolean
-| *transactionManager* (transaction) | The Spring transaction manager to use. | | PlatformTransactionManager
-| *transactionName* (transaction) | The name of the transaction to use. | | String
-| *transactionTimeout* (transaction) | The timeout value of the transaction (in seconds), if using transacted mode. | -1 | int
-|===
// component options: END
-
-
-
-
-
-
-
-
-=== Endpoint options
-
-
-
-
-
-
-
-
-
// endpoint options: START
-The JMS endpoint is configured using URI syntax:
-
-----
-jms:destinationType:destinationName
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (2 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *destinationType* | The kind of destination to use. There are 4 enums and the value can be one of: queue, topic, temp-queue, temp-topic | queue | String
-| *destinationName* | *Required* Name of the queue or topic to use as destination | | String
-|===
-
-
-=== Query Parameters (95 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *clientId* (common) | Sets the JMS client ID to use. Note that this value, if specified, must be unique and can only be used by a single JMS connection instance. It is typically only required for durable topic subscriptions. If using Apache ActiveMQ you may prefer to use Virtual Topics instead. | | String
-| *connectionFactory* (common) | The connection factory to be use. A connection factory must be configured either on the component or endpoint. | | ConnectionFactory
-| *disableReplyTo* (common) | Specifies whether Camel ignores the JMSReplyTo header in messages. If true, Camel does not send a reply back to the destination specified in the JMSReplyTo header. You can use this option if you want Camel to consume from a route and you do not want Camel to automatically send back a reply message because another component in your code handles the reply message. You can also use this option if you want to use Camel as a proxy between different message broker [...]
-| *durableSubscriptionName* (common) | The durable subscriber name for specifying durable topic subscriptions. The clientId option must be configured as well. | | String
-| *jmsMessageType* (common) | Allows you to force the use of a specific javax.jms.Message implementation for sending JMS messages. Possible values are: Bytes, Map, Object, Stream, Text. By default, Camel would determine which JMS message type to use from the In body type. This option allows you to specify it. There are 5 enums and the value can be one of: Bytes, Map, Object, Stream, Text | | JmsMessageType
-| *replyTo* (common) | Provides an explicit ReplyTo destination (overrides any incoming value of Message.getJMSReplyTo() in consumer). | | String
-| *testConnectionOnStartup* (common) | Specifies whether to test the connection on startup. This ensures that when Camel starts that all the JMS consumers have a valid connection to the JMS broker. If a connection cannot be granted then Camel throws an exception on startup. This ensures that Camel is not started with failed connections. The JMS producers is tested as well. | false | boolean
-| *acknowledgementModeName* (consumer) | The JMS acknowledgement name, which is one of: SESSION_TRANSACTED, CLIENT_ACKNOWLEDGE, AUTO_ACKNOWLEDGE, DUPS_OK_ACKNOWLEDGE. There are 4 enums and the value can be one of: SESSION_TRANSACTED, CLIENT_ACKNOWLEDGE, AUTO_ACKNOWLEDGE, DUPS_OK_ACKNOWLEDGE | AUTO_ACKNOWLEDGE | String
-| *artemisConsumerPriority* (consumer) | 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 av [...]
-| *asyncConsumer* (consumer) | Whether the JmsConsumer processes the Exchange asynchronously. If enabled then the JmsConsumer may pickup the next message from the JMS queue, while the previous message is being processed asynchronously (by the Asynchronous Routing Engine). This means that messages may be processed not 100% strictly in order. If disabled (as default) then the Exchange is fully processed before the JmsConsumer will pickup the next message from the JMS queue. Note if transac [...]
-| *autoStartup* (consumer) | Specifies whether the consumer container should auto-startup. | true | boolean
-| *cacheLevel* (consumer) | Sets the cache level by ID for the underlying JMS resources. See cacheLevelName option for more details. | | int
-| *cacheLevelName* (consumer) | Sets the cache level by name for the underlying JMS resources. Possible values are: CACHE_AUTO, CACHE_CONNECTION, CACHE_CONSUMER, CACHE_NONE, and CACHE_SESSION. The default setting is CACHE_AUTO. See the Spring documentation and Transactions Cache Levels for more information. There are 5 enums and the value can be one of: CACHE_AUTO, CACHE_CONNECTION, CACHE_CONSUMER, CACHE_NONE, CACHE_SESSION | CACHE_AUTO | String
-| *concurrentConsumers* (consumer) | Specifies the default number of concurrent consumers when consuming from JMS (not for request/reply over JMS). See also the maxMessagesPerTask option to control dynamic scaling up/down of threads. When doing request/reply over JMS then the option replyToConcurrentConsumers is used to control number of concurrent consumers on the reply message listener. | 1 | int
-| *maxConcurrentConsumers* (consumer) | Specifies the maximum number of concurrent consumers when consuming from JMS (not for request/reply over JMS). See also the maxMessagesPerTask option to control dynamic scaling up/down of threads. When doing request/reply over JMS then the option replyToMaxConcurrentConsumers is used to control number of concurrent consumers on the reply message listener. | | int
-| *replyToDeliveryPersistent* (consumer) | Specifies whether to use persistent delivery by default for replies. | true | boolean
-| *selector* (consumer) | Sets the JMS selector to use | | String
-| *subscriptionDurable* (consumer) | Set whether to make the subscription durable. The durable subscription name to be used can be specified through the subscriptionName property. Default is false. Set this to true to register a durable subscription, typically in combination with a subscriptionName value (unless your message listener class name is good enough as subscription name). Only makes sense when listening to a topic (pub-sub domain), therefore this method switches the pubSubDomai [...]
-| *subscriptionName* (consumer) | Set the name of a subscription to create. To be applied in case of a topic (pub-sub domain) with a shared or durable subscription. The subscription name needs to be unique within this client's JMS client id. Default is the class name of the specified message listener. Note: Only 1 concurrent consumer (which is the default of this message listener container) is allowed for each subscription, except for a shared subscription (which requires JMS 2.0). | | String
-| *subscriptionShared* (consumer) | Set whether to make the subscription shared. The shared subscription name to be used can be specified through the subscriptionName property. Default is false. Set this to true to register a shared subscription, typically in combination with a subscriptionName value (unless your message listener class name is good enough as subscription name). Note that shared subscriptions may also be durable, so this flag can (and often will) be combined with subscrip [...]
-| *acceptMessagesWhileStopping* (consumer) | Specifies whether the consumer accept messages while it is stopping. You may consider enabling this option, if you start and stop JMS routes at runtime, while there are still messages enqueued on the queue. If this option is false, and you stop the JMS route, then messages may be rejected, and the JMS broker would have to attempt redeliveries, which yet again may be rejected, and eventually the message may be moved at a dead letter queue on th [...]
-| *allowReplyManagerQuickStop* (consumer) | Whether the DefaultMessageListenerContainer used in the reply managers for request-reply messaging allow the DefaultMessageListenerContainer.runningAllowed flag to quick stop in case JmsConfiguration#isAcceptMessagesWhileStopping is enabled, and org.apache.camel.CamelContext is currently being stopped. This quick stop ability is enabled by default in the regular JMS consumers but to enable for reply managers you must enable this flag. | false | [...]
-| *consumerType* (consumer) | The consumer type to use, which can be one of: Simple, Default, or Custom. The consumer type determines which Spring JMS listener to use. Default will use org.springframework.jms.listener.DefaultMessageListenerContainer, Simple will use org.springframework.jms.listener.SimpleMessageListenerContainer. When Custom is specified, the MessageListenerContainerFactory defined by the messageListenerContainerFactory option will determine what org.springframework.jms. [...]
-| *defaultTaskExecutorType* (consumer) | Specifies what default TaskExecutor type to use in the DefaultMessageListenerContainer, for both consumer endpoints and the ReplyTo consumer of producer endpoints. Possible values: SimpleAsync (uses Spring's SimpleAsyncTaskExecutor) or ThreadPool (uses Spring's ThreadPoolTaskExecutor with optimal values - cached threadpool-like). If not set, it defaults to the previous behaviour, which uses a cached thread pool for consumer endpoints and SimpleAsy [...]
-| *eagerLoadingOfProperties* (consumer) | Enables eager loading of JMS properties and payload as soon as a message is loaded which generally is inefficient as the JMS properties may not be required but sometimes can catch early any issues with the underlying JMS provider and the use of JMS properties. See also the option eagerPoisonBody. | false | boolean
-| *eagerPoisonBody* (consumer) | If eagerLoadingOfProperties is enabled and the JMS message payload (JMS body or JMS properties) is poison (cannot be read/mapped), then set this text as the message body instead so the message can be processed (the cause of the poison are already stored as exception on the Exchange). This can be turned off by setting eagerPoisonBody=false. See also the option eagerLoadingOfProperties. | Poison JMS message due to ${exception.message} | String
-| *exceptionHandler* (consumer) | 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. | | ExceptionHandler
-| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut | | ExchangePattern
-| *exposeListenerSession* (consumer) | Specifies whether the listener session should be exposed when consuming messages. | false | boolean
-| *replyToSameDestinationAllowed* (consumer) | Whether a JMS consumer is allowed to send a reply message to the same destination that the consumer is using to consume from. This prevents an endless loop by consuming and sending back the same message to itself. | false | boolean
-| *taskExecutor* (consumer) | Allows you to specify a custom task executor for consuming messages. | | TaskExecutor
-| *deliveryDelay* (producer) | Sets delivery delay to use for send calls for JMS. This option requires JMS 2.0 compliant broker. | -1 | long
-| *deliveryMode* (producer) | Specifies the delivery mode to be used. Possible values are those defined by javax.jms.DeliveryMode. NON_PERSISTENT = 1 and PERSISTENT = 2. There are 2 enums and the value can be one of: 1, 2 | | Integer
-| *deliveryPersistent* (producer) | Specifies whether persistent delivery is used by default. | true | boolean
-| *explicitQosEnabled* (producer) | Set if the deliveryMode, priority or timeToLive qualities of service should be used when sending messages. This option is based on Spring's JmsTemplate. The deliveryMode, priority and timeToLive options are applied to the current endpoint. This contrasts with the preserveMessageQos option, which operates at message granularity, reading QoS properties exclusively from the Camel In message headers. | false | Boolean
-| *formatDateHeadersToIso8601* (producer) | Sets whether JMS date properties should be formatted according to the ISO 8601 standard. | false | boolean
-| *lazyStartProducer* (producer) | 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 [...]
-| *preserveMessageQos* (producer) | Set to true, if you want to send message using the QoS settings specified on the message, instead of the QoS settings on the JMS endpoint. The following three headers are considered JMSPriority, JMSDeliveryMode, and JMSExpiration. You can provide all or only some of them. If not provided, Camel will fall back to use the values from the endpoint instead. So, when using this option, the headers override the values from the endpoint. The explicitQosEnable [...]
-| *priority* (producer) | Values greater than 1 specify the message priority when sending (where 1 is the lowest priority and 9 is the highest). The explicitQosEnabled option must also be enabled in order for this option to have any effect. There are 9 enums and the value can be one of: 1, 2, 3, 4, 5, 6, 7, 8, 9 | 4 | int
-| *replyToConcurrentConsumers* (producer) | Specifies the default number of concurrent consumers when doing request/reply over JMS. See also the maxMessagesPerTask option to control dynamic scaling up/down of threads. | 1 | int
-| *replyToMaxConcurrentConsumers* (producer) | Specifies the maximum number of concurrent consumers when using request/reply over JMS. See also the maxMessagesPerTask option to control dynamic scaling up/down of threads. | | int
-| *replyToOnTimeoutMaxConcurrent{zwsp}Consumers* (producer) | Specifies the maximum number of concurrent consumers for continue routing when timeout occurred when using request/reply over JMS. | 1 | int
-| *replyToOverride* (producer) | Provides an explicit ReplyTo destination in the JMS message, which overrides the setting of replyTo. It is useful if you want to forward the message to a remote Queue and receive the reply message from the ReplyTo destination. | | String
-| *replyToType* (producer) | Allows for explicitly specifying which kind of strategy to use for replyTo queues when doing request/reply over JMS. Possible values are: Temporary, Shared, or Exclusive. By default Camel will use temporary queues. However if replyTo has been configured, then Shared is used by default. This option allows you to use exclusive queues instead of shared ones. See Camel JMS documentation for more details, and especially the notes about the implications if running [...]
-| *requestTimeout* (producer) | The timeout for waiting for a reply when using the InOut Exchange Pattern (in milliseconds). The default is 20 seconds. You can include the header CamelJmsRequestTimeout to override this endpoint configured timeout value, and thus have per message individual timeout values. See also the requestTimeoutCheckerInterval option. | 20000 | long
-| *timeToLive* (producer) | When sending messages, specifies the time-to-live of the message (in milliseconds). | -1 | long
-| *allowAdditionalHeaders* (producer) | This option is used to allow additional headers which may have values that are invalid according to JMS specification. For example some message systems such as WMQ do this with header names using prefix JMS_IBM_MQMD_ containing values with byte array or other invalid types. You can specify multiple header names separated by comma, and use as suffix for wildcard matching. | | String
-| *allowNullBody* (producer) | Whether to allow sending messages with no body. If this option is false and the message body is null, then an JMSException is thrown. | true | boolean
-| *alwaysCopyMessage* (producer) | If true, Camel will always make a JMS message copy of the message when it is passed to the producer for sending. Copying the message is needed in some situations, such as when a replyToDestinationSelectorName is set (incidentally, Camel will set the alwaysCopyMessage option to true, if a replyToDestinationSelectorName is set) | false | boolean
-| *correlationProperty* (producer) | When using InOut exchange pattern use this JMS property instead of JMSCorrelationID JMS property to correlate messages. If set messages will be correlated solely on the value of this property JMSCorrelationID property will be ignored and not set by Camel. | | String
-| *disableTimeToLive* (producer) | Use this option to force disabling time to live. For example when you do request/reply over JMS, then Camel will by default use the requestTimeout value as time to live on the message being sent. The problem is that the sender and receiver systems have to have their clocks synchronized, so they are in sync. This is not always so easy to archive. So you can use disableTimeToLive=true to not set a time to live value on the sent message. Then the message w [...]
-| *forceSendOriginalMessage* (producer) | When using mapJmsMessage=false Camel will create a new JMS message to send to a new JMS destination if you touch the headers (get or set) during the route. Set this option to true to force Camel to send the original JMS message that was received. | false | boolean
-| *includeSentJMSMessageID* (producer) | Only applicable when sending to JMS destination using InOnly (eg fire and forget). Enabling this option will enrich the Camel Exchange with the actual JMSMessageID that was used by the JMS client when the message was sent to the JMS destination. | false | boolean
-| *replyToCacheLevelName* (producer) | Sets the cache level by name for the reply consumer when doing request/reply over JMS. This option only applies when using fixed reply queues (not temporary). Camel will by default use: CACHE_CONSUMER for exclusive or shared w/ replyToSelectorName. And CACHE_SESSION for shared without replyToSelectorName. Some JMS brokers such as IBM WebSphere may require to set the replyToCacheLevelName=CACHE_NONE to work. Note: If using temporary queues then CACHE [...]
-| *replyToDestinationSelectorName* (producer) | Sets the JMS Selector using the fixed name to be used so you can filter out your own replies from the others when using a shared queue (that is, if you are not using a temporary reply queue). | | String
-| *streamMessageTypeEnabled* (producer) | Sets whether StreamMessage type is enabled or not. Message payloads of streaming kind such as files, InputStream, etc will either by sent as BytesMessage or StreamMessage. This option controls which kind will be used. By default BytesMessage is used which enforces the entire message payload to be read into memory. By enabling this option the message payload is read into memory in chunks and each chunk is then written to the StreamMessage until no [...]
-| *allowSerializedHeaders* (advanced) | Controls whether or not to include serialized headers. Applies only when transferExchange is true. This requires that the objects are serializable. Camel will exclude any non-serializable objects and log it at WARN level. | false | boolean
-| *artemisStreamingEnabled* (advanced) | Whether optimizing for Apache Artemis streaming mode. | true | boolean
-| *asyncStartListener* (advanced) | Whether to startup the JmsConsumer message listener asynchronously, when starting a route. For example if a JmsConsumer cannot get a connection to a remote JMS broker, then it may block while retrying and/or failover. This will cause Camel to block while starting routes. By setting this option to true, you will let routes startup, while the JmsConsumer connects to the JMS broker using a dedicated thread in asynchronous mode. If this option is used, the [...]
-| *asyncStopListener* (advanced) | Whether to stop the JmsConsumer message listener asynchronously, when stopping a route. | false | boolean
-| *destinationResolver* (advanced) | A pluggable org.springframework.jms.support.destination.DestinationResolver that allows you to use your own resolver (for example, to lookup the real destination in a JNDI registry). | | DestinationResolver
-| *errorHandler* (advanced) | Specifies a org.springframework.util.ErrorHandler to be invoked in case of any uncaught exceptions thrown while processing a Message. By default these exceptions will be logged at the WARN level, if no errorHandler has been configured. You can configure logging level and whether stack traces should be logged using errorHandlerLoggingLevel and errorHandlerLogStackTrace options. This makes it much easier to configure, than having to code a custom errorHandler. [...]
-| *exceptionListener* (advanced) | Specifies the JMS Exception Listener that is to be notified of any underlying JMS exceptions. | | ExceptionListener
-| *headerFilterStrategy* (advanced) | To use a custom HeaderFilterStrategy to filter header to and from Camel message. | | HeaderFilterStrategy
-| *idleConsumerLimit* (advanced) | Specify the limit for the number of consumers that are allowed to be idle at any given time. | 1 | int
-| *idleTaskExecutionLimit* (advanced) | Specifies the limit for idle executions of a receive task, not having received any message within its execution. If this limit is reached, the task will shut down and leave receiving to other executing tasks (in the case of dynamic scheduling; see the maxConcurrentConsumers setting). There is additional doc available from Spring. | 1 | int
-| *includeAllJMSXProperties* (advanced) | Whether to include all JMSXxxx properties when mapping from JMS to Camel Message. Setting this to true will include properties such as JMSXAppID, and JMSXUserID etc. Note: If you are using a custom headerFilterStrategy then this option does not apply. | false | boolean
-| *jmsKeyFormatStrategy* (advanced) | Pluggable strategy for encoding and decoding JMS keys so they can be compliant with the JMS specification. Camel provides two implementations out of the box: default and passthrough. The default strategy will safely marshal dots and hyphens (. and -). The passthrough strategy leaves the key as is. Can be used for JMS brokers which do not care whether JMS header keys contain illegal characters. You can provide your own implementation of the org.apache [...]
-| *mapJmsMessage* (advanced) | Specifies whether Camel should auto map the received JMS message to a suited payload type, such as javax.jms.TextMessage to a String etc. | true | boolean
-| *maxMessagesPerTask* (advanced) | The number of messages per task. -1 is unlimited. If you use a range for concurrent consumers (eg min max), then this option can be used to set a value to eg 100 to control how fast the consumers will shrink when less work is required. | -1 | int
-| *messageConverter* (advanced) | To use a custom Spring org.springframework.jms.support.converter.MessageConverter so you can be in control how to map to/from a javax.jms.Message. | | MessageConverter
-| *messageCreatedStrategy* (advanced) | To use the given MessageCreatedStrategy which are invoked when Camel creates new instances of javax.jms.Message objects when Camel is sending a JMS message. | | MessageCreatedStrategy
-| *messageIdEnabled* (advanced) | When sending, specifies whether message IDs should be added. This is just an hint to the JMS broker. If the JMS provider accepts this hint, these messages must have the message ID set to null; if the provider ignores the hint, the message ID must be set to its normal unique value. | true | boolean
-| *messageListenerContainer{zwsp}Factory* (advanced) | Registry ID of the MessageListenerContainerFactory used to determine what org.springframework.jms.listener.AbstractMessageListenerContainer to use to consume messages. Setting this will automatically set consumerType to Custom. | | MessageListenerContainerFactory
-| *messageTimestampEnabled* (advanced) | Specifies whether timestamps should be enabled by default on sending messages. This is just an hint to the JMS broker. If the JMS provider accepts this hint, these messages must have the timestamp set to zero; if the provider ignores the hint the timestamp must be set to its normal value. | true | boolean
-| *pubSubNoLocal* (advanced) | Specifies whether to inhibit the delivery of messages published by its own connection. | false | boolean
-| *receiveTimeout* (advanced) | The timeout for receiving messages (in milliseconds). | 1000 | long
-| *recoveryInterval* (advanced) | Specifies the interval between recovery attempts, i.e. when a connection is being refreshed, in milliseconds. The default is 5000 ms, that is, 5 seconds. | 5000 | long
-| *requestTimeoutCheckerInterval* (advanced) | Configures how often Camel should check for timed out Exchanges when doing request/reply over JMS. By default Camel checks once per second. But if you must react faster when a timeout occurs, then you can lower this interval, to check more frequently. The timeout is determined by the option requestTimeout. | 1000 | long
-| *synchronous* (advanced) | Sets whether synchronous processing should be strictly used | false | boolean
-| *transferException* (advanced) | If enabled and you are using Request Reply messaging (InOut) and an Exchange failed on the consumer side, then the caused Exception will be send back in response as a javax.jms.ObjectMessage. If the client is Camel, the returned Exception is rethrown. This allows you to use Camel JMS as a bridge in your routing - for example, using persistent queues to enable robust routing. Notice that if you also have transferExchange enabled, this option takes preced [...]
-| *transferExchange* (advanced) | You can transfer the exchange over the wire instead of just the body and headers. The following fields are transferred: In body, Out body, Fault body, In headers, Out headers, Fault headers, exchange properties, exchange exception. This requires that the objects are serializable. Camel will exclude any non-serializable objects and log it at WARN level. You must enable this option on both the producer and consumer side, so Camel knows the payloads is an E [...]
-| *useMessageIDAsCorrelationID* (advanced) | Specifies whether JMSMessageID should always be used as JMSCorrelationID for InOut messages. | false | boolean
-| *waitForProvisionCorrelationTo{zwsp}BeUpdatedCounter* (advanced) | Number of times to wait for provisional correlation id to be updated to the actual correlation id when doing request/reply over JMS and when the option useMessageIDAsCorrelationID is enabled. | 50 | int
-| *waitForProvisionCorrelationTo{zwsp}BeUpdatedThreadSleepingTime* (advanced) | Interval in millis to sleep each time while waiting for provisional correlation id to be updated. | 100 | long
-| *errorHandlerLoggingLevel* (logging) | Allows to configure the default errorHandler logging level for logging uncaught exceptions. There are 6 enums and the value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | WARN | LoggingLevel
-| *errorHandlerLogStackTrace* (logging) | Allows to control whether stacktraces should be logged or not, by the default errorHandler. | true | boolean
-| *password* (security) | Password to use with the ConnectionFactory. You can also configure username/password directly on the ConnectionFactory. | | String
-| *username* (security) | Username to use with the ConnectionFactory. You can also configure username/password directly on the ConnectionFactory. | | String
-| *transacted* (transaction) | Specifies whether to use transacted mode | false | boolean
-| *transactedInOut* (transaction) | Specifies whether InOut operations (request reply) default to using transacted mode If this flag is set to true, then Spring JmsTemplate will have sessionTransacted set to true, and the acknowledgeMode as transacted on the JmsTemplate used for InOut operations. Note from Spring JMS: that within a JTA transaction, the parameters passed to createQueue, createTopic methods are not taken into account. Depending on the Java EE transaction context, the conta [...]
-| *lazyCreateTransactionManager* (transaction) | If true, Camel will create a JmsTransactionManager, if there is no transactionManager injected when option transacted=true. | true | boolean
-| *transactionManager* (transaction) | The Spring transaction manager to use. | | PlatformTransactionManager
-| *transactionName* (transaction) | The name of the transaction to use. | | String
-| *transactionTimeout* (transaction) | The timeout value of the transaction (in seconds), if using transacted mode. | -1 | int
-|===
// endpoint options: END
-
-
== Samples
JMS is used in many examples for other components as well. But we
@@ -563,11 +306,6 @@ whatever you like. For example, you can invoke a method on a Bean or use
a custom processor.
-
-
-
-
-
== Message Mapping between JMS and Camel
Camel automatically maps messages between `javax.jms.Message` and
@@ -1077,8 +815,6 @@ broker more frequent, and thus require more network traffic. +
=== Request-reply over JMS and using an exclusive fixed reply queue
-*Since Camel 2.9*
-
In the previous example, Camel would anticipate the fixed reply queue
named "bar" was shared, and thus it uses a `JMSSelector` to only consume
reply messages which it expects. However there is a drawback doing this
@@ -1228,8 +964,6 @@ messaging:
The `transacted` property applies *only* to the InOnly message
Exchange Pattern (MEP).
-*Since Camel 2.10*
-
You can leverage the
http://static.springsource.org/spring/docs/3.0.x/javadoc-api/org/springframework/jms/listener/AbstractPollingMessageListenerContainer.html#setSessionTransacted(boolean)[DMLC
transacted session API] using the following properties on
@@ -1336,7 +1070,6 @@ like so:
Some versions of WMQ won't accept this option on the destination name
and you will get an exception like:
-[source]
----------------------------------------------------------------------------------------------------------------------------------
com.ibm.msg.client.jms.DetailedJMSException: JMSCC0005: The specified
value 'MY_QUEUE?targetClient=1' is not allowed for
diff --git a/components/camel-jmx/src/main/docs/jmx-component.adoc b/components/camel-jmx/src/main/docs/jmx-component.adoc
index aa7bf5b..c80dd42 100644
--- a/components/camel-jmx/src/main/docs/jmx-component.adoc
+++ b/components/camel-jmx/src/main/docs/jmx-component.adoc
@@ -24,76 +24,10 @@ monitor Camel using JMX.
If you run Camel standalone with just `camel-core` as a dependency, and you want JMX enabled out of the box, then you need to add `camel-management` as a dependency.
====
-== Options
// component options: START
-The JMX component supports 2 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-|===
// component options: END
-
// endpoint options: START
-The JMX endpoint is configured using URI syntax:
-
-----
-jmx:serverURL
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (1 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *serverURL* | Server url comes from the remaining endpoint. Use platform to connect to local JVM. | | String
-|===
-
-
-=== Query Parameters (29 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *format* (consumer) | Format for the message body. Either xml or raw. If xml, the notification is serialized to xml. If raw, then the raw java object is set as the body. There are 2 enums and the value can be one of: xml, raw | xml | String
-| *granularityPeriod* (consumer) | The frequency to poll the bean to check the monitor (monitor types only). | 10000 | long
-| *monitorType* (consumer) | The type of monitor to create. One of string, gauge, counter (monitor types only). There are 3 enums and the value can be one of: counter, gauge, string | | String
-| *objectDomain* (consumer) | *Required* The domain for the mbean you're connecting to | | String
-| *objectName* (consumer) | The name key for the mbean you're connecting to. This value is mutually exclusive with the object properties that get passed. | | String
-| *observedAttribute* (consumer) | The attribute to observe for the monitor bean or consumer. | | String
-| *exceptionHandler* (consumer) | 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. | | ExceptionHandler
-| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut | | ExchangePattern
-| *executorService* (advanced) | To use a custom shared thread pool for the consumers. By default each consume has their own thread-pool to process and route notifications. | | ExecutorService
-| *handback* (advanced) | Value to handback to the listener when a notification is received. This value will be put in the message header with the key jmx.handback | | Object
-| *notificationFilter* (advanced) | Reference to a bean that implements the NotificationFilter. | | NotificationFilter
-| *objectProperties* (advanced) | Properties for the object name. These values will be used if the objectName param is not set | | Map
-| *reconnectDelay* (advanced) | The number of seconds to wait before attempting to retry establishment of the initial connection or attempt to reconnect a lost connection | 10 | int
-| *reconnectOnConnectionFailure* (advanced) | If true the consumer will attempt to reconnect to the JMX server when any connection failure occurs. The consumer will attempt to re-establish the JMX connection every 'x' seconds until the connection is made-- where 'x' is the configured reconnectionDelay | false | boolean
-| *testConnectionOnStartup* (advanced) | If true the consumer will throw an exception if unable to establish the JMX connection upon startup. If false, the consumer will attempt to establish the JMX connection every 'x' seconds until the connection is made -- where 'x' is the configured reconnectionDelay | true | boolean
-| *initThreshold* (counter) | Initial threshold for the monitor. The value must exceed this before notifications are fired (counter monitor only). | | int
-| *modulus* (counter) | The value at which the counter is reset to zero (counter monitor only). | | int
-| *offset* (counter) | The amount to increment the threshold after it's been exceeded (counter monitor only). | | int
-| *differenceMode* (gauge) | If true, then the value reported in the notification is the difference from the threshold as opposed to the value itself (counter and gauge monitor only). | false | boolean
-| *notifyHigh* (gauge) | If true, the gauge will fire a notification when the high threshold is exceeded (gauge monitor only). | false | boolean
-| *notifyLow* (gauge) | If true, the gauge will fire a notification when the low threshold is exceeded (gauge monitor only). | false | boolean
-| *thresholdHigh* (gauge) | Value for the gauge's high threshold (gauge monitor only). | | Double
-| *thresholdLow* (gauge) | Value for the gauge's low threshold (gauge monitor only). | | Double
-| *password* (security) | Credentials for making a remote connection | | String
-| *user* (security) | Credentials for making a remote connection | | String
-| *notifyDiffer* (string) | If true, will fire a notification when the string attribute differs from the string to compare (string monitor or consumer). By default the consumer will notify match if observed attribute and string to compare has been configured. | false | boolean
-| *notifyMatch* (string) | If true, will fire a notification when the string attribute matches the string to compare (string monitor or consumer). By default the consumer will notify match if observed attribute and string to compare has been configured. | false | boolean
-| *stringToCompare* (string) | Value for attribute to compare (string monitor or consumer). By default the consumer will notify match if observed attribute and string to compare has been configured. | | String
-|===
// endpoint options: END
diff --git a/components/camel-jolt/src/main/docs/jolt-component.adoc b/components/camel-jolt/src/main/docs/jolt-component.adoc
index f09719b..df39bc5 100644
--- a/components/camel-jolt/src/main/docs/jolt-component.adoc
+++ b/components/camel-jolt/src/main/docs/jolt-component.adoc
@@ -29,11 +29,9 @@ their `pom.xml` for this component:
</dependency>
------------------------------------------------------------
-
== URI format
-[source,java]
-----------------------
jolt:specName[?options]
-----------------------
@@ -42,72 +40,13 @@ Where *specName* is the classpath-local URI of the specification to
invoke; or the complete URL of the remote specification
(eg: \file://folder/myfile.vm).
-You can append query options to the URI in the following
-format, `?option=value&option=value&...`
-
-== Options
-
-
-
// component options: START
-The JOLT component supports 4 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *allowTemplateFromHeader* (producer) | Whether to allow to use resource template from header or not (default false). Enabling this allows to specify dynamic templates via message header. However this can be seen as a potential security vulnerability if the header is coming from a malicious user, so use this with care. | false | boolean
-| *lazyStartProducer* (producer) | 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 [...]
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-| *transform* (advanced) | Explicitly sets the Transform to use. If not set a Transform specified by the transformDsl will be created | | Transform
-|===
// component options: END
-
-
-
-
-
-
// endpoint options: START
-The JOLT endpoint is configured using URI syntax:
-
-----
-jolt:resourceUri
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (1 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *resourceUri* | *Required* Path to the resource. You can prefix with: classpath, file, http, ref, or bean. classpath, file and http loads the resource using these protocols (classpath is default). ref will lookup the resource in the registry. bean will call a method on a bean to be used as the resource. For bean you can specify the method name after dot, eg bean:myBean.myMethod. | | String
-|===
-
-
-=== Query Parameters (7 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *allowContextMapAll* (producer) | Sets whether the context map should allow access to all details. By default only the message body and headers can be accessed. This option can be enabled for full access to the current Exchange and CamelContext. Doing so impose a potential security risk as this opens access to the full power of CamelContext API. | false | boolean
-| *allowTemplateFromHeader* (producer) | Whether to allow to use resource template from header or not (default false). Enabling this allows to specify dynamic templates via message header. However this can be seen as a potential security vulnerability if the header is coming from a malicious user, so use this with care. | false | boolean
-| *contentCache* (producer) | Sets whether to use resource content cache or not | false | boolean
-| *inputType* (producer) | Specifies if the input is hydrated JSON or a JSON String. There are 2 enums and the value can be one of: Hydrated, JsonString | Hydrated | JoltInputOutputType
-| *lazyStartProducer* (producer) | 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 [...]
-| *outputType* (producer) | Specifies if the output should be hydrated JSON or a JSON String. There are 2 enums and the value can be one of: Hydrated, JsonString | Hydrated | JoltInputOutputType
-| *transformDsl* (producer) | Specifies the Transform DSL of the endpoint resource. If none is specified Chainr will be used. There are 5 enums and the value can be one of: Chainr, Shiftr, Defaultr, Removr, Sortr | Chainr | JoltTransformType
-|===
// endpoint options: END
-
-
== Samples
For example you could use something like
@@ -137,7 +76,5 @@ from("direct:in").
to("jolt:dummy?allowTemplateFromHeader=true");
---------------------------------------------------------------------
-
-
include::{page-component-version}@camel-spring-boot::page$jolt-starter.adoc[]
diff --git a/components/camel-jooq/src/main/docs/jooq-component.adoc b/components/camel-jooq/src/main/docs/jooq-component.adoc
index 8853de1..0b140f1 100644
--- a/components/camel-jooq/src/main/docs/jooq-component.adoc
+++ b/components/camel-jooq/src/main/docs/jooq-component.adoc
@@ -42,82 +42,15 @@ from("jooq://org.apache.camel.component.jooq.db.tables.records.BookStoreRecord?q
See examples below.
== Consuming from endpoint
+
Consuming messages from a JOOQ consumer endpoint removes (or updates) entity beans in the database.
This allows you to use a database table as a logical queue: consumers take messages from the queue and then delete/update them to logically remove them from the queue.
If you do not wish to delete the entity bean when it has been processed, you can specify consumeDelete=false on the URI.
-== Options
// component options: START
-The JOOQ component supports 8 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *configuration* (common) | Component configuration (database connection, database entity type, etc.) | | JooqConfiguration
-| *databaseConfiguration* (common) | To use a specific database configuration | | Configuration
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *consumeDelete* (consumer) | Delete entity after it is consumed | true | boolean
-| *lazyStartProducer* (producer) | 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 [...]
-| *operation* (producer) | Type of operation to execute on query. There are 3 enums and the value can be one of: EXECUTE, FETCH, NONE | NONE | JooqOperation
-| *query* (producer) | To execute plain SQL query | | String
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-|===
// component options: END
-
-
// endpoint options: START
-The JOOQ endpoint is configured using URI syntax:
-
-----
-jooq:entityType
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (1 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *entityType* | JOOQ entity class | | Class
-|===
-
-
-=== Query Parameters (24 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *databaseConfiguration* (common) | To use a specific database configuration | | Configuration
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *consumeDelete* (consumer) | Delete entity after it is consumed | true | boolean
-| *sendEmptyMessageWhenIdle* (consumer) | If the polling consumer did not poll any files, you can enable this option to send an empty message (no body) instead. | false | boolean
-| *exceptionHandler* (consumer) | 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. | | ExceptionHandler
-| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut | | ExchangePattern
-| *pollStrategy* (consumer) | A pluggable org.apache.camel.PollingConsumerPollingStrategy allowing you to provide your custom implementation to control error handling usually occurred during the poll operation before an Exchange have been created and being routed in Camel. | | PollingConsumerPollStrategy
-| *lazyStartProducer* (producer) | 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 [...]
-| *operation* (producer) | Type of operation to execute on query. There are 3 enums and the value can be one of: EXECUTE, FETCH, NONE | NONE | JooqOperation
-| *query* (producer) | To execute plain SQL query | | String
-| *backoffErrorThreshold* (scheduler) | The number of subsequent error polls (failed due some error) that should happen before the backoffMultipler should kick-in. | | int
-| *backoffIdleThreshold* (scheduler) | The number of subsequent idle polls that should happen before the backoffMultipler should kick-in. | | int
-| *backoffMultiplier* (scheduler) | To let the scheduled polling consumer backoff if there has been a number of subsequent idles/errors in a row. The multiplier is then the number of polls that will be skipped before the next actual attempt is happening again. When this option is in use then backoffIdleThreshold and/or backoffErrorThreshold must also be configured. | | int
-| *delay* (scheduler) | Milliseconds before the next poll. | 500 | long
-| *greedy* (scheduler) | If greedy is enabled, then the ScheduledPollConsumer will run immediately again, if the previous run polled 1 or more messages. | false | boolean
-| *initialDelay* (scheduler) | Milliseconds before the first poll starts. | 1000 | long
-| *repeatCount* (scheduler) | Specifies a maximum limit of number of fires. So if you set it to 1, the scheduler will only fire once. If you set it to 5, it will only fire five times. A value of zero or negative means fire forever. | 0 | long
-| *runLoggingLevel* (scheduler) | The consumer logs a start/complete log line when it polls. This option allows you to configure the logging level for that. There are 6 enums and the value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | TRACE | LoggingLevel
-| *scheduledExecutorService* (scheduler) | Allows for configuring a custom/shared thread pool to use for the consumer. By default each consumer has its own single threaded thread pool. | | ScheduledExecutorService
-| *scheduler* (scheduler) | To use a cron scheduler from either camel-spring or camel-quartz component. Use value spring or quartz for built in scheduler | none | Object
-| *schedulerProperties* (scheduler) | To configure additional properties when using a custom scheduler or any of the Quartz, Spring based scheduler. | | Map
-| *startScheduler* (scheduler) | Whether the scheduler should be auto started. | true | boolean
-| *timeUnit* (scheduler) | Time unit for initialDelay and delay options. There are 7 enums and the value can be one of: NANOSECONDS, MICROSECONDS, MILLISECONDS, SECONDS, MINUTES, HOURS, DAYS | MILLISECONDS | TimeUnit
-| *useFixedDelay* (scheduler) | Controls if fixed delay or fixed rate is used. See ScheduledExecutorService in JDK for details. | true | boolean
-|===
// endpoint options: END
diff --git a/components/camel-jpa/src/main/docs/jpa-component.adoc b/components/camel-jpa/src/main/docs/jpa-component.adoc
index 2520cce..da6fef0 100644
--- a/components/camel-jpa/src/main/docs/jpa-component.adoc
+++ b/components/camel-jpa/src/main/docs/jpa-component.adoc
@@ -83,7 +83,6 @@ problems you should set the maximumResults to sensible value.
== URI format
-[source,java]
-----------------------------
jpa:entityClassName[?options]
-----------------------------
@@ -94,116 +93,13 @@ ensure the body is of the correct type.
For consuming, the _entityClassName_ is mandatory.
-You can append query options to the URI in the following format,
-`?option=value&option=value&...`
-
-== Options
-
-
-
// component options: START
-The JPA component supports 7 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *entityManagerFactory* (common) | To use the EntityManagerFactory. This is strongly recommended to configure. | | EntityManagerFactory
-| *joinTransaction* (common) | The camel-jpa component will join transaction by default. You can use this option to turn this off, for example if you use LOCAL_RESOURCE and join transaction doesn't work with your JPA provider. This option can also be set globally on the JpaComponent, instead of having to set it on all endpoints. | true | boolean
-| *sharedEntityManager* (common) | Whether to use Spring's SharedEntityManager for the consumer/producer. Note in most cases joinTransaction should be set to false as this is not an EXTENDED EntityManager. | false | boolean
-| *transactionManager* (common) | To use the PlatformTransactionManager for managing transactions. | | PlatformTransactionManager
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *lazyStartProducer* (producer) | 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 [...]
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-|===
// component options: END
-
-
-
-
-
-
-
-
// endpoint options: START
-The JPA endpoint is configured using URI syntax:
-
-----
-jpa:entityType
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (1 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *entityType* | *Required* Entity class name | | Class
-|===
-
-
-=== Query Parameters (44 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *joinTransaction* (common) | The camel-jpa component will join transaction by default. You can use this option to turn this off, for example if you use LOCAL_RESOURCE and join transaction doesn't work with your JPA provider. This option can also be set globally on the JpaComponent, instead of having to set it on all endpoints. | true | boolean
-| *maximumResults* (common) | Set the maximum number of results to retrieve on the Query. | -1 | int
-| *namedQuery* (common) | To use a named query. | | String
-| *nativeQuery* (common) | To use a custom native query. You may want to use the option resultClass also when using native queries. | | String
-| *persistenceUnit* (common) | *Required* The JPA persistence unit used by default. | camel | String
-| *query* (common) | To use a custom query. | | String
-| *resultClass* (common) | Defines the type of the returned payload (we will call entityManager.createNativeQuery(nativeQuery, resultClass) instead of entityManager.createNativeQuery(nativeQuery)). Without this option, we will return an object array. Only has an affect when using in conjunction with native query when consuming data. | | Class
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *consumeDelete* (consumer) | If true, the entity is deleted after it is consumed; if false, the entity is not deleted. | true | boolean
-| *consumeLockEntity* (consumer) | Specifies whether or not to set an exclusive lock on each entity bean while processing the results from polling. | true | boolean
-| *deleteHandler* (consumer) | To use a custom DeleteHandler to delete the row after the consumer is done processing the exchange | | DeleteHandler
-| *lockModeType* (consumer) | To configure the lock mode on the consumer. There are 8 enums and the value can be one of: READ, WRITE, OPTIMISTIC, OPTIMISTIC_FORCE_INCREMENT, PESSIMISTIC_READ, PESSIMISTIC_WRITE, PESSIMISTIC_FORCE_INCREMENT, NONE | PESSIMISTIC_WRITE | LockModeType
-| *maxMessagesPerPoll* (consumer) | An integer value to define the maximum number of messages to gather per poll. By default, no maximum is set. Can be used to avoid polling many thousands of messages when starting up the server. Set a value of 0 or negative to disable. | | int
-| *preDeleteHandler* (consumer) | To use a custom Pre-DeleteHandler to delete the row after the consumer has read the entity. | | DeleteHandler
-| *sendEmptyMessageWhenIdle* (consumer) | If the polling consumer did not poll any files, you can enable this option to send an empty message (no body) instead. | false | boolean
-| *skipLockedEntity* (consumer) | To configure whether to use NOWAIT on lock and silently skip the entity. | false | boolean
-| *transacted* (consumer) | Whether to run the consumer in transacted mode, by which all messages will either commit or rollback, when the entire batch has been processed. The default behavior (false) is to commit all the previously successfully processed messages, and only rollback the last failed message. | false | boolean
-| *exceptionHandler* (consumer) | 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. | | ExceptionHandler
-| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut | | ExchangePattern
-| *parameters* (consumer) | This key/value mapping is used for building the query parameters. It is expected to be of the generic type java.util.Map where the keys are the named parameters of a given JPA query and the values are their corresponding effective values you want to select for. When it's used for producer, Simple expression can be used as a parameter value. It allows you to retrieve parameter values from the message body, header and etc. | | Map
-| *pollStrategy* (consumer) | A pluggable org.apache.camel.PollingConsumerPollingStrategy allowing you to provide your custom implementation to control error handling usually occurred during the poll operation before an Exchange have been created and being routed in Camel. | | PollingConsumerPollStrategy
-| *findEntity* (producer) | If enabled then the producer will find a single entity by using the message body as key and entityType as the class type. This can be used instead of a query to find a single entity. | false | boolean
-| *flushOnSend* (producer) | Flushes the EntityManager after the entity bean has been persisted. | true | boolean
-| *lazyStartProducer* (producer) | 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 [...]
-| *remove* (producer) | Indicates to use entityManager.remove(entity). | false | boolean
-| *useExecuteUpdate* (producer) | To configure whether to use executeUpdate() when producer executes a query. When you use INSERT, UPDATE or DELETE statement as a named query, you need to specify this option to 'true'. | | Boolean
-| *usePersist* (producer) | Indicates to use entityManager.persist(entity) instead of entityManager.merge(entity). Note: entityManager.persist(entity) doesn't work for detached entities (where the EntityManager has to execute an UPDATE instead of an INSERT query)! | false | boolean
-| *usePassedInEntityManager* (producer) | If set to true, then Camel will use the EntityManager from the header JpaConstants.ENTITY_MANAGER instead of the configured entity manager on the component/endpoint. This allows end users to control which entity manager will be in use. | false | boolean
-| *entityManagerProperties* (advanced) | Additional properties for the entity manager to use. | | Map
-| *sharedEntityManager* (advanced) | Whether to use Spring's SharedEntityManager for the consumer/producer. Note in most cases joinTransaction should be set to false as this is not an EXTENDED EntityManager. | false | boolean
-| *backoffErrorThreshold* (scheduler) | The number of subsequent error polls (failed due some error) that should happen before the backoffMultipler should kick-in. | | int
-| *backoffIdleThreshold* (scheduler) | The number of subsequent idle polls that should happen before the backoffMultipler should kick-in. | | int
-| *backoffMultiplier* (scheduler) | To let the scheduled polling consumer backoff if there has been a number of subsequent idles/errors in a row. The multiplier is then the number of polls that will be skipped before the next actual attempt is happening again. When this option is in use then backoffIdleThreshold and/or backoffErrorThreshold must also be configured. | | int
-| *delay* (scheduler) | Milliseconds before the next poll. | 500 | long
-| *greedy* (scheduler) | If greedy is enabled, then the ScheduledPollConsumer will run immediately again, if the previous run polled 1 or more messages. | false | boolean
-| *initialDelay* (scheduler) | Milliseconds before the first poll starts. | 1000 | long
-| *repeatCount* (scheduler) | Specifies a maximum limit of number of fires. So if you set it to 1, the scheduler will only fire once. If you set it to 5, it will only fire five times. A value of zero or negative means fire forever. | 0 | long
-| *runLoggingLevel* (scheduler) | The consumer logs a start/complete log line when it polls. This option allows you to configure the logging level for that. There are 6 enums and the value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | TRACE | LoggingLevel
-| *scheduledExecutorService* (scheduler) | Allows for configuring a custom/shared thread pool to use for the consumer. By default each consumer has its own single threaded thread pool. | | ScheduledExecutorService
-| *scheduler* (scheduler) | To use a cron scheduler from either camel-spring or camel-quartz component. Use value spring or quartz for built in scheduler | none | Object
-| *schedulerProperties* (scheduler) | To configure additional properties when using a custom scheduler or any of the Quartz, Spring based scheduler. | | Map
-| *startScheduler* (scheduler) | Whether the scheduler should be auto started. | true | boolean
-| *timeUnit* (scheduler) | Time unit for initialDelay and delay options. There are 7 enums and the value can be one of: NANOSECONDS, MICROSECONDS, MILLISECONDS, SECONDS, MINUTES, HOURS, DAYS | MILLISECONDS | TimeUnit
-| *useFixedDelay* (scheduler) | Controls if fixed delay or fixed rate is used. See ScheduledExecutorService in JDK for details. | true | boolean
-|===
// endpoint options: END
-
-
-
-
== Message Headers
Camel adds the following message headers to the exchange:
@@ -410,7 +306,6 @@ https://svn.apache.org/repos/asf/camel/trunk/components/camel-jpa/src/test[tests
of this component] directly inside your IDE, and not through
Maven, then you could see exceptions like these:
-[source,java]
--------------------------------------------------------------------------------------------------------------------------------------------------------
org.springframework.transaction.CannotCreateTransactionException: Could not open JPA EntityManager for transaction; nested exception is
<openjpa-2.2.1-r422266:1396819 nonfatal user error> org.apache.openjpa.persistence.ArgumentException: This configuration disallows runtime optimization,
@@ -434,7 +329,6 @@ OpenJPA version being used in Camel is 2.2.1, to run the
tests inside your IDE you would need to pass the following
argument to the JVM:
-[source,java]
-------------------------------------------------------------------------------------------
-javaagent:<path_to_your_local_m2_cache>/org/apache/openjpa/openjpa/2.2.1/openjpa-2.2.1.jar
-------------------------------------------------------------------------------------------
diff --git a/components/camel-jsch/src/main/docs/scp-component.adoc b/components/camel-jsch/src/main/docs/scp-component.adoc
index a6c323f..63021fe 100644
--- a/components/camel-jsch/src/main/docs/scp-component.adoc
+++ b/components/camel-jsch/src/main/docs/scp-component.adoc
@@ -33,102 +33,21 @@ for this component:
== URI format
-[source,java]
---------------------------------------
scp://host[:port]/destination[?options]
---------------------------------------
-You can append query options to the URI in the following format,
-`?option=value&option=value&...`
-
The file name can be specified either in the <path> part of the URI or
as a "CamelFileName" header on the message (`Exchange.FILE_NAME` if used
in code).
-== Options
-
-
-
// component options: START
-The SCP component supports 3 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *lazyStartProducer* (producer) | 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 [...]
-| *verboseLogging* (producer) | JSCH is verbose logging out of the box. Therefore we turn the logging down to DEBUG logging by default. But setting this option to true turns on the verbose logging again. | false | boolean
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-|===
// component options: END
-
-
-
-
-
-
-
-
-
// endpoint options: START
-The SCP endpoint is configured using URI syntax:
-
-----
-scp:host:port/directoryName
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (3 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *host* | *Required* Hostname of the FTP server | | String
-| *port* | Port of the FTP server | | int
-| *directoryName* | The starting directory | | String
-|===
-
-
-=== Query Parameters (23 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *chmod* (producer) | Allows you to set chmod on the stored file. For example chmod=664. | 664 | String
-| *disconnect* (common) | Whether or not to disconnect from remote FTP server right after use. Disconnect will only disconnect the current connection to the FTP server. If you have a consumer which you want to stop, then you need to stop the consumer/route instead. | false | boolean
-| *fileName* (producer) | Use Expression such as File Language to dynamically set the filename. For consumers, it's used as a filename filter. For producers, it's used to evaluate the filename to write. If an expression is set, it take precedence over the CamelFileName header. (Note: The header itself can also be an Expression). The expression options support both String and Expression types. If the expression is a String type, it is always evaluated using the File Language. If the expre [...]
-| *flatten* (producer) | Flatten is used to flatten the file name path to strip any leading paths, so it's just the file name. This allows you to consume recursively into sub-directories, but when you eg write the files to another directory they will be written in a single directory. Setting this to true on the producer enforces that any file name in CamelFileName header will be stripped for any leading paths. | false | boolean
-| *jailStartingDirectory* (producer) | Used for jailing (restricting) writing files to the starting directory (and sub) only. This is enabled by default to not allow Camel to write files to outside directories (to be more secured out of the box). You can turn this off to allow writing files to directories outside the starting directory, such as parent or root folders. | true | boolean
-| *lazyStartProducer* (producer) | 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 [...]
-| *strictHostKeyChecking* (producer) | Sets whether to use strict host key checking. Possible values are: no, yes. There are 2 enums and the value can be one of: no, yes | no | String
-| *allowNullBody* (producer) | Used to specify if a null body is allowed during file writing. If set to true then an empty file will be created, when set to false, and attempting to send a null body to the file component, a GenericFileWriteException of 'Cannot write null body to file.' will be thrown. If the fileExist option is set to 'Override', then the file will be truncated, and if set to append the file will remain unchanged. | false | boolean
-| *disconnectOnBatchComplete* (producer) | Whether or not to disconnect from remote FTP server right after a Batch upload is complete. disconnectOnBatchComplete will only disconnect the current connection to the FTP server. | false | boolean
-| *moveExistingFileStrategy* (producer) | Strategy (Custom Strategy) used to move file with special naming token to use when fileExist=Move is configured. By default, there is an implementation used if no custom strategy is provided | | FileMoveExistingStrategy
-| *connectTimeout* (advanced) | Sets the connect timeout for waiting for a connection to be established Used by both FTPClient and JSCH | 10000 | int
-| *soTimeout* (advanced) | Sets the so timeout FTP and FTPS Only for Camel 2.4. SFTP for Camel 2.14.3/2.15.3/2.16 onwards. Is the SocketOptions.SO_TIMEOUT value in millis. Recommended option is to set this to 300000 so as not have a hanged connection. On SFTP this option is set as timeout on the JSCH Session instance. | 5m | int
-| *synchronous* (advanced) | Sets whether synchronous processing should be strictly used | false | boolean
-| *timeout* (advanced) | Sets the data timeout for waiting for reply Used only by FTPClient | 30s | int
-| *knownHostsFile* (security) | Sets the known_hosts file, so that the jsch endpoint can do host key verification. You can prefix with classpath: to load the file from classpath instead of file system. | | String
-| *password* (security) | Password to use for login | | String
-| *preferredAuthentications* (security) | Set a comma separated list of authentications that will be used in order of preference. Possible authentication methods are defined by JCraft JSCH. Some examples include: gssapi-with-mic,publickey,keyboard-interactive,password If not specified the JSCH and/or system defaults will be used. | | String
-| *privateKeyBytes* (security) | Set the private key bytes to that the endpoint can do private key verification. This must be used only if privateKeyFile wasn't set. Otherwise the file will have the priority. | | byte[]
-| *privateKeyFile* (security) | Set the private key file to that the endpoint can do private key verification. You can prefix with classpath: to load the file from classpath instead of file system. | | String
-| *privateKeyFilePassphrase* (security) | Set the private key file passphrase to that the endpoint can do private key verification. | | String
-| *username* (security) | Username to use for login | | String
-| *useUserKnownHostsFile* (security) | If knownHostFile has not been explicit configured, then use the host file from System.getProperty(user.home) /.ssh/known_hosts | true | boolean
-| *ciphers* (security) | Set a comma separated list of ciphers that will be used in order of preference. Possible cipher names are defined by JCraft JSCH. Some examples include: aes128-ctr,aes128-cbc,3des-ctr,3des-cbc,blowfish-cbc,aes192-cbc,aes256-cbc. If not specified the default list from JSCH will be used. | | String
-|===
// endpoint options: END
-
-
-
== Limitations
Currently camel-jsch only supports a
diff --git a/components/camel-jslt/src/main/docs/jslt-component.adoc b/components/camel-jslt/src/main/docs/jslt-component.adoc
index bf6a5e9..04cc4e9 100644
--- a/components/camel-jslt/src/main/docs/jslt-component.adoc
+++ b/components/camel-jslt/src/main/docs/jslt-component.adoc
@@ -29,11 +29,9 @@ their `pom.xml` for this component:
</dependency>
------------------------------------------------------------
-
== URI format
-[source,java]
-----------------------
jslt:specName[?options]
-----------------------
@@ -42,70 +40,13 @@ Where *specName* is the classpath-local URI of the specification to
invoke; or the complete URL of the remote specification
(eg: \file://folder/myfile.vm).
-You can append query options to the URI in the following
-format, `?option=value&option=value&...`
-
-== Options
-
-
-
// component options: START
-The JSLT component supports 5 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *allowTemplateFromHeader* (producer) | Whether to allow to use resource template from header or not (default false). Enabling this allows to specify dynamic templates via message header. However this can be seen as a potential security vulnerability if the header is coming from a malicious user, so use this with care. | false | boolean
-| *lazyStartProducer* (producer) | 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 [...]
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-| *functions* (advanced) | JSLT can be extended by plugging in functions written in Java. | | Collection
-| *objectFilter* (advanced) | JSLT can be extended by plugging in a custom jslt object filter | | JsonFilter
-|===
// component options: END
-
-
-
-
-
-
// endpoint options: START
-The JSLT endpoint is configured using URI syntax:
-
-----
-jslt:resourceUri
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (1 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *resourceUri* | *Required* Path to the resource. You can prefix with: classpath, file, http, ref, or bean. classpath, file and http loads the resource using these protocols (classpath is default). ref will lookup the resource in the registry. bean will call a method on a bean to be used as the resource. For bean you can specify the method name after dot, eg bean:myBean.myMethod. | | String
-|===
-
-
-=== Query Parameters (7 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *allowContextMapAll* (producer) | Sets whether the context map should allow access to all details. By default only the message body and headers can be accessed. This option can be enabled for full access to the current Exchange and CamelContext. Doing so impose a potential security risk as this opens access to the full power of CamelContext API. | false | boolean
-| *allowTemplateFromHeader* (producer) | Whether to allow to use resource template from header or not (default false). Enabling this allows to specify dynamic templates via message header. However this can be seen as a potential security vulnerability if the header is coming from a malicious user, so use this with care. | false | boolean
-| *contentCache* (producer) | Sets whether to use resource content cache or not | false | boolean
-| *lazyStartProducer* (producer) | 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 [...]
-| *mapBigDecimalAsFloats* (producer) | If true, the mapper will use the USE_BIG_DECIMAL_FOR_FLOATS in serialization features | false | boolean
-| *objectMapper* (producer) | Setting a custom JSON Object Mapper to be used | | ObjectMapper
-| *prettyPrint* (common) | If true, JSON in output message is pretty printed. | false | boolean
-|===
// endpoint options: END
+
== Passing values to JSLT
Camel can supply exchange information as variables when applying a JSLT expression on the body. The available variables from the *Exchange* are:
diff --git a/components/camel-json-validator/src/main/docs/json-validator-component.adoc b/components/camel-json-validator/src/main/docs/json-validator-component.adoc
index f1834f0..da8794a 100644
--- a/components/camel-json-validator/src/main/docs/json-validator-component.adoc
+++ b/components/camel-json-validator/src/main/docs/json-validator-component.adoc
@@ -32,71 +32,21 @@ for this component:
== URI format
-[source]
----
json-validator:resourceUri[?options]
----
-
-Where *resourceUri* is some URL to a local resource on the classpath or a
+Where *resourceUri* is some URL to a local resource on the classpath or a
full URL to a remote resource or resource on the file system which contains
the JSON Schema to validate against.
-== URI Options
// component options: START
-The JSON Schema Validator component supports 2 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *lazyStartProducer* (producer) | 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 [...]
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-|===
// component options: END
-
-
-
// endpoint options: START
-The JSON Schema Validator endpoint is configured using URI syntax:
-
-----
-json-validator:resourceUri
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (1 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *resourceUri* | *Required* Path to the resource. You can prefix with: classpath, file, http, ref, or bean. classpath, file and http loads the resource using these protocols (classpath is default). ref will lookup the resource in the registry. bean will call a method on a bean to be used as the resource. For bean you can specify the method name after dot, eg bean:myBean.myMethod. | | String
-|===
-
-
-=== Query Parameters (8 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *allowContextMapAll* (producer) | Sets whether the context map should allow access to all details. By default only the message body and headers can be accessed. This option can be enabled for full access to the current Exchange and CamelContext. Doing so impose a potential security risk as this opens access to the full power of CamelContext API. | false | boolean
-| *contentCache* (producer) | Sets whether to use resource content cache or not | false | boolean
-| *failOnNullBody* (producer) | Whether to fail if no body exists. | true | boolean
-| *failOnNullHeader* (producer) | Whether to fail if no header exists when validating against a header. | true | boolean
-| *headerName* (producer) | To validate against a header instead of the message body. | | String
-| *lazyStartProducer* (producer) | 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 [...]
-| *errorHandler* (advanced) | To use a custom ValidatorErrorHandler. The default error handler captures the errors and throws an exception. | | JsonValidatorErrorHandler
-| *uriSchemaLoader* (advanced) | To use a custom schema loader allowing for adding custom format validation. The default implementation will create a schema loader that tries to determine the schema version from the $schema property of the specified schema. | | JsonUriSchemaLoader
-|===
// endpoint options: END
-
== Example
Assuming we have the following JSON Schema
@@ -106,7 +56,7 @@ Assuming we have the following JSON Schema
[source,json]
----
{
- "$schema": "http://json-schema.org/draft-04/schema#",
+ "$schema": "http://json-schema.org/draft-04/schema#",
"definitions": {},
"id": "my-schema",
"properties": {
diff --git a/components/camel-jsonata/src/main/docs/jsonata-component.adoc b/components/camel-jsonata/src/main/docs/jsonata-component.adoc
index 8b52690..a10b347 100644
--- a/components/camel-jsonata/src/main/docs/jsonata-component.adoc
+++ b/components/camel-jsonata/src/main/docs/jsonata-component.adoc
@@ -32,7 +32,6 @@ their `pom.xml` for this component:
== URI format
-[source,java]
-----------------------
jsonata:specName[?options]
-----------------------
@@ -41,64 +40,12 @@ Where *specName* is the classpath-local URI of the specification to
invoke; or the complete URL of the remote specification
(eg: \file://folder/myfile.vm).
-You can append query options to the URI in the following
-format, `?option=value&option=value&...`
-
-== Options
-
-
-
// component options: START
-The JSONata component supports 2 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *lazyStartProducer* (producer) | 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 [...]
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-|===
// component options: END
-
-
// endpoint options: START
-The JSONata endpoint is configured using URI syntax:
-
-----
-jsonata:resourceUri
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (1 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *resourceUri* | *Required* Path to the resource. You can prefix with: classpath, file, http, ref, or bean. classpath, file and http loads the resource using these protocols (classpath is default). ref will lookup the resource in the registry. bean will call a method on a bean to be used as the resource. For bean you can specify the method name after dot, eg bean:myBean.myMethod. | | String
-|===
-
-
-=== Query Parameters (5 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *allowContextMapAll* (producer) | Sets whether the context map should allow access to all details. By default only the message body and headers can be accessed. This option can be enabled for full access to the current Exchange and CamelContext. Doing so impose a potential security risk as this opens access to the full power of CamelContext API. | false | boolean
-| *contentCache* (producer) | Sets whether to use resource content cache or not | false | boolean
-| *inputType* (producer) | Specifies if the input should be Jackson JsonNode or a JSON String. There are 2 enums and the value can be one of: Jackson, JsonString | Jackson | JsonataInputOutputType
-| *lazyStartProducer* (producer) | 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 [...]
-| *outputType* (producer) | Specifies if the output should be Jackson JsonNode or a JSON String. There are 2 enums and the value can be one of: Jackson, JsonString | Jackson | JsonataInputOutputType
-|===
// endpoint options: END
-
-
-
== Samples
For example you could use something like
@@ -118,6 +65,4 @@ from("activemq:My.Queue").
to("activemq:Another.Queue");
---------------------------------------------------------------
-
-
include::{page-component-version}@camel-spring-boot::page$jsonata-starter.adoc[]
diff --git a/components/camel-jt400/src/main/docs/jt400-component.adoc b/components/camel-jt400/src/main/docs/jt400-component.adoc
index e1ebc96..158f137 100644
--- a/components/camel-jt400/src/main/docs/jt400-component.adoc
+++ b/components/camel-jt400/src/main/docs/jt400-component.adoc
@@ -33,113 +33,29 @@ for this component:
To send or receive data from a data queue
-[source,java]
----------------------------------------------------------------------
jt400://user:password@system/QSYS.LIB/LIBRARY.LIB/QUEUE.DTAQ[?options]
----------------------------------------------------------------------
To send or receive messages from a message queue
-[source,java]
----------------------------------------------------------------------
jt400://user:password@system/QSYS.LIB/LIBRARY.LIB/QUEUE.MSGQ[?options]
----------------------------------------------------------------------
To call remote program
-[source,java]
-----------------------------------------------------------------------
jt400://user:password@system/QSYS.LIB/LIBRARY.LIB/program.PGM[?options]
-----------------------------------------------------------------------
-You can append query options to the URI in the following format,
-`?option=value&option=value&...`
-
-== JT400 options
// component options: START
-The JT400 component supports 4 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *lazyStartProducer* (producer) | 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 [...]
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-| *connectionPool* (advanced) | Default connection pool used by the component. Note that this pool is lazily initialized. This is because in a scenario where the user always provides a pool, it would be wasteful for Camel to initialize and keep an idle pool. | | AS400ConnectionPool
-|===
// component options: END
-
-
// endpoint options: START
-The JT400 endpoint is configured using URI syntax:
-
-----
-jt400:userID:password/systemName/objectPath.type
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (5 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *userID* | *Required* Returns the ID of the IBM i user. | | String
-| *password* | *Required* Returns the password of the IBM i user. | | String
-| *systemName* | *Required* Returns the name of the IBM i system. | | String
-| *objectPath* | *Required* Returns the fully qualified integrated file system path name of the target object of this endpoint. | | String
-| *type* | *Required* Whether to work with data queues or remote program call. There are 4 enums and the value can be one of: DTAQ, PGM, SRVPGM, MSGQ | | Jt400Type
-|===
-
-
-=== Query Parameters (33 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *ccsid* (common) | Sets the CCSID to use for the connection with the IBM i system. | | int
-| *format* (common) | Sets the data format for sending messages. There are 2 enums and the value can be one of: text, binary | text | Format
-| *guiAvailable* (common) | Sets whether IBM i prompting is enabled in the environment running Camel. | false | boolean
-| *keyed* (common) | Whether to use keyed or non-keyed data queues. | false | boolean
-| *searchKey* (common) | Search key for keyed data queues. | | String
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *messageAction* (consumer) | Action to be taken on messages when read from a message queue. Messages can be marked as old (OLD), removed from the queue (REMOVE), or neither (SAME). There are 3 enums and the value can be one of: OLD, REMOVE, SAME | OLD | MessageAction
-| *readTimeout* (consumer) | Timeout in millis the consumer will wait while trying to read a new message of the data queue. | 30000 | int
-| *searchType* (consumer) | Search type such as EQ for equal etc. There are 6 enums and the value can be one of: EQ, NE, LT, LE, GT, GE | EQ | SearchType
-| *sendEmptyMessageWhenIdle* (consumer) | If the polling consumer did not poll any files, you can enable this option to send an empty message (no body) instead. | false | boolean
-| *sendingReply* (consumer) | If true, the consumer endpoint will set the Jt400Constants.MESSAGE_REPLYTO_KEY header of the camel message for any IBM i inquiry messages received. If that message is then routed to a producer endpoint, the action will not be processed as sending a message to the queue, but rather a reply to the specific inquiry message. | true | boolean
-| *exceptionHandler* (consumer) | 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. | | ExceptionHandler
-| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut | | ExchangePattern
-| *pollStrategy* (consumer) | A pluggable org.apache.camel.PollingConsumerPollingStrategy allowing you to provide your custom implementation to control error handling usually occurred during the poll operation before an Exchange have been created and being routed in Camel. | | PollingConsumerPollStrategy
-| *lazyStartProducer* (producer) | 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 [...]
-| *outputFieldsIdxArray* (producer) | Specifies which fields (program parameters) are output parameters. | | Integer[]
-| *outputFieldsLengthArray* (producer) | Specifies the fields (program parameters) length as in the IBM i program definition. | | Integer[]
-| *procedureName* (producer) | Procedure name from a service program to call | | String
-| *backoffErrorThreshold* (scheduler) | The number of subsequent error polls (failed due some error) that should happen before the backoffMultipler should kick-in. | | int
-| *backoffIdleThreshold* (scheduler) | The number of subsequent idle polls that should happen before the backoffMultipler should kick-in. | | int
-| *backoffMultiplier* (scheduler) | To let the scheduled polling consumer backoff if there has been a number of subsequent idles/errors in a row. The multiplier is then the number of polls that will be skipped before the next actual attempt is happening again. When this option is in use then backoffIdleThreshold and/or backoffErrorThreshold must also be configured. | | int
-| *delay* (scheduler) | Milliseconds before the next poll. | 500 | long
-| *greedy* (scheduler) | If greedy is enabled, then the ScheduledPollConsumer will run immediately again, if the previous run polled 1 or more messages. | false | boolean
-| *initialDelay* (scheduler) | Milliseconds before the first poll starts. | 1000 | long
-| *repeatCount* (scheduler) | Specifies a maximum limit of number of fires. So if you set it to 1, the scheduler will only fire once. If you set it to 5, it will only fire five times. A value of zero or negative means fire forever. | 0 | long
-| *runLoggingLevel* (scheduler) | The consumer logs a start/complete log line when it polls. This option allows you to configure the logging level for that. There are 6 enums and the value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | TRACE | LoggingLevel
-| *scheduledExecutorService* (scheduler) | Allows for configuring a custom/shared thread pool to use for the consumer. By default each consumer has its own single threaded thread pool. | | ScheduledExecutorService
-| *scheduler* (scheduler) | To use a cron scheduler from either camel-spring or camel-quartz component. Use value spring or quartz for built in scheduler | none | Object
-| *schedulerProperties* (scheduler) | To configure additional properties when using a custom scheduler or any of the Quartz, Spring based scheduler. | | Map
-| *startScheduler* (scheduler) | Whether the scheduler should be auto started. | true | boolean
-| *timeUnit* (scheduler) | Time unit for initialDelay and delay options. There are 7 enums and the value can be one of: NANOSECONDS, MICROSECONDS, MILLISECONDS, SECONDS, MINUTES, HOURS, DAYS | MILLISECONDS | TimeUnit
-| *useFixedDelay* (scheduler) | Controls if fixed delay or fixed rate is used. See ScheduledExecutorService in JDK for details. | true | boolean
-| *secured* (security) | Whether connections to IBM i are secured with SSL. | false | boolean
-|===
// endpoint options: END
-
== Usage
When configured as a data queue consumer endpoint, the endpoint will poll a data
@@ -165,12 +81,10 @@ Inquiry messages or messages requiring a message ID are not supported.
== Connection pool
-*Since Camel 2.10*
-
You can explicit configure a connection pool on the Jt400Component, or as an uri option
on the endpoint.
-=== Remote program call (*Camel 2.7*)
+=== Remote program call
This endpoint expects the input to be either a String array or byte[]
array (depending on format) and handles all the CCSID handling through
diff --git a/components/camel-kafka/src/main/docs/kafka-component.adoc b/components/camel-kafka/src/main/docs/kafka-component.adoc
index 92fd0db..2f90869 100644
--- a/components/camel-kafka/src/main/docs/kafka-component.adoc
+++ b/components/camel-kafka/src/main/docs/kafka-component.adoc
@@ -31,256 +31,14 @@ for this component.
== URI format
-[source,java]
---------------------------
kafka:topic[?options]
---------------------------
-== Options
-
-
// component options: START
-The Kafka component supports 103 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *additionalProperties* (common) | Sets additional properties for either kafka consumer or kafka producer in case they can't be set directly on the camel configurations (e.g: new Kafka properties that are not reflected yet in Camel configurations), the properties have to be prefixed with additionalProperties.. E.g: additionalProperties.transactional.id=12345&additionalProperties.schema.registry.url=\http://localhost:8811/avro | | Map
-| *brokers* (common) | URL of the Kafka brokers to use. The format is host1:port1,host2:port2, and the list can be a subset of brokers or a VIP pointing to a subset of brokers. This option is known as bootstrap.servers in the Kafka documentation. | | String
-| *clientId* (common) | The client id is a user-specified string sent in each request to help trace calls. It should logically identify the application making the request. | | String
-| *configuration* (common) | Allows to pre-configure the Kafka component with common options that the endpoints will reuse. | | KafkaConfiguration
-| *headerFilterStrategy* (common) | To use a custom HeaderFilterStrategy to filter header to and from Camel message. | | HeaderFilterStrategy
-| *reconnectBackoffMaxMs* (common) | The maximum amount of time in milliseconds to wait when reconnecting to a broker that has repeatedly failed to connect. If provided, the backoff per host will increase exponentially for each consecutive connection failure, up to this maximum. After calculating the backoff increase, 20% random jitter is added to avoid connection storms. | 1000 | Integer
-| *shutdownTimeout* (common) | Timeout in milli seconds to wait gracefully for the consumer or producer to shutdown and terminate its worker threads. | 30000 | int
-| *allowManualCommit* (consumer) | Whether to allow doing manual commits via KafkaManualCommit. If this option is enabled then an instance of KafkaManualCommit is stored on the Exchange message header, which allows end users to access this API and perform manual offset commits via the Kafka consumer. | false | boolean
-| *autoCommitEnable* (consumer) | If true, periodically commit to ZooKeeper the offset of messages already fetched by the consumer. This committed offset will be used when the process fails as the position from which the new consumer will begin. | true | Boolean
-| *autoCommitIntervalMs* (consumer) | The frequency in ms that the consumer offsets are committed to zookeeper. | 5000 | Integer
-| *autoCommitOnStop* (consumer) | Whether to perform an explicit auto commit when the consumer stops to ensure the broker has a commit from the last consumed message. This requires the option autoCommitEnable is turned on. The possible values are: sync, async, or none. And sync is the default value. There are 3 enums and the value can be one of: sync, async, none | sync | String
-| *autoOffsetReset* (consumer) | What to do when there is no initial offset in ZooKeeper or if an offset is out of range: earliest : automatically reset the offset to the earliest offset latest : automatically reset the offset to the latest offset fail: throw exception to the consumer. There are 3 enums and the value can be one of: latest, earliest, none | latest | String
-| *breakOnFirstError* (consumer) | This options controls what happens when a consumer is processing an exchange and it fails. If the option is false then the consumer continues to the next message and processes it. If the option is true then the consumer breaks out, and will seek back to offset of the message that caused a failure, and then re-attempt to process this message. However this can lead to endless processing of the same message if its bound to fail every time, eg a poison mess [...]
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *checkCrcs* (consumer) | Automatically check the CRC32 of the records consumed. This ensures no on-the-wire or on-disk corruption to the messages occurred. This check adds some overhead, so it may be disabled in cases seeking extreme performance. | true | Boolean
-| *consumerRequestTimeoutMs* (consumer) | The configuration controls the maximum amount of time the client will wait for the response of a request. If the response is not received before the timeout elapses the client will resend the request if necessary or fail the request if retries are exhausted. | 40000 | Integer
-| *consumersCount* (consumer) | The number of consumers that connect to kafka server | 1 | int
-| *consumerStreams* (consumer) | Number of concurrent consumers on the consumer | 10 | int
-| *fetchMaxBytes* (consumer) | The maximum amount of data the server should return for a fetch request This is not an absolute maximum, if the first message in the first non-empty partition of the fetch is larger than this value, the message will still be returned to ensure that the consumer can make progress. The maximum message size accepted by the broker is defined via message.max.bytes (broker config) or max.message.bytes (topic config). Note that the consumer performs multiple fetch [...]
-| *fetchMinBytes* (consumer) | The minimum amount of data the server should return for a fetch request. If insufficient data is available the request will wait for that much data to accumulate before answering the request. | 1 | Integer
-| *fetchWaitMaxMs* (consumer) | The maximum amount of time the server will block before answering the fetch request if there isn't sufficient data to immediately satisfy fetch.min.bytes | 500 | Integer
-| *groupId* (consumer) | A string that uniquely identifies the group of consumer processes to which this consumer belongs. By setting the same group id multiple processes indicate that they are all part of the same consumer group. This option is required for consumers. | | String
-| *groupInstanceId* (consumer) | A unique identifier of the consumer instance provided by the end user. Only non-empty strings are permitted. If set, the consumer is treated as a static member, which means that only one instance with this ID is allowed in the consumer group at any time. This can be used in combination with a larger session timeout to avoid group rebalances caused by transient unavailability (e.g. process restarts). If not set, the consumer will join the group as a dynami [...]
-| *headerDeserializer* (consumer) | To use a custom KafkaHeaderDeserializer to deserialize kafka headers values | | KafkaHeaderDeserializer
-| *heartbeatIntervalMs* (consumer) | The expected time between heartbeats to the consumer coordinator when using Kafka's group management facilities. Heartbeats are used to ensure that the consumer's session stays active and to facilitate rebalancing when new consumers join or leave the group. The value must be set lower than session.timeout.ms, but typically should be set no higher than 1/3 of that value. It can be adjusted even lower to control the expected time for normal rebalances. [...]
-| *keyDeserializer* (consumer) | Deserializer class for key that implements the Deserializer interface. | org.apache.kafka.common.serialization.StringDeserializer | String
-| *maxPartitionFetchBytes* (consumer) | The maximum amount of data per-partition the server will return. The maximum total memory used for a request will be #partitions max.partition.fetch.bytes. This size must be at least as large as the maximum message size the server allows or else it is possible for the producer to send messages larger than the consumer can fetch. If that happens, the consumer can get stuck trying to fetch a large message on a certain partition. | 1048576 | Integer
-| *maxPollIntervalMs* (consumer) | The maximum delay between invocations of poll() when using consumer group management. This places an upper bound on the amount of time that the consumer can be idle before fetching more records. If poll() is not called before expiration of this timeout, then the consumer is considered failed and the group will rebalance in order to reassign the partitions to another member. | | Long
-| *maxPollRecords* (consumer) | The maximum number of records returned in a single call to poll() | 500 | Integer
-| *offsetRepository* (consumer) | The offset repository to use in order to locally store the offset of each partition of the topic. Defining one will disable the autocommit. | | StateRepository
-| *partitionAssignor* (consumer) | The class name of the partition assignment strategy that the client will use to distribute partition ownership amongst consumer instances when group management is used | org.apache.kafka.clients.consumer.RangeAssignor | String
-| *pollOnError* (consumer) | What to do if kafka threw an exception while polling for new messages. Will by default use the value from the component configuration unless an explicit value has been configured on the endpoint level. DISCARD will discard the message and continue to poll next message. ERROR_HANDLER will use Camel's error handler to process the exception, and afterwards continue to poll next message. RECONNECT will re-connect the consumer and try poll the message again RETRY [...]
-| *pollTimeoutMs* (consumer) | The timeout used when polling the KafkaConsumer. | 5000 | Long
-| *seekTo* (consumer) | Set if KafkaConsumer will read from beginning or end on startup: beginning : read from beginning end : read from end This is replacing the earlier property seekToBeginning. There are 2 enums and the value can be one of: beginning, end | | String
-| *sessionTimeoutMs* (consumer) | The timeout used to detect failures when using Kafka's group management facilities. | 10000 | Integer
-| *specificAvroReader* (consumer) | This enables the use of a specific Avro reader for use with the Confluent Platform schema registry and the io.confluent.kafka.serializers.KafkaAvroDeserializer. This option is only available in the Confluent Platform (not standard Apache Kafka) | false | boolean
-| *topicIsPattern* (consumer) | Whether the topic is a pattern (regular expression). This can be used to subscribe to dynamic number of topics matching the pattern. | false | boolean
-| *valueDeserializer* (consumer) | Deserializer class for value that implements the Deserializer interface. | org.apache.kafka.common.serialization.StringDeserializer | String
-| *kafkaManualCommitFactory* (consumer) | Factory to use for creating KafkaManualCommit instances. This allows to plugin a custom factory to create custom KafkaManualCommit instances in case special logic is needed when doing manual commits that deviates from the default implementation that comes out of the box. | | KafkaManualCommitFactory
-| *pollExceptionStrategy* (consumer) | *Autowired* To use a custom strategy with the consumer to control how to handle exceptions thrown from the Kafka broker while pooling messages. | | PollExceptionStrategy
-| *bufferMemorySize* (producer) | The total bytes of memory the producer can use to buffer records waiting to be sent to the server. If records are sent faster than they can be delivered to the server the producer will either block or throw an exception based on the preference specified by block.on.buffer.full.This setting should correspond roughly to the total memory the producer will use, but is not a hard bound since not all memory the producer uses is used for buffering. Some additio [...]
-| *compressionCodec* (producer) | This parameter allows you to specify the compression codec for all data generated by this producer. Valid values are none, gzip and snappy. There are 4 enums and the value can be one of: none, gzip, snappy, lz4 | none | String
-| *connectionMaxIdleMs* (producer) | Close idle connections after the number of milliseconds specified by this config. | 540000 | Integer
-| *deliveryTimeoutMs* (producer) | An upper bound on the time to report success or failure after a call to send() returns. This limits the total time that a record will be delayed prior to sending, the time to await acknowledgement from the broker (if expected), and the time allowed for retriable send failures. | 120000 | Integer
-| *enableIdempotence* (producer) | If set to 'true' the producer will ensure that exactly one copy of each message is written in the stream. If 'false', producer retries may write duplicates of the retried message in the stream. If set to true this option will require max.in.flight.requests.per.connection to be set to 1 and retries cannot be zero and additionally acks must be set to 'all'. | false | boolean
-| *headerSerializer* (producer) | To use a custom KafkaHeaderSerializer to serialize kafka headers values | | KafkaHeaderSerializer
-| *key* (producer) | The record key (or null if no key is specified). If this option has been configured then it take precedence over header KafkaConstants#KEY | | String
-| *keySerializer* (producer) | The serializer class for keys (defaults to the same as for messages if nothing is given). | org.apache.kafka.common.serialization.StringSerializer | String
-| *lazyStartProducer* (producer) | 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 [...]
-| *lingerMs* (producer) | The producer groups together any records that arrive in between request transmissions into a single batched request. Normally this occurs only under load when records arrive faster than they can be sent out. However in some circumstances the client may want to reduce the number of requests even under moderate load. This setting accomplishes this by adding a small amount of artificial delay that is, rather than immediately sending out a record the producer will w [...]
-| *maxBlockMs* (producer) | The configuration controls how long sending to kafka will block. These methods can be blocked for multiple reasons. For e.g: buffer full, metadata unavailable.This configuration imposes maximum limit on the total time spent in fetching metadata, serialization of key and value, partitioning and allocation of buffer memory when doing a send(). In case of partitionsFor(), this configuration imposes a maximum time threshold on waiting for metadata | 60000 | Integer
-| *maxInFlightRequest* (producer) | The maximum number of unacknowledged requests the client will send on a single connection before blocking. Note that if this setting is set to be greater than 1 and there are failed sends, there is a risk of message re-ordering due to retries (i.e., if retries are enabled). | 5 | Integer
-| *maxRequestSize* (producer) | The maximum size of a request. This is also effectively a cap on the maximum record size. Note that the server has its own cap on record size which may be different from this. This setting will limit the number of record batches the producer will send in a single request to avoid sending huge requests. | 1048576 | Integer
-| *metadataMaxAgeMs* (producer) | The period of time in milliseconds after which we force a refresh of metadata even if we haven't seen any partition leadership changes to proactively discover any new brokers or partitions. | 300000 | Integer
-| *metricReporters* (producer) | A list of classes to use as metrics reporters. Implementing the MetricReporter interface allows plugging in classes that will be notified of new metric creation. The JmxReporter is always included to register JMX statistics. | | String
-| *metricsSampleWindowMs* (producer) | The number of samples maintained to compute metrics. | 30000 | Integer
-| *noOfMetricsSample* (producer) | The number of samples maintained to compute metrics. | 2 | Integer
-| *partitioner* (producer) | The partitioner class for partitioning messages amongst sub-topics. The default partitioner is based on the hash of the key. | org.apache.kafka.clients.producer.internals.DefaultPartitioner | String
-| *partitionKey* (producer) | The partition to which the record will be sent (or null if no partition was specified). If this option has been configured then it take precedence over header KafkaConstants#PARTITION_KEY | | Integer
-| *producerBatchSize* (producer) | The producer will attempt to batch records together into fewer requests whenever multiple records are being sent to the same partition. This helps performance on both the client and the server. This configuration controls the default batch size in bytes. No attempt will be made to batch records larger than this size.Requests sent to brokers will contain multiple batches, one for each partition with data available to be sent.A small batch size will make [...]
-| *queueBufferingMaxMessages* (producer) | The maximum number of unsent messages that can be queued up the producer when using async mode before either the producer must be blocked or data must be dropped. | 10000 | Integer
-| *receiveBufferBytes* (producer) | The size of the TCP receive buffer (SO_RCVBUF) to use when reading data. | 65536 | Integer
-| *reconnectBackoffMs* (producer) | The amount of time to wait before attempting to reconnect to a given host. This avoids repeatedly connecting to a host in a tight loop. This backoff applies to all requests sent by the consumer to the broker. | 50 | Integer
-| *recordMetadata* (producer) | Whether the producer should store the RecordMetadata results from sending to Kafka. The results are stored in a List containing the RecordMetadata metadata's. The list is stored on a header with the key KafkaConstants#KAFKA_RECORDMETA | true | boolean
-| *requestRequiredAcks* (producer) | The number of acknowledgments the producer requires the leader to have received before considering a request complete. This controls the durability of records that are sent. The following settings are common: acks=0 If set to zero then the producer will not wait for any acknowledgment from the server at all. The record will be immediately added to the socket buffer and considered sent. No guarantee can be made that the server has received the record i [...]
-| *requestTimeoutMs* (producer) | The amount of time the broker will wait trying to meet the request.required.acks requirement before sending back an error to the client. | 30000 | Integer
-| *retries* (producer) | Setting a value greater than zero will cause the client to resend any record whose send fails with a potentially transient error. Note that this retry is no different than if the client resent the record upon receiving the error. Allowing retries will potentially change the ordering of records because if two records are sent to a single partition, and the first fails and is retried but the second succeeds, then the second record may appear first. | 0 | Integer
-| *retryBackoffMs* (producer) | Before each retry, the producer refreshes the metadata of relevant topics to see if a new leader has been elected. Since leader election takes a bit of time, this property specifies the amount of time that the producer waits before refreshing the metadata. | 100 | Integer
-| *sendBufferBytes* (producer) | Socket write buffer size | 131072 | Integer
-| *valueSerializer* (producer) | The serializer class for messages. | org.apache.kafka.common.serialization.StringSerializer | String
-| *workerPool* (producer) | To use a custom worker pool for continue routing Exchange after kafka server has acknowledge the message that was sent to it from KafkaProducer using asynchronous non-blocking processing. If using this option then you must handle the lifecycle of the thread pool to shut the pool down when no longer needed. | | ExecutorService
-| *workerPoolCoreSize* (producer) | Number of core threads for the worker pool for continue routing Exchange after kafka server has acknowledge the message that was sent to it from KafkaProducer using asynchronous non-blocking processing. | 10 | Integer
-| *workerPoolMaxSize* (producer) | Maximum number of threads for the worker pool for continue routing Exchange after kafka server has acknowledge the message that was sent to it from KafkaProducer using asynchronous non-blocking processing. | 20 | Integer
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-| *kafkaClientFactory* (advanced) | *Autowired* Factory to use for creating org.apache.kafka.clients.consumer.KafkaConsumer and org.apache.kafka.clients.producer.KafkaProducer instances. This allows to configure a custom factory to create instances with logic that extends the vanilla Kafka clients. | | KafkaClientFactory
-| *synchronous* (advanced) | Sets whether synchronous processing should be strictly used | false | boolean
-| *schemaRegistryURL* (confluent) | URL of the Confluent Platform schema registry servers to use. The format is host1:port1,host2:port2. This is known as schema.registry.url in the Confluent Platform documentation. This option is only available in the Confluent Platform (not standard Apache Kafka) | | String
-| *interceptorClasses* (monitoring) | Sets interceptors for producer or consumers. Producer interceptors have to be classes implementing org.apache.kafka.clients.producer.ProducerInterceptor Consumer interceptors have to be classes implementing org.apache.kafka.clients.consumer.ConsumerInterceptor Note that if you use Producer interceptor on a consumer it will throw a class cast exception in runtime | | String
-| *kerberosBeforeReloginMinTime* (security) | Login thread sleep time between refresh attempts. | 60000 | Integer
-| *kerberosInitCmd* (security) | Kerberos kinit command path. Default is /usr/bin/kinit | /usr/bin/kinit | String
-| *kerberosPrincipalToLocalRules* (security) | A list of rules for mapping from principal names to short names (typically operating system usernames). The rules are evaluated in order and the first rule that matches a principal name is used to map it to a short name. Any later rules in the list are ignored. By default, principal names of the form \{username}/\{hostname}\{REALM} are mapped to \{username}. For more details on the format please see the security authorization and acls docume [...]
-| *kerberosRenewJitter* (security) | Percentage of random jitter added to the renewal time. | 0.05 | Double
-| *kerberosRenewWindowFactor* (security) | Login thread will sleep until the specified window factor of time from last refresh to ticket's expiry has been reached, at which time it will try to renew the ticket. | 0.8 | Double
-| *saslJaasConfig* (security) | Expose the kafka sasl.jaas.config parameter Example: org.apache.kafka.common.security.plain.PlainLoginModule required username=USERNAME password=PASSWORD; | | String
-| *saslKerberosServiceName* (security) | The Kerberos principal name that Kafka runs as. This can be defined either in Kafka's JAAS config or in Kafka's config. | | String
-| *saslMechanism* (security) | The Simple Authentication and Security Layer (SASL) Mechanism used. For the valid values see \http://www.iana.org/assignments/sasl-mechanisms/sasl-mechanisms.xhtml | GSSAPI | String
-| *securityProtocol* (security) | Protocol used to communicate with brokers. SASL_PLAINTEXT, PLAINTEXT and SSL are supported | PLAINTEXT | String
-| *sslCipherSuites* (security) | A list of cipher suites. This is a named combination of authentication, encryption, MAC and key exchange algorithm used to negotiate the security settings for a network connection using TLS or SSL network protocol.By default all the available cipher suites are supported. | | String
-| *sslContextParameters* (security) | SSL configuration using a Camel SSLContextParameters object. If configured it's applied before the other SSL endpoint parameters. NOTE: Kafka only supports loading keystore from file locations, so prefix the location with file: in the KeyStoreParameters.resource option. | | SSLContextParameters
-| *sslEnabledProtocols* (security) | The list of protocols enabled for SSL connections. TLSv1.2, TLSv1.1 and TLSv1 are enabled by default. | | String
-| *sslEndpointAlgorithm* (security) | The endpoint identification algorithm to validate server hostname using server certificate. | https | String
-| *sslKeymanagerAlgorithm* (security) | The algorithm used by key manager factory for SSL connections. Default value is the key manager factory algorithm configured for the Java Virtual Machine. | SunX509 | String
-| *sslKeyPassword* (security) | The password of the private key in the key store file. This is optional for client. | | String
-| *sslKeystoreLocation* (security) | The location of the key store file. This is optional for client and can be used for two-way authentication for client. | | String
-| *sslKeystorePassword* (security) | The store password for the key store file.This is optional for client and only needed if ssl.keystore.location is configured. | | String
-| *sslKeystoreType* (security) | The file format of the key store file. This is optional for client. Default value is JKS | JKS | String
-| *sslProtocol* (security) | The SSL protocol used to generate the SSLContext. Default setting is TLS, which is fine for most cases. Allowed values in recent JVMs are TLS, TLSv1.1 and TLSv1.2. SSL, SSLv2 and SSLv3 may be supported in older JVMs, but their usage is discouraged due to known security vulnerabilities. | | String
-| *sslProvider* (security) | The name of the security provider used for SSL connections. Default value is the default security provider of the JVM. | | String
-| *sslTrustmanagerAlgorithm* (security) | The algorithm used by trust manager factory for SSL connections. Default value is the trust manager factory algorithm configured for the Java Virtual Machine. | PKIX | String
-| *sslTruststoreLocation* (security) | The location of the trust store file. | | String
-| *sslTruststorePassword* (security) | The password for the trust store file. | | String
-| *sslTruststoreType* (security) | The file format of the trust store file. Default value is JKS. | JKS | String
-| *useGlobalSslContextParameters* (security) | Enable usage of global SSL context parameters. | false | boolean
-|===
// component options: END
-
-
-
// endpoint options: START
-The Kafka endpoint is configured using URI syntax:
-
-----
-kafka:topic
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (1 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *topic* | *Required* Name of the topic to use. On the consumer you can use comma to separate multiple topics. A producer can only send a message to a single topic. | | String
-|===
-
-
-=== Query Parameters (99 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *additionalProperties* (common) | Sets additional properties for either kafka consumer or kafka producer in case they can't be set directly on the camel configurations (e.g: new Kafka properties that are not reflected yet in Camel configurations), the properties have to be prefixed with additionalProperties.. E.g: additionalProperties.transactional.id=12345&additionalProperties.schema.registry.url=\http://localhost:8811/avro | | Map
-| *brokers* (common) | URL of the Kafka brokers to use. The format is host1:port1,host2:port2, and the list can be a subset of brokers or a VIP pointing to a subset of brokers. This option is known as bootstrap.servers in the Kafka documentation. | | String
-| *clientId* (common) | The client id is a user-specified string sent in each request to help trace calls. It should logically identify the application making the request. | | String
-| *headerFilterStrategy* (common) | To use a custom HeaderFilterStrategy to filter header to and from Camel message. | | HeaderFilterStrategy
-| *reconnectBackoffMaxMs* (common) | The maximum amount of time in milliseconds to wait when reconnecting to a broker that has repeatedly failed to connect. If provided, the backoff per host will increase exponentially for each consecutive connection failure, up to this maximum. After calculating the backoff increase, 20% random jitter is added to avoid connection storms. | 1000 | Integer
-| *shutdownTimeout* (common) | Timeout in milli seconds to wait gracefully for the consumer or producer to shutdown and terminate its worker threads. | 30000 | int
-| *allowManualCommit* (consumer) | Whether to allow doing manual commits via KafkaManualCommit. If this option is enabled then an instance of KafkaManualCommit is stored on the Exchange message header, which allows end users to access this API and perform manual offset commits via the Kafka consumer. | false | boolean
-| *autoCommitEnable* (consumer) | If true, periodically commit to ZooKeeper the offset of messages already fetched by the consumer. This committed offset will be used when the process fails as the position from which the new consumer will begin. | true | Boolean
-| *autoCommitIntervalMs* (consumer) | The frequency in ms that the consumer offsets are committed to zookeeper. | 5000 | Integer
-| *autoCommitOnStop* (consumer) | Whether to perform an explicit auto commit when the consumer stops to ensure the broker has a commit from the last consumed message. This requires the option autoCommitEnable is turned on. The possible values are: sync, async, or none. And sync is the default value. There are 3 enums and the value can be one of: sync, async, none | sync | String
-| *autoOffsetReset* (consumer) | What to do when there is no initial offset in ZooKeeper or if an offset is out of range: earliest : automatically reset the offset to the earliest offset latest : automatically reset the offset to the latest offset fail: throw exception to the consumer. There are 3 enums and the value can be one of: latest, earliest, none | latest | String
-| *breakOnFirstError* (consumer) | This options controls what happens when a consumer is processing an exchange and it fails. If the option is false then the consumer continues to the next message and processes it. If the option is true then the consumer breaks out, and will seek back to offset of the message that caused a failure, and then re-attempt to process this message. However this can lead to endless processing of the same message if its bound to fail every time, eg a poison mess [...]
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *checkCrcs* (consumer) | Automatically check the CRC32 of the records consumed. This ensures no on-the-wire or on-disk corruption to the messages occurred. This check adds some overhead, so it may be disabled in cases seeking extreme performance. | true | Boolean
-| *consumerRequestTimeoutMs* (consumer) | The configuration controls the maximum amount of time the client will wait for the response of a request. If the response is not received before the timeout elapses the client will resend the request if necessary or fail the request if retries are exhausted. | 40000 | Integer
-| *consumersCount* (consumer) | The number of consumers that connect to kafka server | 1 | int
-| *consumerStreams* (consumer) | Number of concurrent consumers on the consumer | 10 | int
-| *fetchMaxBytes* (consumer) | The maximum amount of data the server should return for a fetch request This is not an absolute maximum, if the first message in the first non-empty partition of the fetch is larger than this value, the message will still be returned to ensure that the consumer can make progress. The maximum message size accepted by the broker is defined via message.max.bytes (broker config) or max.message.bytes (topic config). Note that the consumer performs multiple fetch [...]
-| *fetchMinBytes* (consumer) | The minimum amount of data the server should return for a fetch request. If insufficient data is available the request will wait for that much data to accumulate before answering the request. | 1 | Integer
-| *fetchWaitMaxMs* (consumer) | The maximum amount of time the server will block before answering the fetch request if there isn't sufficient data to immediately satisfy fetch.min.bytes | 500 | Integer
-| *groupId* (consumer) | A string that uniquely identifies the group of consumer processes to which this consumer belongs. By setting the same group id multiple processes indicate that they are all part of the same consumer group. This option is required for consumers. | | String
-| *groupInstanceId* (consumer) | A unique identifier of the consumer instance provided by the end user. Only non-empty strings are permitted. If set, the consumer is treated as a static member, which means that only one instance with this ID is allowed in the consumer group at any time. This can be used in combination with a larger session timeout to avoid group rebalances caused by transient unavailability (e.g. process restarts). If not set, the consumer will join the group as a dynami [...]
-| *headerDeserializer* (consumer) | To use a custom KafkaHeaderDeserializer to deserialize kafka headers values | | KafkaHeaderDeserializer
-| *heartbeatIntervalMs* (consumer) | The expected time between heartbeats to the consumer coordinator when using Kafka's group management facilities. Heartbeats are used to ensure that the consumer's session stays active and to facilitate rebalancing when new consumers join or leave the group. The value must be set lower than session.timeout.ms, but typically should be set no higher than 1/3 of that value. It can be adjusted even lower to control the expected time for normal rebalances. [...]
-| *keyDeserializer* (consumer) | Deserializer class for key that implements the Deserializer interface. | org.apache.kafka.common.serialization.StringDeserializer | String
-| *maxPartitionFetchBytes* (consumer) | The maximum amount of data per-partition the server will return. The maximum total memory used for a request will be #partitions max.partition.fetch.bytes. This size must be at least as large as the maximum message size the server allows or else it is possible for the producer to send messages larger than the consumer can fetch. If that happens, the consumer can get stuck trying to fetch a large message on a certain partition. | 1048576 | Integer
-| *maxPollIntervalMs* (consumer) | The maximum delay between invocations of poll() when using consumer group management. This places an upper bound on the amount of time that the consumer can be idle before fetching more records. If poll() is not called before expiration of this timeout, then the consumer is considered failed and the group will rebalance in order to reassign the partitions to another member. | | Long
-| *maxPollRecords* (consumer) | The maximum number of records returned in a single call to poll() | 500 | Integer
-| *offsetRepository* (consumer) | The offset repository to use in order to locally store the offset of each partition of the topic. Defining one will disable the autocommit. | | StateRepository
-| *partitionAssignor* (consumer) | The class name of the partition assignment strategy that the client will use to distribute partition ownership amongst consumer instances when group management is used | org.apache.kafka.clients.consumer.RangeAssignor | String
-| *pollOnError* (consumer) | What to do if kafka threw an exception while polling for new messages. Will by default use the value from the component configuration unless an explicit value has been configured on the endpoint level. DISCARD will discard the message and continue to poll next message. ERROR_HANDLER will use Camel's error handler to process the exception, and afterwards continue to poll next message. RECONNECT will re-connect the consumer and try poll the message again RETRY [...]
-| *pollTimeoutMs* (consumer) | The timeout used when polling the KafkaConsumer. | 5000 | Long
-| *seekTo* (consumer) | Set if KafkaConsumer will read from beginning or end on startup: beginning : read from beginning end : read from end This is replacing the earlier property seekToBeginning. There are 2 enums and the value can be one of: beginning, end | | String
-| *sessionTimeoutMs* (consumer) | The timeout used to detect failures when using Kafka's group management facilities. | 10000 | Integer
-| *specificAvroReader* (consumer) | This enables the use of a specific Avro reader for use with the Confluent Platform schema registry and the io.confluent.kafka.serializers.KafkaAvroDeserializer. This option is only available in the Confluent Platform (not standard Apache Kafka) | false | boolean
-| *topicIsPattern* (consumer) | Whether the topic is a pattern (regular expression). This can be used to subscribe to dynamic number of topics matching the pattern. | false | boolean
-| *valueDeserializer* (consumer) | Deserializer class for value that implements the Deserializer interface. | org.apache.kafka.common.serialization.StringDeserializer | String
-| *exceptionHandler* (consumer) | 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. | | ExceptionHandler
-| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut | | ExchangePattern
-| *bufferMemorySize* (producer) | The total bytes of memory the producer can use to buffer records waiting to be sent to the server. If records are sent faster than they can be delivered to the server the producer will either block or throw an exception based on the preference specified by block.on.buffer.full.This setting should correspond roughly to the total memory the producer will use, but is not a hard bound since not all memory the producer uses is used for buffering. Some additio [...]
-| *compressionCodec* (producer) | This parameter allows you to specify the compression codec for all data generated by this producer. Valid values are none, gzip and snappy. There are 4 enums and the value can be one of: none, gzip, snappy, lz4 | none | String
-| *connectionMaxIdleMs* (producer) | Close idle connections after the number of milliseconds specified by this config. | 540000 | Integer
-| *deliveryTimeoutMs* (producer) | An upper bound on the time to report success or failure after a call to send() returns. This limits the total time that a record will be delayed prior to sending, the time to await acknowledgement from the broker (if expected), and the time allowed for retriable send failures. | 120000 | Integer
-| *enableIdempotence* (producer) | If set to 'true' the producer will ensure that exactly one copy of each message is written in the stream. If 'false', producer retries may write duplicates of the retried message in the stream. If set to true this option will require max.in.flight.requests.per.connection to be set to 1 and retries cannot be zero and additionally acks must be set to 'all'. | false | boolean
-| *headerSerializer* (producer) | To use a custom KafkaHeaderSerializer to serialize kafka headers values | | KafkaHeaderSerializer
-| *key* (producer) | The record key (or null if no key is specified). If this option has been configured then it take precedence over header KafkaConstants#KEY | | String
-| *keySerializer* (producer) | The serializer class for keys (defaults to the same as for messages if nothing is given). | org.apache.kafka.common.serialization.StringSerializer | String
-| *lazyStartProducer* (producer) | 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 [...]
-| *lingerMs* (producer) | The producer groups together any records that arrive in between request transmissions into a single batched request. Normally this occurs only under load when records arrive faster than they can be sent out. However in some circumstances the client may want to reduce the number of requests even under moderate load. This setting accomplishes this by adding a small amount of artificial delay that is, rather than immediately sending out a record the producer will w [...]
-| *maxBlockMs* (producer) | The configuration controls how long sending to kafka will block. These methods can be blocked for multiple reasons. For e.g: buffer full, metadata unavailable.This configuration imposes maximum limit on the total time spent in fetching metadata, serialization of key and value, partitioning and allocation of buffer memory when doing a send(). In case of partitionsFor(), this configuration imposes a maximum time threshold on waiting for metadata | 60000 | Integer
-| *maxInFlightRequest* (producer) | The maximum number of unacknowledged requests the client will send on a single connection before blocking. Note that if this setting is set to be greater than 1 and there are failed sends, there is a risk of message re-ordering due to retries (i.e., if retries are enabled). | 5 | Integer
-| *maxRequestSize* (producer) | The maximum size of a request. This is also effectively a cap on the maximum record size. Note that the server has its own cap on record size which may be different from this. This setting will limit the number of record batches the producer will send in a single request to avoid sending huge requests. | 1048576 | Integer
-| *metadataMaxAgeMs* (producer) | The period of time in milliseconds after which we force a refresh of metadata even if we haven't seen any partition leadership changes to proactively discover any new brokers or partitions. | 300000 | Integer
-| *metricReporters* (producer) | A list of classes to use as metrics reporters. Implementing the MetricReporter interface allows plugging in classes that will be notified of new metric creation. The JmxReporter is always included to register JMX statistics. | | String
-| *metricsSampleWindowMs* (producer) | The number of samples maintained to compute metrics. | 30000 | Integer
-| *noOfMetricsSample* (producer) | The number of samples maintained to compute metrics. | 2 | Integer
-| *partitioner* (producer) | The partitioner class for partitioning messages amongst sub-topics. The default partitioner is based on the hash of the key. | org.apache.kafka.clients.producer.internals.DefaultPartitioner | String
-| *partitionKey* (producer) | The partition to which the record will be sent (or null if no partition was specified). If this option has been configured then it take precedence over header KafkaConstants#PARTITION_KEY | | Integer
-| *producerBatchSize* (producer) | The producer will attempt to batch records together into fewer requests whenever multiple records are being sent to the same partition. This helps performance on both the client and the server. This configuration controls the default batch size in bytes. No attempt will be made to batch records larger than this size.Requests sent to brokers will contain multiple batches, one for each partition with data available to be sent.A small batch size will make [...]
-| *queueBufferingMaxMessages* (producer) | The maximum number of unsent messages that can be queued up the producer when using async mode before either the producer must be blocked or data must be dropped. | 10000 | Integer
-| *receiveBufferBytes* (producer) | The size of the TCP receive buffer (SO_RCVBUF) to use when reading data. | 65536 | Integer
-| *reconnectBackoffMs* (producer) | The amount of time to wait before attempting to reconnect to a given host. This avoids repeatedly connecting to a host in a tight loop. This backoff applies to all requests sent by the consumer to the broker. | 50 | Integer
-| *recordMetadata* (producer) | Whether the producer should store the RecordMetadata results from sending to Kafka. The results are stored in a List containing the RecordMetadata metadata's. The list is stored on a header with the key KafkaConstants#KAFKA_RECORDMETA | true | boolean
-| *requestRequiredAcks* (producer) | The number of acknowledgments the producer requires the leader to have received before considering a request complete. This controls the durability of records that are sent. The following settings are common: acks=0 If set to zero then the producer will not wait for any acknowledgment from the server at all. The record will be immediately added to the socket buffer and considered sent. No guarantee can be made that the server has received the record i [...]
-| *requestTimeoutMs* (producer) | The amount of time the broker will wait trying to meet the request.required.acks requirement before sending back an error to the client. | 30000 | Integer
-| *retries* (producer) | Setting a value greater than zero will cause the client to resend any record whose send fails with a potentially transient error. Note that this retry is no different than if the client resent the record upon receiving the error. Allowing retries will potentially change the ordering of records because if two records are sent to a single partition, and the first fails and is retried but the second succeeds, then the second record may appear first. | 0 | Integer
-| *retryBackoffMs* (producer) | Before each retry, the producer refreshes the metadata of relevant topics to see if a new leader has been elected. Since leader election takes a bit of time, this property specifies the amount of time that the producer waits before refreshing the metadata. | 100 | Integer
-| *sendBufferBytes* (producer) | Socket write buffer size | 131072 | Integer
-| *valueSerializer* (producer) | The serializer class for messages. | org.apache.kafka.common.serialization.StringSerializer | String
-| *workerPool* (producer) | To use a custom worker pool for continue routing Exchange after kafka server has acknowledge the message that was sent to it from KafkaProducer using asynchronous non-blocking processing. If using this option then you must handle the lifecycle of the thread pool to shut the pool down when no longer needed. | | ExecutorService
-| *workerPoolCoreSize* (producer) | Number of core threads for the worker pool for continue routing Exchange after kafka server has acknowledge the message that was sent to it from KafkaProducer using asynchronous non-blocking processing. | 10 | Integer
-| *workerPoolMaxSize* (producer) | Maximum number of threads for the worker pool for continue routing Exchange after kafka server has acknowledge the message that was sent to it from KafkaProducer using asynchronous non-blocking processing. | 20 | Integer
-| *synchronous* (advanced) | Sets whether synchronous processing should be strictly used | false | boolean
-| *schemaRegistryURL* (confluent) | URL of the Confluent Platform schema registry servers to use. The format is host1:port1,host2:port2. This is known as schema.registry.url in the Confluent Platform documentation. This option is only available in the Confluent Platform (not standard Apache Kafka) | | String
-| *interceptorClasses* (monitoring) | Sets interceptors for producer or consumers. Producer interceptors have to be classes implementing org.apache.kafka.clients.producer.ProducerInterceptor Consumer interceptors have to be classes implementing org.apache.kafka.clients.consumer.ConsumerInterceptor Note that if you use Producer interceptor on a consumer it will throw a class cast exception in runtime | | String
-| *kerberosBeforeReloginMinTime* (security) | Login thread sleep time between refresh attempts. | 60000 | Integer
-| *kerberosInitCmd* (security) | Kerberos kinit command path. Default is /usr/bin/kinit | /usr/bin/kinit | String
-| *kerberosPrincipalToLocalRules* (security) | A list of rules for mapping from principal names to short names (typically operating system usernames). The rules are evaluated in order and the first rule that matches a principal name is used to map it to a short name. Any later rules in the list are ignored. By default, principal names of the form \{username}/\{hostname}\{REALM} are mapped to \{username}. For more details on the format please see the security authorization and acls docume [...]
-| *kerberosRenewJitter* (security) | Percentage of random jitter added to the renewal time. | 0.05 | Double
-| *kerberosRenewWindowFactor* (security) | Login thread will sleep until the specified window factor of time from last refresh to ticket's expiry has been reached, at which time it will try to renew the ticket. | 0.8 | Double
-| *saslJaasConfig* (security) | Expose the kafka sasl.jaas.config parameter Example: org.apache.kafka.common.security.plain.PlainLoginModule required username=USERNAME password=PASSWORD; | | String
-| *saslKerberosServiceName* (security) | The Kerberos principal name that Kafka runs as. This can be defined either in Kafka's JAAS config or in Kafka's config. | | String
-| *saslMechanism* (security) | The Simple Authentication and Security Layer (SASL) Mechanism used. For the valid values see \http://www.iana.org/assignments/sasl-mechanisms/sasl-mechanisms.xhtml | GSSAPI | String
-| *securityProtocol* (security) | Protocol used to communicate with brokers. SASL_PLAINTEXT, PLAINTEXT and SSL are supported | PLAINTEXT | String
-| *sslCipherSuites* (security) | A list of cipher suites. This is a named combination of authentication, encryption, MAC and key exchange algorithm used to negotiate the security settings for a network connection using TLS or SSL network protocol.By default all the available cipher suites are supported. | | String
-| *sslContextParameters* (security) | SSL configuration using a Camel SSLContextParameters object. If configured it's applied before the other SSL endpoint parameters. NOTE: Kafka only supports loading keystore from file locations, so prefix the location with file: in the KeyStoreParameters.resource option. | | SSLContextParameters
-| *sslEnabledProtocols* (security) | The list of protocols enabled for SSL connections. TLSv1.2, TLSv1.1 and TLSv1 are enabled by default. | | String
-| *sslEndpointAlgorithm* (security) | The endpoint identification algorithm to validate server hostname using server certificate. | https | String
-| *sslKeymanagerAlgorithm* (security) | The algorithm used by key manager factory for SSL connections. Default value is the key manager factory algorithm configured for the Java Virtual Machine. | SunX509 | String
-| *sslKeyPassword* (security) | The password of the private key in the key store file. This is optional for client. | | String
-| *sslKeystoreLocation* (security) | The location of the key store file. This is optional for client and can be used for two-way authentication for client. | | String
-| *sslKeystorePassword* (security) | The store password for the key store file.This is optional for client and only needed if ssl.keystore.location is configured. | | String
-| *sslKeystoreType* (security) | The file format of the key store file. This is optional for client. Default value is JKS | JKS | String
-| *sslProtocol* (security) | The SSL protocol used to generate the SSLContext. Default setting is TLS, which is fine for most cases. Allowed values in recent JVMs are TLS, TLSv1.1 and TLSv1.2. SSL, SSLv2 and SSLv3 may be supported in older JVMs, but their usage is discouraged due to known security vulnerabilities. | | String
-| *sslProvider* (security) | The name of the security provider used for SSL connections. Default value is the default security provider of the JVM. | | String
-| *sslTrustmanagerAlgorithm* (security) | The algorithm used by trust manager factory for SSL connections. Default value is the trust manager factory algorithm configured for the Java Virtual Machine. | PKIX | String
-| *sslTruststoreLocation* (security) | The location of the trust store file. | | String
-| *sslTruststorePassword* (security) | The password for the trust store file. | | String
-| *sslTruststoreType* (security) | The file format of the trust store file. Default value is JKS. | JKS | String
-|===
// endpoint options: END
For more information about Producer/Consumer configuration:
@@ -491,14 +249,10 @@ camelContext.addRoutes(new RouteBuilder() {
----
== Using the Kafka idempotent repository
-*Available from Camel 2.19*
The `camel-kafka` library provides a Kafka topic-based idempotent repository. This repository stores broadcasts all changes to idempotent state (add/remove) in a Kafka topic, and populates a local in-memory cache for each repository's process instance through event sourcing.
-
The topic used must be unique per idempotent repository instance. The mechanism does not have any requirements about the number of topic partitions; as the repository consumes from all partitions at the same time. It also does not have any requirements about the replication factor of the topic.
-
Each repository instance that uses the topic (e.g. typically on different machines running in parallel) controls its own consumer group, so in a cluster of 10 Camel processes using the same topic each will control its own offset.
-
On startup, the instance subscribes to the topic and rewinds the offset to the beginning, rebuilding the cache to the latest state. The cache will not be considered warmed up until one poll of `pollDurationMs` in length returns 0 records. Startup will not be completed until either the cache has warmed up, or 30 seconds go by; if the latter happens the idempotent repository may be in an inconsistent state until its consumer catches up to the end of the topic.
A `KafkaIdempotentRepository` has the following properties:
@@ -515,7 +269,6 @@ If setting this value explicitly, be aware that there is a tradeoff between the
|===
The repository can be instantiated by defining the `topic` and `bootstrapServers`, or the `producerConfig` and `consumerConfig` property sets can be explicitly defined to enable features such as SSL/SASL.
-
To use, this repository must be placed in the Camel registry, either manually or by registration as a bean in Spring/Blueprint, as it is `CamelContext` aware.
Sample usage is as follows:
@@ -565,7 +318,6 @@ In XML:
----
== Using manual commit with Kafka consumer
-*Since Camel 2.21*
By default the Kafka consumer will use auto commit, where the offset will be committed automatically in the background using a given interval.
@@ -597,7 +349,6 @@ If you want to use a custom implementation of `KafkaManualCommit` then you can c
on the `KafkaComponent` that creates instances of your custom implementation.
== Kafka Headers propagation
-*Since Camel 2.22*
When consuming messages from Kafka, headers will be propagated to camel exchange headers automatically.
Producing flow backed by same behaviour - camel headers of particular exchange will be propagated to kafka message headers.
@@ -607,20 +358,24 @@ otherwise header will be skipped.
Following header value types are supported: `String`, `Integer`, `Long`, `Double`, `Boolean`, `byte[]`.
Note: all headers propagated *from* kafka *to* camel exchange will contain `byte[]` value by default.
In order to override default functionality uri parameters can be set: `headerDeserializer` for `from` route and `headerSerializer` for `to` route. Example:
-```
+
+[source,java]
+----
from("kafka:my_topic?headerDeserializer=#myDeserializer")
...
.to("kafka:my_topic?headerSerializer=#mySerializer")
-```
+----
By default all headers are being filtered by `KafkaHeaderFilterStrategy`.
Strategy filters out headers which start with `Camel` or `org.apache.camel` prefixes.
Default strategy can be overridden by using `headerFilterStrategy` uri parameter in both `to` and `from` routes:
-```
+
+[source,java]
+----
from("kafka:my_topic?headerFilterStrategy=#myStrategy")
...
.to("kafka:my_topic?headerFilterStrategy=#myStrategy")
-```
+----
`myStrategy` object should be subclass of `HeaderFilterStrategy` and must be placed in the Camel registry, either manually or by registration as a bean in Spring/Blueprint, as it is `CamelContext` aware.
diff --git a/components/camel-kamelet-reify/src/main/docs/kamelet-reify-component.adoc b/components/camel-kamelet-reify/src/main/docs/kamelet-reify-component.adoc
index 28d9cc5..29c7ebb 100644
--- a/components/camel-kamelet-reify/src/main/docs/kamelet-reify-component.adoc
+++ b/components/camel-kamelet-reify/src/main/docs/kamelet-reify-component.adoc
@@ -21,57 +21,10 @@ IMPORTANT: The *camel-kamelet-reify* component is becoming obsolete, as Kamelets
which is the recommended practice to use for building Kamelets that are isolated and independent.
Therefore this component is expected to become deprecated in the near future and removed later.
-== Options
-
-
// component options: START
-The Kamelet Reify component supports 3 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *lazyStartProducer* (producer) | 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 [...]
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-|===
// component options: END
-
-
-
-
// endpoint options: START
-The Kamelet Reify endpoint is configured using URI syntax:
-
-----
-kamelet-reify:delegateUri
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (1 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *delegateUri* | *Required* The delegated uri | | String
-|===
-
-
-=== Query Parameters (4 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *exceptionHandler* (consumer) | 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. | | ExceptionHandler
-| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut | | ExchangePattern
-| *lazyStartProducer* (producer) | 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 [...]
-|===
// endpoint options: END
[NOTE]
diff --git a/components/camel-kamelet/src/main/docs/kamelet-component.adoc b/components/camel-kamelet/src/main/docs/kamelet-component.adoc
index 1f0767e..14cdecd 100644
--- a/components/camel-kamelet/src/main/docs/kamelet-component.adoc
+++ b/components/camel-kamelet/src/main/docs/kamelet-component.adoc
@@ -22,68 +22,10 @@ The Kamelet Component provides support for interacting with the xref:manual::rou
kamelet:templateId/routeId[?options]
----
-== Options
-
-
// component options: START
-The Kamelet component supports 9 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *location* (common) | The location(s) of the Kamelets on the file system. Multiple locations can be set separated by comma. | classpath:/kamelets | String
-| *routeProperties* (common) | Set route local parameters. | | Map
-| *templateProperties* (common) | Set template local parameters. | | Map
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *block* (producer) | If sending a message to a kamelet endpoint which has no active consumer, then we can tell the producer to block and wait for the consumer to become active. | true | boolean
-| *lazyStartProducer* (producer) | 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 [...]
-| *timeout* (producer) | The timeout value to use if block is enabled. | 30000 | long
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-| *routeTemplateLoaderListener* (advanced) | *Autowired* To plugin a custom listener for when the Kamelet component is loading Kamelets from external resources. | | RouteTemplateLoaderListener
-|===
// component options: END
-
-
-
-
// endpoint options: START
-The Kamelet endpoint is configured using URI syntax:
-
-----
-kamelet:templateId/routeId
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (2 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *templateId* | *Required* The Route Template ID | | String
-| *routeId* | The Route ID. Default value notice: The ID will be auto-generated if not provided | | String
-|===
-
-
-=== Query Parameters (8 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *location* (common) | Location of the Kamelet to use which can be specified as a resource from file system, classpath etc. The location cannot use wildcards, and must refer to a file including extension, for example file:/etc/foo-kamelet.xml | | String
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *exceptionHandler* (consumer) | 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. | | ExceptionHandler
-| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut | | ExchangePattern
-| *block* (producer) | If sending a message to a direct endpoint which has no active consumer, then we can tell the producer to block and wait for the consumer to become active. | true | boolean
-| *failIfNoConsumers* (producer) | Whether the producer should fail by throwing an exception, when sending to a kamelet endpoint with no active consumers. | true | boolean
-| *lazyStartProducer* (producer) | 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 [...]
-| *timeout* (producer) | The timeout value to use if block is enabled. | 30000 | long
-|===
// endpoint options: END
[NOTE]
@@ -148,4 +90,4 @@ from("direct:template")
----
-//include::{page-component-version}@camel-spring-boot::page$kamelet-starter.adoc[]
+include::{page-component-version}@camel-spring-boot::page$kamelet-starter.adoc[]
diff --git a/components/camel-kubernetes/src/main/docs/kubernetes-config-maps-component.adoc b/components/camel-kubernetes/src/main/docs/kubernetes-config-maps-component.adoc
index f60a0db..88c9b17 100644
--- a/components/camel-kubernetes/src/main/docs/kubernetes-config-maps-component.adoc
+++ b/components/camel-kubernetes/src/main/docs/kubernetes-config-maps-component.adoc
@@ -18,70 +18,9 @@ The Kubernetes ConfigMap component is one of xref:kubernetes-summary.adoc[Kubern
provides a producer to execute Kubernetes ConfigMap operations and a consumer to consume events related to ConfigMap objects.
-== Component Options
-
// component options: START
-The Kubernetes ConfigMap component supports 2 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *lazyStartProducer* (producer) | 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 [...]
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-|===
// component options: END
-
-
-== Endpoint Options
-
// endpoint options: START
-The Kubernetes ConfigMap endpoint is configured using URI syntax:
-
-----
-kubernetes-config-maps:masterUrl
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (1 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *masterUrl* | *Required* Kubernetes Master url | | String
-|===
-
-
-=== Query Parameters (20 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *apiVersion* (producer) | The Kubernetes API Version to use | | String
-| *dnsDomain* (producer) | The dns domain, used for ServiceCall EIP | | String
-| *kubernetesClient* (producer) | Default KubernetesClient to use if provided | | KubernetesClient
-| *lazyStartProducer* (producer) | 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 [...]
-| *operation* (producer) | Producer operation to do on Kubernetes | | String
-| *portName* (producer) | The port name, used for ServiceCall EIP | | String
-| *portProtocol* (producer) | The port protocol, used for ServiceCall EIP | tcp | String
-| *connectionTimeout* (advanced) | Connection timeout in milliseconds to use when making requests to the Kubernetes API server. | | Integer
-| *caCertData* (security) | The CA Cert Data | | String
-| *caCertFile* (security) | The CA Cert File | | String
-| *clientCertData* (security) | The Client Cert Data | | String
-| *clientCertFile* (security) | The Client Cert File | | String
-| *clientKeyAlgo* (security) | The Key Algorithm used by the client | | String
-| *clientKeyData* (security) | The Client Key data | | String
-| *clientKeyFile* (security) | The Client Key file | | String
-| *clientKeyPassphrase* (security) | The Client Key Passphrase | | String
-| *oauthToken* (security) | The Auth Token | | String
-| *password* (security) | Password to connect to Kubernetes | | String
-| *trustCerts* (security) | Define if the certs we used are trusted anyway or not | | Boolean
-| *username* (security) | Username to connect to Kubernetes | | String
-|===
// endpoint options: END
== Supported producer operation
diff --git a/components/camel-kubernetes/src/main/docs/kubernetes-custom-resources-component.adoc b/components/camel-kubernetes/src/main/docs/kubernetes-custom-resources-component.adoc
index 14da135..ded4e57 100644
--- a/components/camel-kubernetes/src/main/docs/kubernetes-custom-resources-component.adoc
+++ b/components/camel-kubernetes/src/main/docs/kubernetes-custom-resources-component.adoc
@@ -16,89 +16,14 @@ include::{cq-version}@camel-quarkus:ROOT:partial$reference/components/kubernetes
The Kubernetes Custom Resources component is one of xref:kubernetes-summary.adoc[Kubernetes Components] which
provides a producer to execute Kubernetes Custom Resources operations and a consumer to consume events related to Node objects.
-
-== Component Options
-
// component options: START
-The Kubernetes Custom Resources component supports 3 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *lazyStartProducer* (producer) | 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 [...]
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-|===
// component options: END
-
-
-== Endpoint Options
-
// endpoint options: START
-The Kubernetes Custom Resources endpoint is configured using URI syntax:
-
-----
-kubernetes-custom-resources:masterUrl
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (1 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *masterUrl* | *Required* Kubernetes Master url | | String
-|===
-
-
-=== Query Parameters (33 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *apiVersion* (common) | The Kubernetes API Version to use | | String
-| *dnsDomain* (common) | The dns domain, used for ServiceCall EIP | | String
-| *kubernetesClient* (common) | Default KubernetesClient to use if provided | | KubernetesClient
-| *portName* (common) | The port name, used for ServiceCall EIP | | String
-| *portProtocol* (common) | The port protocol, used for ServiceCall EIP | tcp | String
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *crdGroup* (consumer) | The Consumer CRD Resource Group we would like to watch | | String
-| *crdName* (consumer) | The Consumer CRD Resource name we would like to watch | | String
-| *crdPlural* (consumer) | The Consumer CRD Resource Plural we would like to watch | | String
-| *crdScope* (consumer) | The Consumer CRD Resource Scope we would like to watch | | String
-| *crdVersion* (consumer) | The Consumer CRD Resource Version we would like to watch | | String
-| *labelKey* (consumer) | The Consumer Label key when watching at some resources | | String
-| *labelValue* (consumer) | The Consumer Label value when watching at some resources | | String
-| *namespace* (consumer) | The namespace | | String
-| *poolSize* (consumer) | The Consumer pool size | 1 | int
-| *resourceName* (consumer) | The Consumer Resource Name we would like to watch | | String
-| *exceptionHandler* (consumer) | 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. | | ExceptionHandler
-| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut | | ExchangePattern
-| *lazyStartProducer* (producer) | 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 [...]
-| *operation* (producer) | Producer operation to do on Kubernetes | | String
-| *connectionTimeout* (advanced) | Connection timeout in milliseconds to use when making requests to the Kubernetes API server. | | Integer
-| *caCertData* (security) | The CA Cert Data | | String
-| *caCertFile* (security) | The CA Cert File | | String
-| *clientCertData* (security) | The Client Cert Data | | String
-| *clientCertFile* (security) | The Client Cert File | | String
-| *clientKeyAlgo* (security) | The Key Algorithm used by the client | | String
-| *clientKeyData* (security) | The Client Key data | | String
-| *clientKeyFile* (security) | The Client Key file | | String
-| *clientKeyPassphrase* (security) | The Client Key Passphrase | | String
-| *oauthToken* (security) | The Auth Token | | String
-| *password* (security) | Password to connect to Kubernetes | | String
-| *trustCerts* (security) | Define if the certs we used are trusted anyway or not | | Boolean
-| *username* (security) | Username to connect to Kubernetes | | String
-|===
// endpoint options: END
+
== Supported producer operation
- listCustomResources
diff --git a/components/camel-kubernetes/src/main/docs/kubernetes-deployments-component.adoc b/components/camel-kubernetes/src/main/docs/kubernetes-deployments-component.adoc
index 80206ae..8b09ec6 100644
--- a/components/camel-kubernetes/src/main/docs/kubernetes-deployments-component.adoc
+++ b/components/camel-kubernetes/src/main/docs/kubernetes-deployments-component.adoc
@@ -17,88 +17,12 @@ include::{cq-version}@camel-quarkus:ROOT:partial$reference/components/kubernetes
The Kubernetes Deployments component is one of xref:kubernetes-summary.adoc[Kubernetes Components] which
provides a producer to execute Kubernetes Deployments operations and a consumer to consume events related to Deployments objects.
-
-
-== Component Options
-
// component options: START
-The Kubernetes Deployments component supports 3 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *lazyStartProducer* (producer) | 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 [...]
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-|===
// component options: END
-
-
-== Endpoint Options
-
// endpoint options: START
-The Kubernetes Deployments endpoint is configured using URI syntax:
-
-----
-kubernetes-deployments:masterUrl
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (1 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *masterUrl* | *Required* Kubernetes Master url | | String
-|===
-
-
-=== Query Parameters (33 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *apiVersion* (common) | The Kubernetes API Version to use | | String
-| *dnsDomain* (common) | The dns domain, used for ServiceCall EIP | | String
-| *kubernetesClient* (common) | Default KubernetesClient to use if provided | | KubernetesClient
-| *portName* (common) | The port name, used for ServiceCall EIP | | String
-| *portProtocol* (common) | The port protocol, used for ServiceCall EIP | tcp | String
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *crdGroup* (consumer) | The Consumer CRD Resource Group we would like to watch | | String
-| *crdName* (consumer) | The Consumer CRD Resource name we would like to watch | | String
-| *crdPlural* (consumer) | The Consumer CRD Resource Plural we would like to watch | | String
-| *crdScope* (consumer) | The Consumer CRD Resource Scope we would like to watch | | String
-| *crdVersion* (consumer) | The Consumer CRD Resource Version we would like to watch | | String
-| *labelKey* (consumer) | The Consumer Label key when watching at some resources | | String
-| *labelValue* (consumer) | The Consumer Label value when watching at some resources | | String
-| *namespace* (consumer) | The namespace | | String
-| *poolSize* (consumer) | The Consumer pool size | 1 | int
-| *resourceName* (consumer) | The Consumer Resource Name we would like to watch | | String
-| *exceptionHandler* (consumer) | 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. | | ExceptionHandler
-| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut | | ExchangePattern
-| *lazyStartProducer* (producer) | 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 [...]
-| *operation* (producer) | Producer operation to do on Kubernetes | | String
-| *connectionTimeout* (advanced) | Connection timeout in milliseconds to use when making requests to the Kubernetes API server. | | Integer
-| *caCertData* (security) | The CA Cert Data | | String
-| *caCertFile* (security) | The CA Cert File | | String
-| *clientCertData* (security) | The Client Cert Data | | String
-| *clientCertFile* (security) | The Client Cert File | | String
-| *clientKeyAlgo* (security) | The Key Algorithm used by the client | | String
-| *clientKeyData* (security) | The Client Key data | | String
-| *clientKeyFile* (security) | The Client Key file | | String
-| *clientKeyPassphrase* (security) | The Client Key Passphrase | | String
-| *oauthToken* (security) | The Auth Token | | String
-| *password* (security) | Password to connect to Kubernetes | | String
-| *trustCerts* (security) | Define if the certs we used are trusted anyway or not | | Boolean
-| *username* (security) | Username to connect to Kubernetes | | String
-|===
// endpoint options: END
+
== Supported producer operation
- listDeployments
@@ -126,7 +50,6 @@ This operation return a List of Deployment from your cluster
[source,java]
--------------------------------------------------------------------------------
from("direct:listByLabels").process(new Processor() {
-
@Override
public void process(Exchange exchange) throws Exception {
Map<String, String> labels = new HashMap<>();
@@ -146,7 +69,6 @@ This operation return a List of Deployments from your cluster, using a label sel
[source,java]
--------------------------------------------------------------------------------
fromF("kubernetes-deployments://%s?oauthToken=%s&namespace=default&resourceName=test", host, authToken).process(new KubernertesProcessor()).to("mock:result");
-
public class KubernertesProcessor implements Processor {
@Override
public void process(Exchange exchange) throws Exception {
diff --git a/components/camel-kubernetes/src/main/docs/kubernetes-hpa-component.adoc b/components/camel-kubernetes/src/main/docs/kubernetes-hpa-component.adoc
index 5c85978..7cacd77 100644
--- a/components/camel-kubernetes/src/main/docs/kubernetes-hpa-component.adoc
+++ b/components/camel-kubernetes/src/main/docs/kubernetes-hpa-component.adoc
@@ -16,89 +16,13 @@ include::{cq-version}@camel-quarkus:ROOT:partial$reference/components/kubernetes
The Kubernetes HPA component is one of xref:kubernetes-summary.adoc[Kubernetes Components] which
provides a producer to execute kubernetes Horizontal Pod Autoscaler operations and a consumer to consume events related to Horizontal Pod Autoscaler objects.
-
-
-
-== Component Options
// component options: START
-The Kubernetes HPA component supports 3 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *lazyStartProducer* (producer) | 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 [...]
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-|===
// component options: END
-
-
-== Endpoint Options
-
// endpoint options: START
-The Kubernetes HPA endpoint is configured using URI syntax:
-
-----
-kubernetes-hpa:masterUrl
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (1 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *masterUrl* | *Required* Kubernetes Master url | | String
-|===
-
-
-=== Query Parameters (33 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *apiVersion* (common) | The Kubernetes API Version to use | | String
-| *dnsDomain* (common) | The dns domain, used for ServiceCall EIP | | String
-| *kubernetesClient* (common) | Default KubernetesClient to use if provided | | KubernetesClient
-| *portName* (common) | The port name, used for ServiceCall EIP | | String
-| *portProtocol* (common) | The port protocol, used for ServiceCall EIP | tcp | String
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *crdGroup* (consumer) | The Consumer CRD Resource Group we would like to watch | | String
-| *crdName* (consumer) | The Consumer CRD Resource name we would like to watch | | String
-| *crdPlural* (consumer) | The Consumer CRD Resource Plural we would like to watch | | String
-| *crdScope* (consumer) | The Consumer CRD Resource Scope we would like to watch | | String
-| *crdVersion* (consumer) | The Consumer CRD Resource Version we would like to watch | | String
-| *labelKey* (consumer) | The Consumer Label key when watching at some resources | | String
-| *labelValue* (consumer) | The Consumer Label value when watching at some resources | | String
-| *namespace* (consumer) | The namespace | | String
-| *poolSize* (consumer) | The Consumer pool size | 1 | int
-| *resourceName* (consumer) | The Consumer Resource Name we would like to watch | | String
-| *exceptionHandler* (consumer) | 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. | | ExceptionHandler
-| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut | | ExchangePattern
-| *lazyStartProducer* (producer) | 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 [...]
-| *operation* (producer) | Producer operation to do on Kubernetes | | String
-| *connectionTimeout* (advanced) | Connection timeout in milliseconds to use when making requests to the Kubernetes API server. | | Integer
-| *caCertData* (security) | The CA Cert Data | | String
-| *caCertFile* (security) | The CA Cert File | | String
-| *clientCertData* (security) | The Client Cert Data | | String
-| *clientCertFile* (security) | The Client Cert File | | String
-| *clientKeyAlgo* (security) | The Key Algorithm used by the client | | String
-| *clientKeyData* (security) | The Client Key data | | String
-| *clientKeyFile* (security) | The Client Key file | | String
-| *clientKeyPassphrase* (security) | The Client Key Passphrase | | String
-| *oauthToken* (security) | The Auth Token | | String
-| *password* (security) | Password to connect to Kubernetes | | String
-| *trustCerts* (security) | Define if the certs we used are trusted anyway or not | | Boolean
-| *username* (security) | Username to connect to Kubernetes | | String
-|===
// endpoint options: END
+
== Supported producer operation
- listHPA
@@ -125,7 +49,6 @@ This operation return a List of HPAs from your cluster
[source,java]
--------------------------------------------------------------------------------
from("direct:listByLabels").process(new Processor() {
-
@Override
public void process(Exchange exchange) throws Exception {
Map<String, String> labels = new HashMap<>();
@@ -145,7 +68,6 @@ This operation return a List of HPAs from your cluster, using a label selector (
[source,java]
--------------------------------------------------------------------------------
fromF("kubernetes-hpa://%s?oauthToken=%s&namespace=default&resourceName=test", host, authToken).process(new KubernertesProcessor()).to("mock:result");
-
public class KubernertesProcessor implements Processor {
@Override
public void process(Exchange exchange) throws Exception {
diff --git a/components/camel-kubernetes/src/main/docs/kubernetes-job-component.adoc b/components/camel-kubernetes/src/main/docs/kubernetes-job-component.adoc
index dc52e6b..f7bad70 100644
--- a/components/camel-kubernetes/src/main/docs/kubernetes-job-component.adoc
+++ b/components/camel-kubernetes/src/main/docs/kubernetes-job-component.adoc
@@ -16,89 +16,14 @@ include::{cq-version}@camel-quarkus:ROOT:partial$reference/components/kubernetes
The Kubernetes Job component is one of xref:kubernetes-summary.adoc[Kubernetes Components] which
provides a producer to execute kubernetes Job operations and a consumer to consume events related to Job objects.
-
-== Component Options
-
// component options: START
-The Kubernetes Job component supports 3 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *lazyStartProducer* (producer) | 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 [...]
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-|===
// component options: END
-
-
-== Endpoint Options
-
// endpoint options: START
-The Kubernetes Job endpoint is configured using URI syntax:
-
-----
-kubernetes-job:masterUrl
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (1 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *masterUrl* | *Required* Kubernetes Master url | | String
-|===
-
-
-=== Query Parameters (33 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *apiVersion* (common) | The Kubernetes API Version to use | | String
-| *dnsDomain* (common) | The dns domain, used for ServiceCall EIP | | String
-| *kubernetesClient* (common) | Default KubernetesClient to use if provided | | KubernetesClient
-| *portName* (common) | The port name, used for ServiceCall EIP | | String
-| *portProtocol* (common) | The port protocol, used for ServiceCall EIP | tcp | String
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *crdGroup* (consumer) | The Consumer CRD Resource Group we would like to watch | | String
-| *crdName* (consumer) | The Consumer CRD Resource name we would like to watch | | String
-| *crdPlural* (consumer) | The Consumer CRD Resource Plural we would like to watch | | String
-| *crdScope* (consumer) | The Consumer CRD Resource Scope we would like to watch | | String
-| *crdVersion* (consumer) | The Consumer CRD Resource Version we would like to watch | | String
-| *labelKey* (consumer) | The Consumer Label key when watching at some resources | | String
-| *labelValue* (consumer) | The Consumer Label value when watching at some resources | | String
-| *namespace* (consumer) | The namespace | | String
-| *poolSize* (consumer) | The Consumer pool size | 1 | int
-| *resourceName* (consumer) | The Consumer Resource Name we would like to watch | | String
-| *exceptionHandler* (consumer) | 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. | | ExceptionHandler
-| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut | | ExchangePattern
-| *lazyStartProducer* (producer) | 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 [...]
-| *operation* (producer) | Producer operation to do on Kubernetes | | String
-| *connectionTimeout* (advanced) | Connection timeout in milliseconds to use when making requests to the Kubernetes API server. | | Integer
-| *caCertData* (security) | The CA Cert Data | | String
-| *caCertFile* (security) | The CA Cert File | | String
-| *clientCertData* (security) | The Client Cert Data | | String
-| *clientCertFile* (security) | The Client Cert File | | String
-| *clientKeyAlgo* (security) | The Key Algorithm used by the client | | String
-| *clientKeyData* (security) | The Client Key data | | String
-| *clientKeyFile* (security) | The Client Key file | | String
-| *clientKeyPassphrase* (security) | The Client Key Passphrase | | String
-| *oauthToken* (security) | The Auth Token | | String
-| *password* (security) | Password to connect to Kubernetes | | String
-| *trustCerts* (security) | Define if the certs we used are trusted anyway or not | | Boolean
-| *username* (security) | Username to connect to Kubernetes | | String
-|===
// endpoint options: END
+
== Supported producer operation
- listJob
@@ -125,7 +50,6 @@ This operation return a List of Job from your cluster
[source,java]
--------------------------------------------------------------------------------
from("direct:listByLabels").process(new Processor() {
-
@Override
public void process(Exchange exchange) throws Exception {
Map<String, String> labels = new HashMap<>();
@@ -166,9 +90,6 @@ import io.fabric8.kubernetes.api.model.PodSpec;
import io.fabric8.kubernetes.api.model.PodTemplateSpec;
import io.fabric8.kubernetes.api.model.batch.JobSpec;
-/**
- *
- */
public class KubernetesCreateJob extends RouteBuilder {
@Inject
@@ -205,10 +126,6 @@ public class KubernetesCreateJob extends RouteBuilder {
.to(resultEndpoint);
}
- /**
- * Create a new JobSpec
- * @return
- */
private JobSpec generateJobSpec() {
JobSpec js = new JobSpec();
@@ -247,7 +164,6 @@ public class KubernetesCreateJob extends RouteBuilder {
containers.add(container);
return containers;
}
-
}
--------------------------------------------------------------------------------
diff --git a/components/camel-kubernetes/src/main/docs/kubernetes-namespaces-component.adoc b/components/camel-kubernetes/src/main/docs/kubernetes-namespaces-component.adoc
index 774b557..25909a6 100644
--- a/components/camel-kubernetes/src/main/docs/kubernetes-namespaces-component.adoc
+++ b/components/camel-kubernetes/src/main/docs/kubernetes-namespaces-component.adoc
@@ -18,87 +18,12 @@ The Kubernetes Namespaces component is one of xref:kubernetes-summary.adoc[Kuber
provides a producer to execute Kubernetes Namespace operations and a consumer to consume events related to Namespace events.
-
-== Component Options
-
// component options: START
-The Kubernetes Namespaces component supports 3 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *lazyStartProducer* (producer) | 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 [...]
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-|===
// component options: END
-
-
-== Endpoint Options
-
// endpoint options: START
-The Kubernetes Namespaces endpoint is configured using URI syntax:
-
-----
-kubernetes-namespaces:masterUrl
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (1 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *masterUrl* | *Required* Kubernetes Master url | | String
-|===
-
-
-=== Query Parameters (33 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *apiVersion* (common) | The Kubernetes API Version to use | | String
-| *dnsDomain* (common) | The dns domain, used for ServiceCall EIP | | String
-| *kubernetesClient* (common) | Default KubernetesClient to use if provided | | KubernetesClient
-| *portName* (common) | The port name, used for ServiceCall EIP | | String
-| *portProtocol* (common) | The port protocol, used for ServiceCall EIP | tcp | String
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *crdGroup* (consumer) | The Consumer CRD Resource Group we would like to watch | | String
-| *crdName* (consumer) | The Consumer CRD Resource name we would like to watch | | String
-| *crdPlural* (consumer) | The Consumer CRD Resource Plural we would like to watch | | String
-| *crdScope* (consumer) | The Consumer CRD Resource Scope we would like to watch | | String
-| *crdVersion* (consumer) | The Consumer CRD Resource Version we would like to watch | | String
-| *labelKey* (consumer) | The Consumer Label key when watching at some resources | | String
-| *labelValue* (consumer) | The Consumer Label value when watching at some resources | | String
-| *namespace* (consumer) | The namespace | | String
-| *poolSize* (consumer) | The Consumer pool size | 1 | int
-| *resourceName* (consumer) | The Consumer Resource Name we would like to watch | | String
-| *exceptionHandler* (consumer) | 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. | | ExceptionHandler
-| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut | | ExchangePattern
-| *lazyStartProducer* (producer) | 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 [...]
-| *operation* (producer) | Producer operation to do on Kubernetes | | String
-| *connectionTimeout* (advanced) | Connection timeout in milliseconds to use when making requests to the Kubernetes API server. | | Integer
-| *caCertData* (security) | The CA Cert Data | | String
-| *caCertFile* (security) | The CA Cert File | | String
-| *clientCertData* (security) | The Client Cert Data | | String
-| *clientCertFile* (security) | The Client Cert File | | String
-| *clientKeyAlgo* (security) | The Key Algorithm used by the client | | String
-| *clientKeyData* (security) | The Client Key data | | String
-| *clientKeyFile* (security) | The Client Key file | | String
-| *clientKeyPassphrase* (security) | The Client Key Passphrase | | String
-| *oauthToken* (security) | The Auth Token | | String
-| *password* (security) | Password to connect to Kubernetes | | String
-| *trustCerts* (security) | Define if the certs we used are trusted anyway or not | | Boolean
-| *username* (security) | Username to connect to Kubernetes | | String
-|===
// endpoint options: END
+
== Supported producer operation
- listNamespaces
@@ -125,7 +50,6 @@ This operation return a List of namespaces from your cluster
[source,java]
--------------------------------------------------------------------------------
from("direct:listByLabels").process(new Processor() {
-
@Override
public void process(Exchange exchange) throws Exception {
Map<String, String> labels = new HashMap<>();
@@ -145,7 +69,6 @@ This operation return a List of Namespaces from your cluster, using a label sele
[source,java]
--------------------------------------------------------------------------------
fromF("kubernetes-namespaces://%s?oauthToken=%s&namespace=default", host, authToken).process(new KubernertesProcessor()).to("mock:result");
-
public class KubernertesProcessor implements Processor {
@Override
public void process(Exchange exchange) throws Exception {
@@ -158,6 +81,4 @@ fromF("kubernetes-namespaces://%s?oauthToken=%s&namespace=default", host, authTo
This consumer will return a list of events on the namespace default.
-
-
include::{page-component-version}@camel-spring-boot::page$kubernetes-starter.adoc[]
diff --git a/components/camel-kubernetes/src/main/docs/kubernetes-nodes-component.adoc b/components/camel-kubernetes/src/main/docs/kubernetes-nodes-component.adoc
index cff796d..5cd539b 100644
--- a/components/camel-kubernetes/src/main/docs/kubernetes-nodes-component.adoc
+++ b/components/camel-kubernetes/src/main/docs/kubernetes-nodes-component.adoc
@@ -16,89 +16,14 @@ include::{cq-version}@camel-quarkus:ROOT:partial$reference/components/kubernetes
The Kubernetes Nodes component is one of xref:kubernetes-summary.adoc[Kubernetes Components] which
provides a producer to execute Kubernetes Node operations and a consumer to consume events related to Node objects.
-
-== Component Options
-
// component options: START
-The Kubernetes Nodes component supports 3 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *lazyStartProducer* (producer) | 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 [...]
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-|===
// component options: END
-
-
-== Endpoint Options
-
// endpoint options: START
-The Kubernetes Nodes endpoint is configured using URI syntax:
-
-----
-kubernetes-nodes:masterUrl
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (1 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *masterUrl* | *Required* Kubernetes Master url | | String
-|===
-
-
-=== Query Parameters (33 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *apiVersion* (common) | The Kubernetes API Version to use | | String
-| *dnsDomain* (common) | The dns domain, used for ServiceCall EIP | | String
-| *kubernetesClient* (common) | Default KubernetesClient to use if provided | | KubernetesClient
-| *portName* (common) | The port name, used for ServiceCall EIP | | String
-| *portProtocol* (common) | The port protocol, used for ServiceCall EIP | tcp | String
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *crdGroup* (consumer) | The Consumer CRD Resource Group we would like to watch | | String
-| *crdName* (consumer) | The Consumer CRD Resource name we would like to watch | | String
-| *crdPlural* (consumer) | The Consumer CRD Resource Plural we would like to watch | | String
-| *crdScope* (consumer) | The Consumer CRD Resource Scope we would like to watch | | String
-| *crdVersion* (consumer) | The Consumer CRD Resource Version we would like to watch | | String
-| *labelKey* (consumer) | The Consumer Label key when watching at some resources | | String
-| *labelValue* (consumer) | The Consumer Label value when watching at some resources | | String
-| *namespace* (consumer) | The namespace | | String
-| *poolSize* (consumer) | The Consumer pool size | 1 | int
-| *resourceName* (consumer) | The Consumer Resource Name we would like to watch | | String
-| *exceptionHandler* (consumer) | 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. | | ExceptionHandler
-| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut | | ExchangePattern
-| *lazyStartProducer* (producer) | 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 [...]
-| *operation* (producer) | Producer operation to do on Kubernetes | | String
-| *connectionTimeout* (advanced) | Connection timeout in milliseconds to use when making requests to the Kubernetes API server. | | Integer
-| *caCertData* (security) | The CA Cert Data | | String
-| *caCertFile* (security) | The CA Cert File | | String
-| *clientCertData* (security) | The Client Cert Data | | String
-| *clientCertFile* (security) | The Client Cert File | | String
-| *clientKeyAlgo* (security) | The Key Algorithm used by the client | | String
-| *clientKeyData* (security) | The Client Key data | | String
-| *clientKeyFile* (security) | The Client Key file | | String
-| *clientKeyPassphrase* (security) | The Client Key Passphrase | | String
-| *oauthToken* (security) | The Auth Token | | String
-| *password* (security) | Password to connect to Kubernetes | | String
-| *trustCerts* (security) | Define if the certs we used are trusted anyway or not | | Boolean
-| *username* (security) | Username to connect to Kubernetes | | String
-|===
// endpoint options: END
+
== Supported producer operation
- listNodes
@@ -126,7 +51,6 @@ This operation return a List of Nodes from your cluster
[source,java]
--------------------------------------------------------------------------------
from("direct:listByLabels").process(new Processor() {
-
@Override
public void process(Exchange exchange) throws Exception {
Map<String, String> labels = new HashMap<>();
@@ -146,7 +70,6 @@ This operation return a List of Nodes from your cluster, using a label selector
[source,java]
--------------------------------------------------------------------------------
fromF("kubernetes-nodes://%s?oauthToken=%s&resourceName=test", host, authToken).process(new KubernertesProcessor()).to("mock:result");
-
public class KubernertesProcessor implements Processor {
@Override
public void process(Exchange exchange) throws Exception {
diff --git a/components/camel-kubernetes/src/main/docs/kubernetes-persistent-volumes-claims-component.adoc b/components/camel-kubernetes/src/main/docs/kubernetes-persistent-volumes-claims-component.adoc
index 8fc3d0c..098ab8e 100644
--- a/components/camel-kubernetes/src/main/docs/kubernetes-persistent-volumes-claims-component.adoc
+++ b/components/camel-kubernetes/src/main/docs/kubernetes-persistent-volumes-claims-component.adoc
@@ -16,75 +16,14 @@ include::{cq-version}@camel-quarkus:ROOT:partial$reference/components/kubernetes
The Kubernetes Persistent Volume Claim component is one of xref:kubernetes-summary.adoc[Kubernetes Components] which
provides a producer to execute Kubernetes Persistent Volume Claims operations.
-
-== Component Options
-
// component options: START
-The Kubernetes Persistent Volume Claim component supports 2 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *lazyStartProducer* (producer) | 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 [...]
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-|===
// component options: END
-
-
-== Endpoint Options
-
// endpoint options: START
-The Kubernetes Persistent Volume Claim endpoint is configured using URI syntax:
-
-----
-kubernetes-persistent-volumes-claims:masterUrl
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (1 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *masterUrl* | *Required* Kubernetes Master url | | String
-|===
-
-
-=== Query Parameters (20 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *apiVersion* (producer) | The Kubernetes API Version to use | | String
-| *dnsDomain* (producer) | The dns domain, used for ServiceCall EIP | | String
-| *kubernetesClient* (producer) | Default KubernetesClient to use if provided | | KubernetesClient
-| *lazyStartProducer* (producer) | 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 [...]
-| *operation* (producer) | Producer operation to do on Kubernetes | | String
-| *portName* (producer) | The port name, used for ServiceCall EIP | | String
-| *portProtocol* (producer) | The port protocol, used for ServiceCall EIP | tcp | String
-| *connectionTimeout* (advanced) | Connection timeout in milliseconds to use when making requests to the Kubernetes API server. | | Integer
-| *caCertData* (security) | The CA Cert Data | | String
-| *caCertFile* (security) | The CA Cert File | | String
-| *clientCertData* (security) | The Client Cert Data | | String
-| *clientCertFile* (security) | The Client Cert File | | String
-| *clientKeyAlgo* (security) | The Key Algorithm used by the client | | String
-| *clientKeyData* (security) | The Client Key data | | String
-| *clientKeyFile* (security) | The Client Key file | | String
-| *clientKeyPassphrase* (security) | The Client Key Passphrase | | String
-| *oauthToken* (security) | The Auth Token | | String
-| *password* (security) | Password to connect to Kubernetes | | String
-| *trustCerts* (security) | Define if the certs we used are trusted anyway or not | | Boolean
-| *username* (security) | Username to connect to Kubernetes | | String
-|===
// endpoint options: END
+
== Supported producer operation
- listPersistentVolumesClaims
@@ -111,7 +50,6 @@ This operation return a List of pvc from your cluster
[source,java]
--------------------------------------------------------------------------------
from("direct:listByLabels").process(new Processor() {
-
@Override
public void process(Exchange exchange) throws Exception {
Map<String, String> labels = new HashMap<>();
diff --git a/components/camel-kubernetes/src/main/docs/kubernetes-persistent-volumes-component.adoc b/components/camel-kubernetes/src/main/docs/kubernetes-persistent-volumes-component.adoc
index 1a42298..d223885 100644
--- a/components/camel-kubernetes/src/main/docs/kubernetes-persistent-volumes-component.adoc
+++ b/components/camel-kubernetes/src/main/docs/kubernetes-persistent-volumes-component.adoc
@@ -18,73 +18,12 @@ The Kubernetes Persistent Volume component is one of xref:kubernetes-summary.ado
provides a producer to execute Kubernetes Persistent Volume operations.
-
-== Component Options
-
// component options: START
-The Kubernetes Persistent Volume component supports 2 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *lazyStartProducer* (producer) | 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 [...]
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-|===
// component options: END
-
-
-== Endpoint Options
-
// endpoint options: START
-The Kubernetes Persistent Volume endpoint is configured using URI syntax:
-
-----
-kubernetes-persistent-volumes:masterUrl
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (1 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *masterUrl* | *Required* Kubernetes Master url | | String
-|===
-
-
-=== Query Parameters (20 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *apiVersion* (producer) | The Kubernetes API Version to use | | String
-| *dnsDomain* (producer) | The dns domain, used for ServiceCall EIP | | String
-| *kubernetesClient* (producer) | Default KubernetesClient to use if provided | | KubernetesClient
-| *lazyStartProducer* (producer) | 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 [...]
-| *operation* (producer) | Producer operation to do on Kubernetes | | String
-| *portName* (producer) | The port name, used for ServiceCall EIP | | String
-| *portProtocol* (producer) | The port protocol, used for ServiceCall EIP | tcp | String
-| *connectionTimeout* (advanced) | Connection timeout in milliseconds to use when making requests to the Kubernetes API server. | | Integer
-| *caCertData* (security) | The CA Cert Data | | String
-| *caCertFile* (security) | The CA Cert File | | String
-| *clientCertData* (security) | The Client Cert Data | | String
-| *clientCertFile* (security) | The Client Cert File | | String
-| *clientKeyAlgo* (security) | The Key Algorithm used by the client | | String
-| *clientKeyData* (security) | The Client Key data | | String
-| *clientKeyFile* (security) | The Client Key file | | String
-| *clientKeyPassphrase* (security) | The Client Key Passphrase | | String
-| *oauthToken* (security) | The Auth Token | | String
-| *password* (security) | Password to connect to Kubernetes | | String
-| *trustCerts* (security) | Define if the certs we used are trusted anyway or not | | Boolean
-| *username* (security) | Username to connect to Kubernetes | | String
-|===
// endpoint options: END
+
== Supported producer operation
- listPersistentVolumes
@@ -109,7 +48,6 @@ This operation return a List of pv from your cluster
[source,java]
--------------------------------------------------------------------------------
from("direct:listByLabels").process(new Processor() {
-
@Override
public void process(Exchange exchange) throws Exception {
Map<String, String> labels = new HashMap<>();
diff --git a/components/camel-kubernetes/src/main/docs/kubernetes-pods-component.adoc b/components/camel-kubernetes/src/main/docs/kubernetes-pods-component.adoc
index af2c7d3..f1f3388 100644
--- a/components/camel-kubernetes/src/main/docs/kubernetes-pods-component.adoc
+++ b/components/camel-kubernetes/src/main/docs/kubernetes-pods-component.adoc
@@ -18,87 +18,12 @@ The Kubernetes Pods component is one of xref:kubernetes-summary.adoc[Kubernetes
provides a producer to execute Kubernetes Pods operations and a consumer to consume events related to Pod Objects.
-
-== Component Options
-
// component options: START
-The Kubernetes Pods component supports 3 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *lazyStartProducer* (producer) | 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 [...]
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-|===
// component options: END
-
-
-== Endpoint Options
-
// endpoint options: START
-The Kubernetes Pods endpoint is configured using URI syntax:
-
-----
-kubernetes-pods:masterUrl
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (1 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *masterUrl* | *Required* Kubernetes Master url | | String
-|===
-
-
-=== Query Parameters (33 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *apiVersion* (common) | The Kubernetes API Version to use | | String
-| *dnsDomain* (common) | The dns domain, used for ServiceCall EIP | | String
-| *kubernetesClient* (common) | Default KubernetesClient to use if provided | | KubernetesClient
-| *portName* (common) | The port name, used for ServiceCall EIP | | String
-| *portProtocol* (common) | The port protocol, used for ServiceCall EIP | tcp | String
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *crdGroup* (consumer) | The Consumer CRD Resource Group we would like to watch | | String
-| *crdName* (consumer) | The Consumer CRD Resource name we would like to watch | | String
-| *crdPlural* (consumer) | The Consumer CRD Resource Plural we would like to watch | | String
-| *crdScope* (consumer) | The Consumer CRD Resource Scope we would like to watch | | String
-| *crdVersion* (consumer) | The Consumer CRD Resource Version we would like to watch | | String
-| *labelKey* (consumer) | The Consumer Label key when watching at some resources | | String
-| *labelValue* (consumer) | The Consumer Label value when watching at some resources | | String
-| *namespace* (consumer) | The namespace | | String
-| *poolSize* (consumer) | The Consumer pool size | 1 | int
-| *resourceName* (consumer) | The Consumer Resource Name we would like to watch | | String
-| *exceptionHandler* (consumer) | 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. | | ExceptionHandler
-| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut | | ExchangePattern
-| *lazyStartProducer* (producer) | 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 [...]
-| *operation* (producer) | Producer operation to do on Kubernetes | | String
-| *connectionTimeout* (advanced) | Connection timeout in milliseconds to use when making requests to the Kubernetes API server. | | Integer
-| *caCertData* (security) | The CA Cert Data | | String
-| *caCertFile* (security) | The CA Cert File | | String
-| *clientCertData* (security) | The Client Cert Data | | String
-| *clientCertFile* (security) | The Client Cert File | | String
-| *clientKeyAlgo* (security) | The Key Algorithm used by the client | | String
-| *clientKeyData* (security) | The Client Key data | | String
-| *clientKeyFile* (security) | The Client Key file | | String
-| *clientKeyPassphrase* (security) | The Client Key Passphrase | | String
-| *oauthToken* (security) | The Auth Token | | String
-| *password* (security) | Password to connect to Kubernetes | | String
-| *trustCerts* (security) | Define if the certs we used are trusted anyway or not | | Boolean
-| *username* (security) | Username to connect to Kubernetes | | String
-|===
// endpoint options: END
+
== Supported producer operation
- listPods
@@ -125,7 +50,6 @@ This operation return a List of Pods from your cluster
[source,java]
--------------------------------------------------------------------------------
from("direct:listByLabels").process(new Processor() {
-
@Override
public void process(Exchange exchange) throws Exception {
Map<String, String> labels = new HashMap<>();
@@ -145,7 +69,6 @@ This operation return a List of Pods from your cluster, using a label selector (
[source,java]
--------------------------------------------------------------------------------
fromF("kubernetes-pods://%s?oauthToken=%s&namespace=default&resourceName=test", host, authToken).process(new KubernertesProcessor()).to("mock:result");
-
public class KubernertesProcessor implements Processor {
@Override
public void process(Exchange exchange) throws Exception {
diff --git a/components/camel-kubernetes/src/main/docs/kubernetes-replication-controllers-component.adoc b/components/camel-kubernetes/src/main/docs/kubernetes-replication-controllers-component.adoc
index a94f5e9..d0fd34c 100644
--- a/components/camel-kubernetes/src/main/docs/kubernetes-replication-controllers-component.adoc
+++ b/components/camel-kubernetes/src/main/docs/kubernetes-replication-controllers-component.adoc
@@ -19,87 +19,12 @@ provides a producer to execute Kubernetes Replication controller operations and
consume events related to Replication Controller objects.
-
-== Component Options
-
// component options: START
-The Kubernetes Replication Controller component supports 3 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *lazyStartProducer* (producer) | 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 [...]
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-|===
// component options: END
-
-
-== Endpoint Options
-
// endpoint options: START
-The Kubernetes Replication Controller endpoint is configured using URI syntax:
-
-----
-kubernetes-replication-controllers:masterUrl
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (1 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *masterUrl* | *Required* Kubernetes Master url | | String
-|===
-
-
-=== Query Parameters (33 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *apiVersion* (common) | The Kubernetes API Version to use | | String
-| *dnsDomain* (common) | The dns domain, used for ServiceCall EIP | | String
-| *kubernetesClient* (common) | Default KubernetesClient to use if provided | | KubernetesClient
-| *portName* (common) | The port name, used for ServiceCall EIP | | String
-| *portProtocol* (common) | The port protocol, used for ServiceCall EIP | tcp | String
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *crdGroup* (consumer) | The Consumer CRD Resource Group we would like to watch | | String
-| *crdName* (consumer) | The Consumer CRD Resource name we would like to watch | | String
-| *crdPlural* (consumer) | The Consumer CRD Resource Plural we would like to watch | | String
-| *crdScope* (consumer) | The Consumer CRD Resource Scope we would like to watch | | String
-| *crdVersion* (consumer) | The Consumer CRD Resource Version we would like to watch | | String
-| *labelKey* (consumer) | The Consumer Label key when watching at some resources | | String
-| *labelValue* (consumer) | The Consumer Label value when watching at some resources | | String
-| *namespace* (consumer) | The namespace | | String
-| *poolSize* (consumer) | The Consumer pool size | 1 | int
-| *resourceName* (consumer) | The Consumer Resource Name we would like to watch | | String
-| *exceptionHandler* (consumer) | 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. | | ExceptionHandler
-| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut | | ExchangePattern
-| *lazyStartProducer* (producer) | 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 [...]
-| *operation* (producer) | Producer operation to do on Kubernetes | | String
-| *connectionTimeout* (advanced) | Connection timeout in milliseconds to use when making requests to the Kubernetes API server. | | Integer
-| *caCertData* (security) | The CA Cert Data | | String
-| *caCertFile* (security) | The CA Cert File | | String
-| *clientCertData* (security) | The Client Cert Data | | String
-| *clientCertFile* (security) | The Client Cert File | | String
-| *clientKeyAlgo* (security) | The Key Algorithm used by the client | | String
-| *clientKeyData* (security) | The Client Key data | | String
-| *clientKeyFile* (security) | The Client Key file | | String
-| *clientKeyPassphrase* (security) | The Client Key Passphrase | | String
-| *oauthToken* (security) | The Auth Token | | String
-| *password* (security) | Password to connect to Kubernetes | | String
-| *trustCerts* (security) | Define if the certs we used are trusted anyway or not | | Boolean
-| *username* (security) | Username to connect to Kubernetes | | String
-|===
// endpoint options: END
+
== Supported producer operation
- listReplicationControllers
@@ -127,7 +52,6 @@ This operation return a List of RCs from your cluster
[source,java]
--------------------------------------------------------------------------------
from("direct:listByLabels").process(new Processor() {
-
@Override
public void process(Exchange exchange) throws Exception {
Map<String, String> labels = new HashMap<>();
@@ -147,7 +71,6 @@ This operation return a List of RCs from your cluster, using a label selector (w
[source,java]
--------------------------------------------------------------------------------
fromF("kubernetes-replication-controllers://%s?oauthToken=%s&namespace=default&resourceName=test", host, authToken).process(new KubernertesProcessor()).to("mock:result");
-
public class KubernertesProcessor implements Processor {
@Override
public void process(Exchange exchange) throws Exception {
diff --git a/components/camel-kubernetes/src/main/docs/kubernetes-resources-quota-component.adoc b/components/camel-kubernetes/src/main/docs/kubernetes-resources-quota-component.adoc
index 4d967b5..f4cd8e84 100644
--- a/components/camel-kubernetes/src/main/docs/kubernetes-resources-quota-component.adoc
+++ b/components/camel-kubernetes/src/main/docs/kubernetes-resources-quota-component.adoc
@@ -18,73 +18,12 @@ The Kubernetes Resources Quota component is one of xref:kubernetes-summary.adoc[
provides a producer to execute Kubernetes Resource Quota operations.
-
-== Component Options
-
// component options: START
-The Kubernetes Resources Quota component supports 2 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *lazyStartProducer* (producer) | 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 [...]
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-|===
// component options: END
-
-
-== Endpoint Options
-
// endpoint options: START
-The Kubernetes Resources Quota endpoint is configured using URI syntax:
-
-----
-kubernetes-resources-quota:masterUrl
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (1 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *masterUrl* | *Required* Kubernetes Master url | | String
-|===
-
-
-=== Query Parameters (20 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *apiVersion* (producer) | The Kubernetes API Version to use | | String
-| *dnsDomain* (producer) | The dns domain, used for ServiceCall EIP | | String
-| *kubernetesClient* (producer) | Default KubernetesClient to use if provided | | KubernetesClient
-| *lazyStartProducer* (producer) | 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 [...]
-| *operation* (producer) | Producer operation to do on Kubernetes | | String
-| *portName* (producer) | The port name, used for ServiceCall EIP | | String
-| *portProtocol* (producer) | The port protocol, used for ServiceCall EIP | tcp | String
-| *connectionTimeout* (advanced) | Connection timeout in milliseconds to use when making requests to the Kubernetes API server. | | Integer
-| *caCertData* (security) | The CA Cert Data | | String
-| *caCertFile* (security) | The CA Cert File | | String
-| *clientCertData* (security) | The Client Cert Data | | String
-| *clientCertFile* (security) | The Client Cert File | | String
-| *clientKeyAlgo* (security) | The Key Algorithm used by the client | | String
-| *clientKeyData* (security) | The Client Key data | | String
-| *clientKeyFile* (security) | The Client Key file | | String
-| *clientKeyPassphrase* (security) | The Client Key Passphrase | | String
-| *oauthToken* (security) | The Auth Token | | String
-| *password* (security) | Password to connect to Kubernetes | | String
-| *trustCerts* (security) | Define if the certs we used are trusted anyway or not | | Boolean
-| *username* (security) | Username to connect to Kubernetes | | String
-|===
// endpoint options: END
+
== Supported producer operation
- listResourcesQuota
@@ -111,7 +50,6 @@ This operation return a List of Resource Quotas from your cluster
[source,java]
--------------------------------------------------------------------------------
from("direct:listByLabels").process(new Processor() {
-
@Override
public void process(Exchange exchange) throws Exception {
Map<String, String> labels = new HashMap<>();
diff --git a/components/camel-kubernetes/src/main/docs/kubernetes-secrets-component.adoc b/components/camel-kubernetes/src/main/docs/kubernetes-secrets-component.adoc
index 2a66321..6b40356 100644
--- a/components/camel-kubernetes/src/main/docs/kubernetes-secrets-component.adoc
+++ b/components/camel-kubernetes/src/main/docs/kubernetes-secrets-component.adoc
@@ -18,73 +18,12 @@ The Kubernetes Secrets component is one of xref:kubernetes-summary.adoc[Kubernet
provides a producer to execute Kubernetes Secrets operations.
-
-== Component Options
-
// component options: START
-The Kubernetes Secrets component supports 2 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *lazyStartProducer* (producer) | 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 [...]
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-|===
// component options: END
-
-
-== Endpoint Options
-
// endpoint options: START
-The Kubernetes Secrets endpoint is configured using URI syntax:
-
-----
-kubernetes-secrets:masterUrl
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (1 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *masterUrl* | *Required* Kubernetes Master url | | String
-|===
-
-
-=== Query Parameters (20 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *apiVersion* (producer) | The Kubernetes API Version to use | | String
-| *dnsDomain* (producer) | The dns domain, used for ServiceCall EIP | | String
-| *kubernetesClient* (producer) | Default KubernetesClient to use if provided | | KubernetesClient
-| *lazyStartProducer* (producer) | 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 [...]
-| *operation* (producer) | Producer operation to do on Kubernetes | | String
-| *portName* (producer) | The port name, used for ServiceCall EIP | | String
-| *portProtocol* (producer) | The port protocol, used for ServiceCall EIP | tcp | String
-| *connectionTimeout* (advanced) | Connection timeout in milliseconds to use when making requests to the Kubernetes API server. | | Integer
-| *caCertData* (security) | The CA Cert Data | | String
-| *caCertFile* (security) | The CA Cert File | | String
-| *clientCertData* (security) | The Client Cert Data | | String
-| *clientCertFile* (security) | The Client Cert File | | String
-| *clientKeyAlgo* (security) | The Key Algorithm used by the client | | String
-| *clientKeyData* (security) | The Client Key data | | String
-| *clientKeyFile* (security) | The Client Key file | | String
-| *clientKeyPassphrase* (security) | The Client Key Passphrase | | String
-| *oauthToken* (security) | The Auth Token | | String
-| *password* (security) | Password to connect to Kubernetes | | String
-| *trustCerts* (security) | Define if the certs we used are trusted anyway or not | | Boolean
-| *username* (security) | Username to connect to Kubernetes | | String
-|===
// endpoint options: END
+
== Supported producer operation
- listSecrets
@@ -111,7 +50,6 @@ This operation return a List of secrets from your cluster
[source,java]
--------------------------------------------------------------------------------
from("direct:listByLabels").process(new Processor() {
-
@Override
public void process(Exchange exchange) throws Exception {
Map<String, String> labels = new HashMap<>();
diff --git a/components/camel-kubernetes/src/main/docs/kubernetes-service-accounts-component.adoc b/components/camel-kubernetes/src/main/docs/kubernetes-service-accounts-component.adoc
index 92f21c3..1683e50 100644
--- a/components/camel-kubernetes/src/main/docs/kubernetes-service-accounts-component.adoc
+++ b/components/camel-kubernetes/src/main/docs/kubernetes-service-accounts-component.adoc
@@ -18,71 +18,12 @@ The Kubernetes Service Account component is one of xref:kubernetes-summary.adoc[
provides a producer to execute Kubernetes Service Account operations.
-== Component Options
-
// component options: START
-The Kubernetes Service Account component supports 2 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *lazyStartProducer* (producer) | 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 [...]
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-|===
// component options: END
-
-
-== Endpoint Options
// endpoint options: START
-The Kubernetes Service Account endpoint is configured using URI syntax:
-
-----
-kubernetes-service-accounts:masterUrl
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (1 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *masterUrl* | *Required* Kubernetes Master url | | String
-|===
-
-
-=== Query Parameters (20 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *apiVersion* (producer) | The Kubernetes API Version to use | | String
-| *dnsDomain* (producer) | The dns domain, used for ServiceCall EIP | | String
-| *kubernetesClient* (producer) | Default KubernetesClient to use if provided | | KubernetesClient
-| *lazyStartProducer* (producer) | 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 [...]
-| *operation* (producer) | Producer operation to do on Kubernetes | | String
-| *portName* (producer) | The port name, used for ServiceCall EIP | | String
-| *portProtocol* (producer) | The port protocol, used for ServiceCall EIP | tcp | String
-| *connectionTimeout* (advanced) | Connection timeout in milliseconds to use when making requests to the Kubernetes API server. | | Integer
-| *caCertData* (security) | The CA Cert Data | | String
-| *caCertFile* (security) | The CA Cert File | | String
-| *clientCertData* (security) | The Client Cert Data | | String
-| *clientCertFile* (security) | The Client Cert File | | String
-| *clientKeyAlgo* (security) | The Key Algorithm used by the client | | String
-| *clientKeyData* (security) | The Client Key data | | String
-| *clientKeyFile* (security) | The Client Key file | | String
-| *clientKeyPassphrase* (security) | The Client Key Passphrase | | String
-| *oauthToken* (security) | The Auth Token | | String
-| *password* (security) | Password to connect to Kubernetes | | String
-| *trustCerts* (security) | Define if the certs we used are trusted anyway or not | | Boolean
-| *username* (security) | Username to connect to Kubernetes | | String
-|===
// endpoint options: END
+
== Supported producer operation
- listServiceAccounts
@@ -109,7 +50,6 @@ This operation return a List of services from your cluster
[source,java]
--------------------------------------------------------------------------------
from("direct:listByLabels").process(new Processor() {
-
@Override
public void process(Exchange exchange) throws Exception {
Map<String, String> labels = new HashMap<>();
diff --git a/components/camel-kubernetes/src/main/docs/kubernetes-services-component.adoc b/components/camel-kubernetes/src/main/docs/kubernetes-services-component.adoc
index b64b3ce..04a0f65 100644
--- a/components/camel-kubernetes/src/main/docs/kubernetes-services-component.adoc
+++ b/components/camel-kubernetes/src/main/docs/kubernetes-services-component.adoc
@@ -18,87 +18,12 @@ The Kubernetes Services component is one of xref:kubernetes-summary.adoc[Kuberne
provides a producer to execute Kubernetes Service operations and a consumer to consume events related to Service objects.
-
-== Component Options
-
// component options: START
-The Kubernetes Services component supports 3 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *lazyStartProducer* (producer) | 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 [...]
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-|===
// component options: END
-
-
-== Endpoint Options
-
// endpoint options: START
-The Kubernetes Services endpoint is configured using URI syntax:
-
-----
-kubernetes-services:masterUrl
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (1 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *masterUrl* | *Required* Kubernetes Master url | | String
-|===
-
-
-=== Query Parameters (33 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *apiVersion* (common) | The Kubernetes API Version to use | | String
-| *dnsDomain* (common) | The dns domain, used for ServiceCall EIP | | String
-| *kubernetesClient* (common) | Default KubernetesClient to use if provided | | KubernetesClient
-| *portName* (common) | The port name, used for ServiceCall EIP | | String
-| *portProtocol* (common) | The port protocol, used for ServiceCall EIP | tcp | String
-| *bridgeErrorHandler* (consumer) | 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. | false | boolean
-| *crdGroup* (consumer) | The Consumer CRD Resource Group we would like to watch | | String
-| *crdName* (consumer) | The Consumer CRD Resource name we would like to watch | | String
-| *crdPlural* (consumer) | The Consumer CRD Resource Plural we would like to watch | | String
-| *crdScope* (consumer) | The Consumer CRD Resource Scope we would like to watch | | String
-| *crdVersion* (consumer) | The Consumer CRD Resource Version we would like to watch | | String
-| *labelKey* (consumer) | The Consumer Label key when watching at some resources | | String
-| *labelValue* (consumer) | The Consumer Label value when watching at some resources | | String
-| *namespace* (consumer) | The namespace | | String
-| *poolSize* (consumer) | The Consumer pool size | 1 | int
-| *resourceName* (consumer) | The Consumer Resource Name we would like to watch | | String
-| *exceptionHandler* (consumer) | 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. | | ExceptionHandler
-| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut | | ExchangePattern
-| *lazyStartProducer* (producer) | 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 [...]
-| *operation* (producer) | Producer operation to do on Kubernetes | | String
-| *connectionTimeout* (advanced) | Connection timeout in milliseconds to use when making requests to the Kubernetes API server. | | Integer
-| *caCertData* (security) | The CA Cert Data | | String
-| *caCertFile* (security) | The CA Cert File | | String
-| *clientCertData* (security) | The Client Cert Data | | String
-| *clientCertFile* (security) | The Client Cert File | | String
-| *clientKeyAlgo* (security) | The Key Algorithm used by the client | | String
-| *clientKeyData* (security) | The Client Key data | | String
-| *clientKeyFile* (security) | The Client Key file | | String
-| *clientKeyPassphrase* (security) | The Client Key Passphrase | | String
-| *oauthToken* (security) | The Auth Token | | String
-| *password* (security) | Password to connect to Kubernetes | | String
-| *trustCerts* (security) | Define if the certs we used are trusted anyway or not | | Boolean
-| *username* (security) | Username to connect to Kubernetes | | String
-|===
// endpoint options: END
+
== Supported producer operation
- listServices
@@ -125,7 +50,6 @@ This operation return a List of services from your cluster
[source,java]
--------------------------------------------------------------------------------
from("direct:listByLabels").process(new Processor() {
-
@Override
public void process(Exchange exchange) throws Exception {
Map<String, String> labels = new HashMap<>();
diff --git a/components/camel-kubernetes/src/main/docs/openshift-build-configs-component.adoc b/components/camel-kubernetes/src/main/docs/openshift-build-configs-component.adoc
index 1a3f9b3..c6f620d 100644
--- a/components/camel-kubernetes/src/main/docs/openshift-build-configs-component.adoc
+++ b/components/camel-kubernetes/src/main/docs/openshift-build-configs-component.adoc
@@ -15,73 +15,12 @@ include::{cq-version}@camel-quarkus:ROOT:partial$reference/components/openshift-
*{component-header}*
The OpenShift Build Config component is one of xref:kubernetes-summary.adoc[Kubernetes Components] which
-provides a producer to execute Openshift Build Configs operations.
+provides a producer to execute Openshift Build Configs operations.
-== Component Options
-
// component options: START
-The Openshift Build Config component supports 2 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *lazyStartProducer* (producer) | 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 [...]
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-|===
// component options: END
-
-
-== Endpoint Options
-
// endpoint options: START
-The Openshift Build Config endpoint is configured using URI syntax:
-
-----
-openshift-build-configs:masterUrl
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (1 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *masterUrl* | *Required* Kubernetes Master url | | String
-|===
-
-
-=== Query Parameters (20 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *apiVersion* (producer) | The Kubernetes API Version to use | | String
-| *dnsDomain* (producer) | The dns domain, used for ServiceCall EIP | | String
-| *kubernetesClient* (producer) | Default KubernetesClient to use if provided | | KubernetesClient
-| *lazyStartProducer* (producer) | 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 [...]
-| *operation* (producer) | Producer operation to do on Kubernetes | | String
-| *portName* (producer) | The port name, used for ServiceCall EIP | | String
-| *portProtocol* (producer) | The port protocol, used for ServiceCall EIP | tcp | String
-| *connectionTimeout* (advanced) | Connection timeout in milliseconds to use when making requests to the Kubernetes API server. | | Integer
-| *caCertData* (security) | The CA Cert Data | | String
-| *caCertFile* (security) | The CA Cert File | | String
-| *clientCertData* (security) | The Client Cert Data | | String
-| *clientCertFile* (security) | The Client Cert File | | String
-| *clientKeyAlgo* (security) | The Key Algorithm used by the client | | String
-| *clientKeyData* (security) | The Client Key data | | String
-| *clientKeyFile* (security) | The Client Key file | | String
-| *clientKeyPassphrase* (security) | The Client Key Passphrase | | String
-| *oauthToken* (security) | The Auth Token | | String
-| *password* (security) | Password to connect to Kubernetes | | String
-| *trustCerts* (security) | Define if the certs we used are trusted anyway or not | | Boolean
-| *username* (security) | Username to connect to Kubernetes | | String
-|===
// endpoint options: END
@@ -109,7 +48,6 @@ This operation return a List of Builds from your Openshift cluster
[source,java]
--------------------------------------------------------------------------------
from("direct:listByLabels").process(new Processor() {
-
@Override
public void process(Exchange exchange) throws Exception {
Map<String, String> labels = new HashMap<>();
diff --git a/components/camel-kubernetes/src/main/docs/openshift-builds-component.adoc b/components/camel-kubernetes/src/main/docs/openshift-builds-component.adoc
index a00eac9..3b33405 100644
--- a/components/camel-kubernetes/src/main/docs/openshift-builds-component.adoc
+++ b/components/camel-kubernetes/src/main/docs/openshift-builds-component.adoc
@@ -14,77 +14,15 @@ include::{cq-version}@camel-quarkus:ROOT:partial$reference/components/openshift-
*{component-header}*
-The Kubernetes Builds component is one of xref:kubernetes-summary.adoc[Kubernetes Components] which
+The Openshift Builds component is one of xref:kubernetes-summary.adoc[Kubernetes Components] which
provides a producer to execute Openshift builds operations.
-== Component Options
-
// component options: START
-The Openshift Builds component supports 2 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *lazyStartProducer* (producer) | 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 [...]
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-|===
// component options: END
-
-
-== Endpoint Options
-
// endpoint options: START
-The Openshift Builds endpoint is configured using URI syntax:
-
-----
-openshift-builds:masterUrl
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (1 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *masterUrl* | *Required* Kubernetes Master url | | String
-|===
-
-
-=== Query Parameters (20 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *apiVersion* (producer) | The Kubernetes API Version to use | | String
-| *dnsDomain* (producer) | The dns domain, used for ServiceCall EIP | | String
-| *kubernetesClient* (producer) | Default KubernetesClient to use if provided | | KubernetesClient
-| *lazyStartProducer* (producer) | 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 [...]
-| *operation* (producer) | Producer operation to do on Kubernetes | | String
-| *portName* (producer) | The port name, used for ServiceCall EIP | | String
-| *portProtocol* (producer) | The port protocol, used for ServiceCall EIP | tcp | String
-| *connectionTimeout* (advanced) | Connection timeout in milliseconds to use when making requests to the Kubernetes API server. | | Integer
-| *caCertData* (security) | The CA Cert Data | | String
-| *caCertFile* (security) | The CA Cert File | | String
-| *clientCertData* (security) | The Client Cert Data | | String
-| *clientCertFile* (security) | The Client Cert File | | String
-| *clientKeyAlgo* (security) | The Key Algorithm used by the client | | String
-| *clientKeyData* (security) | The Client Key data | | String
-| *clientKeyFile* (security) | The Client Key file | | String
-| *clientKeyPassphrase* (security) | The Client Key Passphrase | | String
-| *oauthToken* (security) | The Auth Token | | String
-| *password* (security) | Password to connect to Kubernetes | | String
-| *trustCerts* (security) | Define if the certs we used are trusted anyway or not | | Boolean
-| *username* (security) | Username to connect to Kubernetes | | String
-|===
// endpoint options: END
-
== Supported producer operation
- listBuilds
@@ -109,7 +47,6 @@ This operation return a List of Builds from your Openshift cluster
[source,java]
--------------------------------------------------------------------------------
from("direct:listByLabels").process(new Processor() {
-
@Override
public void process(Exchange exchange) throws Exception {
Map<String, String> labels = new HashMap<>();
diff --git a/components/camel-kudu/src/main/docs/kudu-component.adoc b/components/camel-kudu/src/main/docs/kudu-component.adoc
index 98ae792..5bad35a 100644
--- a/components/camel-kudu/src/main/docs/kudu-component.adoc
+++ b/components/camel-kudu/src/main/docs/kudu-component.adoc
@@ -12,9 +12,6 @@ include::{cq-version}@camel-quarkus:ROOT:partial$reference/components/kudu.adoc[
*{component-header}*
-*Since Camel 3.0*
-
-
The Kudu component supports storing and retrieving data from/to https://kudu.apache.org/[Apache Kudu], a free and open source column-oriented data store of the Apache Hadoop ecosystem.
== Prerequisites
@@ -23,50 +20,11 @@ You must have a valid Kudu instance running. More information are available at h
// component options: START
-The Kudu component supports 2 options, which are listed below.
-
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *lazyStartProducer* (producer) | 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 [...]
-| *autowiredEnabled* (advanced) | 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. | true | boolean
-|===
// component options: END
-
// endpoint options: START
-The Kudu endpoint is configured using URI syntax:
-
-----
-kudu:host:port/tableName
-----
-
-with the following path and query parameters:
-
-=== Path Parameters (3 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *host* | Host of the server to connect to | | String
-| *port* | Port of the server to connect to | | String
-| *tableName* | Table to connect to | | String
-|===
-
-
-=== Query Parameters (2 parameters):
-
-
-[width="100%",cols="2,5,^1,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *lazyStartProducer* (producer) | 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 [...]
-| *operation* (producer) | Operation to perform. There are 3 enums and the value can be one of: INSERT, CREATE_TABLE, SCAN | | KuduOperations
-|===
// endpoint options: END
+
== Input Body formats
=== Insert
@@ -98,35 +56,4 @@ Maven users will need to add the following dependency to their pom.xml.
where `$\{camel-version}` must be replaced by the actual version of Camel (3.0 or higher).
-== Spring Boot Auto-Configuration
-
-When using Spring Boot make sure to use the following Maven dependency to have support for auto configuration:
-
-[source,xml]
-----
-<dependency>
- <groupId>org.apache.camel.springboot</groupId>
- <artifactId>camel-kudu-starter</artifactId>
- <version>x.x.x</version>
- <!-- use the same version as your Camel core version -->
-</dependency>
-----
-
-
-
-== Camel Kudu Starter
-
-A starter module is available to spring-boot users.
-
-To use this feature, add the following dependencies to your spring boot pom.xml file:
-
-[source,xml]
-----
-<dependency>
- <groupId>org.apache.camel.springboot</groupId>
- <artifactId>camel-kudu-starter</artifactId>
- <version>${camel.version}</version> <!-- use the same version as your Camel core version -->
-</dependency>
-----
-
include::{page-component-version}@camel-spring-boot::page$kudu-starter.adoc[]