LibraryToggle FramesPrintFeedback

The seda: component provides asynchronous SEDA behavior, so that messages are exchanged on a BlockingQueue and consumers are invoked in a separate thread from the producer.

Note that queues are only visible within a single CamelContext. If you want to communicate across CamelContext instances (for example, communicating between Web applications), see the VM component.

This component does not implement any kind of persistence or recovery, if the VM terminates while messages are yet to be processed. If you need persistence, reliability or distributed SEDA, try using either JMS or ActiveMQ.

[Tip]Synchronous

The Direct component provides synchronous invocation of any consumers when a producer sends a message exchange.

seda:queueName[?options]

Where queueName can be any string that uniquely identifies the endpoint within the current CamelContext.

You can append query options to the URI in the following format, ?option=value&option=value&...

[Note]Note

When matching consumer entpoints to producer endpoints, only the queueName is considered and any option settings are ignored. That is, the identity of a consumer endpoint depends only on the queueName. If you want to attach multiple consumers to the same queue, use the approach described in Using multipleConsumers.

Name Default Description
size Unbounded The maximum size (= capacity of the number of messages it can max hold) of the SEDA queue. The default value in Camel 2.2 or older is 1000. From Camel 2.3 onwards the size is unbounded by default.
concurrentConsumers 1 Fuse Mediation Router 1.6.1/2.0: Number of concurrent threads processing exchanges.
waitForTaskToComplete IfReplyExpected Fuse Mediation Router 2.0: Option to specify whether the caller should wait for the async task to complete or not before continuing. The following three options are supported: Always, Never or IfReplyExpected. The first two values are self-explanatory. The last value, IfReplyExpected, will only wait if the message is request-reply based. The default option is IfReplyExpected.
timeout 30000 Fuse Mediation Router 2.0: Timeout in millis a seda producer will at most waiting for an async task to complete. See waitForTaskToComplete for more details. In Camel 2.2 you can now disable timeout by using 0 or a negative value.
multipleConsumers false Camel 2.2: Specifies whether multiple consumers are allowed or not. If enabled, you can use SEDA for a publish/subscribe style of messaging. Send a message to a SEDA queue and have multiple consumers receive a copy of the message.
limitConcurrentConsumers true Camel 2.3: Whether to limit the concurrentConsumers to maximum 500. If its configured with a higher number an exception will be thrown. You can disable this check by turning this option off.

In Fuse Mediation Router 2.0 the Seda component supports using request-reply, where the caller will wait for the Async route to complete. For instance:

from("mina:tcp://0.0.0.0:9876?textline=true&sync=true").to("seda:input");

from("seda:input").to("bean:processInput").to("bean:createResponse");

In the route above, we have a TCP listener on port 9876 that accepts incoming requests. The request is routed to the seda:input queue. As it is a request-reply message, we wait for the response. When the consumer on the seda:input queue is complete, it copies the response to the original message response.

Fuse Mediation Router 1.x does not have this feature implemented, the Seda queues in Fuse Mediation Router 1.x will never wait.

[Note]Camel 2.0 - 2.2: Works only with 2 endpoints

Using request-reply over SEDA or VM only works with 2 endpoints. You cannot chain endpoints by sending to A -> B -> C etc. Only between A -> B. The reason is the implementation logic is fairly simple. To support 3+ endpoints makes the logic much more complex to handle ordering and notification between the waiting threads properly.

This has been improved in Camel 2.3 onwards, which allows you to chain as many endpoints as you like.

Be aware that adding a thread pool to a SEDA endpoint by doing something like:

from("seda:stageName").thread(5).process(...)

Can wind up with two BlockQueues: one from the SEDA endpoint, and one from the workqueue of the thread pool, which may not be what you want. Instead, you might want to consider configuring a Direct endpoint with a thread pool, which can process messages both synchronously and asynchronously. For example:

from("direct:stageName").thread(5).process(...)

You can also directly configure number of threads that process messages on a SEDA endpoint using the concurrentConsumers option.

Comments powered by Disqus