[2/5] camel git commit: CAMEL-10837: Migrate EIP patterns to adoc (squashed)

[da...@apache.org]

http://git-wip-us.apache.org/repos/asf/camel/blob/f0bae85e/camel-core/src/main/docs/eips/loadBalance-eip.adoc
----------------------------------------------------------------------
diff --git a/camel-core/src/main/docs/eips/loadBalance-eip.adoc b/camel-core/src/main/docs/eips/loadBalance-eip.adoc
new file mode 100644
index 0000000..c91d5e6
--- /dev/null
+++ b/camel-core/src/main/docs/eips/loadBalance-eip.adoc
@@ -0,0 +1,266 @@
+## Load Balance EIP
+The Load Balancer Pattern allows you to delegate to one of a number of endpoints using a variety of different load balancing policies.
+
+## Built-in load balancing policies
+Camel provides the following policies out-of-the-box:
+
+[width="100%",cols="3,6",options="header"]
+|=======================================================================
+| Policy | Description
+| Round Robin | The exchanges are selected from in a round robin fashion. This is a well known and classic policy, which spreads the load evenly.
+| Random | A random endpoint is selected for each exchange.
+| Sticky | Sticky load balancing using an Expression to calculate a correlation key to perform the sticky load balancing; rather like jsessionid in the web or JMSXGroupID in JMS.
+| Topic | Topic which sends to all destinations (rather like JMS Topics)
+| Failover | In case of failures the exchange will be tried on the next endpoint.
+| Weighted Round-Robin | *Camel 2.5*: The weighted load balancing policy allows you to specify a processing load distribution ratio for each server with respect to the others. In addition to the weight, endpoint selection is then further refined using *round-robin* distribution based on weight.
+| Weighted Random | *Camel 2.5*: The weighted load balancing policy allows you to specify a processing load distribution ratio for each server with respect to others.In addition to the weight, endpoint selection is then further refined using *random* distribution based on weight.
+| Custom | *Camel 2.8*: From *Camel 2.8* onwards the preferred way of using a custom Load Balancer is to use this policy, instead of using the `@deprecated` ref attribute.
+| Circuit Breaker | *Camel 2.14*: Implements the Circuit Breaker pattern as described in "Release it!" book.
+|=======================================================================
+
+[TIP]
+.Load balancing HTTP endpoints
+====
+If you are proxying and load balancing HTTP, then see link:TODO[this] page for more details.
+====
+
+
+## Round Robin
+The round robin load balancer is not meant to work with failover, for that you should use the dedicated *failover* load balancer. The round robin load balancer will only change to next endpoint per message.
+The round robin load balancer is stateful as it keeps state of which endpoint to use next time.
+
+### Using the Fluent Builders
+[source,java]
+--------------------------------------------------------
+from("direct:start").loadBalance().
+roundRobin().to("mock:x", "mock:y", "mock:z");
+--------------------------------------------------------
+
+### Using the Spring configuration
+[source,xml]
+--------------------------------------------------------
+<camelContext id="camel" xmlns="http://camel.apache.org/schema/spring">
+  <route>
+    <from uri="direct:start"/>
+    <loadBalance>
+        <roundRobin/>
+        <to uri="mock:x"/>
+        <to uri="mock:y"/>
+        <to uri="mock:z"/>
+    </loadBalance>
+  </route>
+</camelContext>
+--------------------------------------------------------
+
+The above example loads balance requests from *direct:start* to one of the available *mock endpoint* instances, in this case using a round robin policy.
+For further examples of this pattern look at link:http://svn.apache.org/viewvc/camel/trunk/camel-core/src/test/java/org/apache/camel/processor/RoundRobinLoadBalanceTest.java?view=markup[this junit test case].
+
+
+## Failover
+The failover load balancer is capable of trying the next processor in case an Exchange failed with an exception during processing.
+You can constrain the failover to activate only when one exception of a list you specify occurs. If you do not specify a list any exception will cause fail over to occur. This balancer uses the same strategy for matching exceptions as the Exception Clause does for the `onException`.
+
+[TIP]
+.Enable stream caching if using streams
+====
+If you use streaming then you should enable Stream caching when using the failover load balancer. This is needed so the stream can be re-read after failing over to the next processor.
+====
+
+// eip options: START
+The Load Balance EIP supports 2 options which are listed below:
+
+{% raw %}
+[width="100%",cols="3,1m,6",options="header"]
+|=======================================================================
+| Name | Java Type | Description
+| loadBalancerType | LoadBalancerDefinition | *Required* The load balancer to be used
+| inheritErrorHandler | Boolean | Sets whether or not to inherit the configured error handler. The default value is true. You can use this to disable using the inherited error handler for a given DSL such as a load balancer where you want to use a custom error handler strategy.
+|=======================================================================
+{% endraw %}
+// eip options: END
+
+*Camel 2.2 or older behavior*
+The current implementation of failover load balancer uses simple logic which *always* tries the first endpoint, and in case of an exception being thrown it tries the next in the list, and so forth. It has no state, and the next message will thus *always* start with the first endpoint.
+*Camel 2.3 onwards behavior*
+The failover load balancer now supports round robin mode, which allows you to failover in a round robin fashion. See the `roundRobin` option.
+
+[WARNING]
+.Redelivery must be enabled
+====
+In Camel 2.2 or older the `failover` load balancer requires you have enabled Camel Error Handler to use redelivery. In Camel 2.3 onwards this is not required as such, as you can mix and match. See the `inheritErrorHandler` option.
+====
+
+Here is a sample to failover only if a IOException related exception was thrown:
+[source,java]
+--------------------------------------------------------
+from("direct:start")
+    // here we will load balance if IOException was thrown
+    // any other kind of exception will result in the Exchange as failed
+    // to failover over any kind of exception we can just omit the exception
+    // in the failOver DSL
+    .loadBalance().failover(IOException.class)
+        .to("direct:x", "direct:y", "direct:z");
+--------------------------------------------------------
+You can specify multiple exceptions to failover as the option is varargs, for instance:
+
+[source,java]
+--------------------------------------------------------
+// enable redelivery so failover can react
+errorHandler(defaultErrorHandler().maximumRedeliveries(5));
+
+from("direct:foo").
+    loadBalance().failover(IOException.class, MyOtherException.class)
+        .to("direct:a", "direct:b");
+--------------------------------------------------------
+
+### Using failover in Spring DSL
+Failover can also be used from Spring DSL and you configure it as:
+[source,xml]
+--------------------------------------------------------
+<route errorHandlerRef="myErrorHandler">
+   <from uri="direct:foo"/>
+   <loadBalance>
+       <failover>
+           <exception>java.io.IOException</exception>
+           <exception>com.mycompany.MyOtherException</exception>
+       </failover>
+       <to uri="direct:a"/>
+       <to uri="direct:b"/>
+   </loadBalance>
+ </route>
+--------------------------------------------------------
+
+### Using failover in round robin mode
+An example using Java DSL:
+[source,java]
+--------------------------------------------------------
+from("direct:start")
+    // Use failover load balancer in stateful round robin mode
+    // which mean it will failover immediately in case of an exception
+    // as it does NOT inherit error handler. It will also keep retrying as
+    // its configured to newer exhaust.
+    .loadBalance().failover(-1, false, true).
+        to("direct:bad", "direct:bad2", "direct:good", "direct:good2");
+--------------------------------------------------------
+
+And the same example using Spring XML:
+[source,xml]
+--------------------------------------------------------
+<route>
+    <from uri="direct:start"/>
+    <loadBalance>
+        <!-- failover using stateful round robin,
+             which will keep retrying forever those 4 endpoints until success.
+             You can set the maximumFailoverAttempt to break out after X attempts -->
+        <failover roundRobin="true"/>
+        <to uri="direct:bad"/>
+        <to uri="direct:bad2"/>
+        <to uri="direct:good"/>
+        <to uri="direct:good2"/>
+    </loadBalance>
+</route>
+--------------------------------------------------------
+
+[TIP]
+.Disabled inheritErrorHandler
+====
+You can configure `inheritErrorHandler=false` if you want to failover to the next endpoint as fast as possible.
+By disabling the Error Handler you ensure it does not _intervene_ which allows the `failover` load balancer to handle failover asap.
+By also enabling `roundRobin` mode, then it will keep retrying until it success. You can then configure the `maximumFailoverAttempts` option to a high value to let it eventually exhaust (give up) and fail.
+====
+
+## Weighted Round-Robin and Random Load Balancing
+*Available as of Camel 2.5*
+In many enterprise environments where server nodes of unequal processing power & performance characteristics are utilized to host services and processing endpoints, it is frequently necessary to distribute processing load based on their individual server capabilities so that some endpoints are not unfairly burdened with requests. Obviously simple round-robin or random load balancing do not alleviate problems of this nature. A Weighted Round-Robin and/or Weighted Random load balancer can be used to address this problem.
+The weighted load balancing policy allows you to specify a processing load distribution ratio for each server with respect to others. You can specify this as a positive processing weight for each server. A larger number indicates that the server can handle a larger load. The weight is utilized to determine the payload distribution ratio to different processing endpoints with respect to others.
+[TIP]
+.Disabled inheritErrorHandler
+====
+As of Camel 2.6, the Weighted Load balancer usage has been further simplified, there is no need to send in distributionRatio as a `List<Integer>`. It can be simply sent as a delimited String of integer weights separated by a delimiter of choice.
+====
+The parameters that can be used are
+
+*In Camel 2.5*
+
+[width="100%",cols="3,1,2,6",options="header"]
+|=======================================================================
+| Option | Type | Default | Description
+| roundRobin | boolean | false | The default value for round-robin is false. In the absence of this setting or parameter the load balancing algorithm used is random.
+| distributionRatio | List<Integer> | none | The distributionRatio is a list consisting on integer weights passed in as a parameter. The distributionRatio must match the number of endpoints and/or processors specified in the load balancer list. In Camel 2.5 if endpoints do not match ratios, then a best effort distribution is attempted.
+|=======================================================================
+
+*Available In Camel 2.6*
+
+[width="100%",cols="3,1,2,6",options="header"]
+|=======================================================================
+| Option | Type | Default | Description
+| roundRobin | boolean | false | The default value for round-robin is false. In the absence of this setting or parameter the load balancing algorithm used is random.
+| distributionRatio | String | none | The distributionRatio is a delimited String consisting on integer weights separated by delimiters for example "2,3,5". The distributionRatio must match the number of endpoints and/or processors specified in the load balancer list.
+| distributionRatioDelimiter | String | , | The distributionRatioDelimiter is the delimiter used to specify the distributionRatio. If this attribute is not specified a default delimiter "," is expected as the delimiter used for specifying the distributionRatio.
+|=======================================================================
+
+### Using Weighted round-robin & random load balancing
+*In Camel 2.5*
+
+An example using Java DSL:
+[source,java]
+--------------------------------------------------------
+ArrayList<integer> distributionRatio = new ArrayList<integer>();
+distributionRatio.add(4);
+distributionRatio.add(2);
+distributionRatio.add(1);
+
+// round-robin
+from("direct:start")
+    .loadBalance().weighted(true, distributionRatio)
+    .to("mock:x", "mock:y", "mock:z");
+
+//random
+from("direct:start")
+    .loadBalance().weighted(false, distributionRatio)
+    .to("mock:x", "mock:y", "mock:z");
+--------------------------------------------------------
+
+And the same example using Spring XML:
+[source,xml]
+--------------------------------------------------------
+<route>
+  <from uri="direct:start"/>
+  <loadBalance>
+    <weighted roundRobin="false" distributionRatio="4 2 1"/>
+      <to uri="mock:x"/>
+      <to uri="mock:y"/>
+      <to uri="mock:z"/>
+  </loadBalance>
+</route>
+--------------------------------------------------------
+
+*Available In Camel 2.6*
+
+An example using Java DSL:
+[source,java]
+--------------------------------------------------------
+// round-robin
+from("direct:start")
+    .loadBalance().weighted(true, "4:2:1" distributionRatioDelimiter=":")
+    .to("mock:x", "mock:y", "mock:z");
+
+//random
+from("direct:start")
+    .loadBalance().weighted(false, "4,2,1")
+    .to("mock:x", "mock:y", "mock:z");
+--------------------------------------------------------
+
+And the same example using Spring XML:
+[source,xml]
+--------------------------------------------------------
+<route>
+  <from uri="direct:start"/>
+  <loadBalance>
+    <weighted roundRobin="false" distributionRatio="4-2-1" distributionRatioDelimiter="-" />
+      <to uri="mock:x"/>
+      <to uri="mock:y"/>
+      <to uri="mock:z"/>
+  </loadBalance>
+</route>
+--------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/camel/blob/f0bae85e/camel-core/src/main/docs/eips/message-bus.adoc
----------------------------------------------------------------------
diff --git a/camel-core/src/main/docs/eips/message-bus.adoc b/camel-core/src/main/docs/eips/message-bus.adoc
new file mode 100644
index 0000000..8ad4ea8
--- /dev/null
+++ b/camel-core/src/main/docs/eips/message-bus.adoc
@@ -0,0 +1,64 @@
+[[MessageBus-MessageBus]]
+Message Bus
+^^^^^^^^^^^
+
+Camel supports the
+http://www.enterpriseintegrationpatterns.com/PointToPointChannel.html[Message
+Bus] from the link:enterprise-integration-patterns.html[EIP patterns].
+You could view Camel as a Message Bus itself as it allows producers and
+consumers to be decoupled.
+
+image:http://www.enterpriseintegrationpatterns.com/img/MessageBusSolution.gif[image]
+
+Folks often assume that a Message Bus is a JMS though so you may wish to
+refer to the link:jms.html[JMS] component for traditional MOM support. +
+ Also worthy of note is the link:xmpp.html[XMPP] component for
+supporting messaging over XMPP (Jabber)
+
+Of course there are also ESB products such as
+http://servicemix.apache.org/home.html[Apache ServiceMix] which serve as
+full fledged message busses. +
+ You can interact with http://servicemix.apache.org/home.html[Apache
+ServiceMix] from Camel in many ways, but in particular you can use the
+link:nmr.html[NMR] or link:jbi.html[JBI] component to access the
+ServiceMix message bus directly.
+
+�
+
+[[MessageBus-Example]]
+Example
++++++++
+
+The following demonstrates how the Camel message bus can be used to
+communicate with consumers and producers
+
+*Using the�link:fluent-builders.html[Fluent Builders]*
+
+[source,java]
+-----------------------------------------------
+from("direct:start")
+    .pollEnrich("file:inbox?fileName=data.txt")
+    .to("jms:queue:foo");
+-----------------------------------------------
+
+**Using the�link:spring-xml-extensions.html[Spring XML Extensions]**
+
+[source,xml]
+----------------------------------------------------
+<route>
+    <from uri="direct:start"/>
+    <pollEnrich uri="file:inbox?fileName=data.txt"/>
+    <to uri="jms:queue:foo"/>
+</route>
+----------------------------------------------------
+
+[[MessageBus-UsingThisPattern]]
+Using This Pattern
+++++++++++++++++++
+
+If you would like to use this EIP Pattern then please read the
+link:getting-started.html[Getting Started], you may also find the
+link:architecture.html[Architecture] useful particularly the description
+of link:endpoint.html[Endpoint] and link:uris.html[URIs]. Then you could
+try out some of the link:examples.html[Examples] first before trying
+this pattern out.

