{section}
{column}

h1. Integration Pattern supported


* Aggregator
* Bridge
* Dispatcher
* Router
* DynamicRouter
* RoutingSlip
* ScatterGather
* WireTap
* Splitter

h1. Service Configuration

h2. Service Unit descriptor

{code:lang=xml}
<?xml version="1.0" encoding="UTF-8"?>
<jbi:jbi version="1.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:jbi="http://java.sun.com/xml/ns/jbi"
xmlns:petalsCDK="http://petals.ow2.org/components/extensions/version-5"
xmlns:eip="http://petals.ow2.org/components/eip/version-2"
xmlns:sample="http://petals.ow2.org/sample">
<jbi:services binding-component="false">
<!-- The Provides -->
<jbi:provides interface-name="sample:interface" service-name="sample:service"
endpoint-name="endpoint">
<petalsCDK:wsdl xsi:nil="true" />
<eip:eip>pattern</eip:eip>
</jbi:provides>
<!-- The first Consumes -->
<jbi:consumes interface-name="sample:calledInterface1" service-name="sample:calledService1"
endpoint-name="calledEndpoint1">
<petalsCDK:mep xsi:nil="true" />
</jbi:consumes>
<!-- The second Consumes -->
<jbi:consumes interface-name="sample:calledInterface2" service-name="sample:calledService2"
endpoint-name="calledEndpoint2">
<petalsCDK:mep xsi:nil="true" />
</jbi:consumes>
</jbi:services>
</jbi:jbi>
{code}

{include:0 CDK SU Provide Configuration}
\\
{include:0 JBI SU Consume Configuration}
\\
{include:0 CDK SU Interceptor configuration}

h3. Processing an integration pattern

Processing a pattern is providing a service that invokes 'sub-services', this service is called the 'original' service and its caller the 'original' consumer.

A Service Unit contains one and only one {{Provides}} section, which describes the pattern that will be processed when a request message is received.

The Service Unit contains also one or more {{Consumes}} sections, which reference services to invoke during the pattern processing. The order of the {{consumes}} sections is important, as it is the order taken account when a pattern need 'sub-service' coordination.

The number of {{consumes}} sections depends on the pattern implemented.

If the MEP {{InOut}} or {{InOptionalOut}} are supported by a pattern, the component returns to the original consumer an {{{{OUT}}}} or {{FAULT}} response built according to the pattern feature.

If an invoked service returns a {{Fault}} or an {{Error}} status, the behavior of process can be configured:
* The process can terminate and the {{Fault}} or the {{Error}} is sent back to the original consumer
* The process can continue, ignoring the {{Fault}} or the {{Error}} received

{note:title=Caution}The MEP is mandatory for each consumes sections.{note}
{note:title=Caution}Either an operation must be specified in the consumes sections or the 'original' operation is used for 'sub-service' requests.{note}

h3. Aggregator Pattern

*Enterprise Integration Pattern*
{center} !aggregator.gif!{center}

{center}{*}Configuration of a Service Unit to provide a service (Aggregator)*{center}

| test | XPath condition applied on the message to complete or not the sequence and invoke the 'sub-service' | {center}\-{center} |
| aggregator-correlation | XPath condition that is applied on the incoming message to correlate them together | {center}\-{center} |
{table-plus}

The EIP Component receives 'original' exchanges and correlates their content amongst the aggregation configurations. The correlation is identified from the XPath expression specified in the SU parameter {{aggregator-correlation}}. If an 'original' exchange is on a {{InOut}} or {{InOptionalOut}} MEP, a standard response is sent back to the 'original' consumer :

{code:xml}
<result xmlns="http://petals.ow2.org/petals-se-eip/aggregator">
Aggregator: the content is buffered by the pattern
</result>
{code}

The exchange messages matching an {{aggregator-correlation}} condition are stored in memory.
Once an 'original' exchange message matches the XPath expression specified in the SU parameter {{test}}, the message and the previous stored messages on the condition {{aggregator-correlation}} are aggregated and send to the target 'sub-service'.
The current 'original' exchange properties are copied into the target exchange.
The aggregated content is the result of a concatenation of the messages in the following form :

