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 485709e CAMEL-16861: Cleanup and update EIP docs
485709e is described below
commit 485709eef61e23bece6d8c4da2afee2c3f3f20a4
Author: Claus Ibsen <[email protected]>
AuthorDate: Sat Sep 18 18:21:21 2021 +0200
CAMEL-16861: Cleanup and update EIP docs
---
.../main/docs/modules/eips/pages/choice-eip.adoc | 4 -
.../modules/eips/pages/fault-tolerance-eip.adoc | 54 +++++---
.../pages/faultToleranceConfiguration-eip.adoc | 5 +
.../main/docs/modules/eips/pages/filter-eip.adoc | 140 ++++++++++++++-------
.../src/main/docs/modules/eips/pages/from-eip.adoc | 22 ++--
5 files changed, 146 insertions(+), 79 deletions(-)
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 522c841..06d62a1 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
@@ -28,10 +28,6 @@ The Choice EIP supports 2 options which are listed below:
== Example
-The following example shows how to route a request from an input
-*seda:a* endpoint to either *seda:b*, *seda:c* or *seda:d* depending on
-the evaluation of various xref:latest@manual:ROOT:predicate.adoc[Predicate].
-
The Camel xref:components: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.
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 9459656..e841610 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,7 +1,8 @@
[[faulttolerance-eip]]
= Fault Tolerance EIP
-This component supports the Circuit Breaker EIP with the MicroProfile Fault
Tolerance library.
+This component supports the xref:circuitBreaker-eip.adoc[Circuit Breaker] EIP
with the
+xref:components:others:microprofile-fault-tolerance.adoc[MicroProfile Fault
Tolerance] library.
== Options
@@ -16,11 +17,13 @@ The Fault Tolerance EIP supports 2 options which are listed
below:
|===
// eip options: END
-See xref:faultToleranceConfiguration-eip.adoc[Fault Tolerance Configuration]
for all the configuration options on Fault Tolerance Circuit Breaker.
+See xref:faultToleranceConfiguration-eip.adoc[Fault Tolerance Configuration]
for all the configuration options
+on the Fault Tolerance xref:circuitBreaker-eip.adoc[Circuit Breaker].
-== Example
+== Using Fault Tolerance EIP
-Below is an example route showing a Fault Tolerance endpoint that protects
against a downstream HTTP operation by falling back to the in-lined fallback
route.
+Below is an example route showing a Fault Tolerance EIP circuit breaker
+that protects against a downstream HTTP operation with fallback.
[source,java]
----
@@ -51,9 +54,16 @@ And in XML DSL:
</route>
----
-== Configuring Fault Tolerance
+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.
-You can fine-tune Fault Tolerance by the many
xref:faultToleranceConfiguration-eip.adoc[Fault Tolerance Configuration]
options.
+If there was no fallback, then the circuit breaker will throw an exception.
+
+TIP: For more information about fallback see
xref:onFallback-eip.adoc[onFallback].
+
+=== Configuring Fault Tolerance
+
+You can fine-tune the Fault Tolerance EIP by the many
xref:faultToleranceConfiguration-eip.adoc[Fault Tolerance Configuration]
options.
For example to use 2 second execution timeout, you can do as follows:
@@ -64,7 +74,7 @@ from("direct:start")
// use 2 second timeout
.faultToleranceConfiguration().timeoutEnabled(true).timeoutDuration(2000).end()
.log("Fault Tolerance processing start: ${threadName}")
- .toD("direct:${body}")
+ .to("http://fooservice.com/faulty";)
.log("Fault Tolerance processing end: ${threadName}")
.end()
.log("After Fault Tolerance ${body}");
@@ -79,26 +89,24 @@ And in XML:
<circuitBreaker>
<faultToleranceConfiguration timeoutEnabled="true" timeoutDuration="2000"/>
<log message="Fault Tolerance processing start: ${threadName}"/>
- <toD uri="direct:${body}"/>
+ <to uri="http://fooservice.com/faulty"/>
<log message="Fault Tolerance processing end: ${threadName}"/>
</circuitBreaker>
<log message="After Fault Tolerance: ${body}"/>
</route>
----
-== Fallback
-
-See xref:onFallback-eip.adoc[onFallback].
-
-== Using Fault Tolerance with Spring Boot
-
-This component does not support Spring Boot. Instead, its support in
standalone and with Camel Quarkus.
+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.
== Camel's Error Handler and Circuit Breaker EIP
-By default, the Circuit Breaker EIP handles errors by itself. This means if
the circuit breaker is open and
-the message fails, then Camel's error handler is not reacting also.
-However, you can enable Camels error handler with circuit breaker by enabling
the `inheritErrorHandler` option, as shown:
+By default, the xref:circuitBreaker-eip.adoc[Circuit Breaker] EIP handles
errors by itself.
+This means if the circuit breaker is open, and the message fails, then Camel's
error handler
+is not reacting also.
+
+However, you can enable Camels error handler with circuit breaker by enabling
+the `inheritErrorHandler` option, as shown:
[source,java]
----
@@ -116,7 +124,7 @@ from("direct:start")
.to("mock:result");
----
-This example is from an unit test, where you can see the Circuit Breaker EIP
block has been hardcoded
+This example is from a test, where you can see the Circuit Breaker EIP block
has been hardcoded
to always fail by throwing an exception. Because the `inheritErrorHandler` has
been enabled,
then Camel's error handler will attempt to call the Circuit Breaker EIP block
again.
@@ -130,7 +138,8 @@ executed once because it handled the error itself.
[NOTE]
====
-Camel provides the Circuit Breaker EIP in the route model, which allows to
plugin different implementations.
+Camel provides the xref:circuitBreaker-eip.adoc[Circuit Breaker] EIP in the
route model,
+which allows to plugin different implementations.
MicroProfile Fault Tolerance is one such implementation.
====
@@ -145,3 +154,8 @@ Maven users will need to add the following dependency to
their pom.xml to use th
</dependency>
----
+=== Using Fault Tolerance with Spring Boot
+
+This component does not support Spring Boot.
+Instead, it is supported in Standalone and with Camel Quarkus.
+
diff --git
a/core/camel-core-engine/src/main/docs/modules/eips/pages/faultToleranceConfiguration-eip.adoc
b/core/camel-core-engine/src/main/docs/modules/eips/pages/faultToleranceConfiguration-eip.adoc
index aa57867..e85824b 100644
---
a/core/camel-core-engine/src/main/docs/modules/eips/pages/faultToleranceConfiguration-eip.adoc
+++
b/core/camel-core-engine/src/main/docs/modules/eips/pages/faultToleranceConfiguration-eip.adoc
@@ -5,6 +5,7 @@
:since:
:supportLevel: Stable
+This page documents all the specific options for the
xref:fault-tolerance-eip.adoc[Fault Tolerance] EIP.
// eip options: START
The Fault Tolerance Configuration EIP supports 13 options which are listed
below:
@@ -27,3 +28,7 @@ The Fault Tolerance Configuration EIP supports 13 options
which are listed below
| *bulkheadExecutorServiceRef* | References to a custom thread pool to use
when bulkhead is enabled. | | String
|===
// eip options: END
+
+== Example
+
+See xref:fault-tolerance-eip.adoc[Fault Tolerance] EIP for details how to use
this EIP.
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 61eab1a..d0e8f96 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
@@ -7,13 +7,12 @@
The http://www.enterpriseintegrationpatterns.com/Filter.html[Message
Filter] from the xref:enterprise-integration-patterns.adoc[EIP patterns]
-allows you to filter messages
+allows you to filter messages.
-image::eip/MessageFilter.gif[image]
+IMPORTANT: The message filter implemented in Camel is similar to `if
(predicate) { block }`
+in Java. The filter will *include* the message if the predicate evaluated to
`true`.
-The following example shows how to create a Message Filter route
-consuming messages from an endpoint called *queue:a*, which if the
-xref:latest@manual:ROOT:predicate.adoc[Predicate] is true will be dispatched
to *queue:b*
+image::eip/MessageFilter.gif[image]
== EIP options
@@ -21,18 +20,37 @@ xref:latest@manual:ROOT:predicate.adoc[Predicate] is true
will be dispatched to
The Filter EIP has no options.
// eip options: END
-== Samples
+== Example
-Here is a little example in Java DSL:
+The Camel xref:components: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.
[source,java]
----
from("direct:a")
.filter(simple("${header.foo} == 'bar'"))
- .to("direct:b");
+ .to("direct:bar")
+ .end()
+ .to("direct:b")
+----
+
+And in XML:
+
+[source,xml]
+----
+<route>
+ <from uri="direct:a"/>
+ <filter>
+ <simple>${header.foo} == 'bar'</simple>
+ <to uri="direct:bar"/>
+ </filter>
+ <to uri="direct:b"/>
+</route>
----
-You can use many different languages as the predicate, such as XPath:
+You can use many languages as the predicate, such as
xref:components:languages:xpath-language.adoc[XPath]:
+
[source,java]
----
from("direct:start").
@@ -40,7 +58,21 @@ from("direct:start").
to("mock:result");
----
-Here is another example of using a bean to define the filter behavior
+And in XML:
+
+[source,xml]
+----
+<route>
+ <from uri="direct:start"/>
+ <filter>
+ <xpath>/person[@name='James']</xpath>
+ <to uri="mock:result"/>
+ </filter>
+</route>
+----
+
+Here is another example of calling a
xref:components:languages:bean-language.adoc[method on a bean]
+to define the filter behavior:
[source,java]
----
@@ -49,56 +81,72 @@ from("direct:start")
.to("mock:gold")
.end()
.to("mock:all");
+}
+----
+
+And then bean can have a method that returns a `boolean` as the predicate:
+[source,java]
+----
public static class MyBean {
- public boolean isGoldCustomer(@Header("level") String level) {
- return level.equals("gold");
+
+ public boolean isGoldCustomer(@Header("level") String level) {
+ return level.equals("gold");
}
+
}
----
-And the example in XML:
+And in XML we can call the bean in `<method> where we can specify the FQN
classname
+of the bean as shown:
[source,xml]
----
-<bean id="myBean" class="com.foo.MyBean"/>
-
-<camelContext xmlns="http://camel.apache.org/schema/spring";>
- <route>
- <from uri="direct:a"/>
- <filter>
- <method ref="myBean" method="isGoldCustomer"/>
- <to uri="direct:b"/>
- </filter>
- </route>
-</camelContext>
+<route>
+ <from uri="direct:start"/>
+ <filter>
+ <method type="com.foo.MyBean" method="isGoldCustomer"/>
+ <to uri="mock:gold"/>
+ </filter>
+ <to uri="mock:all"/>
+</route>
----
+=== Filtering and stopping
-== Using stop
+When using the Message Filter EIP, then it only applies to its children.
-Stop is a bit different than a message filter as it will filter out all
-messages and end the route entirely (filter only applies to its child
-processor). Stop is convenient to use in a
-xref:choice-eip.adoc[Content Based Router] when you for
-example need to stop further processing in one of the predicates.
+For example in the previous example:
-In the example below we do not want to route messages any further that
-has the word `Bye` in the message body. Notice how we prevent this in
-the when predicate by using the `.stop()`.
+[source,xml]
+----
+<route>
+ <from uri="direct:start"/>
+ <filter>
+ <method type="com.foo.MyBean" method="isGoldCustomer"/>
+ <to uri="mock:gold"/>
+ </filter>
+ <to uri="mock:all"/>
+</route>
+----
+
+Then for a message that is a gold customer will be routed to both mock:gold
and mock:all (predicate is true).
+However, for a non-gold message (predicate is false) then the message will not
be routed in the filter block,
+but will be routed to mock:all.
-== Knowing if Exchange was filtered or not
+Sometimes you may want to stop continue routing for messages that was filtered.
+To do this, you can use the xref:stop-eip.adoc[Stop] EIP as shown:
-The xref:filter-eip.adoc[Message Filter] EIP will add a property on
-the xref:latest@manual:ROOT:exchange.adoc[Exchange] that states if it was
filtered or not.
+[source,xml]
+----
+<route>
+ <from uri="direct:start"/>
+ <filter>
+ <method type="com.foo.MyBean" method="isGoldCustomer"/>
+ <to uri="mock:gold"/>
+ <stop/>
+ </filter>
+ <to uri="mock:all"/>
+</route>
+----
-The property has the key `Exchange.FILTER_MATCHED`, which has the String
-value of `CamelFilterMatched`. Its value is a boolean indicating `true`
-or `false`. If the value is `true` then the
xref:latest@manual:ROOT:exchange.adoc[Exchange]
-was routed in the filter block. This property will be visible within the
-xref:filter-eip.adoc[Message Filter] block who's
-xref:latest@manual:ROOT:predicate.adoc[Predicate] matches (value set to
`true`), and to the
-steps immediately following the xref:filter-eip.adoc[Message Filter]
-with the value set based on the results of the last
-xref:filter-eip.adoc[Message Filter]
xref:latest@manual:ROOT:predicate.adoc[Predicate]
-evaluated.
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 c87052a..8b19731 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
@@ -5,6 +5,11 @@
:since:
:supportLevel: Stable
+Every Camel xref:latest@manual:ROOT:routes.adoc[route] starts from an
xref:latest@manual:ROOT:endpoint.adoc[Endpoint]
+as the input (source) to the route.
+
+The From EIP is the input.
+
== Options
// eip options: START
@@ -17,24 +22,23 @@ The From EIP supports 1 options which are listed below:
|===
// eip options: END
-== Samples
+== Example
-Start a route with the File endpoint. Each file in the directory creates an
exchange that is put into the camel route.
-
-A camel route is started using from inside the configure method of the class
*RouteBuilder*
+In the route below the route starts from
+a xref:components::file-component.adoc[File] endpoint.
[source,java]
----
-from("file:c:/in")
+from("file:inbox")
+ .to("log:inbox");
----
-And examples in Spring XML Schema:
-
-The route is defined inside a CamelContext.
+And the same example in XML DSL:
[source,xml]
----
<route>
- <from uri="file:c:/in" />
+ <from uri="file:inbox"/>
+ <to uri="log:inbox"/>
</route>
----