http://git-wip-us.apache.org/repos/asf/camel/blob/f0bae85e/camel-core/src/main/docs/eips/message-channel.adoc
----------------------------------------------------------------------
diff --git a/camel-core/src/main/docs/eips/message-channel.adoc b/camel-core/src/main/docs/eips/message-channel.adoc
new file mode 100644
index 0000000..67c34e9
--- /dev/null
+++ b/camel-core/src/main/docs/eips/message-channel.adoc
@@ -0,0 +1,58 @@
+[[MessageChannel-MessageChannel]]
+Message Channel
+^^^^^^^^^^^^^^^
+
+Camel supports the
+http://www.enterpriseintegrationpatterns.com/MessageChannel.html[Message
+Channel] from the link:enterprise-integration-patterns.html[EIP
+patterns]. The Message Channel is an internal implementation detail of
+the
+http://camel.apache.org/maven/current/camel-core/apidocs/org/apache/camel/Endpoint.html[Endpoint]
+interface and all interactions with the Message Channel are via the
+Endpoint interfaces.
+
+image:http://www.enterpriseintegrationpatterns.com/img/MessageChannelSolution.gif[image]
+
+
+*Example*
+
+In JMS, Message Channels are represented by topics and queues such as
+the following
+
+[source,text]
+-------------
+jms:queue:foo
+-------------
+
+This message channel can be then used within the
+link:jms.html[JMS]�component
+
+*Using the�link:fluent-builders.html[Fluent Builders]*
+
+[source,java]
+-------------------
+to("jms:queue:foo")
+-------------------
+
+*Using the�link:spring-xml-extensions.html[Spring XML Extensions]*
+
+[source,xml]
+-------------------------
+<to uri="jms:queue:foo"/>
+-------------------------
+
+For more details see
+
+* link:message.html[Message]
+* link:message-endpoint.html[Message Endpoint]
+
+[[MessageChannel-UsingThisPattern]]
+Using This Pattern
+++++++++++++++++++
+
+If you would like to use this EIP Pattern then please read the
+link:getting-started.html[Getting Started], you may also find the
+link:architecture.html[Architecture] useful particularly the description
+of link:endpoint.html[Endpoint] and link:uris.html[URIs]. Then you could
+try out some of the link:examples.html[Examples] first before trying
+this pattern out.