{code:xml}
<result xmlns="http://petals.ow2.org/petals-se-eip/aggregator">
...
</result>
{code}

The result of the 'sub-service' is sent back to the 'original' consumer of the last aggregated exchange.

An example of Service Unit configuration for the *aggregator* pattern :

{code:xml}
<?xml version="1.0" encoding="UTF-8"?>
<!-- JBI descriptor for the PEtALS component "EIP"-->
<jbi:jbi version="1.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:jbi="http://java.sun.com/xml/ns/jbi"
xmlns:petalsCDK="http://petals.ow2.org/components/extensions/version-5"
xmlns:eip="http://petals.ow2.org/components/eip/version-2"
xmlns:test="http://petals.ow2.org/test">

<jbi:services binding-component="false">
<jbi:provides
interface-name="test:aggregator"
service-name="test:aggregatorService1"
endpoint-name="aggregatorService1Endpoint">
<petalsCDK:wsdl xsi:nil="true" />
<eip:eip>aggregator</eip:eip>
<eip:aggregator-correlation>/*[local-name()='helloworld']/text()</eip:aggregator-correlation>
<eip:test>
boolean(/*[local-name()='helloworld' and namespace-uri()='http://petals.ow2.org/test3'])
</eip:test>
</jbi:provides>

<jbi:consumes interface-name="test:aggregateProvider"
service-name="test:aggregateProviderService1"
endpoint-name="aggregateProviderService1Endpoint">
<petalsCDK:operation xmlns:petals="http://org.ow2.petals">petals:operation</petalsCDK:operation>
<petalsCDK:mep>InOnly</petalsCDK:mep>
</jbi:consumes>
</jbi:services>
</jbi:jbi>
{code}

h3. Scatter-Gather Pattern

*Enterprise Integration Pattern*
{center} !scattergather.gif!{center}
\\

The EIP Component forwards the message to all the configured 'sub-service(s)'. The component waits for all the responses from these services, and aggregates them.
The aggregation is returned to the 'original' consumer in the following form :

{code:xml}
<result xmlns="http://petals.ow2.org/petals-se-eip/scatter-gather">
...
</result>
{code}

An example of Service Unit configuration for the *scatter-gather* pattern :

{code:xml}
<?xml version="1.0" encoding="UTF-8"?>
<!-- JBI descriptor for the PEtALS component "EIP"-->
<jbi:jbi version="1.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:jbi="http://java.sun.com/xml/ns/jbi"
xmlns:petalsCDK="http://petals.ow2.org/components/extensions/version-5"
xmlns:eip="http://petals.ow2.org/components/eip/version-2"
xmlns:test="http://petals.ow2.org/test">

<jbi:services binding-component="false">
<jbi:provides
interface-name="test:scatterGather"
service-name="test:scatterGatherService1"
endpoint-name="scatterGatherService1Endpoint">
<petalsCDK:wsdl xsi:nil="true" />
<eip:eip>scatter-gather</eip:eip>
</jbi:provides>

<jbi:consumes interface-name="test:scatterGatherProvider"
service-name="test:scatterGatherProviderService1"
endpoint-name="scatterGatherProviderService1Endpoint">
<petalsCDK:mep>InOut</petalsCDK:mep>
<petalsCDK:operation xmlns:petals="http://org.ow2.petals">petals:operation</petalsCDK:operation>
</jbi:consumes>

<jbi:consumes interface-name="test:scatterGatherProvider"
service-name="test:scatterGatherProviderService2"
endpoint-name="scatterGatherProviderService2Endpoint">
<petalsCDK:mep>InOut</petalsCDK:mep>
<petalsCDK:operation xmlns:petals="http://org.ow2.petals">petals:operation</petalsCDK:operation>
</jbi:consumes>
</jbi:services>
</jbi:jbi>

h3. Routing-Slip Pattern

*Enterprise Integration Pattern*
{center} !routingslip.gif!{center}

{center}{*}Configuration of a Service Unit to provide a service (Routing Slip)*{center}

<!-- JBI descriptor for the PEtALS component "EIP"-->
<jbi:jbi version="1.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:jbi="http://java.sun.com/xml/ns/jbi"
xmlns:petalsCDK="http://petals.ow2.org/components/extensions/version-5"
xmlns:eip="http://petals.ow2.org/components/eip/version-2"
xmlns:test="http://petals.ow2.org/test">

<jbi:services binding-component="false">
<jbi:provides
interface-name="test:routingSlip"
service-name="test:routingSlipService1"
endpoint-name="routingSlipService1Endpoint">

<petalsCDK:wsdl xsi:nil="true" />
<eip:eip>routing-slip</eip:eip>
<eip:fault-to-exception>false</eip:fault-to-exception>
</jbi:provides>

<jbi:consumes interface-name="test:routingSlipProvider"
service-name="test:routingSlipProviderService1"
endpoint-name="routingSlipProviderService1Endpoint">

<petalsCDK:mep>InOut</petalsCDK:mep>
<petalsCDK:operation xmlns:petals="http://org.ow2.petals">petals:operation</petalsCDK:operation>
</jbi:consumes>

<jbi:consumes interface-name="test:routingSlipProvider"
service-name="test:routingSlipProviderService2"
endpoint-name="routingSlipProviderService2Endpoint">

<petalsCDK:mep>InOut</petalsCDK:mep>
<petalsCDK:operation xmlns:petals="http://org.ow2.petals">petals:operation</petalsCDK:operation>
</jbi:consumes>
</jbi:services>

*Enterprise Integration Pattern*

{code:lang=xml}<?xml version="1.0" encoding="UTF-8"?>

<!-- JBI descriptor for the PEtALS component "EIP" -->
<jbi:jbi version="1.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:jbi="http://java.sun.com/xml/ns/jbi"
xmlns:petalsCDK="http://petals.ow2.org/components/extensions/version-5"
xmlns:eip="http://petals.ow2.org/components/eip/version-2"
xmlns:test="http://petals.ow2.org/test">

<jbi:services binding-component="false">

<jbi:provides
interface-name="test:wireTap"
service-name="test:wireTapService1"
endpoint-name="wireTapService1Endpoint">
<petalsCDK:wsdl xsi:nil="true" />
<eip:eip>wire-tap</eip:eip>
<eip:wiretap-way>request</eip:wiretap-way>
</jbi:provides>

<jbi:consumes interface-name="test:aggregateProvider"
service-name="test:aggregateProviderService1"
endpoint-name="aggregateProviderService1Endpoint">
<petalsCDK:operation xmlns:petals="http://org.ow2.petals">petals:operation</petalsCDK:operation>
<petalsCDK:mep>InOut</petalsCDK:mep>
</jbi:consumes>

<!-- monitoring -->
<jbi:consumes interface-name="test:aggregateProvider"
service-name="test:aggregateProviderService2"
endpoint-name="aggregateProviderService2Endpoint">
<petalsCDK:operation xmlns:petals="http://org.ow2.petals">petals:operation</petalsCDK:operation>
<petalsCDK:mep>InOut</petalsCDK:mep>
</jbi:consumes>

</jbi:services>
</jbi:jbi>{code}

{note:title=Caution}{{{}consumes}} sections cardinality is 2.{note}
{note:title=Caution}message exchange pattern of the second target exchange, the "monitoring" exchange, is {{InOnly{}}}{note}
{note:title=Caution}all the Message Exchange Pattern are accepted for the source exchange{note}


h3. Splitter Pattern

*Enterprise Integration Pattern*
{center} !splitter.gif!{center}

{center}{*}Configuration of a Service Unit to provide a service (EIP)*{center}
{table-plus}

| test | XPath condition applied on the message to split the source exchange | {center}\-{center} |
| attachment | true to split the source exchange on the attachments, false to split it on the IN content | {center}false{center} |
| fault-robust | If true, a fault thrown by a target exchange don't stop the process and don't change the original exchange status to FAULT | {center}false{center} |
| exception-robust | If true, an exception thrown by a target exchange don't stop the process and don't change the original exchange status to ERROR | {center}false{center} |
{table-plus}
\\
The EIP Component acts as an exchange pattern splitter, and allows you to split your message into multiple elements, each of these elements are sent to a specified service. A {{consumes}} section defines the target service. The IN message of the source exchange is splitted with the Xpath expression specified with the parameter 'test'. The list of attachment into the source exchange is splitted file by file if the parameter attachment is true.

The aggregation of the responses is returned into the source exchange :
{code:lang=xml}<result xmlns="http://petals.ow2.org/petals-se-eip/splitter">
...
</result>{code}
An example of service unit configuration :
{code:lang=xml}<?xml version="1.0" encoding="UTF-8"?>

<!-- JBI descriptor for the PEtALS component "EIP" -->
<jbi:jbi version="1.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:jbi="http://java.sun.com/xml/ns/jbi"
xmlns:petalsCDK="http://petals.ow2.org/components/extensions/version-5"
xmlns:eip="http://petals.ow2.org/components/eip/version-2"
xmlns:test="http://petals.ow2.org/test">

<jbi:services binding-component="false">
<jbi:provides
interface-name="test:splitter"
service-name="test:splitterService1"
endpoint-name="splitterService1Endpoint">

<petalsCDK:wsdl xsi:nil="true" />
<eip:eip>splitter</eip:eip>
<eip:test>
/*[local-name()='helloworld' and namespace-uri()='http://petals.ow2.org/test']/*[local-name()='split']
</eip:test>
<eip:fault-robust>false</eip:fault-robust>
<eip:exception-robust>false</eip:exception-robust>
<eip:attachment-mode>false</eip:attachment-mode>
</jbi:provides>

<jbi:consumes interface-name="test:splitterProvider"
service-name="test:splitterProviderService1"
endpoint-name="splitterProviderService1Endpoint">
<petalsCDK:operation xmlns:petals="http://org.ow2.petals">petals:operation</petalsCDK:operation>
<petalsCDK:mep>InOut</petalsCDK:mep>
</jbi:consumes>
</jbi:services>
</jbi:jbi>{code}
{note:title=Caution}{{{}consumes}} sections cardinality is 1{note}
{note:title=Caution}message exchange pattern of the incoming exchange is InOut.{note}
{note:title=Caution}by default, the process stops when an Exception is returned by the provider. To continue the process even if an&nbsp;exception is thrown, set the exception-robust to TRUE. The exception is concatenate with the others results.{note}
{note:title=Caution}by default, the process stops when an Exception is returned by the provider. To continue the process even if an exception is thrown, set the exception-robust to TRUE. The exception is concatenate with the others results.{note}


h3. Bridge Pattern

*Enterprise Integration Pattern*
{center} !bridge.gif!{center}

{center}{*}Configuration of a Service Unit to provide a service (EIP)*{center}

{table-plus}

| fault-to-exception | if true, a fault received from the target service is transformed into an exception and set to the 'orginal' exchange | false |
{table-plus}
\\
The EIP Component acts as an exchange pattern bridge, and allows you, for instance, to transform an InOnly invocation pattern into an InOut one. It is used, for example, when the consumer of a service "MyService" sends its request as InOnly, and the provider is waiting an {{InOut}} message. Define in a {{consumes}} section the service you want to call, and the EIP component will match the incoming and outgoing exchange pattern as better as possible. So :
* If the source exchange needs a response (InOut or InOptionalOut patterns) and no response are received (InOnly,
RobustInOnly or InOptionalOut patterns), a default response is returned:
If the source exchange needs a response (InOut or InOptionalOut patterns) and no response are received (InOnly, RobustInOnly or InOptionalOut patterns), a default response is returned :
{code:lang=xml}<result xmlns="http://petals.ow2.org/petals-se-eip/bridge">
Bridge: no content into the final target exchange
</result>{code}
* If the source exchange doesn't accept a response (InOnly or RobustInOnly patterns) and a response is received (InOut or InOptionalOut patterns), the response is ignored.
* If the source exchange doesn't accept a fault (InOnly pattern) and a fault is received (RobustInOnly, InOut or InOptionalOut patterns), the fault is ignored.

An example of service unit configuration :
{code:lang=xml}<?xml version="1.0"?>

<!-- JBI descriptor for the PEtALS component "EIP" -->
<jbi:jbi version="1.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:jbi="http://java.sun.com/xml/ns/jbi"
xmlns:petalsCDK="http://petals.ow2.org/components/extensions/version-5"
xmlns:eip="http://petals.ow2.org/components/eip/version-2"
xmlns:test="http://petals.ow2.org/test">

<jbi:services binding-component="false">
<jbi:provides
  interface-name="test:splitter"
  service-name="test:splitterService1"
  endpoint-name="splitterService1Endpoint">


<petalsCDK:wsdl xsi:nil="true" />
  <eip:eip>splitter</eip:eip>
  <eip:fault-to-exception>false</eip:fault-to-exception>
  <eip:test>
/*[local-name()='helloworld' and namespace-uri()='http://petals.ow2.org/test']/*[local-name()='split']
</eip:test>
  <eip:fault-robust>false</eip:fault-robust>
  <eip:exception-robust>false</eip:exception-robust>
  <eip:attachment-mode>false</eip:attachment-mode>
</jbi:provides>

<jbi:consumes interface-name="test:splitterProvider"
  service-name="test:splitterProviderService1"
  endpoint-name="splitterProviderService1Endpoint">
  <petalsCDK:operation xmlns:petals="http://org.ow2.petals">petals:operation</petalsCDK:operation>
  <petalsCDK:mep>InOut</petalsCDK:mep>
 </jbi:consumes>
</jbi:services>
</jbi:jbi>{code}
{note:title=Caution}{{{}consumes}} sections cardinality is 1{note}

h3. Router Pattern

*Enterprise Integration Pattern*
{center} !router.gif!{center}

{center}{*}Configuration of a Service Unit to provide a service (EIP)*{center}

{table-plus}

| test | XPath condition applied on the message to choose the target service | {center}\-{center} |
| fault-to-exception | if true, a fault received from the target service is transformed into an exception and set to the 'original' exchange | false |
{table-plus}

The EIP Component evaluates expressions on IN message from the source exchange. Conditions are valuated against the message until a {{true}} result. Then, the exchange is forwarded to the service referenced in the {{consumes}} section matching the position of the condition. If none of the conditions are true, the exchange is forwarded to the service referenced in the last {{consumes}} section (default).

An example of service unit configuration :
{code:lang=xml}<?xml version="1.0"?>

<!-- JBI descriptor for the PEtALS component "EIP" -->
<jbi:jbi version="1.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:jbi="http://java.sun.com/xml/ns/jbi"
xmlns:petalsCDK="http://petals.ow2.org/components/extensions/version-5"
xmlns:eip="http://petals.ow2.org/components/eip/version-2"
xmlns:test="http://petals.ow2.org/test">

<jbi:services binding-component="false">

<jbi:provides
interface-name="test:router"
service-name="test:routerService1"
endpoint-name="routerService1Endpoint">
<petalsCDK:wsdl xsi:nil="true" />
<eip:eip>router</eip:eip>
<eip:test>
boolean(/*[local-name()='helloworld' and namespace-uri()='http://petals.ow2.org/test1'])
</eip:test>
<eip:test>
boolean(/*[local-name()='helloworld' and namespace-uri()='http://petals.ow2.org/test2'])
</eip:test>
<eip:fault-to-exception>false</eip:fault-to-exception>
</jbi:provides>

<jbi:consumes interface-name="test:routerProvider"
service-name="test:routerProviderService1"
endpoint-name="routerProviderService1Endpoint">
<petalsCDK:mep>InOut</petalsCDK:mep>
<petalsCDK:operation xmlns:petals="http://org.ow2.petals">petals:operation</petalsCDK:operation>
</jbi:consumes>

<jbi:consumes interface-name="test:routerProvider"
service-name="test:routerProviderService2"
endpoint-name="routerProviderService2Endpoint">
<petalsCDK:mep>InOut</petalsCDK:mep>
<petalsCDK:operation xmlns:petals="http://org.ow2.petals">petals:operation</petalsCDK:operation>
</jbi:consumes>

<!-- default -->
<jbi:consumes interface-name="test:routerProvider"
service-name="test:routerProviderService3"
endpoint-name="routerProviderService3Endpoint">
<petalsCDK:mep>InOut</petalsCDK:mep>
<petalsCDK:operation xmlns:petals="http://org.ow2.petals">petals:operation</petalsCDK:operation>
</jbi:consumes>
</jbi:services>
</jbi:jbi>{code}
{note:title=Caution}{{{}consumes}} sections cardinality is the number of conditions plus 1 (the last one is the default service).{note}
{note:title=Caution}the last {{consumes}} section is the default service to invoke if no condition has been fullfilled.{note}

h3. Dynamic Router Pattern

*Enterprise Integration Pattern*
{center} !dynamicrouter.gif!{center}

{center}{*}Configuration of a Service Unit to provide a service (EIP)*{center}
{table-plus}

| test | XPath condition applied on the message to choose the target service | {center}\-{center} |
| fault-to-exception | if true, a fault received from the target service is transformed into an exception and set to the 'original' exchange | false |
{table-plus}
\\
The EIP Component evaluates expressions on OUT or fault message from a router exchange. The IN message from the source exchange is sent to the first consumes defined. Conditions are valuated against the response of this router service until a {{true}} result. Then, the exchange is forwarded to the service referenced in the {{consumes}} section matching the position of the condition, swtiching of the first consumes (used to define the routzer service). If none of the conditions are true, the exchange is forwarded to the service referenced in the last {{consumes}} section (default).

An example of service unit configuration :
{code:lang=xml}<?xml version="1.0"?>

<!-- JBI descriptor for the PEtALS component "EIP" -->
<jbi:jbi version="1.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:jbi="http://java.sun.com/xml/ns/jbi"
xmlns:petalsCDK="http://petals.ow2.org/components/extensions/version-5"
xmlns:eip="http://petals.ow2.org/components/eip/version-2"
xmlns:test="http://petals.ow2.org/test">

<jbi:services binding-component="false">
<jbi:provides
interface-name="test:dynamicRouter"
service-name="test:dynamicRouterService1"
endpoint-name="dynamicRouterService1Endpoint">
<petalsCDK:wsdl xsi:nil="true" />
<eip:eip>dynamic-router</eip:eip>
<eip:test>
boolean(/*[local-name()='helloworld' and namespace-uri()='http://petals.ow2.org/test2'])
</eip:test>
<eip:test>
boolean(/*[local-name()='helloworld' and namespace-uri()='http://petals.ow2.org/test3'])
</eip:test>
<eip:fault-to-exception>false</eip:fault-to-exception>
</jbi:provides>

<!-- router -->
<jbi:consumes interface-name="test:dynamicRouterProvider"
service-name="test:dynamicRouterProviderService1"
endpoint-name="dynamicRouterProviderService1Endpoint">
<petalsCDK:mep>InOut</petalsCDK:mep>
<petalsCDK:operation xmlns:petals="http://org.ow2.petals">petals:operation</petalsCDK:operation>
</jbi:consumes>

<jbi:consumes interface-name="test:dynamicRouterProvider"
service-name="test:dynamicRouterProviderService2"
endpoint-name="dynamicRouterProviderService2Endpoint">
<petalsCDK:mep>InOut</petalsCDK:mep>
<petalsCDK:operation xmlns:petals="http://org.ow2.petals">petals:operation</petalsCDK:operation>
</jbi:consumes>

<jbi:consumes interface-name="test:dynamicRouterProvider"
service-name="test:dynamicRouterProviderService3"
endpoint-name="dynamicRouterProviderService3Endpoint">
<petalsCDK:mep>InOut</petalsCDK:mep>
<petalsCDK:operation xmlns:petals="http://org.ow2.petals">petals:operation</petalsCDK:operation>
</jbi:consumes>

<!-- default -->
<jbi:consumes interface-name="test:dynamicRouterProvider"
service-name="test:dynamicRouterProviderService4"
endpoint-name="dynamicRouterProviderService4Endpoint">
<petalsCDK:mep>InOut</petalsCDK:mep>
<petalsCDK:operation xmlns:petals="http://org.ow2.petals">petals:operation</petalsCDK:operation>
</jbi:consumes>
</jbi:services>
</jbi:jbi>{code}

{note:title=Caution}{{{}consumes}} sections cardinality is the number of conditions plus 2{note}
{note:title=Caution}the first {{consumes}} section is the service to invoke to get the message to evaluate. So its pattern is {{InOut{}}}{note}
{note:title=Caution}the last {{consumes}} section is the default service to invoke if no condition has been fullfilled.{note}

h3. Dispatcher Pattern

*Enterprise Integration Pattern*
{center} !dispatcher.gif!{center}

{center}{*}Configuration of a Service Unit to provide a service (EIP)*{center}
{table-plus}

| fault-to-exception | if true, a fault received from the target service is transformed to an exception into the source exchange. | {center}false{center} |
{table-plus}
\\
The EIP Component dispatches the incoming IN message toward the configured service in consumes sections. No response message is returned.

An example of service unit configuration :
{code:lang=xml}<?xml version="1.0"?>

<!-- JBI descriptor for the PEtALS component "EIP" -->
<jbi:jbi version="1.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:jbi="http://java.sun.com/xml/ns/jbi"
xmlns:petalsCDK="http://petals.ow2.org/components/extensions/version-5"
xmlns:eip="http://petals.ow2.org/components/eip/version-2"
xmlns:test="http://petals.ow2.org/test">

<jbi:services binding-component="false">
<jbi:provides
interface-name="test:dispatcher"
service-name="test:dispatcherService1"
endpoint-name="dispatcherService1Endpoint">
<petalsCDK:wsdl xsi:nil="true" />
<eip:eip>dispatcher</eip:eip>
<eip:fault-to-exception>false</eip:fault-to-exception>
</jbi:provides>

<jbi:consumes
interface-name="test:dispatcherProvider"
service-name="test:dispatcherProviderService1"
endpoint-name="dispatcherProviderService1Endpoint">
<petalsCDK:mep>InOnly</petalsCDK:mep>
<petalsCDK:operation xmlns:petals="http://org.ow2.petals">petals:operation</petalsCDK:operation>
</jbi:consumes>

<jbi:consumes
interface-name="test:dispatcherProvider"
service-name="test:dispatcherProviderService2"
endpoint-name="dispatcherProviderService2Endpoint">
<petalsCDK:mep>InOnly</petalsCDK:mep>
<petalsCDK:operation xmlns:petals="http://org.ow2.petals">petals:operation</petalsCDK:operation>
</jbi:consumes>
</jbi:services>
</jbi:jbi>
{code}
{note:title=Caution}{{{}consumes}} sections cardinality is [1-n|1-n].{note}
{note:title=Caution}message exchange pattern of the incoming exchange and the consumed services is {{InOnly}}.{note}

h1. Component Extension

The component can be extended by any contributor to provide the support of new EIP pattern.

To add a new pattern, provide a Java class implementing the interface {{Pattern}} :

{code}
/**
* The pattern interface
*
* @author Adrien Louis
* @author Christophe Hamerling
* @author Frederic Gardes
*/
public interface Pattern {

/**
* Initialize the pattern
*
*/
void init();

/**
* Process the Pattern.
*
* @param exchange
* The exchange to process
* @param context
* The context of the exchange
*/
boolean processPattern(Exchange exchange, ExchangeContext context);

/**
* Process an exchange for an asynchronous pattern.
*
* @param exchange
* The exchange to process
* @param context
* The context of the exchange
* @param asyncContext
* The EIP asynchronous context
* @param expired
* true if the asynchronous exchange is expired, false else
*/
boolean processAsyncPattern(Exchange exchange, ExchangeContext context,
EIPAsyncContext asyncContext, boolean expired);

/**
* Get the pattern name.
*
* @return The name
*/
String getName();
}
{code}
\\
Use the {{ExchangeContext}} to interact with the container, during your pattern processing :
{code}
/**
* The exchange context.
*
* @author Adrien Louis
* @author Frederic Gardes
*/
public interface ExchangeContext {

/**
* Get the logger
*
* @return the logger
*/
public Logger getLogger();

/**
* get the Consumes for an endpoint
*
* @param endpoint
* The endpoint
* @return The Consumes of the endpoint
*/
public List<Consumes> getSUConsumes(ServiceEndpoint endpoint);

/**
* Send synchronously an exchange. The response will be provided into the
* same exchange
*
* @param exchange
* The exchange to send
* @return true if the exchange was sent, false else (reached timeout,
* technical error,...)
* @throws MessagingException
*/
public boolean sendSync(final Exchange exchange) throws MessagingException;

/**
* Send asynchronously an exchange. The response will be provided as an
* asynchronous exchange
*
* @param exchange
* The exchange to send
* @param asyncContext
* The asynchronous context, provided on the response
* @throws MessagingException
*/
public void sendAsync(final Exchange exchange, AsyncContext asyncContext) throws MessagingException;

/**
* Send asynchronously an exchange. The response will be provided as a
* synchronous exchange
*
* @param exchange
* The exchange to send
* @throws MessagingException
*/
public void send(final Exchange exchange) throws MessagingException;

/**
* Create an exchange from a Consumes
*
* @param consumes
* The Consumes used as JBI Consumer of the exchange
* @return The exchange created
* @throws MessagingException
* @throws PEtALSCDKException
*/
public Exchange createConsumeExchange(Consumes consumes) throws MessagingException, PEtALSCDKException;

/**
* Get the extensions
*
* @return The extensions
*/
public ConfigurationExtensions getExtensions();
}
{code}
\\
Extends the JBI.xml file of the component to reference your new pattern.

