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 2023/05/04 12:05:00 UTC
[camel] branch main updated: Added DSL tabs for EIPs docs (#9992)
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
The following commit(s) were added to refs/heads/main by this push:
new eee3b671e62 Added DSL tabs for EIPs docs (#9992)
eee3b671e62 is described below
commit eee3b671e62764f457b1972278659a7bd33a7af1
Author: Ivan Mashtak <de...@yandex.ru>
AuthorDate: Thu May 4 15:04:46 2023 +0300
Added DSL tabs for EIPs docs (#9992)
---
.../src/main/docs/modules/eips/pages/bean-eip.adoc | 64 ++++++-
.../main/docs/modules/eips/pages/choice-eip.adoc | 46 ++++-
.../modules/eips/pages/circuitBreaker-eip.adoc | 10 +-
.../docs/modules/eips/pages/claimCheck-eip.adoc | 178 ++++++++++++++-----
.../modules/eips/pages/competing-consumers.adoc | 65 ++++++-
.../docs/modules/eips/pages/content-enricher.adoc | 48 +++++-
.../modules/eips/pages/content-filter-eip.adoc | 52 +++++-
.../docs/modules/eips/pages/convertBodyTo-eip.adoc | 23 ++-
.../modules/eips/pages/correlation-identifier.adoc | 23 ++-
.../modules/eips/pages/customLoadBalancer-eip.adoc | 10 +-
.../main/docs/modules/eips/pages/delay-eip.adoc | 71 +++++++-
.../modules/eips/pages/durable-subscriber.adoc | 15 +-
.../docs/modules/eips/pages/dynamicRouter-eip.adoc | 25 ++-
.../main/docs/modules/eips/pages/enrich-eip.adoc | 108 ++++++++++--
.../docs/modules/eips/pages/event-message.adoc | 19 +-
.../eips/pages/eventDrivenConsumer-eip.adoc | 20 ++-
.../modules/eips/pages/fault-tolerance-eip.adoc | 19 +-
.../main/docs/modules/eips/pages/filter-eip.adoc | 32 +++-
.../src/main/docs/modules/eips/pages/from-eip.adoc | 21 ++-
.../modules/eips/pages/guaranteed-delivery.adoc | 11 +-
.../src/main/docs/modules/eips/pages/loop-eip.adoc | 85 +++++----
.../main/docs/modules/eips/pages/marshal-eip.adoc | 27 ++-
.../main/docs/modules/eips/pages/message-bus.adoc | 10 +-
.../docs/modules/eips/pages/message-channel.adoc | 12 +-
.../docs/modules/eips/pages/message-endpoint.adoc | 11 +-
.../modules/eips/pages/message-expiration.adoc | 10 +-
.../docs/modules/eips/pages/message-router.adoc | 10 +-
.../modules/eips/pages/message-translator.adoc | 37 +++-
.../docs/modules/eips/pages/messaging-bridge.adoc | 10 +-
.../docs/modules/eips/pages/multicast-eip.adoc | 60 +++++--
.../main/docs/modules/eips/pages/pipeline-eip.adoc | 32 +++-
.../modules/eips/pages/point-to-point-channel.adoc | 11 +-
.../docs/modules/eips/pages/pollEnrich-eip.adoc | 10 +-
.../eips/pages/publish-subscribe-channel.adoc | 11 +-
.../main/docs/modules/eips/pages/random-eip.adoc | 12 +-
.../docs/modules/eips/pages/recipientList-eip.adoc | 62 +++++--
.../docs/modules/eips/pages/removeHeader-eip.adoc | 23 ++-
.../docs/modules/eips/pages/removeHeaders-eip.adoc | 43 ++++-
.../modules/eips/pages/removeProperties-eip.adoc | 19 +-
.../modules/eips/pages/removeProperty-eip.adoc | 10 +-
.../docs/modules/eips/pages/requestReply-eip.adoc | 19 +-
.../docs/modules/eips/pages/resequence-eip.adoc | 89 +++++++---
.../docs/modules/eips/pages/resilience4j-eip.adoc | 19 +-
.../docs/modules/eips/pages/return-address.adoc | 19 +-
.../main/docs/modules/eips/pages/rollback-eip.adoc | 19 +-
.../docs/modules/eips/pages/routingSlip-eip.adoc | 37 ++--
.../main/docs/modules/eips/pages/sample-eip.adoc | 28 ++-
.../main/docs/modules/eips/pages/script-eip.adoc | 12 +-
.../modules/eips/pages/selective-consumer.adoc | 20 ++-
.../docs/modules/eips/pages/service-activator.adoc | 12 +-
.../main/docs/modules/eips/pages/setBody-eip.adoc | 10 +-
.../docs/modules/eips/pages/setHeader-eip.adoc | 45 +++--
.../docs/modules/eips/pages/setProperty-eip.adoc | 30 +++-
.../src/main/docs/modules/eips/pages/step-eip.adoc | 10 +-
.../main/docs/modules/eips/pages/sticky-eip.adoc | 10 +-
.../src/main/docs/modules/eips/pages/stop-eip.adoc | 10 +-
.../main/docs/modules/eips/pages/threads-eip.adoc | 28 ++-
.../main/docs/modules/eips/pages/throttle-eip.adoc | 191 +++++++++++++++++----
.../src/main/docs/modules/eips/pages/to-eip.adoc | 21 ++-
.../src/main/docs/modules/eips/pages/toD-eip.adoc | 39 ++++-
.../docs/modules/eips/pages/transform-eip.adoc | 24 ++-
.../docs/modules/eips/pages/unmarshal-eip.adoc | 47 ++++-
.../main/docs/modules/eips/pages/validate-eip.adoc | 74 ++++++--
.../main/docs/modules/eips/pages/wireTap-eip.adoc | 49 +++++-
64 files changed, 1802 insertions(+), 425 deletions(-)
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/bean-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/bean-eip.adoc
index 9e042d579eb..709ed3d2acb 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/bean-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/bean-eip.adoc
@@ -4,6 +4,7 @@
:description: Calls a Java bean
:since:
:supportlevel: Stable
+:tabs-sync-option:
The Bean EIP is used for invoking a method on a bean, and the returned value
is the new message body.
@@ -44,6 +45,10 @@ However, when using `prototype` then behaviour is dependent on the delegated reg
The Bean EIP can be used directly in the routes as shown below:
+[tabs]
+====
+Java::
++
[source,java]
----
// lookup bean from registry and invoke the given method by the name
@@ -53,14 +58,15 @@ from("direct:foo").bean("myBean", "myMethod");
from("direct:bar").bean("myBean");
----
-And with Spring XML you can declare the bean using `<bean>` as shown:
+XML:: With Spring XML you can declare the bean using `<bean>` as shown:
++
[source,xml]
----
<bean id="myBean" class="com.foo.ExampleBean"/>
----
-
++
And in XML DSL you can call this bean:
-
++
[source,xml]
----
<routes>
@@ -75,9 +81,34 @@ And in XML DSL you can call this bean:
</routes>
----
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: direct:start
+ steps:
+ - bean:
+ ref: myBean
+ method: myMethod
+- from:
+ uri: direct:start
+ steps:
+ - bean:
+ ref: myBean
+- beans:
+ - name: myBean
+ type: com.foo.ExampleBean
+----
+====
+
Instead of passing name of the reference to the bean (so that Camel will
lookup for it in the registry), you can provide the bean:
+[tabs]
+====
+Java::
++
[source,java]
----
// Send message to the given bean instance.
@@ -90,8 +121,8 @@ from("direct:bar").bean(new ExampleBean(), "myMethod");
from("direct:cheese").bean(ExampleBean.class);
----
-In XML DSL this is also possible using `beanType`:
-
+XML::
++
[source,xml]
----
<routes>
@@ -110,6 +141,29 @@ In XML DSL this is also possible using `beanType`:
</routes>
----
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: direct:foo
+ steps:
+ - bean:
+ beanType: com.foo.ExampleBean
+ method: myMethod
+- from:
+ uri: direct:bar
+ steps:
+ - bean:
+ beanType: com.foo.ExampleBean
+- from:
+ uri: direct:cheese
+ steps:
+ - bean:
+ beanType: com.foo.ExampleBean
+----
+====
+
== Bean binding
How bean methods to be invoked are chosen (if they are not specified
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/choice-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/choice-eip.adoc
index e36f44fb404..54cde2045db 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/choice-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/choice-eip.adoc
@@ -4,6 +4,7 @@
:description: Route messages based on a series of predicates
:since:
:supportlevel: Stable
+:tabs-sync-option:
The
http://www.enterpriseintegrationpatterns.com/ContentBasedRouter.html[Content
@@ -25,6 +26,10 @@ The Camel xref:languages:simple-language.adoc[Simple] language
is great to use with the Choice EIP when routing is based on the content of the message,
such as checking message headers.
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:a")
@@ -37,8 +42,8 @@ from("direct:a")
.to("direct:d");
----
-And the same example using XML DSL:
-
+XML::
++
[source,xml]
----
<route>
@@ -59,6 +64,30 @@ And the same example using XML DSL:
</route>
----
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: direct:a
+ steps:
+ - choice:
+ when:
+ - simple: "${header.foo} == 'bar'"
+ steps:
+ - to:
+ uri: direct:b
+ - simple: "${header.foo} == 'cheese'"
+ steps:
+ - to:
+ uri: direct:c
+ otherwise:
+ steps:
+ - to:
+ uri: direct:d
+----
+====
+
=== Why can I not use otherwise in Java DSL
When using the Choice EIP in the Java DSL you may have a situation where the compiler will not accept
@@ -170,6 +199,10 @@ Here we select from the Switch the first predicate that matches. So if there is
a property placeholder with the key `foo` then its select, and so on.
Notice how we can use `{{?foo}}` to mark the property placeholder as optional.
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:a")
@@ -179,8 +212,8 @@ from("direct:a")
.otherwise().to("direct:other");
----
-And the same example using XML DSL:
-
+XML::
++
[source,xml]
----
<route>
@@ -201,8 +234,8 @@ And the same example using XML DSL:
</route>
----
-And in YAML DSL:
-
+YAML::
++
[source,yaml]
----
- from:
@@ -221,5 +254,6 @@ And in YAML DSL:
steps:
- to: "direct:other"
----
+====
TIP: Otherwise, is optional, and if none of the predicates would match, then no branches is selected.
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/circuitBreaker-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/circuitBreaker-eip.adoc
index 9f481490f9f..d63abee4510 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/circuitBreaker-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/circuitBreaker-eip.adoc
@@ -4,6 +4,7 @@
:description: Route messages in a fault tolerance way using Circuit Breaker
:since:
:supportlevel: Stable
+:tabs-sync-option:
The Circuit Breaker pattern is inspired by the real-world electrical circuit breaker,
which is used to detect excessive current draw and fail fast to protect electrical equipment.
@@ -34,6 +35,10 @@ slow operation by falling back to the in-lined fallback route.
By default, the timeout request is just *1000ms, so the HTTP endpoint has to be fairly quick to succeed.
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
@@ -45,8 +50,8 @@ from("direct:start")
.to("mock:result");
----
-And in XML DSL:
-
+XML::
++
[source,xml]
----
<route>
@@ -62,6 +67,7 @@ And in XML DSL:
<to uri="mock:result"/>
</route>
----
+====
== Circuit Breaker components
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/claimCheck-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/claimCheck-eip.adoc
index 48498e342bc..5111acb1836 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/claimCheck-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/claimCheck-eip.adoc
@@ -4,6 +4,7 @@
:description: The Claim Check EIP allows you to replace message content with a claim check (a unique key), which can be used to retrieve the message content at a later time.
:since:
:supportlevel: Stable
+:tabs-sync-option:
The http://www.enterpriseintegrationpatterns.com/patterns/messaging/StoreInLibrary.html[Claim Check] from the xref:enterprise-integration-patterns.adoc[EIP patterns]
allows you to replace message content with a claim check (a unique key), which can be used to retrieve the message content at a later time.
@@ -154,6 +155,10 @@ from("direct:start")
The following example shows the `Push` and `Pop` operations in action:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
@@ -165,12 +170,55 @@ from("direct:start")
.to("mock:c");
----
+XML::
++
+[source,xml]
+----
+<route>
+ <from uri="direct:start"/>
+ <to uri="mock:a"/>
+ <claimCheck operation="Push"/>
+ <transform>
+ <constant>Bye World</constant>
+ </transform>
+ <to uri="mock:b"/>
+ <claimCheck operation="Pop"/>
+ <to uri="mock:c"/>
+</route>
+----
+
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: direct:start
+ steps:
+ - to: mock:a
+ - claimCheck:
+ operation: Push
+ - transform:
+ expression:
+ constant: Bye World
+ - to:
+ uri: mock:b
+ - claimCheck:
+ operation: Pop
+ - to:
+ uri: mock:c
+----
+====
+
In the above example, imagine message body from the beginning is `Hello World`. That data is pushed on the stack of the Claim Check EIP.
Then the message body is transformed to `Bye World`, which is what `mock:b` endpoint receives. When we `Pop` from the Claim Check EIP,
the original message body is retrieved and merged back, so `mock:c` will retrieve the message body with `Hello World`.
Here is an example using `Get` and `Set` operations, which uses the key `foo`:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
@@ -186,50 +234,8 @@ from("direct:start")
.to("mock:e");
----
-Notice how we can `Get` the same data twice using the `Get` operation as it will not remove the data. If you only want
-to get the data once, you can use `GetAndRemove`.
-
-The last example shows how to use the `filter` option where we only want to get back header named `foo` or `bar`:
-
-[source,java]
-----
-from("direct:start")
- .to("mock:a")
- .claimCheck(ClaimCheckOperation.Push)
- .transform().constant("Bye World")
- .setHeader("foo", constant(456))
- .removeHeader("bar")
- .to("mock:b")
- // only merge in the message headers foo or bar
- .claimCheck(ClaimCheckOperation.Pop, null, "header:(foo|bar)")
- .to("mock:c");
-----
-
-=== XML examples
-
-The following example shows the `Push` and `Pop` operations in action;
-
-[source,xml]
-----
-<route>
- <from uri="direct:start"/>
- <to uri="mock:a"/>
- <claimCheck operation="Push"/>
- <transform>
- <constant>Bye World</constant>
- </transform>
- <to uri="mock:b"/>
- <claimCheck operation="Pop"/>
- <to uri="mock:c"/>
-</route>
-----
-
-For example if the message body from the beginning is `Hello World` then that data is pushed on the stack of the Claim Check EIP.
-And then the message body is transformed to `Bye World`, which is what `mock:b` endpoint receives. When we `Pop` from the Claim Check EIP
-then the original message body is retrieved and merged back so `mock:c` will retrieve the message body with `Hello World`.
-
-Here is an example using `Get` and `Set` operations, which uses the key `foo`:
-
+XML::
++
[source,xml]
----
<route>
@@ -251,11 +257,65 @@ Here is an example using `Get` and `Set` operations, which uses the key `foo`:
</route>
----
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: direct:start
+ steps:
+ - to: mock:a
+ - claimCheck:
+ operation: Set
+ key: foo
+ - transform:
+ expression:
+ constant: Bye World
+ - to:
+ uri: mock:b
+ - claimCheck:
+ operation: Get
+ key: foo
+ - to:
+ uri: mock:c
+ - transform:
+ expression:
+ constant: Hi World
+ - to:
+ uri: mock:d
+ - claimCheck:
+ operation: Get
+ key: foo
+ - to:
+ uri: mock:e
+----
+====
+
Notice how we can `Get` the same data twice using the `Get` operation as it will not remove the data. If you only want
to get the data once, you can use `GetAndRemove`.
The last example shows how to use the `filter` option where we only want to get back header named `foo` or `bar`:
+[tabs]
+====
+Java::
++
+[source,java]
+----
+from("direct:start")
+ .to("mock:a")
+ .claimCheck(ClaimCheckOperation.Push)
+ .transform().constant("Bye World")
+ .setHeader("foo", constant(456))
+ .removeHeader("bar")
+ .to("mock:b")
+ // only merge in the message headers foo or bar
+ .claimCheck(ClaimCheckOperation.Pop, null, "header:(foo|bar)")
+ .to("mock:c");
+----
+
+XML::
++
[source,xml]
----
<route>
@@ -275,3 +335,33 @@ The last example shows how to use the `filter` option where we only want to get
<to uri="mock:c"/>
</route>
----
+
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: direct:start
+ steps:
+ - to:
+ uri: mock:a
+ - claimCheck:
+ operation: Push
+ - transform:
+ expression:
+ constant: ByeWorld
+ - setHeader:
+ name: foo
+ expression:
+ constant: 456
+ - removeHeader:
+ name: bar
+ - to:
+ uri: mock:b
+ - claimCheck:
+ operation: Pop
+ filter: "header:(foo|bar)"
+ - to:
+ uri: mock:c
+----
+====
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/competing-consumers.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/competing-consumers.adoc
index a7a3c2706f4..1b0b49a354b 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/competing-consumers.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/competing-consumers.adoc
@@ -1,4 +1,5 @@
= Competing Consumers
+:tabs-sync-option:
Camel supports the
https://www.enterpriseintegrationpatterns.com/patterns/messaging/CompetingConsumers.html[Competing Consumers]
@@ -22,14 +23,18 @@ To enable Competing Consumers you just need to set the `concurrentConsumers` pro
For example
+[tabs]
+====
+Java::
++
[source,java]
----
from("jms:MyQueue?concurrentConsumers=5")
.to("bean:someBean");
----
-or in XML DSL
-
+XML::
++
[source,xml]
----
<route>
@@ -38,6 +43,20 @@ or in XML DSL
</route>
----
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: jms:MyQueue
+ parameters:
+ concurrentConsumers: 5
+ steps:
+ - to:
+ uri: bean:someBean
+----
+====
+
== Competing Consumers with Thread Pool
You can simulate competing consumers by using a thread pool which then continue processing the messages concurrently.
@@ -47,14 +66,18 @@ Then the single thread consumer can quickly continue and pickup new messages to
Suppose we have this simple route where we poll a folder for new files,
process the files and afterwards move the files to a backup folder when complete.
+[tabs]
+====
+Java::
++
[source,java]
----
from("file://inbox?move=../backup-${date:now:yyyyMMdd}")
.to("bean:calculateBean");
----
-And in XML DSL
-
+XML::
++
[source,xml]
----
<route>
@@ -63,6 +86,18 @@ And in XML DSL
</route>
----
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: "file://inbox?move=../backup-${date:now:yyyyMMdd}"
+ steps:
+ - to:
+ uri: bean:calculateBean
+----
+====
+
The route is synchronous and there is only a single consumer running at any given time.
This scenario is well known, and it doesn't affect thread safety as we only have one active thread
involved at any given time.
@@ -84,6 +119,10 @@ So how can we process messages with this bean concurrently?
We can use the xref:threads-eip.adoc[Threads EIP], so if we insert it in the route we get:
+[tabs]
+====
+Java::
++
[source,java]
----
from("file://inbox?move=../backup-${date:now:yyyyMMdd}")
@@ -91,8 +130,8 @@ from("file://inbox?move=../backup-${date:now:yyyyMMdd}")
.to("bean:calculateBean");
----
-And in XML DSL
-
+XML::
++
[source,xml]
----
<route>
@@ -102,6 +141,20 @@ And in XML DSL
</route>
----
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: "file://inbox?move=../backup-${date:now:yyyyMMdd}"
+ steps:
+ - threads:
+ poolSize: 10
+ - to:
+ uri: bean:calculateBean
+----
+====
+
So by inserting `threads(10)` we have instructed Camel that from this point forward in the route
it should use a thread pool with up till 10 concurrent threads.
So when the file consumer delivers a message to the threads, then the threads take it from there,
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/content-enricher.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/content-enricher.adoc
index 8e6f35614cb..5a65a755b4a 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/content-enricher.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/content-enricher.adoc
@@ -1,4 +1,5 @@
= Content Enricher
+:tabs-sync-option:
Camel supports the
http://www.enterpriseintegrationpatterns.com/DataEnricher.html[Content
@@ -25,6 +26,10 @@ xref:ROOT:velocity-component.adoc[Velocity], xref:ROOT:xquery-component.adoc[XQu
or xref:ROOT:atlasmap-component.adoc[AtlasMap]
and then send it on to another destination.
+[tabs]
+====
+Java::
++
[source,java]
----
from("activemq:My.Queue")
@@ -32,8 +37,8 @@ from("activemq:My.Queue")
.to("activemq:Another.Queue");
----
-And in XML
-
+XML::
++
[source,xml]
----
<route>
@@ -43,6 +48,20 @@ And in XML
</route>
----
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: activemq:My.Queue
+ steps:
+ - to:
+ uri: velocity:com/acme/MyResponse.vm
+ - to:
+ uri: activemq:Another.Queue
+----
+====
+
You can also enrich the message in Java DSL directly (using fluent builder) as an
xref:manual::expression.adoc[Expression]. In the example below the message
is enriched by appending ` World!` to the message body:
@@ -87,9 +106,13 @@ from("direct:start")
== Content enrichment using a Bean EIP
-we can use xref:bean-eip.adoc[Bean EIP] to use any Java
+We can use xref:bean-eip.adoc[Bean EIP] to use any Java
method on any bean to act as content enricher:
+[tabs]
+====
+Java::
++
[source,java]
----
from("activemq:My.Queue")
@@ -97,8 +120,8 @@ from("activemq:My.Queue")
.to("activemq:Another.Queue");
----
-And in XML DSL:
-
+XML::
++
[source,xml]
----
<route>
@@ -108,6 +131,21 @@ And in XML DSL:
</route>
----
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: activemq:Input
+ steps:
+ - bean:
+ ref: myBeanName
+ method: doTransform
+ - to:
+ uri: activemq:Output
+----
+====
+
== Content enrichment using Enrich EIP
Camel comes with two kinds of Content Enricher EIPs:
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/content-filter-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/content-filter-eip.adoc
index 0c4ed61074d..63bfdd7442a 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/content-filter-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/content-filter-eip.adoc
@@ -1,4 +1,5 @@
= Content Filter
+:tabs-sync-option:
Camel supports the
http://www.enterpriseintegrationpatterns.com/ContentFilter.html[Content
@@ -35,9 +36,13 @@ from("direct:start")
== Message Content filtering using a Bean EIP
-we can use xref:bean-eip.adoc[Bean EIP] to use any Java
+We can use xref:bean-eip.adoc[Bean EIP] to use any Java
method on any bean to act as content filter:
+[tabs]
+====
+Java::
++
[source,java]
----
from("activemq:My.Queue")
@@ -45,8 +50,8 @@ from("activemq:My.Queue")
.to("activemq:Another.Queue");
----
-And in XML DSL:
-
+XML::
++
[source,xml]
----
<route>
@@ -56,6 +61,21 @@ And in XML DSL:
</route>
----
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: activemq:Input
+ steps:
+ - bean:
+ ref: myBeanName
+ method: doFilter
+ - to:
+ uri: activemq:Output
+----
+====
+
== Message Content filtering using expression
Some languages like xref:languages:xpath-language.adoc[XPath], and xref:languages:xquery-language.adoc[XQuery]
@@ -63,6 +83,10 @@ can be used to transform and filter content from messages.
In the example we use xpath to filter a XML message to select all the `<foo><bar>` elements:
+[tabs]
+====
+Java::
++
[source,java]
----
from("activemq:Input")
@@ -70,14 +94,30 @@ from("activemq:Input")
.to("activemq:Output");
----
-And in XML DSL:
-
+XML::
++
[source,xml]
----
<route>
<from uri="activemq:Input"/>
- <setBody><xpath>//foo:bar</xpath></setBody>
+ <setBody>
+ <xpath>//foo:bar</xpath>
+ </setBody>
<to uri="activemq:Output"/>
</route>
----
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: activemq:Input
+ steps:
+ - setBody:
+ expression:
+ xpath: //foo:bar
+ - to:
+ uri: activemq:Output
+----
+====
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/convertBodyTo-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/convertBodyTo-eip.adoc
index 9986c2e09f6..2704dc0b531 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/convertBodyTo-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/convertBodyTo-eip.adoc
@@ -4,6 +4,7 @@
:description: Converts the message body to another type
:since:
:supportlevel: Stable
+:tabs-sync-option:
The ConvertBodyTo EIP allows you to transform the message body to a different type.
@@ -19,6 +20,10 @@ You can also use `byte[]` for a byte array.
A common use-case is for converting the message body to a `String`:
+[tabs]
+====
+Java::
++
[source,java]
----
from("file:inbox")
@@ -26,8 +31,8 @@ from("file:inbox")
.log("The file content: ${body}");
----
-And in XML DSL:
-
+XML::
++
[source,xml]
----
<route>
@@ -36,3 +41,17 @@ And in XML DSL:
<log message="The file content: ${body}"/>
</route>
----
+
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: file:inbox
+ steps:
+ - convertBodyTo:
+ type: String
+ - log:
+ message: "The file content: ${body}"
+----
+====
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/correlation-identifier.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/correlation-identifier.adoc
index df8be577579..3cb13e9e861 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/correlation-identifier.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/correlation-identifier.adoc
@@ -1,4 +1,5 @@
= Correlation Identifier
+:tabs-sync-option:
Camel supports the
http://www.enterpriseintegrationpatterns.com/CorrelationIdentifier.html[Correlation
@@ -44,6 +45,10 @@ The following EIPs does this:
The following example uses a request/reply pattern in
the xref:ROOT:jms-component.adoc[JMS] component, where correlation identifiers are automatically handled:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
@@ -51,8 +56,8 @@ from("direct:start")
.to("mock:result");
----
-And with XML DSL:
-
+XML::
++
[source,xml]
----
<route>
@@ -62,3 +67,17 @@ And with XML DSL:
</route>
----
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: direct:start
+ steps:
+ - to:
+ uri: jms:queue:foo
+ pattern: InOut
+ - to:
+ uri: mock:result
+----
+====
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/customLoadBalancer-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/customLoadBalancer-eip.adoc
index 33b1935ae1f..17cec1bc391 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/customLoadBalancer-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/customLoadBalancer-eip.adoc
@@ -4,6 +4,7 @@
:description: To use a custom load balancer implementation.
:since:
:supportlevel: Stable
+:tabs-sync-option:
This EIP allows you to use your own xref:loadBalance-eip.adoc[Load Balancer] implementation.
@@ -15,6 +16,10 @@ include::partial$eip-options.adoc[]
An example using Java DSL:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
@@ -26,8 +31,8 @@ from("direct:start")
.end();
----
-And the same example using XML DSL:
-
+XML::
++
[source,xml]
----
<!-- this is the implementation of our custom load balancer -->
@@ -47,6 +52,7 @@ And the same example using XML DSL:
</route>
</camelContext>
----
+====
To implement a custom load balancer you can extend some support classes such as `LoadBalancerSupport` and `SimpleLoadBalancerSupport`.
The former supports the asynchronous routing engine, and the latter does not. Here is an example of a custom load balancer implementation:
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/delay-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/delay-eip.adoc
index f75e38669d2..fcf7b9f4ea9 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/delay-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/delay-eip.adoc
@@ -4,6 +4,7 @@
:description: Delays processing for a specified length of time
:since:
:supportlevel: Stable
+:tabs-sync-option:
The Delay EIP is used for delaying messages during routing.
@@ -17,6 +18,10 @@ include::partial$eip-options.adoc[]
The example below will delay all messages received on *seda:b* 1 second before sending them to *mock:result*.
+[tabs]
+====
+Java::
++
[source,java]
----
from("seda:b")
@@ -24,8 +29,8 @@ from("seda:b")
.to("mock:result");
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -37,6 +42,21 @@ And in XML:
</route>
----
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: seda:b
+ steps:
+ - delay:
+ expression:
+ constant: 1000
+ - to:
+ uri: mock:result
+----
+====
+
Note that delay creates its own block, so some DSLs (including Java) require the delay block be closed:
[source,java]
----
@@ -57,6 +77,10 @@ The delayed value can be a dynamic xref:manual::expression.adoc[Expression].
For example to delay a random between 1 and 5 seconds, we can use
the xref:languages:simple-language.adoc[Simple] language:
+[tabs]
+====
+Java::
++
[source,java]
----
from("seda:b")
@@ -64,8 +88,8 @@ from("seda:b")
.to("mock:result");
----
-And in XML DSL:
-
+XML::
++
[source,xml]
----
<route>
@@ -77,6 +101,21 @@ And in XML DSL:
</route>
----
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: seda:b
+ steps:
+ - delay:
+ expression:
+ simple: "${random(1000,5000)}"
+ - to:
+ uri: mock:result
+----
+====
+
You can also call a xref:languages:bean-language.adoc[Bean Method] to compute the
delayed value from Java code:
@@ -109,6 +148,10 @@ This allows the caller thread to not block and be able to service other messages
You use the `asyncDelayed()` to enable the async behavior.
+[tabs]
+====
+Java::
++
[source,java]
----
from("activemq:queue:foo")
@@ -116,8 +159,8 @@ from("activemq:queue:foo")
.to("activemq:aDelayedQueue");
----
-In XML DSL you use the `asyncDelayed` attribute to enable the async mode:
-
+XML::
++
[source,xml]
----
<route>
@@ -128,3 +171,19 @@ In XML DSL you use the `asyncDelayed` attribute to enable the async mode:
<to uri="activemq:aDealyedQueue"/>
</route>
----
+
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: activemq:queue:foo
+ steps:
+ - delay:
+ expression:
+ constant: 1000
+ asyncDelayed: true
+ - to:
+ uri: activemq:aDealyedQueue
+----
+====
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/durable-subscriber.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/durable-subscriber.adoc
index 78af17e6539..a8f0ddef52e 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/durable-subscriber.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/durable-subscriber.adoc
@@ -13,10 +13,12 @@ image::eip/DurableSubscriptionSolution.gif[image]
== Example
-Here is a simple example of creating durable subscribers to a JMS topic
-
-Using Java DSL
+Here is a simple example of creating durable subscribers to a JMS topic:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
@@ -29,8 +31,8 @@ from("activemq:topic:foo?clientId=2&durableSubscriptionName=bar2")
.to("mock:result2");
----
-Using XML DSL
-
+XML::
++
[source,xml]
----
<routes>
@@ -49,4 +51,5 @@ Using XML DSL
<to uri="mock:result2"/>
</route>
</routes>
-----
\ No newline at end of file
+----
+====
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/dynamicRouter-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/dynamicRouter-eip.adoc
index c2cd42db2b9..e9483c6cf57 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/dynamicRouter-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/dynamicRouter-eip.adoc
@@ -4,6 +4,7 @@
:description: Route messages based on dynamic rules
:since:
:supportlevel: Stable
+:tabs-sync-option:
The
http://www.enterpriseintegrationpatterns.com/DynamicRouter.html[Dynamic
@@ -30,8 +31,12 @@ with the current slip. This allows you to know how far we have processed in the
== Example
-In Java DSL you can use the `dynamicRouter` as shown below:
+You can use the `dynamicRouter` as shown below:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
@@ -39,8 +44,8 @@ from("direct:start")
.dynamicRouter(method(MySlipBean.class, "slip"));
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -52,6 +57,20 @@ And in XML:
</route>
----
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: direct:start
+ steps:
+ - dynamicRouter:
+ method:
+ beanType: com.foo.MySlipBean
+ method: slip
+----
+====
+
Which will call a xref:languages:bean-language.adoc[Bean Method] to compute the slip
_on-the-fly_. The bean could be implemented as follows:
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/enrich-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/enrich-eip.adoc
index 995edeb0c0b..2d190dcb4b1 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/enrich-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/enrich-eip.adoc
@@ -4,6 +4,7 @@
:description: Enriches a message with data from a secondary resource
:since:
:supportlevel: Stable
+:tabs-sync-option:
Camel supports the
http://www.enterpriseintegrationpatterns.com/DataEnricher.html[Content
@@ -68,8 +69,13 @@ public class ExampleAggregationStrategy implements AggregationStrategy {
}
----
-You then use the `AggregationStrategy` with the `enrich` in the Java DSL as shown:
+In the example Camel will call the http endpoint to collect some data, that will then
+be merged with the original message using the `AggregationStrategy`:
+[tabs]
+====
+Java::
++
[source,java]
----
AggregationStrategy aggregationStrategy = ...
@@ -79,11 +85,8 @@ from("direct:start")
.to("mock:result");
----
-In the example Camel will call the http endpoint to collect some data, that will then
-be merged with the original message using the `AggregationStrategy`.
-
-In XML DSL you use `enrich` as follows:
-
+XML::
++
[source,xml]
----
<bean id="myStrategy" class="com.foo.ExampleAggregationStrategy"/>
@@ -99,6 +102,25 @@ In XML DSL you use `enrich` as follows:
</camelContext>
----
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: direct:start
+ steps:
+ - enrich:
+ expression:
+ constant: "http:remoteserver/foo"
+ aggregationStrategy: "#myStrategy"
+ - to:
+ uri: mock:result
+- beans:
+ - name: myStrategy
+ type: com.foo.ExampleAggregationStrategy
+----
+====
+
=== Aggregation Strategy is optional
The aggregation strategy is optional.
@@ -106,6 +128,10 @@ If not provided then Camel will just use the result exchange as the result.
The following example:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
@@ -113,8 +139,8 @@ from("direct:start")
.to("direct:result");
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -126,9 +152,27 @@ And in XML:
</route>
----
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: direct:start
+ steps:
+ - enrich:
+ expression:
+ constant: "http:remoteserver/foo"
+ - to:
+ uri: mock:result
+----
+====
Would be the same as using `to`:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
@@ -136,10 +180,39 @@ from("direct:start")
.to("direct:result");
----
+XML::
++
+[source,xml]
+----
+<route>
+ <from uri="direct:start"/>
+ <to uri="http:remoteserver/foo"/>
+ <to uri="mock:result"/>
+</route>
+----
+
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: direct:start
+ steps:
+ - to:
+ uri: http:remoteserver/foo
+ - to:
+ uri: mock:result
+----
+====
+
=== Using dynamic uris
Both `enrich` and `pollEnrich` supports using dynamic uris computed based on information from the current Exchange. For example to enrich from a HTTP endpoint where the header with key orderId is used as part of the content-path of the HTTP url:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
@@ -147,8 +220,8 @@ from("direct:start")
.to("direct:result");
----
-And in XML DSL:
-
+XML::
++
[source,xml]
----
<route>
@@ -160,6 +233,21 @@ And in XML DSL:
</route>
----
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: direct:start
+ steps:
+ - enrich:
+ expression:
+ simple: "http:myserver/${header.orderId}/order"
+ - to:
+ uri: mock:result
+----
+====
+
TIP: See the `cacheSize` option for more details on _how much cache_ to use depending on how many or few unique endpoints are used.
=== Using out of the box Aggregation Strategies
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/event-message.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/event-message.adoc
index 6d5323c476c..8cf11c86ed0 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/event-message.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/event-message.adoc
@@ -1,4 +1,5 @@
= Event Message
+:tabs-sync-option:
Camel supports the
http://www.enterpriseintegrationpatterns.com/EventMessage.html[Event Message]
@@ -40,14 +41,18 @@ IMPORTANT: This is only possible on endpoints used by consumers (i.e. in `<from>
In the example below the message will be forced as an event message as the consumer
is in `InOnly` mode.
+[tabs]
+====
+Java::
++
[source,java]
----
from("mq:someQueue?exchangePattern=InOnly")
.to("activemq:queue:one-way");
----
-And with XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -55,12 +60,17 @@ And with XML:
<to uri="activemq:queue:one-way"/>
</route>
----
+====
== Using setExchangePattern EIP
You can specify the
xref:manual::exchange-pattern.adoc[Exchange Pattern] using `setExchangePattern` in the DSL.
+[tabs]
+====
+Java::
++
[source,java]
----
from("mq:someQueue")
@@ -68,8 +78,8 @@ from("mq:someQueue")
.to("activemq:queue:one-way");
----
-And with XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -78,6 +88,7 @@ And with XML:
<to uri="activemq:queue:one-way"/>
</route>
----
+====
When using `setExchangePattern` then the xref:manual::exchange-pattern.adoc[Exchange Pattern]
on the xref:manual::exchange.adoc[Exchange] is changed from this point onwards in the route.
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/eventDrivenConsumer-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/eventDrivenConsumer-eip.adoc
index 118f3de40f9..88782c6877e 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/eventDrivenConsumer-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/eventDrivenConsumer-eip.adoc
@@ -1,4 +1,5 @@
= Event Driven Consumer
+:tabs-sync-option:
Camel supports the
http://www.enterpriseintegrationpatterns.com/EventDrivenConsumer.html[Event Driven Consumer]
@@ -23,14 +24,18 @@ when a xref:message.adoc[Message] is available for processing.
The following demonstrates a xref:bean-eip.adoc[Bean] being invoked when
an event occurs from a xref:ROOT:jms-component.adoc[JMS] queue.
+[tabs]
+====
+Java::
++
[source,java]
----
from("jms:queue:foo")
.bean(MyBean.class);
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -39,3 +44,14 @@ And in XML:
</route>
----
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: jms:queue:foo
+ steps:
+ - bean:
+ beanType: com.foo.MyBean
+----
+====
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/fault-tolerance-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/fault-tolerance-eip.adoc
index 3227f4eac53..9f98c08596f 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/fault-tolerance-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/fault-tolerance-eip.adoc
@@ -1,4 +1,5 @@
= Fault Tolerance EIP
+:tabs-sync-option:
This component supports the xref:circuitBreaker-eip.adoc[Circuit Breaker] EIP with the
xref:others:microprofile-fault-tolerance.adoc[MicroProfile Fault Tolerance] library.
@@ -24,6 +25,10 @@ on the Fault Tolerance xref:circuitBreaker-eip.adoc[Circuit Breaker].
Below is an example route showing a Fault Tolerance EIP circuit breaker
that protects against a downstream HTTP operation with fallback.
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
@@ -35,8 +40,8 @@ from("direct:start")
.to("mock:result");
----
-And in XML DSL:
-
+XML::
++
[source,xml]
----
<route>
@@ -52,6 +57,7 @@ And in XML DSL:
<to uri="mock:result"/>
</route>
----
+====
In case the calling the downstream HTTP service is failing, and an exception is thrown
then the circuit breaker will react and execute the fallback route instead.
@@ -66,6 +72,10 @@ You can fine-tune the Fault Tolerance EIP by the many xref:faultToleranceConfigu
For example to use 2 second execution timeout, you can do as follows:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
@@ -79,8 +89,8 @@ from("direct:start")
.log("After Fault Tolerance ${body}");
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -94,6 +104,7 @@ And in XML:
<log message="After Fault Tolerance: ${body}"/>
</route>
----
+====
In this example if calling the downstream service does not return a response within 2 seconds,
a timeout is triggered, and the exchange will fail with a TimeoutException.
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/filter-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/filter-eip.adoc
index 15f29414322..dc91dab8180 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/filter-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/filter-eip.adoc
@@ -4,6 +4,7 @@
:description: Filter out messages based using a predicate
:since:
:supportlevel: Stable
+:tabs-sync-option:
The http://www.enterpriseintegrationpatterns.com/Filter.html[Message
Filter] from the xref:enterprise-integration-patterns.adoc[EIP patterns]
@@ -30,6 +31,10 @@ The Camel xref:languages:simple-language.adoc[Simple] language
is great to use with the Filter EIP when routing is based on the content of the message,
such as checking message headers.
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:a")
@@ -39,8 +44,8 @@ from("direct:a")
.to("direct:b")
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -52,9 +57,14 @@ And in XML:
<to uri="direct:b"/>
</route>
----
+====
You can use many languages as the predicate, such as xref:languages:xpath-language.adoc[XPath]:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start").
@@ -62,8 +72,8 @@ from("direct:start").
to("mock:result");
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -74,6 +84,7 @@ And in XML:
</filter>
</route>
----
+====
Here is another example of calling a xref:languages:bean-language.adoc[method on a bean]
to define the filter behavior:
@@ -85,7 +96,6 @@ from("direct:start")
.to("mock:gold")
.end()
.to("mock:all");
-}
----
And then bean can have a method that returns a `boolean` as the predicate:
@@ -101,7 +111,7 @@ public static class MyBean {
}
----
-And in XML we can call the bean in `<method> where we can specify the FQN classname
+And in XML we can call the bean in `<method>` where we can specify the FQN classname
of the bean as shown:
[source,xml]
@@ -121,6 +131,10 @@ of the bean as shown:
To know whether an `Exchange` was filtered or not, then you can choose to specify a name of a property
to store on the exchange with the result (boolean), using `statusPropertyName` as shown below:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
@@ -128,11 +142,10 @@ from("direct:start")
.to("mock:gold")
.end()
.to("mock:all");
-}
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -144,6 +157,7 @@ And in XML:
<to uri="mock:all"/>
</route>
----
+====
In the example above then Camel will store an exchange property with key `gold` with the result of the filtering,
whether it was `true` or `false`.
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/from-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/from-eip.adoc
index a783187c7e5..563f0deceb5 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/from-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/from-eip.adoc
@@ -4,6 +4,7 @@
:description: Act as a message source as input to a route
:since:
:supportlevel: Stable
+:tabs-sync-option:
Every Camel xref:manual::routes.adoc[route] starts from an xref:manual::endpoint.adoc[Endpoint]
as the input (source) to the route.
@@ -21,14 +22,18 @@ include::partial$eip-options.adoc[]
In the route below the route starts from
a xref:ROOT:file-component.adoc[File] endpoint.
+[tabs]
+====
+Java::
++
[source,java]
----
from("file:inbox")
.to("log:inbox");
----
-And the same example in XML DSL:
-
+XML::
++
[source,xml]
----
<route>
@@ -36,3 +41,15 @@ And the same example in XML DSL:
<to uri="log:inbox"/>
</route>
----
+
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: file:inbox
+ steps:
+ - to:
+ uri: log:inbox
+----
+====
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/guaranteed-delivery.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/guaranteed-delivery.adoc
index 3f11481026c..d1ad9983c0e 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/guaranteed-delivery.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/guaranteed-delivery.adoc
@@ -1,4 +1,5 @@
= Guaranteed Delivery
+:tabs-sync-option:
Camel supports the
http://www.enterpriseintegrationpatterns.com/GuaranteedMessaging.html[Guaranteed
@@ -28,14 +29,18 @@ is not considered successfully delivered until the recipient has
persisted the message locally guaranteeing its receipt in the event the
destination becomes unavailable.
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
.to("jms:queue:foo");
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -43,4 +48,4 @@ And in XML:
<to uri="jms:queue:foo"/>
</route>
----
-
+====
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/loop-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/loop-eip.adoc
index c57d3649498..20aa6ff7014 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/loop-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/loop-eip.adoc
@@ -4,6 +4,7 @@
:description: Processes a message multiple times
:since:
:supportlevel: Stable
+:tabs-sync-option:
The Loop EIP allows for processing a message a number of times, possibly in a different way for each iteration. Useful mostly during testing.
@@ -39,8 +40,8 @@ In the while mode, then the Loop EIP will keep looping until the expression eval
== Example
-The following example shows how to take a request from the direct:x endpoint,
-then send the message repetitively to mock:result.
+The following example shows how to take a request from the `direct:x` endpoint,
+then send the message repetitively to `mock:result`.
The number of times the message is sent is either passed as an argument to `loop`,
or determined at runtime by evaluating an expression.
@@ -50,6 +51,10 @@ otherwise a `RuntimeCamelException` is thrown.
Pass loop count as an argument:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:a")
@@ -57,28 +62,8 @@ from("direct:a")
.to("mock:result");
----
-Use expression to determine loop count:
-
-[source,java]
-----
-from("direct:b")
- .loop(header("loop"))
- .to("mock:result");
-----
-
-And with the xref:languages:xpath-language.adoc[XPath] language:
-
-[source,java]
-----
-from("direct:c")
- .loop(xpath("/hello/@times"))
- .to("mock:result");
-----
-
-And in XML:
-
-Pass loop count as an argument
-
+XML::
++
[source,xml]
----
<route>
@@ -89,9 +74,23 @@ Pass loop count as an argument
</loop>
</route>
----
+====
+
+Use expression to determine loop count:
-Use expression to determine loop count
+[tabs]
+====
+Java::
++
+[source,java]
+----
+from("direct:b")
+ .loop(header("loop"))
+ .to("mock:result");
+----
+XML::
++
[source,xml]
----
<route>
@@ -102,12 +101,26 @@ Use expression to determine loop count
</loop>
</route>
----
+====
+
+And with the xref:languages:xpath-language.adoc[XPath] language:
+
+[source,java]
+----
+from("direct:c")
+ .loop(xpath("/hello/@times"))
+ .to("mock:result");
+----
== Using copy mode
Now suppose we send a message to direct:start endpoint containing the letter A.
The output of processing this route will be that, each mock:loop endpoint will receive AB as message.
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
@@ -120,10 +133,8 @@ from("direct:start")
.to("mock:result");
----
-However, if we do *not* enable copy mode then mock:loop will receive "AB", "ABB", "ABBB", etc. messages.
-
-The equivalent example in XML DSL in copy mode is as follows:
-
+XML::
++
[source,xml]
----
<route>
@@ -139,6 +150,9 @@ The equivalent example in XML DSL in copy mode is as follows:
<to uri="mock:result"/>
</route>
----
+====
+
+However, if we do *not* enable copy mode then mock:loop will receive "AB", "ABB", "ABBB", etc. messages.
== Looping using while
@@ -147,6 +161,10 @@ The loop can act like a while loop that loops until the expression evaluates to
For example the route below loops while the length of the message body is 5 or fewer characters.
Notice that the DSL uses `loopDoWhile`.
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
@@ -157,8 +175,8 @@ from("direct:start")
.to("mock:result");
----
-And the same example in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -173,5 +191,6 @@ And the same example in XML:
<to uri="mock:result"/>
</route>
----
-
-Notice in XML that the while loop is turned on using the `doWhile` attribute.
++
+Notice that the while loop is turned on using the `doWhile` attribute.
+====
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/marshal-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/marshal-eip.adoc
index ae425f5cb5a..96207985c40 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/marshal-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/marshal-eip.adoc
@@ -1,4 +1,5 @@
= Marshal EIP
+:tabs-sync-option:
The xref:marshal-eip.adoc[Marshal] and xref:unmarshal-eip.adoc[Unmarshal] EIPs are used
for xref:message-translator.adoc[Message Transformation].
@@ -25,6 +26,10 @@ Then a xref:ROOT:bean-component.adoc[Bean] is invoked that takes in the Java obj
Then the reverse operation happens to transform the Java objects back into XML also via JAXB,
but using the `marshal` operation. And finally the message is routed to a xref:ROOT:jms-component.adoc[JMS] queue.
+[tabs]
+====
+Java::
++
[source,java]
----
from("file:inbox/xml")
@@ -34,8 +39,8 @@ from("file:inbox/xml")
.to("jms:queue:order");
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -47,3 +52,21 @@ And in XML:
</route>
----
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: file:inbox/xml
+ steps:
+ - unmarshal:
+ jaxb: {}
+ - to:
+ uri: bean:validateOrder
+ - marshal:
+ jaxb: {}
+ - to:
+ uri: jms:queue:order
+----
+====
+
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/message-bus.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/message-bus.adoc
index d5a0bed8df1..912fff631a1 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/message-bus.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/message-bus.adoc
@@ -1,4 +1,5 @@
= Message Bus
+:tabs-sync-option:
Camel supports the
https://www.enterpriseintegrationpatterns.com/MessageBus.html[Message
@@ -15,14 +16,18 @@ A messaging system such as Apache ActiveMQ can be used as Message Bus.
The following demonstrates how the Camel message bus can be used to
ingest message into the bus with the xref:ROOT:jms-component.adoc[JMS] component.
+[tabs]
+====
+Java::
++
[source,java]
----
from("file:inbox")
.to("jms:inbox");
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -30,3 +35,4 @@ And in XML:
<to uri="jms:inbox"/>
</route>
----
+====
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/message-channel.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/message-channel.adoc
index 1f7dfbc26de..bb7e3cd2b3a 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/message-channel.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/message-channel.adoc
@@ -1,4 +1,5 @@
= Message Channel
+:tabs-sync-option:
Camel supports the
http://www.enterpriseintegrationpatterns.com/MessageChannel.html[Message
@@ -21,16 +22,20 @@ the following:
jms:queue:foo
-------------
-The following shows a little Java route snippet:
+The following shows a little route snippet:
+[tabs]
+====
+Java::
++
[source,java]
----
from("file:foo")
.to("jms:queue:foo")
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -38,3 +43,4 @@ And in XML:
<to uri="jms:queue:foo"/>
</route>
----
+====
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/message-endpoint.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/message-endpoint.adoc
index 44ed4ae45c1..b6121616f97 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/message-endpoint.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/message-endpoint.adoc
@@ -1,4 +1,5 @@
= Message Endpoint
+:tabs-sync-option:
Camel supports the
http://www.enterpriseintegrationpatterns.com/MessageEndpoint.html[Message
@@ -27,14 +28,18 @@ available xref:ROOT:index.adoc[Components].
The following example route demonstrates the use of a xref:ROOT:file-component.adoc[File] consumer endpoint and a xref:ROOT:jms-component.adoc[JMS] producer endpoint,
by their xref:manual::uris.adoc[URIs]:
+[tabs]
+====
+Java::
++
[source,java]
----
from("file:messages/foo")
.to("jms:queue:foo");
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -42,4 +47,4 @@ And in XML:
<to uri="jms:queue:foo"/>
</route>
----
-
+====
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/message-expiration.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/message-expiration.adoc
index 0473d8b259e..89245a93ecb 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/message-expiration.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/message-expiration.adoc
@@ -1,4 +1,5 @@
= Message Expiration
+:tabs-sync-option:
Camel supports the
https://www.enterpriseintegrationpatterns.com/patterns/messaging/MessageExpiration.html[Message Expiration]
@@ -19,14 +20,18 @@ IMPORTANT: When using message expiration then mind about keeping clock's synchro
A message should expire after 5 seconds:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:cheese")
.to("jms:queue:cheese?timeToLive=5000");
----
-And in XML
-
+XML::
++
[source,xml]
----
<route>
@@ -34,3 +39,4 @@ And in XML
<to uri="jms:queue:cheese?timeToLive=5000"/>
</route>
----
+====
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/message-router.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/message-router.adoc
index 218214c5545..9fa5aed7d5f 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/message-router.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/message-router.adoc
@@ -1,4 +1,5 @@
= Message Router
+:tabs-sync-option:
The
http://www.enterpriseintegrationpatterns.com/MessageRouter.html[Message
@@ -26,6 +27,10 @@ The following example shows how to route a request from an input
direct:a endpoint to either direct:b, direct:c, or direct:d depending on
the evaluation of various xref:manual::predicate.adoc[Predicate]:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:a")
@@ -38,8 +43,8 @@ from("direct:a")
.to("direct:d");
----
-And the same example using XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -59,3 +64,4 @@ And the same example using XML:
</choice>
</route>
----
+====
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/message-translator.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/message-translator.adoc
index 95351fcda43..f2871683b38 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/message-translator.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/message-translator.adoc
@@ -1,4 +1,5 @@
= Message Translator
+:tabs-sync-option:
Camel supports the
http://www.enterpriseintegrationpatterns.com/MessageTranslator.html[Message
@@ -28,6 +29,10 @@ xref:manual::expression.adoc[Expression] to do the transformation:
In the example below we prepend Hello to the message body using the
xref:components:languages:simple-language.adoc[Simple] language:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:cheese")
@@ -35,8 +40,8 @@ from("direct:cheese")
.to("log:hello");
----
-And in XML DSL:
-
+XML::
++
[source,xml]
----
<route>
@@ -47,6 +52,7 @@ And in XML DSL:
<to uri="activemq:wine"/>
</route>
----
+====
=== Message Translator with Bean
@@ -54,6 +60,10 @@ You can transform a message using Camels
xref:manual::bean-integration.adoc[Bean Integration] to call any method on a bean
that performs the message translation:
+[tabs]
+====
+Java::
++
[source,java]
----
from("activemq:cheese")
@@ -61,8 +71,8 @@ from("activemq:cheese")
.to("activemq:wine");
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -71,12 +81,17 @@ And in XML:
<to uri="activemq:wine"/>
</route>
----
+====
=== Message Translator with Processor
You can also use a xref:manual::processor.adoc[Processor] to do
the transformation:
+[tabs]
+====
+Java::
++
[source,java]
----
from("activemq:cheese")
@@ -84,8 +99,8 @@ from("activemq:cheese")
.to("activemq:wine");
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -94,6 +109,7 @@ And in XML:
<to uri="activemq:wine"/>
</route>
----
+====
=== Message Translator using Templating Components
@@ -101,6 +117,10 @@ You can also consume a message from one destination, transform it with something
xref:ROOT:velocity-component.adoc[Velocity] or xref:ROOT:xquery-component.adoc[XQuery] and then send
it on to another destination.
+[tabs]
+====
+Java::
++
[source,java]
----
from("activemq:cheese")
@@ -108,8 +128,8 @@ from("activemq:cheese")
.to("activemq:wine");
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -118,6 +138,7 @@ And in XML:
<to uri="activemq:wine"/>
</route>
----
+====
=== Message Translator using Data Format
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/messaging-bridge.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/messaging-bridge.adoc
index bfaa860dac2..c487220ffda 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/messaging-bridge.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/messaging-bridge.adoc
@@ -1,4 +1,5 @@
= Messaging Bridge
+:tabs-sync-option:
Camel supports the
https://www.enterpriseintegrationpatterns.com/patterns/messaging/MessagingBridge.html[Messaging Bridge]
@@ -20,14 +21,18 @@ Another alternative is to bridge systems using xref:change-data-capture.adoc[Cha
A basic bridge between two messaging systems (such as WebsphereMQ and xref:ROOT:jms-component.adoc[JMS] broker)
can be done with a single Camel route:
+[tabs]
+====
+Java::
++
[source,java]
----
from("mq:queue:foo")
.to("jms:queue:foo")
----
-And in XML
-
+XML::
++
[source,xml]
----
<route>
@@ -36,3 +41,4 @@ And in XML
</route>
----
+====
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/multicast-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/multicast-eip.adoc
index a8c01165237..81f8c639ecf 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/multicast-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/multicast-eip.adoc
@@ -4,6 +4,7 @@
:description: Routes the same message to multiple paths either sequentially or in parallel.
:since:
:supportlevel: Stable
+:tabs-sync-option:
The Multicast EIP allows to route *the same* message to a number of xref:manual::endpoint.adoc[endpoints]
and process them in a different way.
@@ -37,6 +38,10 @@ The following exchange properties are set on each `Exchange` that are multicaste
The following example shows how to take a request from the direct:a
endpoint, then multicast these request to direct:x, direct:y, and direct:z.
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:a")
@@ -46,8 +51,8 @@ from("direct:a")
.to("direct:z");
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -59,6 +64,7 @@ And in XML:
</multicast>
</route>
----
+====
By default, Multicast EIP runs in single threaded mode, which mean
that the next multicasted message is processed only when the previous is finished.
@@ -71,6 +77,10 @@ is processed by its own thread in parallel.
The example below enabled parallel mode:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:a")
@@ -80,8 +90,8 @@ from("direct:a")
.to("direct:z");
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -93,16 +103,20 @@ And in XML:
</multicast>
</route>
----
+====
=== Ending a Multicast block
-You may want to continue routing the exchange after the Multicast EIP. In Java DSL you need to use `end()`
-to mark where multicast ends, and where other EIPs can be added to continue the route.
+You may want to continue routing the exchange after the Multicast EIP.
In the example above then sending to mock:result happens after the Multicast EIP has finished.
In other words direct:y, direct:y, and direct:z should be completed first, before the message
continues.
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:a")
@@ -113,9 +127,12 @@ from("direct:a")
.end()
.to("mock:result");
----
++
+Note that you need to use `end()` to mark where multicast ends, and where other
+EIPs can be added to continue the route.
-And in XML its intuitive as `</multicast>` marks the end of the block:
-
+XML::
++
[source,xml]
----
<route>
@@ -128,6 +145,7 @@ And in XML its intuitive as `</multicast>` marks the end of the block:
<to uri="mock:result"/>
</route>
----
+====
=== Aggregating
@@ -136,6 +154,10 @@ as a single response exchange, that becomes the outgoing exchange after the Mult
The example now aggregates with the `MyAggregationStrategy` class:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
@@ -147,8 +169,10 @@ from("direct:start")
.to("mock:result");
----
-And in XML we can refer to the FQN class name with `#class:` syntax as shown below:
-
+XML::
++
+We can refer to the FQN class name with `#class:` syntax as shown below:
++
[source,xml]
----
<route>
@@ -162,6 +186,7 @@ And in XML we can refer to the FQN class name with `#class:` syntax as shown bel
<to uri="mock:result"/>
</route>
----
+====
[NOTE]
====
@@ -188,6 +213,10 @@ handle it. You can do this by specifying that it should stop in case of an
exception occurred. This is done by the `stopOnException` option as
shown below:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
@@ -203,11 +232,8 @@ from("direct:start")
from("direct:baz").to("mock:baz");
----
-In the example above, then `MyProcessor` is causing a failure and throws an exception.
-This means the Multicast EIP will stop after this, and not the last route (direct:baz).
-
-And using XML DSL you specify it as follows:
-
+XML::
++
[source,xml]
----
<routes>
@@ -238,6 +264,10 @@ And using XML DSL you specify it as follows:
</route>
</routes>
----
+====
+
+In the example above, then `MyProcessor` is causing a failure and throws an exception.
+This means the Multicast EIP will stop after this, and not the last route (direct:baz).
=== Preparing the message by deep copying before multicasting
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/pipeline-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/pipeline-eip.adoc
index 7050b05a55b..07a644f183f 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/pipeline-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/pipeline-eip.adoc
@@ -4,6 +4,7 @@
:description: Routes the message to a sequence of processors.
:since:
:supportlevel: Stable
+:tabs-sync-option:
Camel supports the http://www.enterpriseintegrationpatterns.com/PipesAndFilters.html[Pipes and Filters]
from the xref:enterprise-integration-patterns.adoc[EIP patterns] in various ways.
@@ -26,6 +27,10 @@ You can create pipelines of logic using multiple
xref:manual::endpoint.adoc[Endpoint] or
xref:message-translator.adoc[Message Translator] instances as follows:
+[tabs]
+====
+Java::
++
[source,java]
----
from("activemq:cheese")
@@ -35,8 +40,8 @@ from("activemq:cheese")
.to("acitvemq:wine");
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -48,10 +53,15 @@ And in XML:
</pipeline>
</route>
----
+====
Though pipeline is the default mode of operation when you specify
multiple outputs in Camel. Therefore, it's much more common to see this with Camel:
+[tabs]
+====
+Java::
++
[source,java]
----
from("activemq:SomeQueue")
@@ -60,8 +70,8 @@ from("activemq:SomeQueue")
.to("acitvemq:OutputQueueu");
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -71,6 +81,7 @@ And in XML:
<to uri="activemq:wine"/>
</route>
----
+====
=== Pipeline vs Multicast
@@ -87,8 +98,10 @@ For example in the example below where xref:multicast-eip.adoc[Multicast] EIP is
message in two different pipelines. The first pipeline calls the something bean, and the second pipeline
calls the foo and bar beans and then route the message to another queue.
-Notice how we have to use `end()` in the Java DSL to mark the end of the blocks:
-
+[tabs]
+====
+Java::
++
[source,java]
----
from("activemq:SomeQueue")
@@ -105,9 +118,11 @@ from("activemq:SomeQueue")
.end() // ends multicast
.to("log:result");
----
++
+Notice how we have to use `end()` to mark the end of the blocks.
-In XML its intuitive where you do not need to use `end`:
-
+XML::
++
[source,xml]
----
<route>
@@ -126,3 +141,4 @@ In XML its intuitive where you do not need to use `end`:
<to uri="log:result"/>
</route>
----
+====
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/point-to-point-channel.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/point-to-point-channel.adoc
index 767c13e9785..c2c1aa0a53e 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/point-to-point-channel.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/point-to-point-channel.adoc
@@ -1,4 +1,5 @@
= Point to Point Channel
+:tabs-sync-option:
Camel supports the
http://www.enterpriseintegrationpatterns.com/PointToPointChannel.html[Point
@@ -28,6 +29,10 @@ TIP: See also the related xref:publish-subscribe-channel.adoc[Publish Scribe Cha
The following example demonstrates point to point messaging using
the xref:ROOT:jms-component.adoc[JMS] component:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
@@ -37,8 +42,8 @@ from("jms:queue:foo")
.to("bean:foo");
----
-And in XML:
-
+XML::
++
[source,xml]
----
<routes>
@@ -52,4 +57,4 @@ And in XML:
</route>
</routes>
----
-
+====
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/pollEnrich-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/pollEnrich-eip.adoc
index 9180ca8ed9b..af55941ab54 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/pollEnrich-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/pollEnrich-eip.adoc
@@ -4,6 +4,7 @@
:description: Enriches messages with data polled from a secondary resource
:since:
:supportlevel: Stable
+:tabs-sync-option:
Camel supports the
http://www.enterpriseintegrationpatterns.com/DataEnricher.html[Content
@@ -152,6 +153,10 @@ Both `enrich` and `pollEnrich` supports using dynamic uris computed based on inf
For example to `pollEnrich` from an endpoint that uses a header to indicate a SEDA queue name:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
@@ -159,8 +164,8 @@ from("direct:start")
.to("direct:result");
----
-And in XML DSL:
-
+XML::
++
[source,xml]
----
<route>
@@ -171,6 +176,7 @@ And in XML DSL:
<to uri="direct:result"/>
</route>
----
+====
TIP: See the `cacheSize` option for more details on _how much cache_ to use depending on how many or few unique endpoints are used.
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/publish-subscribe-channel.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/publish-subscribe-channel.adoc
index 10dd971fc37..b52482f4559 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/publish-subscribe-channel.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/publish-subscribe-channel.adoc
@@ -1,4 +1,5 @@
= Publish Subscribe Channel
+:tabs-sync-option:
Camel supports the
http://www.enterpriseintegrationpatterns.com/PublishSubscribeChannel.html[Publish Subscribe Channel]
@@ -26,6 +27,10 @@ TIP: See also the related xref:point-to-point-channel.adoc[Point to Point Channe
The following example demonstrates publish sbuscriber messaging using
the xref:ROOT:jms-component.adoc[JMS] component with JMS topics:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
@@ -38,8 +43,8 @@ from("jms:topic:cheese")
.to("bean:bar");
----
-And in XML:
-
+XML::
++
[source,xml]
----
<routes>
@@ -53,4 +58,4 @@ And in XML:
</route>
</routes>
----
-
+====
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/random-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/random-eip.adoc
index a3be01958fd..e1de9ac8d92 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/random-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/random-eip.adoc
@@ -4,6 +4,7 @@
:description: The destination endpoints are selected by random.
:since:
:supportlevel: Stable
+:tabs-sync-option:
Random mode for the xref:loadBalance-eip.adoc[Load Balancer] EIP.
@@ -18,8 +19,12 @@ include::partial$eip-options.adoc[]
We want to load balance between three endpoints in random mode.
-This is done as follows in Java DSL:
+This is done as follows:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
@@ -30,8 +35,8 @@ from("direct:start")
.end();
----
-In XML you'll have a route like this:
-
+XML::
++
[source,xml]
----
<route>
@@ -44,3 +49,4 @@ In XML you'll have a route like this:
</loadBalance>
</route>
----
+====
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/recipientList-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/recipientList-eip.adoc
index 227d071f47b..04ebed37e68 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/recipientList-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/recipientList-eip.adoc
@@ -4,6 +4,7 @@
:description: Route messages to a number of dynamically specified recipients
:since:
:supportlevel: Stable
+:tabs-sync-option:
Camel supports the
https://www.enterpriseintegrationpatterns.com/RecipientList.html[Recipient List]
@@ -51,14 +52,18 @@ _response_ message as the result after the Recipient List EIP.
The following example shows how to route a request from an input queue:a endpoint
to a static list of destinations, using `constant`:
+[tabs]
+====
+Java::
++
[source,java]
----
from("jms:queue:a")
.recipientList(constant("seda:x,seda:y,seda:z"));
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -68,6 +73,7 @@ And in XML:
</recipientList>
</route>
----
+====
=== Using Dynamic Recipient List
@@ -78,16 +84,18 @@ The following example demonstrates how to create a dynamic recipient list using
(which in this case extracts a named header value dynamically) to calculate the list of endpoints; which are either
of type `Endpoint` or are converted to a `String` and then resolved using the endpoint URIs (separated by comma).
-In Java DSL its as easy as:
-
+[tabs]
+====
+Java::
++
[source,java]
----
from("jms:queue:a")
.recipientList(header("foo"));
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -97,6 +105,7 @@ And in XML:
</recipientList>
</route>
----
+====
==== How is dynamic destinations evaluated
@@ -144,16 +153,20 @@ The Recipient List supports `parallelProcessing` similar to what xref:multicast-
When using parallel processing then a thread pool is used to have concurrent tasks sending the `Exchange`
to multiple recipients concurrently.
-You can enable parallel mode using `parallelProcessing` in Java as shown:
+You can enable parallel mode using `parallelProcessing` as shown:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:a")
.recipientList(header("myHeader")).parallelProcessing();
----
-And in XML it is an attribute on `<recipientList>`:
-
+XML::
++
[source,xml]
----
<route>
@@ -163,6 +176,7 @@ And in XML it is an attribute on `<recipientList>`:
</recipientList>
</route>
----
+====
==== Using custom thread pool
@@ -183,6 +197,10 @@ handle it. You can do this by specifying that it should stop in case of an
exception occurred. This is done by the `stopOnException` option as
shown below:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
@@ -196,14 +214,8 @@ from("direct:start")
from("direct:baz").to("mock:baz");
----
-In this example suppose a message is sent with the header `whereTo=direct:foo,direct:bar,direct:baz`
-that means the recipient list sends messages to those 3 endpoints.
-
-Now suppose that the `MyProcessor` is causing a failure and throws an exception.
-This means the Recipient List EIP will stop after this, and not the last route (direct:baz).
-
-And using XML DSL you specify it as follows:
-
+XML::
++
[source,xml]
----
<routes>
@@ -232,20 +244,31 @@ And using XML DSL you specify it as follows:
</route>
</routes>
----
+====
+
+In this example suppose a message is sent with the header `whereTo=direct:foo,direct:bar,direct:baz`
+that means the recipient list sends messages to those 3 endpoints.
+
+Now suppose that the `MyProcessor` is causing a failure and throws an exception.
+This means the Recipient List EIP will stop after this, and not the last route (direct:baz).
=== Ignore invalid endpoints
The Recipient List supports `ignoreInvalidEndpoints` (like xref:routingSlip-eip.adoc[Routing Slip] EIP).
You can use it to skip endpoints which are invalid.
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:a")
.recipientList(header("myHeader")).ignoreInvalidEndpoints();
----
-And in XML it is an attribute on `<recipientList>`:
-
+XML::
++
[source,xml]
----
<route>
@@ -255,6 +278,7 @@ And in XML it is an attribute on `<recipientList>`:
</recipientList>
</route>
----
+====
Then let us say the `myHeader` contains the following two endpoints `direct:foo,xxx:bar`.
The first endpoint is valid and works. However, the second one is invalid and will just be ignored.
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/removeHeader-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/removeHeader-eip.adoc
index 81ad38f263b..100ef9a9109 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/removeHeader-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/removeHeader-eip.adoc
@@ -4,6 +4,7 @@
:description: Removes a named header from the message
:since:
:supportlevel: Stable
+:tabs-sync-option:
The Remove Header EIP allows you to remove a single header from the xref:message.adoc[Message].
@@ -17,6 +18,10 @@ include::partial$eip-options.adoc[]
We want to remove a header with key "myHeader" from the message:
+[tabs]
+====
+Java::
++
[source,java]
----
from("seda:b")
@@ -24,8 +29,8 @@ from("seda:b")
.to("mock:result");
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -35,6 +40,20 @@ And in XML:
</route>
----
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: seda:b
+ steps:
+ - removeHeader:
+ name: myHeader
+ - to:
+ uri: mock:result
+----
+====
+
== See Also
Camel provides the following EIPs for removing headers or exchange properties:
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/removeHeaders-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/removeHeaders-eip.adoc
index 408df1908f7..0b1c5d20ce7 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/removeHeaders-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/removeHeaders-eip.adoc
@@ -4,6 +4,7 @@
:description: Removes message headers whose name matches a specified pattern
:since:
:supportlevel: Stable
+:tabs-sync-option:
The Remove Headers EIP allows you to remove one or more headers from the xref:message.adoc[Message],
based on pattern syntax.
@@ -27,6 +28,10 @@ matching by the following rules in the given order:
To remove all headers you can use `*` as the pattern:
+[tabs]
+====
+Java::
++
[source,java]
----
from("seda:b")
@@ -34,8 +39,8 @@ from("seda:b")
.to("mock:result");
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -45,10 +50,27 @@ And in XML:
</route>
----
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: seda:b
+ steps:
+ - removeHeaders: "*"
+ - to:
+ uri: mock:result
+----
+====
+
== Remove all Camel headers
To remove all headers that start with `Camel` then use `Camel*` as shown:
+[tabs]
+====
+Java::
++
[source,java]
----
from("seda:b")
@@ -56,8 +78,8 @@ from("seda:b")
.to("mock:result");
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -67,6 +89,19 @@ And in XML:
</route>
----
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: seda:b
+ steps:
+ - removeHeaders: "Camel*"
+ - to:
+ uri: mock:result
+----
+====
+
== See Also
Camel provides the following EIPs for removing headers or exchange properties:
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/removeProperties-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/removeProperties-eip.adoc
index a2028027700..2b6757bc8bf 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/removeProperties-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/removeProperties-eip.adoc
@@ -4,6 +4,7 @@
:description: Removes message exchange properties whose name matches a specified pattern
:since:
:supportlevel: Stable
+:tabs-sync-option:
The Remove Properties EIP allows you to remove one or more `Exchange` properties,
based on pattern syntax.
@@ -25,6 +26,10 @@ matching by the following rules in the given order:
== Remove all properties
+[tabs]
+====
+Java::
++
[source,java]
----
from("seda:b")
@@ -32,8 +37,8 @@ from("seda:b")
.to("mock:result");
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -42,6 +47,7 @@ And in XML:
<to uri="mock:result"/>
</route>
----
+====
NOTE: Be careful to remove all exchange properties as Camel uses internally exchange properties
to keep state on the `Exchange` during routing. So use this with care. You should generally only remove
@@ -51,6 +57,10 @@ custom exchange properties that are under your own control.
To remove all exchange properties that start with `Foo` then use `Foo*` as shown:
+[tabs]
+====
+Java::
++
[source,java]
----
from("seda:b")
@@ -58,8 +68,8 @@ from("seda:b")
.to("mock:result");
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -68,6 +78,7 @@ And in XML:
<to uri="mock:result"/>
</route>
----
+====
== See Also
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/removeProperty-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/removeProperty-eip.adoc
index 56b0554ec11..20543f047f9 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/removeProperty-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/removeProperty-eip.adoc
@@ -4,6 +4,7 @@
:description: Removes a named property from the message exchange
:since:
:supportlevel: Stable
+:tabs-sync-option:
The Remove Property EIP allows you to remove a single property from the `Exchange`.
@@ -17,6 +18,10 @@ include::partial$eip-options.adoc[]
We want to remove an exchange property with key "myProperty" from the exchange:
+[tabs]
+====
+Java::
++
[source,java]
----
from("seda:b")
@@ -24,8 +29,8 @@ from("seda:b")
.to("mock:result");
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -34,6 +39,7 @@ And in XML:
<to uri="mock:result"/>
</route>
----
+====
== See Also
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/requestReply-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/requestReply-eip.adoc
index 973a8facb2c..cf74d8a0e67 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/requestReply-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/requestReply-eip.adoc
@@ -1,4 +1,5 @@
= Request Reply
+:tabs-sync-option:
Camel supports the
http://www.enterpriseintegrationpatterns.com/RequestReply.html[Request Reply]
@@ -44,14 +45,18 @@ IMPORTANT: This is only possible on endpoints used by consumers (i.e. in `<from>
In the example below the message will be forced as a request reply message as the consumer
is in `InOut` mode.
+[tabs]
+====
+Java::
++
[source,java]
----
from("jms:someQueue?exchangePattern=InOut")
.to("bean:processMessage");
----
-And with XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -59,12 +64,17 @@ And with XML:
<to uri="bean:processMessage"/>
</route>
----
+====
== Using setExchangePattern EIP
You can specify the
xref:manual::exchange-pattern.adoc[Exchange Pattern] using `setExchangePattern` in the DSL.
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:foo")
@@ -72,8 +82,8 @@ from("direct:foo")
.to("jms:queue:cheese");
----
-And with XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -82,6 +92,7 @@ And with XML:
<to uri="jms:queue:cheese"/>
</route>
----
+====
When using `setExchangePattern` then the xref:manual::exchange-pattern.adoc[Exchange Pattern]
on the xref:manual::exchange.adoc[Exchange] is changed from this point onwards in the route.
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/resequence-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/resequence-eip.adoc
index 7b4ae593f88..de376bac838 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/resequence-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/resequence-eip.adoc
@@ -4,6 +4,7 @@
:description: Resequences (re-order) messages based on an expression
:since:
:supportlevel: Stable
+:tabs-sync-option:
Camel supports the
http://www.enterpriseintegrationpatterns.com/Resequencer.html[Resequencer]
@@ -44,15 +45,19 @@ then they are sorted, and sent out, to continue being routed.
In the example below we re-order the message based on content of the message body.
The default batch modes will collect up till 100 messages per batch, or timeout every second.
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
.resequence().body()
.to("mock:result");
----
-
++
This is equivalent to:
-
++
[source,java]
----
from("direct:start")
@@ -60,8 +65,8 @@ from("direct:start")
.to("mock:result");
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -72,9 +77,14 @@ And in XML:
</resequence>
</route>
----
+====
The batch resequencer can be further configured via the `size()` and `timeout()` methods:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
@@ -82,10 +92,8 @@ from("direct:start")
.to("mock:result")
----
-This sets the batch size to 300 and the batch timeout to 4000 ms (by default, the batch size is 100 and the timeout is 1000 ms).
-
-And the example in XML DSL:
-
+XML::
++
[source,xml]
----
<route>
@@ -97,11 +105,18 @@ And the example in XML DSL:
</resequence>
</route>
----
+====
+
+This sets the batch size to 300 and the batch timeout to 4000 ms (by default, the batch size is 100 and the timeout is 1000 ms).
So the above example will reorder messages in order of their bodies.
Typically, you'd use a header rather than the body to order things; or maybe a part of the body.
So you could replace this expression with:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
@@ -109,8 +124,8 @@ from("direct:start")
.to("mock:result")
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -121,6 +136,7 @@ And in XML:
</resequence>
</route>
----
+====
This reorders messages using a custom sequence number with the header name mySeqNo.
@@ -131,6 +147,10 @@ of keeping only last duplicated message.
In batch mode, you can turn on duplicates as follows:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
@@ -138,8 +158,8 @@ from("direct:start")
.to("mock:result")
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -151,6 +171,7 @@ And in XML:
</resequence>
</route>
----
+====
=== Reverse Ordering
@@ -160,6 +181,9 @@ In some cases you want to reverse the ordering.
In batch mode, you can turn on reverse as follows:
+[tabs]
+====
++
[source,java]
----
from("direct:start")
@@ -167,8 +191,8 @@ from("direct:start")
.to("mock:result")
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -180,6 +204,7 @@ And in XML:
</resequence>
</route>
----
+====
=== Ignoring invalid messages
@@ -190,6 +215,10 @@ You can ignore these kinds of errors, and let the Resequencer skip the invalid E
To do this you do as follows in Java DSL:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
@@ -199,8 +228,8 @@ from("direct:start")
.to("mock:result");
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -212,6 +241,7 @@ And in XML:
</resequence>
</route>
----
+====
This option is available for both batch and stream mode.
@@ -242,6 +272,10 @@ that are ordered 1,2,3...N.
The following example uses the header seqnum for the ordering:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
@@ -249,8 +283,8 @@ from("direct:start")
.to("mock:result");
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -262,10 +296,15 @@ And in XML:
</resequence>
</route>
----
+====
The Resequencer keeps a backlog of pending messages in a backlog.
The default capacity is 1000 elements, which can be configured:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
@@ -273,8 +312,8 @@ from("direct:start")
.to("mock:result")
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -286,6 +325,7 @@ And in XML:
</resequence>
</route>
----
+====
This uses a capacity of 5000 elements. And the timeout has been set to 4 seconds.
In case of a timeout, then the resequencer disreards the current exepected sequence number,
@@ -355,6 +395,10 @@ This provides an extra level of control in regard to delayed message ordering.
In the example below old messages are rejected:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
@@ -362,8 +406,8 @@ from("direct:start")
.to("mock:result");
----
-And in XML DSL:
-
+XML::
++
[source,xml]
----
<route>
@@ -375,5 +419,6 @@ And in XML DSL:
</resequence>
</route>
----
+====
If an old message is detected then Camel throws `MessageRejectedException`.
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/resilience4j-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/resilience4j-eip.adoc
index 5d9100a6291..df745863fd1 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/resilience4j-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/resilience4j-eip.adoc
@@ -1,4 +1,5 @@
= Resilience4j EIP
+:tabs-sync-option:
The Resilience4j EIP provides integration with Resilience4j https://resilience4j.readme.io/[Resilience4j]
to be used as xref:circuitBreaker-eip.adoc[Circuit Breaker] in the Camel routes.
@@ -24,6 +25,10 @@ on Resilience xref:circuitBreaker-eip.adoc[Circuit Breaker].
Below is an example route showing a Resilience4j circuit breaker
that protects against a downstream HTTP operation with fallback.
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
@@ -35,8 +40,8 @@ from("direct:start")
.to("mock:result");
----
-And in XML DSL:
-
+XML::
++
[source,xml]
----
<route>
@@ -52,6 +57,7 @@ And in XML DSL:
<to uri="mock:result"/>
</route>
----
+====
In case the calling the downstream HTTP service is failing, and an exception is thrown
then the circuit breaker will react and execute the fallback route instead.
@@ -66,6 +72,10 @@ You can fine-tune Resilience4j by the many xref:resilience4jConfiguration-eip.ad
For example to use 2 second execution timeout, you can do as follows:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
@@ -79,8 +89,8 @@ from("direct:start")
.log("After Resilience ${body}");
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -94,6 +104,7 @@ And in XML:
<log message="After Resilience: ${body}"/>
</route>
----
+====
In this example if calling the downstream service does not return a response within 2 seconds,
a timeout is triggered, and the exchange will fail with a `TimeoutException`.
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/return-address.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/return-address.adoc
index 0b2fbe6b5e6..c65e4786d75 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/return-address.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/return-address.adoc
@@ -1,4 +1,5 @@
= Return Address
+:tabs-sync-option:
Camel supports the
http://www.enterpriseintegrationpatterns.com/ReturnAddress.html[Return
@@ -20,14 +21,18 @@ component via the `JMSReplyTo` header.
In the example below we send a message to the JMS cheese queue using `InOut` mode, this means
that Camel will automatically configure the `JMSReplyTo` header with a temporary queue as the Return Address.
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:foo")
.to(ExchangePattern.InOut, "jms:queue:cheese");
----
-And in XML
-
+XML::
++
[source,xml]
----
<route>
@@ -35,18 +40,23 @@ And in XML
<to pattern="InOut" uri="jms:queue:cheese"/>
</route>
----
+====
You can also specify a named reply queue with the `replyTo` option (instead of a temporary queue).
When doing so then `InOut` mode is implied:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:foo")
.to("jms:queue:cheese?replyTo=myReplyQueue");
----
-And in XML
-
+XML::
++
[source,xml]
----
<route>
@@ -54,6 +64,7 @@ And in XML
<to uri="jms:queue:cheese?replyTo=myReplyQueue"/>
</route>
----
+====
== See Also
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/rollback-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/rollback-eip.adoc
index 2407fa47a69..aac6e76a219 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/rollback-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/rollback-eip.adoc
@@ -4,6 +4,7 @@
:description: Forces a rollback by stopping routing the message
:since:
:supportlevel: Stable
+:tabs-sync-option:
The Rollback EIP is used for marking an xref:manual::exchange.adoc[Exchange]
to rollback and stop continue routing the message.
@@ -19,6 +20,10 @@ We want test message for some conditions and force a rollback if a message may b
In Java DSL we can do:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
@@ -28,8 +33,8 @@ from("direct:start")
.to("direct:continue");
----
-And in XML DSL:
-
+XML::
++
[source,xml]
----
<route>
@@ -45,6 +50,7 @@ And in XML DSL:
</choice>
</route>
----
+====
When Camel is rolling back, then a `RollbackExchangeException` is thrown with the caused message "That do not work".
@@ -55,6 +61,10 @@ to cause the message to fail and rollback.
This behavior can be modified to only mark for rollback, and not throw the exception.
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
@@ -64,8 +74,8 @@ from("direct:start")
.to("direct:continue");
----
-And in XML DSL:
-
+XML::
++
[source,xml]
----
<route>
@@ -81,6 +91,7 @@ And in XML DSL:
</choice>
</route>
----
+====
Then no exception is thrown, but the message is marked to rollback and stopped continue routing.
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/routingSlip-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/routingSlip-eip.adoc
index 938991a2fd2..4dd83b197e5 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/routingSlip-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/routingSlip-eip.adoc
@@ -4,6 +4,7 @@
:description: Routes a message through a series of steps that are pre-determined (the slip)
:since:
:supportlevel: Stable
+:tabs-sync-option:
Camel supports the
https://www.enterpriseintegrationpatterns.com/patterns/messaging/RoutingTable.html[Routing Slip]
@@ -45,23 +46,18 @@ TIP: A slip can be empty, meaning that the message will not be routed anywhere.
The following route will take any messages sent to the Apache ActiveMQ queue cheese
and use the header with key "whereTo" that is used to compute the slip (endpoint xref:manual::uris.adoc[uris]).
+[tabs]
+====
+Java::
++
[source,java]
---------------------
from("activemq:cheese")
.routingSlip(header("whereTo"));
---------------------
-The value of the header ("whereTo") should be a comma-delimited string of endpoint URIs you wish the message to be routed to.
-The message will be routed in a xref:pipeline-eip.adoc[pipeline] fashion, i.e., one after the other.
-
-The Routing Slip sets a property, `Exchange.SLIP_ENDPOINT`, on the `Exchange` which contains the
-current endpoint as it advanced though the slip. This allows you to _know_ how far we have processed in the slip.
-
-The Routing Slip will compute the slip *beforehand* which means,
-the slip is only computed once. If you need to compute the slip _on-the-fly_ then use the xref:dynamicRouter-eip.adoc[Dynamic Router] EIP instead.
-
-The same example in XML is simply just:
-
+XML::
++
[source,xml]
----
<route>
@@ -71,6 +67,16 @@ The same example in XML is simply just:
</routingSlip>
</route>
----
+====
+
+The value of the header ("whereTo") should be a comma-delimited string of endpoint URIs you wish the message to be routed to.
+The message will be routed in a xref:pipeline-eip.adoc[pipeline] fashion, i.e., one after the other.
+
+The Routing Slip sets a property, `Exchange.SLIP_ENDPOINT`, on the `Exchange` which contains the
+current endpoint as it advanced though the slip. This allows you to _know_ how far we have processed in the slip.
+
+The Routing Slip will compute the slip *beforehand* which means,
+the slip is only computed once. If you need to compute the slip _on-the-fly_ then use the xref:dynamicRouter-eip.adoc[Dynamic Router] EIP instead.
=== How is the slip computed
@@ -90,14 +96,18 @@ The default delimiter is comma, but can be re-configured.
The Routing Slip supports `ignoreInvalidEndpoints` (like xref:recipientList-eip.adoc[Recipient List] EIP).
You can use it to skip endpoints which are invalid.
+[tabs]
+====
+Java::
++
[source,java]
---------------------
from("direct:start")
.routingSlip("myHeader").ignoreInvalidEndpoints();
---------------------
-And in XML DSL it is an attribute on `<routingSlip>`:
-
+XML::
++
[source,xml]
---------------------
<route>
@@ -107,6 +117,7 @@ And in XML DSL it is an attribute on `<routingSlip>`:
</routingSlip>
</route>
---------------------
+====
Then let us say the `myHeader` contains the following two endpoints `direct:foo,xxx:bar`.
The first endpoint is valid and works. However, the second one is invalid and will just be ignored.
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/sample-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/sample-eip.adoc
index d172cd19e51..9337fb7d594 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/sample-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/sample-eip.adoc
@@ -4,6 +4,7 @@
:description: Extract a sample of the messages passing through a route
:since:
:supportlevel: Stable
+:tabs-sync-option:
A sampling throttler allows you to extract a sample of the exchanges from the traffic through a route.
@@ -22,6 +23,10 @@ include::partial$eip-options.adoc[]
In the example below we sample one message per second (default time period):
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:sample")
@@ -29,8 +34,8 @@ from("direct:sample")
.to("direct:sampled");
----
-And in XML
-
+XML::
++
[source,xml]
----
<route>
@@ -40,12 +45,17 @@ And in XML
</sample>
</route>
----
+====
=== Sampling using time period
The default time period is 1 second, but this can easily be configured.
For example to sample 1 message per 5 seconds you can do:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:sample")
@@ -53,8 +63,8 @@ from("direct:sample")
.to("direct:sampled");
----
-And in XML
-
+XML::
++
[source,xml]
----
<route>
@@ -64,6 +74,7 @@ And in XML
</sample>
</route>
----
+====
=== Sampling using message frequency
@@ -71,6 +82,10 @@ The Sample EIP can also be configured to sample based on frequency instead of ti
For example to sample every 10th message you can do:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:sample")
@@ -78,8 +93,8 @@ from("direct:sample")
.to("direct:sampled");
----
-And in XML
-
+XML::
++
[source,xml]
----
<route>
@@ -89,3 +104,4 @@ And in XML
</sample>
</route>
----
+====
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/script-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/script-eip.adoc
index 4c08f9ac6c4..1f87671f30f 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/script-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/script-eip.adoc
@@ -4,6 +4,7 @@
:description: Executes a script from a language which does not change the message body.
:since:
:supportlevel: Stable
+:tabs-sync-option:
The Script EIP is used for executing a coding script.
@@ -24,6 +25,10 @@ include::partial$eip-options.adoc[]
The route below will read the file contents and call a groovy script
+[tabs]
+====
+Java::
++
[source,java]
----
from("file:inbox")
@@ -31,8 +36,8 @@ from("file:inbox")
.to("bean:myServiceBean.processLine");
----
-And from XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -44,7 +49,7 @@ And from XML:
</route>
----
-Mind that you can use _CDATA_ in XML if the script uses `< >` etc:
+Mind that you can use _CDATA_ if the script uses `< >` etc:
[source,xml]
----
@@ -56,6 +61,7 @@ Mind that you can use _CDATA_ in XML if the script uses `< >` etc:
<to uri="bean:myServiceBean.processLine"/>
</route>
----
+====
=== Scripting Context
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/selective-consumer.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/selective-consumer.adoc
index d3f017d5e1e..c87df435d82 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/selective-consumer.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/selective-consumer.adoc
@@ -1,4 +1,5 @@
= Selective Consumer
+:tabs-sync-option:
Camel supports the
https://www.enterpriseintegrationpatterns.com/patterns/messaging/MessageSelector.html[Selective Consumer]
@@ -23,14 +24,18 @@ The first solution is to provide a Message Selector to the underlying URIs when
For example when using xref:components::jms-component.adoc[JMS] you can specify a
JMS selector parameter so that the message broker will only deliver messages matching your criteria.
+[tabs]
+====
+Java::
++
[source,java]
----
from("jms:queue:hello?selector=color='red'")
.to("bean:red");
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -38,12 +43,17 @@ And in XML:
<to uri="bean:red"/>
</route>
----
+====
=== Selective Consumer using Filter EIP
The other approach is to use a xref:filter-eip.adoc[Message Filter] which is applied;
if the filter matches the message your "consumer" is invoked as shown in the following example:
+[tabs]
+====
+Java::
++
[source,java]
----
from("seda:colors")
@@ -51,8 +61,8 @@ from("seda:colors")
.to("bean:red")
----
-And in XML
-
+XML::
++
[source,xml]
----
<route>
@@ -63,4 +73,4 @@ And in XML
</filter>
</route>
----
-
+====
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/service-activator.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/service-activator.adoc
index f3a16f8e043..c84fcef2417 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/service-activator.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/service-activator.adoc
@@ -1,4 +1,5 @@
= Service Activator
+:tabs-sync-option:
Camel supports the
https://www.enterpriseintegrationpatterns.com/patterns/messaging/MessagingAdapter.html[Service Activator]
@@ -24,16 +25,18 @@ to a bean using Java annotation.
Here is a simple example of using a xref:ROOT:direct-component.adoc[Direct] endpoint
to create a messaging interface to a POJO xref:ROOT:bean-component.adoc[Bean] service.
-Using Java DSL:
-
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:invokeMyService")
.to("bean:myService");
----
-Using the XML DSL:
-
+XML::
++
[source,xml]
----
<route>
@@ -41,3 +44,4 @@ Using the XML DSL:
<to uri="bean:myService"/>
</route>
----
+====
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/setBody-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/setBody-eip.adoc
index d300c6698d6..a9b7a986acd 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/setBody-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/setBody-eip.adoc
@@ -4,6 +4,7 @@
:description: Sets the contents of the message body
:since:
:supportlevel: Stable
+:tabs-sync-option:
Camel supports the
http://www.enterpriseintegrationpatterns.com/MessageTranslator.html[Message
@@ -39,6 +40,10 @@ xref:manual::expression.adoc[Expression] to do the transformation:
In the example below we prepend Hello to the message body using the
xref:components:languages:simple-language.adoc[Simple] language:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:cheese")
@@ -46,8 +51,8 @@ from("direct:cheese")
.to("log:hello");
----
-And in XML DSL:
-
+XML::
++
[source,xml]
----
<route>
@@ -58,6 +63,7 @@ And in XML DSL:
<to uri="log:hello"/>
</route>
----
+====
=== What is the difference between Transform and Set Body
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/setHeader-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/setHeader-eip.adoc
index 2ef8ba96456..9ae9c6cf79a 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/setHeader-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/setHeader-eip.adoc
@@ -4,6 +4,7 @@
:description: Sets the value of a message header
:since:
:supportlevel: Stable
+:tabs-sync-option:
The SetHeader EIP is used for setting a xref:message.adoc[message] header.
@@ -17,6 +18,10 @@ include::partial$eip-options.adoc[]
The following example shows how to set a header in a Camel route:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:a")
@@ -24,8 +29,8 @@ from("direct:a")
.to("direct:b");
----
-And the same example using XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -36,20 +41,34 @@ And the same example using XML:
<to uri="direct:b"/>
</route>
----
+====
In the example the header value is a xref:components:languages:constant-language.adoc[constant].
Any of the Camel languages can be used, such as xref:components:languages:simple-language.adoc[Simple].
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:a")
.setHeader("randomNumber", simple("${random(1,100)}"))
.to("direct:b");
----
++
+Header can be set using fluent syntax.
++
+[source,java]
+----
+from("direct:a")
+ .setHeader("randomNumber").simple("${random(1,100)}")
+ .to("direct:b");
+----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -60,15 +79,8 @@ And in XML:
<to uri="direct:b"/>
</route>
----
+====
-Header can be set using fluent syntax.
-
-[source,java]
-----
-from("direct:a")
- .setHeader("randomNumber").simple("${random(1,100)}")
- .to("direct:b");
-----
See xref:components:languages:jsonpath-language.adoc#_using_header_as_input[JSONPath] for another example.
=== Setting a header from another header
@@ -77,6 +89,10 @@ You can also set a header with the value from another header.
In the example we set the header foo with the value from an existing header named bar.
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:a")
@@ -84,8 +100,8 @@ from("direct:a")
.to("direct:b");
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -96,3 +112,4 @@ And in XML:
<to uri="direct:b"/>
</route>
----
+====
\ No newline at end of file
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/setProperty-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/setProperty-eip.adoc
index 2816a78c70f..89892e3eb54 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/setProperty-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/setProperty-eip.adoc
@@ -4,6 +4,7 @@
:description: Sets a named property on the message exchange
:since:
:supportlevel: Stable
+:tabs-sync-option:
The SetProperty EIP is used for setting a xref:manual:ROOT:exchange.adoc[Exchange] property.
@@ -20,6 +21,10 @@ include::partial$eip-options.adoc[]
The following example shows how to set a property on the exchange in a Camel route:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:a")
@@ -27,8 +32,8 @@ from("direct:a")
.to("direct:b");
----
-And the same example using XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -39,6 +44,7 @@ And the same example using XML:
<to uri="direct:b"/>
</route>
----
+====
=== Setting an exchange property from another exchange property
@@ -46,6 +52,10 @@ You can also set an exchange property with the value from another exchange prope
In the example we set the exchange property foo with the value from an existing exchange property named bar.
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:a")
@@ -53,8 +63,8 @@ from("direct:a")
.to("direct:b");
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -65,12 +75,17 @@ And in XML:
<to uri="direct:b"/>
</route>
----
+====
=== Setting an exchange property with the current message body
It is of course also possible to set an exchange property with a value
from anything on the `Exchange` such as the message body:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:a")
@@ -78,9 +93,11 @@ from("direct:a")
.to("direct:b");
----
-And in XML we use the xref:components:languages:simple-language.adoc[Simple] language
+XML::
++
+We use the xref:components:languages:simple-language.adoc[Simple] language
to refer to the message body:
-
++
[source,xml]
----
<route>
@@ -91,3 +108,4 @@ to refer to the message body:
<to uri="direct:b"/>
</route>
----
+====
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/step-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/step-eip.adoc
index 78fba52a02e..856692dced4 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/step-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/step-eip.adoc
@@ -4,6 +4,7 @@
:description: Routes the message to a sequence of processors which is grouped together as one logical name
:since:
:supportlevel: Stable
+:tabs-sync-option:
Camel supports the http://www.enterpriseintegrationpatterns.com/PipesAndFilters.html[Pipes and Filters]
from the xref:enterprise-integration-patterns.adoc[EIP patterns] in various ways.
@@ -67,6 +68,10 @@ In XML you use the `<step>` tag:
You can have multiple steps:
+[tabs]
+====
+Java::
++
[source,java]
----
from("activemq:SomeQueue")
@@ -80,8 +85,8 @@ from("activemq:SomeQueue")
.end()
----
-And in XML
-
+XML::
++
[source,xml]
----
<route>
@@ -96,6 +101,7 @@ And in XML
</step>
</route>
----
+====
=== JMX Management of Step EIP
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/sticky-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/sticky-eip.adoc
index d25391bd44a..958da7441f2 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/sticky-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/sticky-eip.adoc
@@ -4,6 +4,7 @@
:description: Sticky load balancing using an expression to calculate a correlation key to perform the sticky load balancing.
:since:
:supportlevel: Stable
+:tabs-sync-option:
Sticky mode for the xref:loadBalance-eip.adoc[Load Balancer] EIP.
@@ -20,6 +21,10 @@ include::partial$eip-options.adoc[]
In this case we are using the header myKey as correlation expression:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
@@ -30,8 +35,8 @@ from("direct:start")
.end();
----
-In XML you'll have a route like this:
-
+XML::
++
[source,xml]
----
<route>
@@ -48,3 +53,4 @@ In XML you'll have a route like this:
</loadBalance>
</route>
----
+====
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/stop-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/stop-eip.adoc
index 537d8e060ff..1741456836d 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/stop-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/stop-eip.adoc
@@ -4,6 +4,7 @@
:description: Stops the processing of the current message
:since:
:supportlevel: Stable
+:tabs-sync-option:
How can I stop continue routing a message?
@@ -22,6 +23,10 @@ include::partial$eip-options.adoc[]
We want to stop routing a message if the message body contains the word Bye.
In the xref:choice-eip.adoc[Content Based Router] below we use `stop` in such case.
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
@@ -33,8 +38,8 @@ from("direct:start")
.to("mock:result");
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -54,6 +59,7 @@ And in XML:
</choice>
</route>
----
+====
=== Calling stop from Java
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/threads-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/threads-eip.adoc
index 39ce56e5ee5..c3b4cd0ca34 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/threads-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/threads-eip.adoc
@@ -4,6 +4,7 @@
:description: Specifies that all steps after this node are processed asynchronously
:since:
:supportlevel: Stable
+:tabs-sync-option:
How can I decouple the continued routing of a message from the current thread?
@@ -23,6 +24,10 @@ include::partial$eip-options.adoc[]
The example below will add a Thread pool with a pool size of 5 threads before sending to mock:result.
+[tabs]
+====
+Java::
++
[source,java]
----
from("seda:a")
@@ -30,8 +35,8 @@ from("seda:a")
.to("mock:result");
----
-And in XML DSL
-
+XML::
++
[source,xml]
----
<route>
@@ -40,9 +45,14 @@ And in XML DSL
<to uri="mock:result"/>
</route>
----
+====
And to use a thread pool with a task queue of only 20 elements:
+[tabs]
+====
+Java::
++
[source,java]
----
from("seda:a")
@@ -50,8 +60,8 @@ from("seda:a")
.to("mock:result");
----
-And in XML DSL
-
+XML::
++
[source,xml]
----
<route>
@@ -60,9 +70,14 @@ And in XML DSL
<to uri="mock:result"/>
</route>
----
+====
And you can also use a thread pool with no queue (meaning that a task cannot be pending on a queue):
+[tabs]
+====
+Java::
++
[source,java]
----
from("seda:a")
@@ -70,8 +85,8 @@ from("seda:a")
.to("mock:result");
----
-And in XML DSL
-
+XML::
++
[source,xml]
----
<route>
@@ -80,6 +95,7 @@ And in XML DSL
<to uri="mock:result"/>
</route>
----
+====
=== About rejected tasks
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/throttle-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/throttle-eip.adoc
index 6a1f6577e9e..ceeaec370b0 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/throttle-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/throttle-eip.adoc
@@ -4,6 +4,7 @@
:description: Controls the rate at which messages are passed to the next node in the route
:since:
:supportlevel: Stable
+:tabs-sync-option:
How can I throttle messages to ensure that a specific endpoint does not get overloaded, or we don’t exceed an agreed SLA with some external service?
@@ -22,6 +23,10 @@ include::partial$eip-options.adoc[]
The below example will throttle messages received on seda:a before being sent to mock:result
ensuring that a maximum of 3 messages are sent during a running 10-seconds window slot.
+[tabs]
+====
+Java::
++
[source,java]
----
from("seda:a")
@@ -29,11 +34,44 @@ from("seda:a")
.to("mock:result");
----
+XML::
++
+[source,xml]
+----
+<route>
+ <from uri="seda:a"/>
+ <throttle timePeriodMillis="10000">
+ <constant>3</constant>
+ </throttle>
+ <to uri="mock:result"/>
+</route>
+----
+
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: seda:a
+ steps:
+ - throttle:
+ expression:
+ constant: 3
+ timePeriodMillis: 10000
+ - to:
+ uri: mock:result
+----
+====
+
To use 10-seconds window we set the `timePeriodMillis` to ten-thousand. The default value is 1000 (i.e. 1 second),
meaning that setting just `throttle(3)` has the effect of setting the maximum number of requests per second.
To throttle by 50 requests per second, would look like this:
+[tabs]
+====
+Java::
++
[source,java]
----
from("seda:a")
@@ -41,31 +79,33 @@ from("seda:a")
.to("seda:b");
----
-And the same examples but in XML:
-
+XML::
++
[source,xml]
----
<route>
<from uri="seda:a"/>
- <throttle timePeriodMillis="10000">
- <constant>3</constant>
+ <throttle>
+ <constant>50</constant>
</throttle>
<to uri="mock:result"/>
</route>
----
-And to throttle 50 messages per second:
-
-[source,xml]
+YAML::
++
+[source,yaml]
----
-<route>
- <from uri="seda:a"/>
- <throttle>
- <constant>50</constant>
- </throttle>
- <to uri="mock:result"/>
-</route>
+- from:
+ uri: seda:a
+ steps:
+ - throttle:
+ expression:
+ constant: 50
+ - to:
+ uri: mock:result
----
+====
=== Dynamically changing maximum requests per period
@@ -78,6 +118,10 @@ At runtime Camel evaluates the expression and converts the result to a `java.lan
In the example below we use a header from the message to determine the maximum requests per period.
If the header is absent, then the Throttler uses the old value. This allows you to only provide a header if the value is to be changed:
+[tabs]
+====
+Java::
++
[source,java]
----
from("seda:a")
@@ -85,8 +129,8 @@ from("seda:a")
.to("seda:b")
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -99,34 +143,71 @@ And in XML:
</route>
----
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: seda:a
+ steps:
+ - throttle:
+ expression:
+ # use a header to determine how many messages to throttle per 0.5 sec
+ header: throttleValue
+ timePeriodMillis: 500
+ - to:
+ uri: seda:b
+----
+====
+
=== Asynchronous delaying
You can let the Throttler use non-blocking asynchronous delaying,
which means Camel will use a scheduler to schedule a task to be executed in the future.
The task will then continue routing. This allows the caller thread to not block and be able to service other messages, etc.
-In Java DSL you enable asynchronous delaying using `asyncDelayed` as shown:
+You enable asynchronous delaying using `asyncDelayed` as shown:
+[tabs]
+====
+Java::
++
[source,java]
----------------------
+----
from("seda:a")
.throttle(100).asyncDelayed()
.to("seda:b");
----------------------
-
-And in XML:
+----
+XML::
++
[source,xml]
----
<route>
<from uri="seda:a"/>
- <throttle timePeriodMillis="100" asyncDelayed="true">
+ <throttle asyncDelayed="true">
<constant>100</constant>
</throttle>
<to uri="seda:b"/>
</route>
----
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: seda:a
+ steps:
+ - throttle:
+ expression:
+ constant: 100
+ asyncDelayed: true
+ - to:
+ uri: seda:b
+----
+====
+
=== Rejecting processing if rate limit hit
When a message is being _throttled_ due the maximum request per limit has been reached, then
@@ -135,15 +216,19 @@ the Throttler will by default wait until there is _free space_ before continue r
Instead of waiting you can also configure the Throttler to reject the message by throwing `ThrottlerRejectedExecutionException`
exception.
+[tabs]
+====
+Java::
++
[source,java]
----------------------
+----
from("seda:a")
.throttle(100).rejectExecution(true)
.to("seda:b");
----------------------
-
-And in XML:
+----
+XML::
++
[source,xml]
----
<route>
@@ -155,6 +240,23 @@ And in XML:
</route>
----
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: seda:a
+ steps:
+ - throttle:
+ expression:
+ constant: 100
+ timePeriodMillis: 100
+ rejectExecution: true
+ - to:
+ uri: seda:b
+----
+====
+
=== Throttling per group
The Throttler will by default throttle all messages in the same group. However, it is possible to use
@@ -162,19 +264,19 @@ a _correlation expression_ to diving into multiple groups, where each group is t
For example, you can throttle by a xref:message.adoc[message] header as shown in the following example:
+[tabs]
+====
+Java::
++
[source,java]
----------------------
+----
from("seda:a")
.throttle(100).correlationExpression(header("region"))
.to("seda:b");
----------------------
-
-In the example above messages are throttled by the header with name region.
-So suppose there are regions for US, EMEA, and ASIA, then we have three different groups, that each
-are throttled by 100 messages per second.
-
-And in XML:
+----
+XML::
++
[source,xml]
----
<route>
@@ -188,3 +290,24 @@ And in XML:
<to uri="seda:b"/>
</route>
----
+
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: seda:a
+ steps:
+ - throttle:
+ expression:
+ constant: 100
+ correlationExpression:
+ header: region
+ - to:
+ uri: seda:b
+----
+====
+
+In the example above messages are throttled by the header with name region.
+So suppose there are regions for US, EMEA, and ASIA, then we have three different groups, that each
+are throttled by 100 messages per second.
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/to-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/to-eip.adoc
index d08c98ab6a9..70faf723368 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/to-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/to-eip.adoc
@@ -4,6 +4,7 @@
:description: Sends the message to a static endpoint
:since:
:supportlevel: Stable
+:tabs-sync-option:
Camel supports the
http://www.enterpriseintegrationpatterns.com/MessageEndpoint.html[Message
@@ -43,14 +44,18 @@ the dynamic endpoint URI.
The following example route demonstrates the use of a xref:ROOT:file-component.adoc[File] consumer endpoint and a xref:ROOT:jms-component.adoc[JMS] producer endpoint,
by their xref:manual::uris.adoc[URIs]:
+[tabs]
+====
+Java::
++
[source,java]
----
from("file:messages/foo")
.to("jms:queue:foo");
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -59,3 +64,15 @@ And in XML:
</route>
----
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: file:messages/foo
+ steps:
+ - to:
+ uri: jms:queue:foo
+----
+====
+
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/toD-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/toD-eip.adoc
index ac508e4d682..d44d5eedfe2 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/toD-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/toD-eip.adoc
@@ -4,6 +4,7 @@
:description: Sends the message to a dynamic endpoint
:since:
:supportlevel: Stable
+:tabs-sync-option:
Camel supports the
http://www.enterpriseintegrationpatterns.com/MessageEndpoint.html[Message
@@ -43,14 +44,18 @@ the dynamic endpoint URI.
For example to send a message to an endpoint which is dynamic determined by a
xref:message.adoc[message header] you can do as shown below:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
.toD("${header.foo}");
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -58,18 +63,23 @@ And in XML:
<toD uri="${header.foo}"/>
</route>
----
+====
You can also prefix the uri with a value because the endpoint xref:manual::uris.adoc[URI] is
evaluated using the xref:languages:simple-language.adoc[Simple] language:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
.toD("mock:${header.foo}");
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -77,6 +87,7 @@ And in XML:
<toD uri="mock:${header.foo}"/>
</route>
----
+====
In the example above we compute the dynamic endpoint with a prefix "mock:" and
then the header foo is appended. So for example if the header foo has
@@ -90,14 +101,18 @@ specify `language:` then the endpoint is a component name. And in some
cases there is both a component and language with the same name such as
xquery.
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
.toD("language:xpath:/order/@uri");
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -105,6 +120,7 @@ And in XML:
<toD uri="language:xpath:/order/@uri"/>
</route>
----
+====
=== Avoid creating endless dynamic endpoints which takes up resources
@@ -123,14 +139,18 @@ In the example above then the parameter `userid` is dynamic computed, and would
for each different userid. To avoid having too many dynamic endpoints you can configure `toD` to reduce its cache size, for example
to use a cache size of 10:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:login")
.toD("http:myloginserver:8080/login?userid=${header.userName}", 10);
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -138,6 +158,7 @@ And in XML:
<toD uri="http:myloginserver:8080/login?userid=${header.userName}" cacheSize="10"/>
</route>
----
+====
IMPORTANT: this will only reduce the endpoint cache of the `toD` that has a chance
of being reused in case a message is routed with the same `userName` header. Therefore, reducing the cache size
@@ -213,7 +234,7 @@ from("direct:login")
.removeHeader(Exchange.HTTP_QUERY);
----
-Where _expression_ will be evaluated dynamically. Notice how the uri in `toD` is now static (`\http:myloginserver:8080`).
+Where _expression_ will be evaluated dynamically. Notice how the uri in `toD` is now static (`http:myloginserver:8080`).
This optimisation allows Camel to reuse the same endpoint and its associated producer for all dynamic variations.
This yields much lower resource overhead as the same http producer will be used for all the different variations of userid's.
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/transform-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/transform-eip.adoc
index 82c9cc34980..670f8d31c26 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/transform-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/transform-eip.adoc
@@ -4,6 +4,7 @@
:description: Transforms the message body based on an expression
:since:
:supportlevel: Stable
+:tabs-sync-option:
Camel supports the
http://www.enterpriseintegrationpatterns.com/MessageTranslator.html[Message
@@ -41,6 +42,10 @@ xref:manual::expression.adoc[Expression] to do the transformation:
In the example below we prepend Hello to the message body using the
xref:components:languages:simple-language.adoc[Simple] language:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:cheese")
@@ -48,8 +53,8 @@ from("direct:cheese")
.to("log:hello");
----
-And in XML DSL:
-
+XML::
++
[source,xml]
----
<route>
@@ -61,6 +66,21 @@ And in XML DSL:
</route>
----
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: direct:cheese
+ steps:
+ - transform:
+ expression:
+ simple: Hello ${body}
+ - to:
+ uri: log:hello
+----
+====
+
=== What is the difference between Transform and Set Body
The Transform EIP always sets the result on the OUT message body.
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/unmarshal-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/unmarshal-eip.adoc
index 05f069b18bd..11c7a2296bb 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/unmarshal-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/unmarshal-eip.adoc
@@ -1,4 +1,5 @@
= Unmarshal EIP
+:tabs-sync-option:
The xref:marshal-eip.adoc[Marshal] and xref:unmarshal-eip.adoc[Unmarshal] EIPs are used
for xref:message-translator.adoc[Message Transformation].
@@ -25,6 +26,10 @@ Then a xref:ROOT:bean-component.adoc[Bean] is invoked that takes in the Java obj
Then the reverse operation happens to transform the Java objects back into XML also via JAXB,
but using the `marshal` operation. And finally the message is routed to a xref:ROOT:jms-component.adoc[JMS] queue.
+[tabs]
+====
+Java::
++
[source,java]
----
from("file:inbox/xml")
@@ -34,8 +39,8 @@ from("file:inbox/xml")
.to("jms:queue:order");
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -47,10 +52,32 @@ And in XML:
</route>
----
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: file:inbox/xml
+ steps:
+ - unmarshal:
+ jaxb: {}
+ - to:
+ uri: bean:validateOrder
+ - marshal:
+ jaxb: {}
+ - to:
+ uri: jms:queue:order
+----
+====
+
== Allow Null Body
Sometimes, there are situations where `null` can be a normal value for the body of a message but `null` by default is not an accepted value to unmarshal. To workaround that, it is possible to allow `null` as value to a body to unmarshall using the option `allowNullBody` as shown in the next code snippets:
+[tabs]
+====
+Java::
++
[source,java]
----
// Beginning of the route
@@ -58,11 +85,23 @@ Sometimes, there are situations where `null` can be a normal value for the body
// End of the route
----
-And in XML:
-
+XML::
++
[source,xml]
----
<!-- Beginning of the route -->
<unmarshal allowNullBody="true"><jaxb/></unmarshal>
<!-- End of the route -->
----
+
+YAML::
++
+[source,yaml]
+----
+# Beginning of the route
+unmarshal:
+ allowNullBody: true
+ jaxb: {}
+# End of the route
+----
+====
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/validate-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/validate-eip.adoc
index 48b1311de30..201722b5022 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/validate-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/validate-eip.adoc
@@ -4,6 +4,7 @@
:description: Validates a message based on an expression
:since:
:supportlevel: Stable
+:tabs-sync-option:
The Validate EIP uses an xref:manual::expression.adoc[Expression] or xref:manual::predicate.adoc[Predicate]
to validate the contents of a message.
@@ -24,6 +25,10 @@ include::partial$eip-options.adoc[]
The route below will read the file contents and validate the message body against a regular expression.
+[tabs]
+====
+Java::
++
[source,java]
----
from("file:inbox")
@@ -31,17 +36,51 @@ from("file:inbox")
.to("bean:myServiceBean.processLine");
----
+XML::
++
+[source,xml]
+----
+<route>
+ <from uri="file:inbox"/>
+ <validate>
+ <simple>${body} regex ^\\w{10}\\,\\d{2}\\,\\w{24}$</simple>
+ </validate>
+ <to uri="bean:myServiceBean" method="processLine"/>
+</route>
+----
+
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: file:inbox
+ steps:
+ - validate:
+ expression:
+ simple: ${body} regex "^\\w{10}\\,\\d{2}\\,\\w{24}$"
+ - to:
+ uri: bean:myServiceBean
+ parameters:
+ method: processLine
+----
+====
+
Validate EIP is not limited to the message body. You can also validate the message header.
+[tabs]
+====
+Java::
++
[source,java]
----
from("file:inbox")
.validate(header("bar").isGreaterThan(100))
.to("bean:myServiceBean.processLine");
----
-
++
You can also use validate together with the xref:components:languages:simple-language.adoc[Simple] language.
-
++
[source,java]
----
from("file:inbox")
@@ -49,29 +88,32 @@ from("file:inbox")
.to("bean:myServiceBean.processLine");
----
-To use validate in the XML DSL, the easiest way is to use
-xref:components:languages:simple-language.adoc[Simple] language:
-
+XML::
++
[source,xml]
----
<route>
<from uri="file:inbox"/>
<validate>
- <simple>${body} regex ^\\w{10}\\,\\d{2}\\,\\w{24}$</simple>
+ <simple>${header.bar} > 100</simple>
</validate>
<to uri="bean:myServiceBean" method="processLine"/>
</route>
----
-The XML DSL to validate the message header is as follows::
-
-[source,xml]
+YAML::
++
+[source,yaml]
----
-<route>
- <from uri="file:inbox"/>
- <validate>
- <simple>${header.bar} > 100</simple>
- </validate>
- <to uri="bean:myServiceBean" method="processLine"/>
-</route>
+- from:
+ uri: file:inbox
+ steps:
+ - validate:
+ expression:
+ simple: ${header.bar} > 100
+ - to:
+ uri: bean:myServiceBean
+ parameters:
+ method: processLine
----
+====
diff --git a/core/camel-core-engine/src/main/docs/modules/eips/pages/wireTap-eip.adoc b/core/camel-core-engine/src/main/docs/modules/eips/pages/wireTap-eip.adoc
index c284aa619cd..8d0c8b59d4a 100644
--- a/core/camel-core-engine/src/main/docs/modules/eips/pages/wireTap-eip.adoc
+++ b/core/camel-core-engine/src/main/docs/modules/eips/pages/wireTap-eip.adoc
@@ -4,6 +4,7 @@
:description: Routes a copy of a message (or creates a new message) to a secondary destination while continue routing the original message.
:since:
:supportlevel: Stable
+:tabs-sync-option:
http://www.enterpriseintegrationpatterns.com/WireTap.html[Wire Tap]
from the xref:enterprise-integration-patterns.adoc[EIP patterns]
@@ -37,6 +38,10 @@ This route delays the message 1 second before continuing. This is because
it allows you to see that the tapped message is routed independently of the original
route, so that you would see log:result happens before log:tap
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
@@ -49,8 +54,8 @@ from("direct:tap")
.to("log:tap");
----
-And in XML:
-
+XML::
++
[source,xml]
----
<routes>
@@ -69,6 +74,25 @@ And in XML:
</routes>
----
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: direct:start
+ steps:
+ - wireTap:
+ uri: direct:tap
+ - to:
+ uri: log:result
+- from:
+ uri: direct:tap
+ steps:
+ - to:
+ uri: log:log
+----
+====
+
=== Wire tapping with dynamic URIs
For example to wire tap to a dynamic URI, then the URI
@@ -77,6 +101,10 @@ allows to construct dynamic URIs.
For example to wire tap to a JMS queue where the header ID is part of the queue name:
+[tabs]
+====
+Java::
++
[source,java]
----
from("direct:start")
@@ -84,8 +112,8 @@ from("direct:start")
.to("bean:doSomething");
----
-And in XML:
-
+XML::
++
[source,xml]
----
<route>
@@ -95,6 +123,19 @@ And in XML:
</route>
----
+YAML::
++
+[source,yaml]
+----
+- from:
+ uri: direct:start
+ steps:
+ - wireTap:
+ uri: jms:queue:backup-${header.id}
+ - to:
+ uri: bean:doSomething
+----
+====
== WireTap Thread Pools