http://git-wip-us.apache.org/repos/asf/camel/blob/f0bae85e/camel-core/src/main/docs/eips/message-endpoint.adoc
----------------------------------------------------------------------
diff --git a/camel-core/src/main/docs/eips/message-endpoint.adoc b/camel-core/src/main/docs/eips/message-endpoint.adoc
new file mode 100644
index 0000000..bb7bd5d
--- /dev/null
+++ b/camel-core/src/main/docs/eips/message-endpoint.adoc
@@ -0,0 +1,192 @@
+[[MessageEndpoint-MessageEndpoint]]
+Message Endpoint
+^^^^^^^^^^^^^^^^
+
+Camel supports the
+http://www.enterpriseintegrationpatterns.com/MessageEndpoint.html[Message
+Endpoint] from the link:enterprise-integration-patterns.html[EIP
+patterns] using the
+http://camel.apache.org/maven/current/camel-core/apidocs/org/apache/camel/Endpoint.html[Endpoint]
+interface.
+
+image:http://www.enterpriseintegrationpatterns.com/img/MessageEndpointSolution.gif[image]
+
+When using the link:dsl.html[DSL] to create link:routes.html[Routes] you
+typically refer to Message Endpoints by their link:uris.html[URIs]
+rather than directly using the
+http://camel.apache.org/maven/current/camel-core/apidocs/org/apache/camel/Endpoint.html[Endpoint]
+interface. Its then a responsibility of the
+http://camel.apache.org/maven/current/camel-core/apidocs/org/apache/camel/CamelContext.html[CamelContext]
+to create and activate the necessary Endpoint instances using the
+available
+http://camel.apache.org/maven/current/camel-core/apidocs/org/apache/camel/Component.html[Component]
+implementations.
+
+[[MessageEndpoint-Example]]
+Example
++++++++
+
+The following example route demonstrates the use of a
+https://cwiki.apache.org/confluence/pages/viewpage.action?pageId=38922[File]
+Consumer Endpoint and link:jms.html[JMS] Producer Endpoint
+
+*Using the�link:fluent-builders.html[Fluent Builders]*
+
+[source,java]
+----------------------------------------
+from("file://local/router/messages/foo")
+    .to("jms:queue:foo");
+----------------------------------------
+
+**Using the�link:spring-xml-extensions.html[Spring XML Extensions]**
+
+[source,xml]
+--------------------------------------------------
+<route>
+    <from uri="file://local/router/messages/foo"/>
+    <to uri="jms:queue:foo"/>
+</route>
+--------------------------------------------------
+
+�
+
+[[MessageEndpoint-DynamicTo]]
+Dynamic To
+^^^^^^^^^^
+
+*Available as of Camel 2.16*
+
+There is a new <toD> that allows to send a message to a dynamic
+computed�link:endpoint.html[Endpoint] using one or
+more�link:expression.html[Expression] that are concat together. By
+default the�link:simple.html[Simple] language is used to compute
+the�endpoint. For example to send a message to a endpoint defined by a
+header you can do
+
+[source,xml]
+----------------------------
+<route>
+  <from uri="direct:start"/>
+  <toD uri="${header.foo}"/>
+</route>
+----------------------------
+
+And in Java DSL
+
+[source,java]
+------------------------
+from("direct:start")
+  .toD("${header.foo}");
+------------------------
+
+�
+
+You can also prefix the uri with a value because by default the uri is
+evaluated using the�link:simple.html[Simple] language
+
+[source,xml]
+--------------------------------
+<route>
+  <from uri="direct:start"/>
+  <toD uri="mock:${header.foo"/>
+</route>
+--------------------------------
+
+And in Java DSL
+
+[source,java]
+-----------------------------
+from("direct:start")
+  .toD("mock:${header.foo}");
+-----------------------------
+
+In the example above we compute an endpoint that has prefix "mock:" and
+then the header foo is appended. So for example if the header foo has
+value order, then the endpoint is computed as "mock:order".
+
+You can also use other languages than link:simple.html[Simple]�such
+as�link:xpath.html[XPath]�- this requires to prefix with language: as
+shown below (simple language is the default language). If you do not
+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.
+
+[source,xml]
+-----------------------------------------
+<route>
+  <from uri="direct:start"/>
+  <toD uri="language:xpath:/order/@uri"/>
+</route>
+-----------------------------------------
+
+This is done by specifying the name of the language followed by a colon.
+
+[source,java]
+-------------------------------------
+from("direct:start")
+  .toD("language:xpath:/order/@uri");
+-------------------------------------
+
+You can also concat multiple�link:language.html[Language](s) together
+using the plus sign�`+` such as shown below:
+
+[source,xml]
+-----------------------------------------------------------
+<route>
+  <from uri="direct:start"/>
+  <toD uri="jms:${header.base}+language:xpath:/order/@id"/>
+</route>
+-----------------------------------------------------------
+
+In the example above the uri is a combination
+of�link:simple.html[Simple]�language and�link:xpath.html[XPath]�where
+the first part is simple (simple is default language). And then the plus
+sign separate to another language, where we specify the language name
+followed by a colon
+
+[source,java]
+-------------------------------------------------------
+from("direct:start")
+  .toD("jms:${header.base}+language:xpath:/order/@id");
+-------------------------------------------------------
+
+You can concat as many languages as you want, just separate them with
+the plus sign
+
+The Dynamic To has a few options you can configure
+
+[width="100%",cols="10%,10%,80%",options="header",]
+|=======================================================================
+|Name |Default Value |Description
+
+|uri |  | *Mandatory:* The uri to use. See above
+
+|pattern |  | To set a specific link:exchange-pattern.html[Exchange Pattern] to use
+when sending to the endpoint. The original MEP is restored afterwards.
+
+|cacheSize |  | Allows to configure the cache size for the�`ProducerCache`�which caches
+producers for reuse. Will by default use the default cache size which is
+1000. Setting the value to -1 allows to turn off the cache all together.
+
+|ignoreInvalidEndpoint |`false` |Whether to ignore an endpoint URI that could not be resolved. If
+disabled, Camel will throw an exception identifying the invalid endpoint
+URI.
+|=======================================================================
+�
+
+For more details see
+
+* link:recipient-list.html[Recipient List]
+* link:message.html[Message]
+* link:wire-tap.html[Wire Tap] 
+
+[[MessageEndpoint-UsingThisPattern]]
+Using This Pattern
+++++++++++++++++++
+
+If you would like to use this EIP Pattern then please read the
+link:getting-started.html[Getting Started], you may also find the
+link:architecture.html[Architecture] useful particularly the description
+of link:endpoint.html[Endpoint] and link:uris.html[URIs]. Then you could
+try out some of the link:examples.html[Examples] first before trying
+this pattern out.