h1. Component Configuration

{code:xml}
<?xml version="1.0" encoding="UTF-8"?>
<jbi version="1.0"
xmlns="http://java.sun.com/xml/ns/jbi"
xmlns:petalsCDK="http://petals.ow2.org/components/extensions/version-5"
xmlns:eip="http://petals.ow2.org/components/eip/version-2">
<component type="service-engine" component-class-loader-delegation="parent-first">
<identification>
<name>petals-se-eip</name>
<description>EIP Service engine</description>
</identification>
<component-class-name>org.ow2.petals.se.eip.EIPComponent</component-class-name>
<component-class-path>
<path-element />
</component-class-path>
<bootstrap-class-name>org.ow2.petals.component.framework.DefaultBootstrap</bootstrap-class-name>
<bootstrap-class-path>
<path-element></path-element>
</bootstrap-class-path>
<petalsCDK:acceptor-pool-size>5</petalsCDK:acceptor-pool-size>
<petalsCDK:processor-pool-size>10</petalsCDK:processor-pool-size>
<petalsCDK:ignored-status>NOTHING_IGNORED</petalsCDK:ignored-status>
<petalsCDK:notifications>false</petalsCDK:notifications>
<petalsCDK:jbi-listener-class-name>
org.ow2.petals.se.eip.listener.JBIListener
</petalsCDK:jbilistener-class-name>
<petalsCDK:properties-file />