http://git-wip-us.apache.org/repos/asf/camel/blob/f0bae85e/camel-core/src/main/docs/eips/message-filter.adoc
----------------------------------------------------------------------
diff --git a/camel-core/src/main/docs/eips/message-filter.adoc b/camel-core/src/main/docs/eips/message-filter.adoc
new file mode 100644
index 0000000..ba5d7b8
--- /dev/null
+++ b/camel-core/src/main/docs/eips/message-filter.adoc
@@ -0,0 +1,130 @@
+[[MessageFilter-MessageFilter]]
+Message Filter
+^^^^^^^^^^^^^^
+
+The http://www.enterpriseintegrationpatterns.com/Filter.html[Message
+Filter] from the link:enterprise-integration-patterns.html[EIP patterns]
+allows you to filter messages
+
+image:http://www.enterpriseintegrationpatterns.com/img/MessageFilter.gif[image]
+
+The following example shows how to create a Message Filter route
+consuming messages from an endpoint called *queue:a*, which if the
+link:predicate.html[Predicate] is true will be dispatched to *queue:b*
+
+*Using the link:fluent-builders.html[Fluent Builders]*
+
+[source,java]
+----------------------------------------------------------------------------
+RouteBuilder builder = new RouteBuilder() {
+    public void configure() {
+        errorHandler(deadLetterChannel("mock:error"));
+ 
+        from("direct:a")
+            .filter(header("foo").isEqualTo("bar"))
+                .to("direct:b");
+    }
+};
+----------------------------------------------------------------------------
+
+You can, of course, use many different link:predicate.html[Predicate]
+languages such as link:xpath.html[XPath], link:xquery.html[XQuery],
+link:sql.html[SQL] or various link:scripting-languages.html[Scripting
+Languages]. Here is an
+http://svn.apache.org/repos/asf/camel/trunk/camel-core/src/test/java/org/apache/camel/processor/XPathFilterTest.java[XPath
+example]
+
+[source,java]
+----------------------------------------------------------------------------
+from("direct:start").
+        filter().xpath("/person[@name=&#39;James&#39;]").
+        to("mock:result");
+----------------------------------------------------------------------------
+
+Here is another example of using a bean to define the filter behavior
+
+[source,java]
+----------------------------------------------------------------------------
+from("direct:start")
+    .filter().method(MyBean.class, "isGoldCustomer").to("mock:result").end()
+    .to("mock:end");
+
+public static class MyBean {
+    public boolean isGoldCustomer(@Header("level") String level) { 
+        return level.equals("gold"); 
+    }
+}
+----------------------------------------------------------------------------
+
+*Using the link:spring-xml-extensions.html[Spring XML Extensions]*
+
+You can also use a method call expression (to call a method on a bean)
+in the Message Filter, as shown below:
+
+[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>
+----------------------------------------------------------------------------
+
+
+INFO:make sure you put the endpoint you want to filter (<to uri="seda:b"/>,
+etc.) before the closing </filter> tag or the filter will not be applied
+(in 2.8+, omitting this will result in an error)
+
+For further examples of this pattern in use you could look at the
+http://svn.apache.org/viewvc/camel/trunk/camel-core/src/test/java/org/apache/camel/processor/FilterTest.java?view=markup[junit
+test case]
+
+[[MessageFilter-Usingstop]]
+*Using stop*
+++++++++++++
+
+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
+link:content-based-router.html[Content Based Router] when you for
+example need to stop further processing in one of the predicates.
+
+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()`.
+
+[[MessageFilter-Knowingifwasfilteredornot]]
+Knowing if link:exchange.html[Exchange] was filtered or not
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+*Available as of Camel 2.5*
+
+The link:message-filter.html[Message Filter] EIP will add a property on
+the link:exchange.html[Exchange] that states if it was filtered or not.
+
+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 link:exchange.html[Exchange]
+was routed in the filter block. This property will be visible within the
+link:message-filter.html[Message Filter] block who's
+link:predicate.html[Predicate] matches (value set to `true`), and to the
+steps immediately following the link:message-filter.html[Message Filter]
+with the value set based on the results of the last
+link:message-filter.html[Message Filter] link:predicate.html[Predicate]
+evaluated.
+
+[[MessageFilter-UsingThisPattern]]
+Using This Pattern
+++++++++++++++++++
+
+If you would like to use this EIP Pattern then please read the
+link:getting-started.html[Getting Started], you may also find the
+link:architecture.html[Architecture] useful particularly the description
+of link:endpoint.html[Endpoint] and link:uris.html[URIs]. Then you could
+try out some of the link:examples.html[Examples] first before trying
+this pattern out.

http://git-wip-us.apache.org/repos/asf/camel/blob/f0bae85e/camel-core/src/main/docs/eips/message-router.adoc
----------------------------------------------------------------------
diff --git a/camel-core/src/main/docs/eips/message-router.adoc b/camel-core/src/main/docs/eips/message-router.adoc
new file mode 100644
index 0000000..827f70c
--- /dev/null
+++ b/camel-core/src/main/docs/eips/message-router.adoc
@@ -0,0 +1,37 @@
+[[MessageRouter-MessageRouter]]
+Message Router
+^^^^^^^^^^^^^^
+
+The
+http://www.enterpriseintegrationpatterns.com/MessageRouter.html[Message
+Router] from the link:enterprise-integration-patterns.html[EIP patterns]
+allows you to consume from an input destination, evaluate some predicate
+then choose the right output destination.
+
+image:http://www.enterpriseintegrationpatterns.com/img/MessageRouter.gif[image]
+
+The following example shows how to route a request from an input
+*queue:a* endpoint to either *queue:b*, *queue:c* or *queue:d* depending
+on the evaluation of various link:predicate.html[Predicate] expressions
+
+*Using the link:fluent-builders.html[Fluent Builders]*
+
+*Using the link:spring-xml-extensions.html[Spring XML Extensions]*
+
+[[MessageRouter-Choicewithoutotherwise]]
+Choice without otherwise
+++++++++++++++++++++++++
+
+If you use a `choice` without adding an `otherwise`, any unmatched
+exchanges will be dropped by default.
+
+[[MessageRouter-UsingThisPattern]]
+Using This Pattern
+++++++++++++++++++
+
+If you would like to use this EIP Pattern then please read the
+link:getting-started.html[Getting Started], you may also find the
+link:architecture.html[Architecture] useful particularly the description
+of link:endpoint.html[Endpoint] and link:uris.html[URIs]. Then you could
+try out some of the link:examples.html[Examples] first before trying
+this pattern out.

http://git-wip-us.apache.org/repos/asf/camel/blob/f0bae85e/camel-core/src/main/docs/eips/message-translator.adoc
----------------------------------------------------------------------
diff --git a/camel-core/src/main/docs/eips/message-translator.adoc b/camel-core/src/main/docs/eips/message-translator.adoc
new file mode 100644
index 0000000..8d4d573
--- /dev/null
+++ b/camel-core/src/main/docs/eips/message-translator.adoc
@@ -0,0 +1,96 @@
+[[MessageTranslator-MessageTranslator]]
+Message Translator
+^^^^^^^^^^^^^^^^^^
+
+Camel supports the
+http://www.enterpriseintegrationpatterns.com/MessageTranslator.html[Message
+Translator] from the link:enterprise-integration-patterns.html[EIP
+patterns] by using an arbitrary link:processor.html[Processor] in the
+routing logic, by using a link:bean-integration.html[bean] to perform
+the transformation, or by using transform() in the DSL. You can also use
+a link:data-format.html[Data Format] to marshal and unmarshal messages
+in different encodings.
+
+image:http://www.enterpriseintegrationpatterns.com/img/MessageTranslator.gif[image]
+
+*Using the link:fluent-builders.html[Fluent Builders]*
+
+You can transform a message using Camel's
+link:bean-integration.html[Bean Integration] to call any method on a
+bean in your link:registry.html[Registry] such as your
+link:spring.html[Spring] XML configuration file as follows
+
+[source,java]
+-----------------------------------------------
+from("activemq:SomeQueue").
+  beanRef("myTransformerBean", "myMethodName").
+  to("mqseries:AnotherQueue");
+-----------------------------------------------
+
+Where the "myTransformerBean" would be defined in a Spring XML file or
+defined in JNDI etc. You can omit the method name parameter from
+beanRef() and the link:bean-integration.html[Bean Integration] will try
+to deduce the method to invoke from the message exchange.
+
+or you can add your own explicit link:processor.html[Processor] to do
+the transformation
+
+or you can use the DSL to explicitly configure the transformation
+
+*Use Spring XML*
+
+You can also use link:spring-xml-extensions.html[Spring XML Extensions]
+to do a transformation. Basically any link:expression.html[Expression]
+language can be substituted inside the transform element as shown below
+
+Or you can use the link:bean-integration.html[Bean Integration] to
+invoke a bean
+
+[source,java]
+-----------------------------------------------
+<route>
+  <from uri="activemq:Input"/>
+  <bean ref="myBeanName" method="doTransform"/>
+  <to uri="activemq:Output"/>
+</route>
+-----------------------------------------------
+
+You can also use link:templating.html[Templating] to consume a message
+from one destination, transform it with something like
+link:velocity.html[Velocity] or link:xquery.html[XQuery] and then send
+it on to another destination. For example using InOnly (one way
+messaging)
+
+[source,java]
+----------------------------------------
+from("activemq:My.Queue").
+  to("velocity:com/acme/MyResponse.vm").
+  to("activemq:Another.Queue");
+----------------------------------------
+
+If you want to use InOut (request-reply) semantics to process requests
+on the *My.Queue* queue on link:activemq.html[ActiveMQ] with a template
+generated response, then sending responses back to the JMSReplyTo
+Destination you could use this.
+
+[source,java]
+----------------------------------------
+from("activemq:My.Queue").
+  to("velocity:com/acme/MyResponse.vm");
+----------------------------------------
+
+[[MessageTranslator-UsingThisPattern]]
+Using This Pattern
+++++++++++++++++++
+
+If you would like to use this EIP Pattern then please read the
+link:getting-started.html[Getting Started], you may also find the
+link:architecture.html[Architecture] useful particularly the description
+of link:endpoint.html[Endpoint] and link:uris.html[URIs]. Then you could
+try out some of the link:examples.html[Examples] first before trying
+this pattern out.
+
+* link:content-enricher.html[Content Enricher]
+* link:using-getin-or-getout-methods-on-exchange.html[Using getIn or
+getOut methods on Exchange]
+

http://git-wip-us.apache.org/repos/asf/camel/blob/f0bae85e/camel-core/src/main/docs/eips/message.adoc
----------------------------------------------------------------------
diff --git a/camel-core/src/main/docs/eips/message.adoc b/camel-core/src/main/docs/eips/message.adoc
new file mode 100644
index 0000000..c75a2bb
--- /dev/null
+++ b/camel-core/src/main/docs/eips/message.adoc
@@ -0,0 +1,69 @@
+[[Message-Message]]
+Message
+^^^^^^^
+
+Camel supports the
+http://www.enterpriseintegrationpatterns.com/Message.html[Message] from
+the link:enterprise-integration-patterns.html[EIP patterns] using the
+http://camel.apache.org/maven/current/camel-core/apidocs/org/apache/camel/Message.html[Message]
+interface.
+
+image:http://www.enterpriseintegrationpatterns.com/img/MessageSolution.gif[image]
+
+To support various message link:exchange-pattern.html[exchange patterns]
+like one way link:event-message.html[Event Message] and
+link:request-reply.html[Request Reply] messages Camel uses an
+link:exchange.html[Exchange] interface which has a *pattern* property
+which can be set to *InOnly* for an link:event-message.html[Event
+Message] which has a single inbound Message, or *InOut* for a
+link:request-reply.html[Request Reply] where there is an inbound and
+outbound message.
+
+Here is a basic example of sending a Message to a route in *InOnly* and
+*InOut* modes
+
+*Requestor Code*
+
+[source,java]
+---------------------------------------------------------------------------------------------------------------
+//InOnly
+getContext().createProducerTemplate().sendBody("direct:startInOnly", "Hello World");
+
+//InOut
+String result = (String) getContext().createProducerTemplate().requestBody("direct:startInOut", "Hello World");
+---------------------------------------------------------------------------------------------------------------
+
+*Route Using the link:fluent-builders.html[Fluent Builders]*
+
+[source,java]
+--------------------------------------------------
+from("direct:startInOnly").inOnly("bean:process");
+
+from("direct:startInOut").inOut("bean:process");
+--------------------------------------------------
+
+*Route Using the link:spring-xml-extensions.html[Spring XML Extensions]*
+
+[source,java]
+----------------------------------
+<route>
+  <from uri="direct:startInOnly"/>
+  <inOnly uri="bean:process"/>
+</route>
+
+<route>
+  <from uri="direct:startInOut"/>
+  <inOut uri="bean:process"/>
+</route>
+----------------------------------
+
+[[Message-UsingThisPattern]]
+Using This Pattern
+++++++++++++++++++
+
+If you would like to use this EIP Pattern then please read the
+link:getting-started.html[Getting Started], you may also find the
+link:architecture.html[Architecture] useful particularly the description
+of link:endpoint.html[Endpoint] and link:uris.html[URIs]. Then you could
+try out some of the link:examples.html[Examples] first before trying
+this pattern out.

http://git-wip-us.apache.org/repos/asf/camel/blob/f0bae85e/camel-core/src/main/docs/eips/pipes-and-filters.adoc
----------------------------------------------------------------------
diff --git a/camel-core/src/main/docs/eips/pipes-and-filters.adoc b/camel-core/src/main/docs/eips/pipes-and-filters.adoc
new file mode 100644
index 0000000..3a820a6
--- /dev/null
+++ b/camel-core/src/main/docs/eips/pipes-and-filters.adoc
@@ -0,0 +1,93 @@
+[[PipesandFilters-PipesandFilters]]
+Pipes and Filters
+^^^^^^^^^^^^^^^^^
+
+Camel supports the
+http://www.enterpriseintegrationpatterns.com/PipesAndFilters.html[Pipes
+and Filters] from the link:enterprise-integration-patterns.html[EIP
+patterns] in various ways.
+
+image:http://www.enterpriseintegrationpatterns.com/img/PipesAndFilters.gif[image]
+
+With Camel you can split your processing across multiple independent
+link:endpoint.html[Endpoint] instances which can then be chained
+together.
+
+[[PipesandFilters-UsingRoutingLogic]]
+Using Routing Logic
++++++++++++++++++++
+
+You can create pipelines of logic using multiple
+link:endpoint.html[Endpoint] or link:message-translator.html[Message
+Translator] instances as follows
+
+Though pipeline is the default mode of operation when you specify
+multiple outputs in Camel. The opposite to pipeline is multicast; which
+fires the same message into each of its outputs. (See the example
+below).
+
+In Spring XML you can use the <pipeline/> element
+
+[source,java]
+------------------------------------
+<route>
+  <from uri="activemq:SomeQueue"/>
+  <pipeline>
+    <bean ref="foo"/>
+    <bean ref="bar"/>
+    <to uri="activemq:OutputQueue"/>
+  </pipeline>
+</route>
+------------------------------------
+
+In the above the pipeline element is actually unnecessary, you could use
+this...
+
+[source,java]
+----------------------------------
+<route>
+  <from uri="activemq:SomeQueue"/>
+  <bean ref="foo"/>
+  <bean ref="bar"/>
+  <to uri="activemq:OutputQueue"/>
+</route>
+----------------------------------
+
+Its just a bit more explicit. However if you wish to use <multicast/> to
+avoid a pipeline - to send the same message into multiple pipelines -
+then the <pipeline/> element comes into its own.
+
+[source,java]
+--------------------------------------
+<route>
+  <from uri="activemq:SomeQueue"/>
+  <multicast>
+    <pipeline>
+      <bean ref="something"/>
+      <to uri="log:Something"/>
+    </pipeline>
+    <pipeline>
+      <bean ref="foo"/>
+      <bean ref="bar"/>
+      <to uri="activemq:OutputQueue"/>
+    </pipeline>
+  </multicast>
+</route>
+--------------------------------------
+
+In the above example we are routing from a single
+link:endpoint.html[Endpoint] to a list of different endpoints specified
+using link:uris.html[URIs]. If you find the above a bit confusing, try
+reading about the link:architecture.html[Architecture] or try the
+link:examples.html[Examples]
+
+[[PipesandFilters-UsingThisPattern]]
+Using This Pattern
+++++++++++++++++++
+
+If you would like to use this EIP Pattern then please read the
+link:getting-started.html[Getting Started], you may also find the
+link:architecture.html[Architecture] useful particularly the description
+of link:endpoint.html[Endpoint] and link:uris.html[URIs]. Then you could
+try out some of the link:examples.html[Examples] first before trying
+this pattern out.

http://git-wip-us.apache.org/repos/asf/camel/blob/f0bae85e/camel-core/src/main/docs/eips/point-to-point-channel.adoc
----------------------------------------------------------------------
diff --git a/camel-core/src/main/docs/eips/point-to-point-channel.adoc b/camel-core/src/main/docs/eips/point-to-point-channel.adoc
new file mode 100644
index 0000000..ca8ff56
--- /dev/null
+++ b/camel-core/src/main/docs/eips/point-to-point-channel.adoc
@@ -0,0 +1,52 @@
+[[PointtoPointChannel-PointtoPointChannel]]
+Point to Point Channel
+^^^^^^^^^^^^^^^^^^^^^^
+
+Camel supports the
+http://www.enterpriseintegrationpatterns.com/PointToPointChannel.html[Point
+to Point Channel] from the link:enterprise-integration-patterns.html[EIP
+patterns] using the following components
+
+* link:seda.html[SEDA] for in-VM seda based messaging
+* link:jms.html[JMS] for working with JMS Queues for high performance,
+clustering and load balancing
+* link:jpa.html[JPA] for using a database as a simple message queue
+* link:xmpp.html[XMPP] for point-to-point communication over XMPP
+(Jabber)
+* and others
+
+image:http://www.enterpriseintegrationpatterns.com/img/PointToPointSolution.gif[image]
+
+The following example demonstrates point to point messaging using
+the�link:jms.html[JMS]�component�
+
+*Using the�link:fluent-builders.html[Fluent Builders]*
+
+[source,java]
+-------------------------
+from("direct:start")
+    .to("jms:queue:foo");
+-------------------------
+
+�
+
+**Using the�link:spring-xml-extensions.html[Spring XML Extensions]**
+
+[source,xml]
+------------------------------
+<route>
+    <from uri="direct:start"/>
+    <to uri="jms:queue:foo"/>
+</route>
+------------------------------
+
+[[PointtoPointChannel-UsingThisPattern]]
+Using This Pattern
+++++++++++++++++++
+
+If you would like to use this EIP Pattern then please read the
+link:getting-started.html[Getting Started], you may also find the
+link:architecture.html[Architecture] useful particularly the description
+of link:endpoint.html[Endpoint] and link:uris.html[URIs]. Then you could
+try out some of the link:examples.html[Examples] first before trying
+this pattern out.

http://git-wip-us.apache.org/repos/asf/camel/blob/f0bae85e/camel-core/src/main/docs/eips/publish-subscribe-channel.adoc
----------------------------------------------------------------------
diff --git a/camel-core/src/main/docs/eips/publish-subscribe-channel.adoc b/camel-core/src/main/docs/eips/publish-subscribe-channel.adoc
new file mode 100644
index 0000000..5665251
--- /dev/null
+++ b/camel-core/src/main/docs/eips/publish-subscribe-channel.adoc
@@ -0,0 +1,69 @@
+[[PublishSubscribeChannel-PublishSubscribeChannel]]
+Publish Subscribe Channel
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Camel supports the
+http://www.enterpriseintegrationpatterns.com/PublishSubscribeChannel.html[Publish
+Subscribe Channel] from the
+link:enterprise-integration-patterns.html[EIP patterns] using for
+example the following components:
+
+* link:jms.html[JMS] for working with JMS Topics for high performance,
+clustering and load balancing
+* link:xmpp.html[XMPP] when using rooms for group communication
+* link:seda.html[SEDA] for working with SEDA in the same
+link:camelcontext.html[CamelContext] which can work in pub-sub, but
+allowing multiple consumers.
+* link:vm.html[VM] as SEDA but for intra-JVM.
+
+image:http://www.enterpriseintegrationpatterns.com/img/PublishSubscribeSolution.gif[image]
+
+[[PublishSubscribeChannel-UsingRoutingLogic]]
+Using Routing Logic
++++++++++++++++++++
+
+Another option is to explicitly list the publish-subscribe relationship
+in your routing logic; this keeps the producer and consumer decoupled
+but lets you control the fine grained routing configuration using the
+link:dsl.html[DSL] or link:xml-configuration.html[Xml Configuration].
+
+*Using the link:fluent-builders.html[Fluent Builders]*
+
+[source,java]
+---------------------------------------------------
+RouteBuilder builder = new RouteBuilder() {
+    public void configure() {
+        errorHandler(deadLetterChannel("mock:error"));
+ 
+        from("direct:a")
+            .multicast().to("direct:b", "direct:c", "direct:d");
+    }
+};
+---------------------------------------------------
+
+*Using the link:spring-xml-extensions.html[Spring XML Extensions]*
+
+[source,xml]
+---------------------------------------------------
+<camelContext errorHandlerRef="errorHandler" xmlns="http://camel.apache.org/schema/spring">
+    <route>
+        <from uri="direct:a"/>
+        <multicast>
+            <to uri="direct:b"/>
+            <to uri="direct:c"/>
+            <to uri="direct:d"/>
+        </multicast>
+    </route>
+</camelContext>
+---------------------------------------------------
+
+[[PublishSubscribeChannel-UsingThisPattern]]
+Using This Pattern
+++++++++++++++++++
+
+If you would like to use this EIP Pattern then please read the
+link:getting-started.html[Getting Started], you may also find the
+link:architecture.html[Architecture] useful particularly the description
+of link:endpoint.html[Endpoint] and link:uris.html[URIs]. Then you could
+try out some of the link:examples.html[Examples] first before trying
+this pattern out.

http://git-wip-us.apache.org/repos/asf/camel/blob/f0bae85e/camel-core/src/main/docs/eips/random-eip.adoc
----------------------------------------------------------------------
diff --git a/camel-core/src/main/docs/eips/random-eip.adoc b/camel-core/src/main/docs/eips/random-eip.adoc
new file mode 100644
index 0000000..37e3000
--- /dev/null
+++ b/camel-core/src/main/docs/eips/random-eip.adoc
@@ -0,0 +1,13 @@
+## Random EIP
+
+
+// eip options: START
+The Random EIP supports 0 options which are listed below:
+
+{% raw %}
+[width="100%",cols="3,1m,6",options="header"]
+|=======================================================================
+| Name | Java Type | Description
+|=======================================================================
+{% endraw %}
+// eip options: END

http://git-wip-us.apache.org/repos/asf/camel/blob/f0bae85e/camel-core/src/main/docs/event-message.adoc
----------------------------------------------------------------------
diff --git a/camel-core/src/main/docs/event-message.adoc b/camel-core/src/main/docs/event-message.adoc
deleted file mode 100644
index a25cf8f..0000000
--- a/camel-core/src/main/docs/event-message.adoc
+++ /dev/null
@@ -1,86 +0,0 @@
-[[EventMessage-EventMessage]]
-Event Message
-~~~~~~~~~~~~~
-
-Camel supports the
-http://www.enterpriseintegrationpatterns.com/EventMessage.html[Event
-Message] from the link:enterprise-integration-patterns.html[EIP
-patterns] by supporting the link:exchange-pattern.html[Exchange Pattern]
-on a link:message.html[Message] which can be set to *InOnly* to indicate
-a oneway event message. Camel link:components.html[Components] then
-implement this pattern using the underlying transport or protocols.
-
-image:http://www.enterpriseintegrationpatterns.com/img/EventMessageSolution.gif[image]
-
-The default behaviour of many link:components.html[Components] is InOnly
-such as for link:jms.html[JMS], link:file2.html[File] or
-link:seda.html[SEDA]
-
-[TIP]
-====
-*Related*
-
-See the related link:request-reply.html[Request Reply] message.
-====
-
-[[EventMessage-ExplicitlyspecifyingInOnly]]
-Explicitly specifying InOnly
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-If you are using a component which defaults to InOut you can override
-the link:exchange-pattern.html[Exchange Pattern] for an endpoint using
-the pattern property.
-
-[source,java]
-------------------------------
-foo:bar?exchangePattern=InOnly
-------------------------------
-
-From 2.0 onwards on Camel you can specify the
-link:exchange-pattern.html[Exchange Pattern] using the DSL.
-
-*Using the link:fluent-builders.html[Fluent Builders]*
-
-[source,java]
----------------------------------------------
-from("mq:someQueue").
-  setExchangePattern(ExchangePattern.InOnly).
-  bean(Foo.class);
----------------------------------------------
-
-or you can invoke an endpoint with an explicit pattern
-
-[source,java]
-----------------------------
-from("mq:someQueue").
-  inOnly("mq:anotherQueue");
-----------------------------
-
-*Using the link:spring-xml-extensions.html[Spring XML Extensions]*
-
-[source,java]
-------------------------------
-<route>
-    <from uri="mq:someQueue"/>
-    <inOnly uri="bean:foo"/>
-</route>
-------------------------------
-
-[source,java]
------------------------------------
-<route>
-    <from uri="mq:someQueue"/>
-    <inOnly uri="mq:anotherQueue"/>
-</route>
------------------------------------
-
-[[EventMessage-UsingThisPattern]]
-Using This Pattern
-++++++++++++++++++
-
-If you would like to use this EIP Pattern then please read the
-link:getting-started.html[Getting Started], you may also find the
-link:architecture.html[Architecture] useful particularly the description
-of link:endpoint.html[Endpoint] and link:uris.html[URIs]. Then you could
-try out some of the link:examples.html[Examples] first before trying
-this pattern out.

http://git-wip-us.apache.org/repos/asf/camel/blob/f0bae85e/camel-core/src/main/docs/guaranteed-delivery.adoc
----------------------------------------------------------------------
diff --git a/camel-core/src/main/docs/guaranteed-delivery.adoc b/camel-core/src/main/docs/guaranteed-delivery.adoc
deleted file mode 100644
index 7620c9b..0000000
--- a/camel-core/src/main/docs/guaranteed-delivery.adoc
+++ /dev/null
@@ -1,64 +0,0 @@
-[[GuaranteedDelivery-GuaranteedDelivery]]
-Guaranteed Delivery
-^^^^^^^^^^^^^^^^^^^
-
-Camel supports the
-http://www.enterpriseintegrationpatterns.com/GuaranteedMessaging.html[Guaranteed
-Delivery] from the link:enterprise-integration-patterns.html[EIP
-patterns] using among others the following components:
-
-* link:file2.html[File] for using file systems as a persistent store of
-messages
-* link:jms.html[JMS] when using persistent delivery (the default) for
-working with JMS Queues and Topics for high performance, clustering and
-load balancing
-* link:jpa.html[JPA] for using a database as a persistence layer, or use
-any of the many other database component such as link:sql.html[SQL],
-link:jdbc.html[JDBC],
-link:ibatis.html[iBATIS]/link:mybatis.html[MyBatis],
-link:hibernate.html[Hibernate]
-* link:hawtdb.html[HawtDB] for a lightweight key-value persistent store
-
-image:http://www.enterpriseintegrationpatterns.com/img/GuaranteedMessagingSolution.gif[image]
-
-[[GuaranteedDelivery-Example]]
-Example
-+++++++
-
-The following example demonstrates illustrates the use
-of�http://www.enterpriseintegrationpatterns.com/GuaranteedMessaging.html[Guaranteed
-Delivery]�within the�link:jms.html[JMS]�component. By default, a message
-is not considered successfully delivered until the recipient has
-persisted the message locally guaranteeing its receipt in the event the
-destination becomes unavailable.
-
-*Using the�link:fluent-builders.html[Fluent Builders]*
-
-[source,java]
--------------------------
-from("direct:start")
-    .to("jms:queue:foo");
--------------------------
-
-�
-
-**Using the�link:spring-xml-extensions.html[Spring XML Extensions]**
-
-[source,xml]
-------------------------------
-<route>
-    <from uri="direct:start"/>
-    <to uri="jms:queue:foo"/>
-</route>
-------------------------------
-
-[[GuaranteedDelivery-UsingThisPattern]]
-Using This Pattern
-++++++++++++++++++
-
-If you would like to use this EIP Pattern then please read the
-link:getting-started.html[Getting Started], you may also find the
-link:architecture.html[Architecture] useful particularly the description
-of link:endpoint.html[Endpoint] and link:uris.html[URIs]. Then you could
-try out some of the link:examples.html[Examples] first before trying
-this pattern out.

http://git-wip-us.apache.org/repos/asf/camel/blob/f0bae85e/camel-core/src/main/docs/message-bus.adoc
----------------------------------------------------------------------
diff --git a/camel-core/src/main/docs/message-bus.adoc b/camel-core/src/main/docs/message-bus.adoc
deleted file mode 100644
index 8ad4ea8..0000000
--- a/camel-core/src/main/docs/message-bus.adoc
+++ /dev/null
@@ -1,64 +0,0 @@
-[[MessageBus-MessageBus]]
-Message Bus
-^^^^^^^^^^^
-
-Camel supports the
-http://www.enterpriseintegrationpatterns.com/PointToPointChannel.html[Message
-Bus] from the link:enterprise-integration-patterns.html[EIP patterns].
-You could view Camel as a Message Bus itself as it allows producers and
-consumers to be decoupled.
-
-image:http://www.enterpriseintegrationpatterns.com/img/MessageBusSolution.gif[image]
-
-Folks often assume that a Message Bus is a JMS though so you may wish to
-refer to the link:jms.html[JMS] component for traditional MOM support. +
- Also worthy of note is the link:xmpp.html[XMPP] component for
-supporting messaging over XMPP (Jabber)
-
-Of course there are also ESB products such as
-http://servicemix.apache.org/home.html[Apache ServiceMix] which serve as
-full fledged message busses. +
- You can interact with http://servicemix.apache.org/home.html[Apache
-ServiceMix] from Camel in many ways, but in particular you can use the
-link:nmr.html[NMR] or link:jbi.html[JBI] component to access the
-ServiceMix message bus directly.
-
-�
-
-[[MessageBus-Example]]
-Example
-+++++++
-
-The following demonstrates how the Camel message bus can be used to
-communicate with consumers and producers
-
-*Using the�link:fluent-builders.html[Fluent Builders]*
-
-[source,java]
------------------------------------------------
-from("direct:start")
-    .pollEnrich("file:inbox?fileName=data.txt")
-    .to("jms:queue:foo");
------------------------------------------------
-
-**Using the�link:spring-xml-extensions.html[Spring XML Extensions]**
-
-[source,xml]
-----------------------------------------------------
-<route>
-    <from uri="direct:start"/>
-    <pollEnrich uri="file:inbox?fileName=data.txt"/>
-    <to uri="jms:queue:foo"/>
-</route>
-----------------------------------------------------
-
-[[MessageBus-UsingThisPattern]]
-Using This Pattern
-++++++++++++++++++
-
-If you would like to use this EIP Pattern then please read the
-link:getting-started.html[Getting Started], you may also find the
-link:architecture.html[Architecture] useful particularly the description
-of link:endpoint.html[Endpoint] and link:uris.html[URIs]. Then you could
-try out some of the link:examples.html[Examples] first before trying
-this pattern out.

http://git-wip-us.apache.org/repos/asf/camel/blob/f0bae85e/camel-core/src/main/docs/message-channel.adoc
----------------------------------------------------------------------
diff --git a/camel-core/src/main/docs/message-channel.adoc b/camel-core/src/main/docs/message-channel.adoc
deleted file mode 100644
index 67c34e9..0000000
--- a/camel-core/src/main/docs/message-channel.adoc
+++ /dev/null
@@ -1,58 +0,0 @@
-[[MessageChannel-MessageChannel]]
-Message Channel
-^^^^^^^^^^^^^^^
-
-Camel supports the
-http://www.enterpriseintegrationpatterns.com/MessageChannel.html[Message
-Channel] from the link:enterprise-integration-patterns.html[EIP
-patterns]. The Message Channel is an internal implementation detail of
-the
-http://camel.apache.org/maven/current/camel-core/apidocs/org/apache/camel/Endpoint.html[Endpoint]
-interface and all interactions with the Message Channel are via the
-Endpoint interfaces.
-
-image:http://www.enterpriseintegrationpatterns.com/img/MessageChannelSolution.gif[image]
-
-
-*Example*
-
-In JMS, Message Channels are represented by topics and queues such as
-the following
-
-[source,text]
--------------
-jms:queue:foo
--------------
-
-This message channel can be then used within the
-link:jms.html[JMS]�component
-
-*Using the�link:fluent-builders.html[Fluent Builders]*
-
-[source,java]
--------------------
-to("jms:queue:foo")
--------------------
-
-*Using the�link:spring-xml-extensions.html[Spring XML Extensions]*
-
-[source,xml]
--------------------------
-<to uri="jms:queue:foo"/>
--------------------------
-
-For more details see
-
-* link:message.html[Message]
-* link:message-endpoint.html[Message Endpoint]
-
-[[MessageChannel-UsingThisPattern]]
-Using This Pattern
-++++++++++++++++++
-
-If you would like to use this EIP Pattern then please read the
-link:getting-started.html[Getting Started], you may also find the
-link:architecture.html[Architecture] useful particularly the description
-of link:endpoint.html[Endpoint] and link:uris.html[URIs]. Then you could
-try out some of the link:examples.html[Examples] first before trying
-this pattern out.

http://git-wip-us.apache.org/repos/asf/camel/blob/f0bae85e/camel-core/src/main/docs/message-endpoint.adoc
----------------------------------------------------------------------
diff --git a/camel-core/src/main/docs/message-endpoint.adoc b/camel-core/src/main/docs/message-endpoint.adoc
deleted file mode 100644
index bb7bd5d..0000000
--- a/camel-core/src/main/docs/message-endpoint.adoc
+++ /dev/null
@@ -1,192 +0,0 @@
-[[MessageEndpoint-MessageEndpoint]]
-Message Endpoint
-^^^^^^^^^^^^^^^^
-
-Camel supports the
-http://www.enterpriseintegrationpatterns.com/MessageEndpoint.html[Message
-Endpoint] from the link:enterprise-integration-patterns.html[EIP
-patterns] using the
-http://camel.apache.org/maven/current/camel-core/apidocs/org/apache/camel/Endpoint.html[Endpoint]
-interface.
-
-image:http://www.enterpriseintegrationpatterns.com/img/MessageEndpointSolution.gif[image]
-
-When using the link:dsl.html[DSL] to create link:routes.html[Routes] you
-typically refer to Message Endpoints by their link:uris.html[URIs]
-rather than directly using the
-http://camel.apache.org/maven/current/camel-core/apidocs/org/apache/camel/Endpoint.html[Endpoint]
-interface. Its then a responsibility of the
-http://camel.apache.org/maven/current/camel-core/apidocs/org/apache/camel/CamelContext.html[CamelContext]
-to create and activate the necessary Endpoint instances using the
-available
-http://camel.apache.org/maven/current/camel-core/apidocs/org/apache/camel/Component.html[Component]
-implementations.
-
-[[MessageEndpoint-Example]]
-Example
-+++++++
-
-The following example route demonstrates the use of a
-https://cwiki.apache.org/confluence/pages/viewpage.action?pageId=38922[File]
-Consumer Endpoint and link:jms.html[JMS] Producer Endpoint
-
-*Using the�link:fluent-builders.html[Fluent Builders]*
-
-[source,java]
-----------------------------------------
-from("file://local/router/messages/foo")
-    .to("jms:queue:foo");
-----------------------------------------
-
-**Using the�link:spring-xml-extensions.html[Spring XML Extensions]**
-
-[source,xml]
---------------------------------------------------
-<route>
-    <from uri="file://local/router/messages/foo"/>
-    <to uri="jms:queue:foo"/>
-</route>
---------------------------------------------------
-
-�
-
-[[MessageEndpoint-DynamicTo]]
-Dynamic To
-^^^^^^^^^^
-
-*Available as of Camel 2.16*
-
-There is a new <toD> that allows to send a message to a dynamic
-computed�link:endpoint.html[Endpoint] using one or
-more�link:expression.html[Expression] that are concat together. By
-default the�link:simple.html[Simple] language is used to compute
-the�endpoint. For example to send a message to a endpoint defined by a
-header you can do
-
-[source,xml]
-----------------------------
-<route>
-  <from uri="direct:start"/>
-  <toD uri="${header.foo}"/>
-</route>
-----------------------------
-
-And in Java DSL
-
-[source,java]
-------------------------
-from("direct:start")
-  .toD("${header.foo}");
-------------------------
-
-�
-
-You can also prefix the uri with a value because by default the uri is
-evaluated using the�link:simple.html[Simple] language
-
-[source,xml]
---------------------------------
-<route>
-  <from uri="direct:start"/>
-  <toD uri="mock:${header.foo"/>
-</route>
---------------------------------
-
-And in Java DSL
-
-[source,java]
------------------------------
-from("direct:start")
-  .toD("mock:${header.foo}");
------------------------------
-
-In the example above we compute an endpoint that has prefix "mock:" and
-then the header foo is appended. So for example if the header foo has
-value order, then the endpoint is computed as "mock:order".
-
-You can also use other languages than link:simple.html[Simple]�such
-as�link:xpath.html[XPath]�- this requires to prefix with language: as
-shown below (simple language is the default language). If you do not
-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.
-
-[source,xml]
------------------------------------------
-<route>
-  <from uri="direct:start"/>
-  <toD uri="language:xpath:/order/@uri"/>
-</route>
------------------------------------------
-
-This is done by specifying the name of the language followed by a colon.
-
-[source,java]
--------------------------------------
-from("direct:start")
-  .toD("language:xpath:/order/@uri");
--------------------------------------
-
-You can also concat multiple�link:language.html[Language](s) together
-using the plus sign�`+` such as shown below:
-
-[source,xml]
------------------------------------------------------------
-<route>
-  <from uri="direct:start"/>
-  <toD uri="jms:${header.base}+language:xpath:/order/@id"/>
-</route>
------------------------------------------------------------
-
-In the example above the uri is a combination
-of�link:simple.html[Simple]�language and�link:xpath.html[XPath]�where
-the first part is simple (simple is default language). And then the plus
-sign separate to another language, where we specify the language name
-followed by a colon
-
-[source,java]
--------------------------------------------------------
-from("direct:start")
-  .toD("jms:${header.base}+language:xpath:/order/@id");
--------------------------------------------------------
-
-You can concat as many languages as you want, just separate them with
-the plus sign
-
-The Dynamic To has a few options you can configure
-
-[width="100%",cols="10%,10%,80%",options="header",]
-|=======================================================================
-|Name |Default Value |Description
-
-|uri |  | *Mandatory:* The uri to use. See above
-
-|pattern |  | To set a specific link:exchange-pattern.html[Exchange Pattern] to use
-when sending to the endpoint. The original MEP is restored afterwards.
-
-|cacheSize |  | Allows to configure the cache size for the�`ProducerCache`�which caches
-producers for reuse. Will by default use the default cache size which is
-1000. Setting the value to -1 allows to turn off the cache all together.
-
-|ignoreInvalidEndpoint |`false` |Whether to ignore an endpoint URI that could not be resolved. If
-disabled, Camel will throw an exception identifying the invalid endpoint
-URI.
-|=======================================================================
-�
-
-For more details see
-
-* link:recipient-list.html[Recipient List]
-* link:message.html[Message]
-* link:wire-tap.html[Wire Tap] 
-
-[[MessageEndpoint-UsingThisPattern]]
-Using This Pattern
-++++++++++++++++++
-
-If you would like to use this EIP Pattern then please read the
-link:getting-started.html[Getting Started], you may also find the
-link:architecture.html[Architecture] useful particularly the description
-of link:endpoint.html[Endpoint] and link:uris.html[URIs]. Then you could
-try out some of the link:examples.html[Examples] first before trying
-this pattern out.

http://git-wip-us.apache.org/repos/asf/camel/blob/f0bae85e/camel-core/src/main/docs/message-filter.adoc
----------------------------------------------------------------------
diff --git a/camel-core/src/main/docs/message-filter.adoc b/camel-core/src/main/docs/message-filter.adoc
deleted file mode 100644
index ba5d7b8..0000000
--- a/camel-core/src/main/docs/message-filter.adoc
+++ /dev/null
@@ -1,130 +0,0 @@
-[[MessageFilter-MessageFilter]]
-Message Filter
-^^^^^^^^^^^^^^
-
-The http://www.enterpriseintegrationpatterns.com/Filter.html[Message
-Filter] from the link:enterprise-integration-patterns.html[EIP patterns]
-allows you to filter messages
-
-image:http://www.enterpriseintegrationpatterns.com/img/MessageFilter.gif[image]
-
-The following example shows how to create a Message Filter route
-consuming messages from an endpoint called *queue:a*, which if the
-link:predicate.html[Predicate] is true will be dispatched to *queue:b*
-
-*Using the link:fluent-builders.html[Fluent Builders]*
-
-[source,java]
-----------------------------------------------------------------------------
-RouteBuilder builder = new RouteBuilder() {
-    public void configure() {
-        errorHandler(deadLetterChannel("mock:error"));
- 
-        from("direct:a")
-            .filter(header("foo").isEqualTo("bar"))
-                .to("direct:b");
-    }
-};
-----------------------------------------------------------------------------
-
-You can, of course, use many different link:predicate.html[Predicate]
-languages such as link:xpath.html[XPath], link:xquery.html[XQuery],
-link:sql.html[SQL] or various link:scripting-languages.html[Scripting
-Languages]. Here is an
-http://svn.apache.org/repos/asf/camel/trunk/camel-core/src/test/java/org/apache/camel/processor/XPathFilterTest.java[XPath
-example]
-
-[source,java]
-----------------------------------------------------------------------------
-from("direct:start").
-        filter().xpath("/person[@name=&#39;James&#39;]").
-        to("mock:result");
-----------------------------------------------------------------------------
-
-Here is another example of using a bean to define the filter behavior
-
-[source,java]
-----------------------------------------------------------------------------
-from("direct:start")
-    .filter().method(MyBean.class, "isGoldCustomer").to("mock:result").end()
-    .to("mock:end");
-
-public static class MyBean {
-    public boolean isGoldCustomer(@Header("level") String level) { 
-        return level.equals("gold"); 
-    }
-}
-----------------------------------------------------------------------------
-
-*Using the link:spring-xml-extensions.html[Spring XML Extensions]*
-
-You can also use a method call expression (to call a method on a bean)
-in the Message Filter, as shown below:
-
-[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>
-----------------------------------------------------------------------------
-
-
-INFO:make sure you put the endpoint you want to filter (<to uri="seda:b"/>,
-etc.) before the closing </filter> tag or the filter will not be applied
-(in 2.8+, omitting this will result in an error)
-
-For further examples of this pattern in use you could look at the
-http://svn.apache.org/viewvc/camel/trunk/camel-core/src/test/java/org/apache/camel/processor/FilterTest.java?view=markup[junit
-test case]
-
-[[MessageFilter-Usingstop]]
-*Using stop*
-++++++++++++
-
-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
-link:content-based-router.html[Content Based Router] when you for
-example need to stop further processing in one of the predicates.
-
-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()`.
-
-[[MessageFilter-Knowingifwasfilteredornot]]
-Knowing if link:exchange.html[Exchange] was filtered or not
-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-
-*Available as of Camel 2.5*
-
-The link:message-filter.html[Message Filter] EIP will add a property on
-the link:exchange.html[Exchange] that states if it was filtered or not.
-
-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 link:exchange.html[Exchange]
-was routed in the filter block. This property will be visible within the
-link:message-filter.html[Message Filter] block who's
-link:predicate.html[Predicate] matches (value set to `true`), and to the
-steps immediately following the link:message-filter.html[Message Filter]
-with the value set based on the results of the last
-link:message-filter.html[Message Filter] link:predicate.html[Predicate]
-evaluated.
-
-[[MessageFilter-UsingThisPattern]]
-Using This Pattern
-++++++++++++++++++
-
-If you would like to use this EIP Pattern then please read the
-link:getting-started.html[Getting Started], you may also find the
-link:architecture.html[Architecture] useful particularly the description
-of link:endpoint.html[Endpoint] and link:uris.html[URIs]. Then you could
-try out some of the link:examples.html[Examples] first before trying
-this pattern out.

http://git-wip-us.apache.org/repos/asf/camel/blob/f0bae85e/camel-core/src/main/docs/message-router.adoc
----------------------------------------------------------------------
diff --git a/camel-core/src/main/docs/message-router.adoc b/camel-core/src/main/docs/message-router.adoc
deleted file mode 100644
index 827f70c..0000000
--- a/camel-core/src/main/docs/message-router.adoc
+++ /dev/null
@@ -1,37 +0,0 @@
-[[MessageRouter-MessageRouter]]
-Message Router
-^^^^^^^^^^^^^^
-
-The
-http://www.enterpriseintegrationpatterns.com/MessageRouter.html[Message
-Router] from the link:enterprise-integration-patterns.html[EIP patterns]
-allows you to consume from an input destination, evaluate some predicate
-then choose the right output destination.
-
-image:http://www.enterpriseintegrationpatterns.com/img/MessageRouter.gif[image]
-
-The following example shows how to route a request from an input
-*queue:a* endpoint to either *queue:b*, *queue:c* or *queue:d* depending
-on the evaluation of various link:predicate.html[Predicate] expressions
-
-*Using the link:fluent-builders.html[Fluent Builders]*
-
-*Using the link:spring-xml-extensions.html[Spring XML Extensions]*
-
-[[MessageRouter-Choicewithoutotherwise]]
-Choice without otherwise
-++++++++++++++++++++++++
-
-If you use a `choice` without adding an `otherwise`, any unmatched
-exchanges will be dropped by default.
-
-[[MessageRouter-UsingThisPattern]]
-Using This Pattern
-++++++++++++++++++
-
-If you would like to use this EIP Pattern then please read the
-link:getting-started.html[Getting Started], you may also find the
-link:architecture.html[Architecture] useful particularly the description
-of link:endpoint.html[Endpoint] and link:uris.html[URIs]. Then you could
-try out some of the link:examples.html[Examples] first before trying
-this pattern out.