<!-- Declaring the supported patterns -->
<eip:aggregator>org.ow2.petals.se.eip.patterns.Aggregator</eip:aggregator>
<eip:router>org.ow2.petals.se.eip.patterns.Router</eip:router>
<eip:dynamic-router>org.ow2.petals.se.eip.patterns.DynamicRouter</eip:dynamic-router>
<eip:dispatcher>org.ow2.petals.se.eip.patterns.Dispatcher</eip:dispatcher>
<eip:routing-slip>org.ow2.petals.se.eip.patterns.RoutingSlip</eip:routing-slip>
<eip:bridge>org.ow2.petals.se.eip.patterns.Bridge</eip:bridge>
<eip:wire-tap>org.ow2.petals.se.eip.patterns.WireTap</eip:wire-tap>
<eip:scatter-gather>org.ow2.petals.se.eip.patterns.ScatterGather</eip:scatter-gather>
<eip:splitter>org.ow2.petals.se.eip.patterns.Splitter</eip:splitter>
</component>
</jbi>
{code}

{include:0 CDK Component Configuration Table 2.1}
\\
{center}{*}Configuration of the component (EIP)*{center}
{table-plus}

{table-plus}

{include:0 CDK Component Interceptor configuration}
{column}
{column:width=350px}
{panel:title=Table of contents}{toc}{panel}
{panel:title=Contributors}{contributors:order=name|mode=list}{panel}
{column}
{section}