http://git-wip-us.apache.org/repos/asf/camel/blob/f0bae85e/camel-core/src/main/docs/message-translator.adoc
----------------------------------------------------------------------
diff --git a/camel-core/src/main/docs/message-translator.adoc b/camel-core/src/main/docs/message-translator.adoc
deleted file mode 100644
index 8d4d573..0000000
--- a/camel-core/src/main/docs/message-translator.adoc
+++ /dev/null
@@ -1,96 +0,0 @@
-[[MessageTranslator-MessageTranslator]]
-Message Translator
-^^^^^^^^^^^^^^^^^^
-
-Camel supports the
-http://www.enterpriseintegrationpatterns.com/MessageTranslator.html[Message
-Translator] from the link:enterprise-integration-patterns.html[EIP
-patterns] by using an arbitrary link:processor.html[Processor] in the
-routing logic, by using a link:bean-integration.html[bean] to perform
-the transformation, or by using transform() in the DSL. You can also use
-a link:data-format.html[Data Format] to marshal and unmarshal messages
-in different encodings.
-
-image:http://www.enterpriseintegrationpatterns.com/img/MessageTranslator.gif[image]
-
-*Using the link:fluent-builders.html[Fluent Builders]*
-
-You can transform a message using Camel's
-link:bean-integration.html[Bean Integration] to call any method on a
-bean in your link:registry.html[Registry] such as your
-link:spring.html[Spring] XML configuration file as follows
-
-[source,java]
------------------------------------------------
-from("activemq:SomeQueue").
-  beanRef("myTransformerBean", "myMethodName").
-  to("mqseries:AnotherQueue");
------------------------------------------------
-
-Where the "myTransformerBean" would be defined in a Spring XML file or
-defined in JNDI etc. You can omit the method name parameter from
-beanRef() and the link:bean-integration.html[Bean Integration] will try
-to deduce the method to invoke from the message exchange.
-
-or you can add your own explicit link:processor.html[Processor] to do
-the transformation
-
-or you can use the DSL to explicitly configure the transformation
-
-*Use Spring XML*
-
-You can also use link:spring-xml-extensions.html[Spring XML Extensions]
-to do a transformation. Basically any link:expression.html[Expression]
-language can be substituted inside the transform element as shown below
-
-Or you can use the link:bean-integration.html[Bean Integration] to
-invoke a bean
-
-[source,java]
------------------------------------------------
-<route>
-  <from uri="activemq:Input"/>
-  <bean ref="myBeanName" method="doTransform"/>
-  <to uri="activemq:Output"/>
-</route>
------------------------------------------------
-
-You can also use link:templating.html[Templating] to consume a message
-from one destination, transform it with something like
-link:velocity.html[Velocity] or link:xquery.html[XQuery] and then send
-it on to another destination. For example using InOnly (one way
-messaging)
-
-[source,java]
-----------------------------------------
-from("activemq:My.Queue").
-  to("velocity:com/acme/MyResponse.vm").
-  to("activemq:Another.Queue");
-----------------------------------------
-
-If you want to use InOut (request-reply) semantics to process requests
-on the *My.Queue* queue on link:activemq.html[ActiveMQ] with a template
-generated response, then sending responses back to the JMSReplyTo
-Destination you could use this.
-
-[source,java]
-----------------------------------------
-from("activemq:My.Queue").
-  to("velocity:com/acme/MyResponse.vm");
-----------------------------------------
-
-[[MessageTranslator-UsingThisPattern]]
-Using This Pattern
-++++++++++++++++++
-
-If you would like to use this EIP Pattern then please read the
-link:getting-started.html[Getting Started], you may also find the
-link:architecture.html[Architecture] useful particularly the description
-of link:endpoint.html[Endpoint] and link:uris.html[URIs]. Then you could
-try out some of the link:examples.html[Examples] first before trying
-this pattern out.
-
-* link:content-enricher.html[Content Enricher]
-* link:using-getin-or-getout-methods-on-exchange.html[Using getIn or
-getOut methods on Exchange]
-

http://git-wip-us.apache.org/repos/asf/camel/blob/f0bae85e/camel-core/src/main/docs/message.adoc
----------------------------------------------------------------------
diff --git a/camel-core/src/main/docs/message.adoc b/camel-core/src/main/docs/message.adoc
deleted file mode 100644
index c75a2bb..0000000
--- a/camel-core/src/main/docs/message.adoc
+++ /dev/null
@@ -1,69 +0,0 @@
-[[Message-Message]]
-Message
-^^^^^^^
-
-Camel supports the
-http://www.enterpriseintegrationpatterns.com/Message.html[Message] from
-the link:enterprise-integration-patterns.html[EIP patterns] using the
-http://camel.apache.org/maven/current/camel-core/apidocs/org/apache/camel/Message.html[Message]
-interface.
-
-image:http://www.enterpriseintegrationpatterns.com/img/MessageSolution.gif[image]
-
-To support various message link:exchange-pattern.html[exchange patterns]
-like one way link:event-message.html[Event Message] and
-link:request-reply.html[Request Reply] messages Camel uses an
-link:exchange.html[Exchange] interface which has a *pattern* property
-which can be set to *InOnly* for an link:event-message.html[Event
-Message] which has a single inbound Message, or *InOut* for a
-link:request-reply.html[Request Reply] where there is an inbound and
-outbound message.
-
-Here is a basic example of sending a Message to a route in *InOnly* and
-*InOut* modes
-
-*Requestor Code*
-
-[source,java]
----------------------------------------------------------------------------------------------------------------
-//InOnly
-getContext().createProducerTemplate().sendBody("direct:startInOnly", "Hello World");
-
-//InOut
-String result = (String) getContext().createProducerTemplate().requestBody("direct:startInOut", "Hello World");
----------------------------------------------------------------------------------------------------------------
-
-*Route Using the link:fluent-builders.html[Fluent Builders]*
-
-[source,java]
---------------------------------------------------
-from("direct:startInOnly").inOnly("bean:process");
-
-from("direct:startInOut").inOut("bean:process");
---------------------------------------------------
-
-*Route Using the link:spring-xml-extensions.html[Spring XML Extensions]*
-
-[source,java]
-----------------------------------
-<route>
-  <from uri="direct:startInOnly"/>
-  <inOnly uri="bean:process"/>
-</route>
-
-<route>
-  <from uri="direct:startInOut"/>
-  <inOut uri="bean:process"/>
-</route>
-----------------------------------
-
-[[Message-UsingThisPattern]]
-Using This Pattern
-++++++++++++++++++
-
-If you would like to use this EIP Pattern then please read the
-link:getting-started.html[Getting Started], you may also find the
-link:architecture.html[Architecture] useful particularly the description
-of link:endpoint.html[Endpoint] and link:uris.html[URIs]. Then you could
-try out some of the link:examples.html[Examples] first before trying
-this pattern out.

http://git-wip-us.apache.org/repos/asf/camel/blob/f0bae85e/camel-core/src/main/docs/pipes-and-filters.adoc
----------------------------------------------------------------------
diff --git a/camel-core/src/main/docs/pipes-and-filters.adoc b/camel-core/src/main/docs/pipes-and-filters.adoc
deleted file mode 100644
index 3a820a6..0000000
--- a/camel-core/src/main/docs/pipes-and-filters.adoc
+++ /dev/null
@@ -1,93 +0,0 @@
-[[PipesandFilters-PipesandFilters]]
-Pipes and Filters
-^^^^^^^^^^^^^^^^^
-
-Camel supports the
-http://www.enterpriseintegrationpatterns.com/PipesAndFilters.html[Pipes
-and Filters] from the link:enterprise-integration-patterns.html[EIP
-patterns] in various ways.
-
-image:http://www.enterpriseintegrationpatterns.com/img/PipesAndFilters.gif[image]
-
-With Camel you can split your processing across multiple independent
-link:endpoint.html[Endpoint] instances which can then be chained
-together.
-
-[[PipesandFilters-UsingRoutingLogic]]
-Using Routing Logic
-+++++++++++++++++++
-
-You can create pipelines of logic using multiple
-link:endpoint.html[Endpoint] or link:message-translator.html[Message
-Translator] instances as follows
-
-Though pipeline is the default mode of operation when you specify
-multiple outputs in Camel. The opposite to pipeline is multicast; which
-fires the same message into each of its outputs. (See the example
-below).
-
-In Spring XML you can use the <pipeline/> element
-
-[source,java]
-------------------------------------
-<route>
-  <from uri="activemq:SomeQueue"/>
-  <pipeline>
-    <bean ref="foo"/>
-    <bean ref="bar"/>
-    <to uri="activemq:OutputQueue"/>
-  </pipeline>
-</route>
-------------------------------------
-
-In the above the pipeline element is actually unnecessary, you could use
-this...
-
-[source,java]
-----------------------------------
-<route>
-  <from uri="activemq:SomeQueue"/>
-  <bean ref="foo"/>
-  <bean ref="bar"/>
-  <to uri="activemq:OutputQueue"/>
-</route>
-----------------------------------
-
-Its just a bit more explicit. However if you wish to use <multicast/> to
-avoid a pipeline - to send the same message into multiple pipelines -
-then the <pipeline/> element comes into its own.
-
-[source,java]
---------------------------------------
-<route>
-  <from uri="activemq:SomeQueue"/>
-  <multicast>
-    <pipeline>
-      <bean ref="something"/>
-      <to uri="log:Something"/>
-    </pipeline>
-    <pipeline>
-      <bean ref="foo"/>
-      <bean ref="bar"/>
-      <to uri="activemq:OutputQueue"/>
-    </pipeline>
-  </multicast>
-</route>
---------------------------------------
-
-In the above example we are routing from a single
-link:endpoint.html[Endpoint] to a list of different endpoints specified
-using link:uris.html[URIs]. If you find the above a bit confusing, try
-reading about the link:architecture.html[Architecture] or try the
-link:examples.html[Examples]
-
-[[PipesandFilters-UsingThisPattern]]
-Using This Pattern
-++++++++++++++++++
-
-If you would like to use this EIP Pattern then please read the
-link:getting-started.html[Getting Started], you may also find the
-link:architecture.html[Architecture] useful particularly the description
-of link:endpoint.html[Endpoint] and link:uris.html[URIs]. Then you could
-try out some of the link:examples.html[Examples] first before trying
-this pattern out.

http://git-wip-us.apache.org/repos/asf/camel/blob/f0bae85e/camel-core/src/main/docs/point-to-point-channel.adoc
----------------------------------------------------------------------
diff --git a/camel-core/src/main/docs/point-to-point-channel.adoc b/camel-core/src/main/docs/point-to-point-channel.adoc
deleted file mode 100644
index ca8ff56..0000000
--- a/camel-core/src/main/docs/point-to-point-channel.adoc
+++ /dev/null
@@ -1,52 +0,0 @@
-[[PointtoPointChannel-PointtoPointChannel]]
-Point to Point Channel
-^^^^^^^^^^^^^^^^^^^^^^
-
-Camel supports the
-http://www.enterpriseintegrationpatterns.com/PointToPointChannel.html[Point
-to Point Channel] from the link:enterprise-integration-patterns.html[EIP
-patterns] using the following components
-
-* link:seda.html[SEDA] for in-VM seda based messaging
-* link:jms.html[JMS] for working with JMS Queues for high performance,
-clustering and load balancing
-* link:jpa.html[JPA] for using a database as a simple message queue
-* link:xmpp.html[XMPP] for point-to-point communication over XMPP
-(Jabber)
-* and others
-
-image:http://www.enterpriseintegrationpatterns.com/img/PointToPointSolution.gif[image]
-
-The following example demonstrates point to point messaging using
-the�link:jms.html[JMS]�component�
-
-*Using the�link:fluent-builders.html[Fluent Builders]*
-
-[source,java]
--------------------------
-from("direct:start")
-    .to("jms:queue:foo");
--------------------------
-
-�
-
-**Using the�link:spring-xml-extensions.html[Spring XML Extensions]**
-
-[source,xml]
-------------------------------
-<route>
-    <from uri="direct:start"/>
-    <to uri="jms:queue:foo"/>
-</route>
-------------------------------
-
-[[PointtoPointChannel-UsingThisPattern]]
-Using This Pattern
-++++++++++++++++++
-
-If you would like to use this EIP Pattern then please read the
-link:getting-started.html[Getting Started], you may also find the
-link:architecture.html[Architecture] useful particularly the description
-of link:endpoint.html[Endpoint] and link:uris.html[URIs]. Then you could
-try out some of the link:examples.html[Examples] first before trying
-this pattern out.