org.apache.camel.processor

Class MulticastProcessor

java.lang.Object

org.apache.camel.support.service.BaseService

org.apache.camel.support.service.ServiceSupport

org.apache.camel.support.AsyncProcessorSupport

org.apache.camel.processor.MulticastProcessor

All Implemented Interfaces:

AutoCloseable, org.apache.camel.AsyncProcessor, org.apache.camel.Navigate<org.apache.camel.Processor>, org.apache.camel.Processor, org.apache.camel.Service, org.apache.camel.ShutdownableService, org.apache.camel.spi.HasId, org.apache.camel.spi.IdAware, org.apache.camel.spi.RouteIdAware, org.apache.camel.StatefulService, org.apache.camel.SuspendableService, org.apache.camel.Traceable

Direct Known Subclasses:

RecipientListProcessor, Splitter

public class MulticastProcessor
extends org.apache.camel.support.AsyncProcessorSupport
implements org.apache.camel.Navigate<org.apache.camel.Processor>, org.apache.camel.Traceable, org.apache.camel.spi.IdAware, org.apache.camel.spi.RouteIdAware

Implements the Multicast pattern to send a message exchange to a number of endpoints, each endpoint receiving a copy of the message exchange.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
protected class	MulticastProcessor.MulticastTask

Field Summary

Fields

Modifier and Type	Field and Description
protected org.apache.camel.Processor	onPrepare

Fields inherited from class org.apache.camel.support.service.BaseService

BUILDED, FAILED, INITIALIZED, INITIALIZING, lock, NEW, SHUTDOWN, SHUTTINGDOWN, STARTED, STARTING, status, STOPPED, STOPPING, SUSPENDED, SUSPENDING

Constructor Summary

Constructors

Constructor and Description
MulticastProcessor(org.apache.camel.CamelContext camelContext, org.apache.camel.Route route, Collection<org.apache.camel.Processor> processors)
MulticastProcessor(org.apache.camel.CamelContext camelContext, org.apache.camel.Route route, Collection<org.apache.camel.Processor> processors, org.apache.camel.AggregationStrategy aggregationStrategy)
MulticastProcessor(org.apache.camel.CamelContext camelContext, org.apache.camel.Route route, Collection<org.apache.camel.Processor> processors, org.apache.camel.AggregationStrategy aggregationStrategy, boolean parallelProcessing, ExecutorService executorService, boolean shutdownExecutorService, boolean streaming, boolean stopOnException, long timeout, org.apache.camel.Processor onPrepare, boolean shareUnitOfWork, boolean parallelAggregate)
MulticastProcessor(org.apache.camel.CamelContext camelContext, org.apache.camel.Route route, Collection<org.apache.camel.Processor> processors, org.apache.camel.AggregationStrategy aggregationStrategy, boolean parallelProcessing, ExecutorService executorService, boolean shutdownExecutorService, boolean streaming, boolean stopOnException, long timeout, org.apache.camel.Processor onPrepare, boolean shareUnitOfWork, boolean parallelAggregate, boolean stopOnAggregateException)

Method Summary

Modifier and Type	Method and Description
protected void	afterSend(ProcessorExchangePair pair, org.apache.camel.util.StopWatch watch)
protected org.apache.camel.util.StopWatch	beforeSend(ProcessorExchangePair pair)
protected ExecutorService	createAggregateExecutorService(String name) Strategy to create the thread pool for the aggregator background task which waits for and aggregates completed tasks when running in parallel mode.
protected org.apache.camel.Processor	createErrorHandler(org.apache.camel.Route route, org.apache.camel.Exchange exchange, org.apache.camel.Processor processor)
protected ProcessorExchangePair	createProcessorExchangePair(int index, org.apache.camel.Processor processor, org.apache.camel.Exchange exchange, org.apache.camel.Route route) Creates the ProcessorExchangePair which holds the processor and exchange to be send out.
protected Iterable<ProcessorExchangePair>	createProcessorExchangePairs(org.apache.camel.Exchange exchange)
protected org.apache.camel.Processor	createUnitOfWorkProcessor(org.apache.camel.Route route, org.apache.camel.Processor processor, org.apache.camel.Exchange exchange) Strategy to create the unit of work to be used for the sub route
protected void	doAggregate(AtomicReference<org.apache.camel.Exchange> result, org.apache.camel.Exchange exchange, org.apache.camel.Exchange inputExchange) Aggregate the Exchange with the current result.
protected void	doDone(org.apache.camel.Exchange original, org.apache.camel.Exchange subExchange, Iterable<ProcessorExchangePair> pairs, org.apache.camel.AsyncCallback callback, boolean doneSync, boolean forceExhaust) Common work which must be done when we are done multicasting.
protected void	doInit()
protected void	doShutdown()
protected void	doStart()
protected void	doStop()
ExecutorService	getAggregateExecutorService()
org.apache.camel.AggregationStrategy	getAggregationStrategy() Use getAggregationStrategy(org.apache.camel.Exchange) instead.
protected org.apache.camel.AggregationStrategy	getAggregationStrategy(org.apache.camel.Exchange exchange)
org.apache.camel.CamelContext	getCamelContext()
protected Integer	getExchangeIndex(org.apache.camel.Exchange exchange)
String	getId()
Collection<org.apache.camel.Processor>	getProcessors() Returns the producers to multicast to
String	getRouteId()
long	getTimeout() An optional timeout in millis when using parallel processing
String	getTraceLabel()
boolean	hasNext()
boolean	isParallelAggregate()
boolean	isParallelProcessing()
boolean	isShareUnitOfWork()
boolean	isStopOnAggregateException()
boolean	isStopOnException() Should the multicast processor stop processing further exchanges in case of an exception occurred?
boolean	isStreaming() Is the multicast processor working in streaming mode? In streaming mode: we use Iterable to ensure we can send messages as soon as the data becomes available for parallel processing, we start aggregating responses as they get send back to the processor; this means the AggregationStrategy has to take care of handling out-of-order arrival of exchanges
List<org.apache.camel.Processor>	next()
protected void	prepareSharedUnitOfWork(org.apache.camel.Exchange childExchange, org.apache.camel.Exchange parentExchange) Prepares the exchange for participating in a shared unit of work This ensures a child exchange can access its parent UnitOfWork when it participate in a shared unit of work.
boolean	process(org.apache.camel.Exchange exchange, org.apache.camel.AsyncCallback callback)
protected void	removeAggregationStrategyFromExchange(org.apache.camel.Exchange exchange) Removes the associated AggregationStrategy from the Exchange which must be done after use.
protected void	schedule(Executor executor, Runnable runnable, long delay, TimeUnit unit)
protected void	schedule(Runnable runnable)
void	setAggregateExecutorService(ExecutorService aggregateExecutorService)
protected void	setAggregationStrategyOnExchange(org.apache.camel.Exchange exchange, org.apache.camel.AggregationStrategy aggregationStrategy) Sets the given AggregationStrategy on the Exchange.
void	setId(String id)
void	setRouteId(String routeId)
protected static void	setToEndpoint(org.apache.camel.Exchange exchange, org.apache.camel.Processor processor)
String	toString()
protected void	updateNewExchange(org.apache.camel.Exchange exchange, int index, Iterable<ProcessorExchangePair> allPairs, boolean hasNext)

Methods inherited from class org.apache.camel.support.AsyncProcessorSupport

process, processAsync

Methods inherited from class org.apache.camel.support.service.BaseService

build, doBuild, doFail, doLifecycleChange, doResume, doSuspend, fail, getStatus, init, isBuild, isInit, isNew, isRunAllowed, isShutdown, isStarted, isStarting, isStartingOrStarted, isStopped, isStopping, isStoppingOrStopped, isSuspended, isSuspending, isSuspendingOrSuspended, resume, shutdown, start, stop, suspend

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.apache.camel.StatefulService

getStatus, isRunAllowed, isStarted, isStarting, isStopped, isStopping, isSuspending

Methods inherited from interface org.apache.camel.SuspendableService

isSuspended, resume, suspend

Methods inherited from interface org.apache.camel.ShutdownableService

shutdown

Methods inherited from interface org.apache.camel.Service

build, close, init, start, stop

Field Detail

onPrepare

protected final org.apache.camel.Processor onPrepare

Constructor Detail

MulticastProcessor

public MulticastProcessor(org.apache.camel.CamelContext camelContext,
                          org.apache.camel.Route route,
                          Collection<org.apache.camel.Processor> processors)

MulticastProcessor

public MulticastProcessor(org.apache.camel.CamelContext camelContext,
                          org.apache.camel.Route route,
                          Collection<org.apache.camel.Processor> processors,
                          org.apache.camel.AggregationStrategy aggregationStrategy)

MulticastProcessor

public MulticastProcessor(org.apache.camel.CamelContext camelContext,
                          org.apache.camel.Route route,
                          Collection<org.apache.camel.Processor> processors,
                          org.apache.camel.AggregationStrategy aggregationStrategy,
                          boolean parallelProcessing,
                          ExecutorService executorService,
                          boolean shutdownExecutorService,
                          boolean streaming,
                          boolean stopOnException,
                          long timeout,
                          org.apache.camel.Processor onPrepare,
                          boolean shareUnitOfWork,
                          boolean parallelAggregate)

MulticastProcessor

public MulticastProcessor(org.apache.camel.CamelContext camelContext,
                          org.apache.camel.Route route,
                          Collection<org.apache.camel.Processor> processors,
                          org.apache.camel.AggregationStrategy aggregationStrategy,
                          boolean parallelProcessing,
                          ExecutorService executorService,
                          boolean shutdownExecutorService,
                          boolean streaming,
                          boolean stopOnException,
                          long timeout,
                          org.apache.camel.Processor onPrepare,
                          boolean shareUnitOfWork,
                          boolean parallelAggregate,
                          boolean stopOnAggregateException)

Method Detail

toString

public String toString()

Overrides:

toString in class Object

getId

public String getId()

Specified by:

getId in interface org.apache.camel.spi.HasId

setId

public void setId(String id)

Specified by:

setId in interface org.apache.camel.spi.IdAware

getRouteId

public String getRouteId()

Specified by:

getRouteId in interface org.apache.camel.spi.RouteIdAware

setRouteId

public void setRouteId(String routeId)

Specified by:

setRouteId in interface org.apache.camel.spi.RouteIdAware

getTraceLabel

public String getTraceLabel()

Specified by:

getTraceLabel in interface org.apache.camel.Traceable

getCamelContext

public org.apache.camel.CamelContext getCamelContext()

doInit

protected void doInit()
               throws Exception

Overrides:

doInit in class org.apache.camel.support.service.BaseService

Throws:

Exception

process

public boolean process(org.apache.camel.Exchange exchange,
                       org.apache.camel.AsyncCallback callback)

Specified by:

process in interface org.apache.camel.AsyncProcessor

schedule

protected void schedule(Runnable runnable)

schedule

protected void schedule(Executor executor,
                        Runnable runnable,
                        long delay,
                        TimeUnit unit)

beforeSend

protected org.apache.camel.util.StopWatch beforeSend(ProcessorExchangePair pair)

afterSend

protected void afterSend(ProcessorExchangePair pair,
                         org.apache.camel.util.StopWatch watch)

doDone

protected void doDone(org.apache.camel.Exchange original,
                      org.apache.camel.Exchange subExchange,
                      Iterable<ProcessorExchangePair> pairs,
                      org.apache.camel.AsyncCallback callback,
                      boolean doneSync,
                      boolean forceExhaust)

Common work which must be done when we are done multicasting.

This logic applies for both running synchronous and asynchronous as there are multiple exist points when using the asynchronous routing engine. And therefore we want the logic in one method instead of being scattered.

Parameters:

original - the original exchange

subExchange - the current sub exchange, can be null for the synchronous part

pairs - the pairs with the exchanges to process

callback - the callback

doneSync - the doneSync parameter to call on callback

forceExhaust - whether or not error handling is exhausted

doAggregate

protected void doAggregate(AtomicReference<org.apache.camel.Exchange> result,
                           org.apache.camel.Exchange exchange,
                           org.apache.camel.Exchange inputExchange)

Aggregate the Exchange with the current result. This method is synchronized and is called directly when parallelAggregate is disabled (by default).

Parameters:

result - the current result

exchange - the exchange to be added to the result

inputExchange - the input exchange that was sent as input to this EIP

updateNewExchange

protected void updateNewExchange(org.apache.camel.Exchange exchange,
                                 int index,
                                 Iterable<ProcessorExchangePair> allPairs,
                                 boolean hasNext)

getExchangeIndex

protected Integer getExchangeIndex(org.apache.camel.Exchange exchange)

createProcessorExchangePairs

protected Iterable<ProcessorExchangePair> createProcessorExchangePairs(org.apache.camel.Exchange exchange)
                                                                throws Exception

Throws:

Exception

createProcessorExchangePair

protected ProcessorExchangePair createProcessorExchangePair(int index,
                                                            org.apache.camel.Processor processor,
                                                            org.apache.camel.Exchange exchange,
                                                            org.apache.camel.Route route)

Creates the ProcessorExchangePair which holds the processor and exchange to be send out.

You must use this method to create the instances of ProcessorExchangePair as they need to be specially prepared before use.

Parameters:

index - the index

processor - the processor

exchange - the exchange

route - the route context

Returns:

prepared for use

createErrorHandler

protected org.apache.camel.Processor createErrorHandler(org.apache.camel.Route route,
                                                        org.apache.camel.Exchange exchange,
                                                        org.apache.camel.Processor processor)

createUnitOfWorkProcessor

protected org.apache.camel.Processor createUnitOfWorkProcessor(org.apache.camel.Route route,
                                                               org.apache.camel.Processor processor,
                                                               org.apache.camel.Exchange exchange)

Strategy to create the unit of work to be used for the sub route

Parameters:

processor - the processor

exchange - the exchange

Returns:

the unit of work processor

prepareSharedUnitOfWork

protected void prepareSharedUnitOfWork(org.apache.camel.Exchange childExchange,
                                       org.apache.camel.Exchange parentExchange)

Prepares the exchange for participating in a shared unit of work

This ensures a child exchange can access its parent UnitOfWork when it participate in a shared unit of work.

Parameters:

childExchange - the child exchange

parentExchange - the parent exchange

doStart

protected void doStart()
                throws Exception

Overrides:

doStart in class org.apache.camel.support.AsyncProcessorSupport

Throws:

Exception

createAggregateExecutorService

protected ExecutorService createAggregateExecutorService(String name)

Strategy to create the thread pool for the aggregator background task which waits for and aggregates completed tasks when running in parallel mode.

Parameters:

name - the suggested name for the background thread

Returns:

the thread pool

doStop

protected void doStop()
               throws Exception

Overrides:

doStop in class org.apache.camel.support.AsyncProcessorSupport

Throws:

Exception

doShutdown

protected void doShutdown()
                   throws Exception

Overrides:

doShutdown in class org.apache.camel.support.service.BaseService

Throws:

Exception

setToEndpoint

protected static void setToEndpoint(org.apache.camel.Exchange exchange,
                                    org.apache.camel.Processor processor)

getAggregationStrategy

protected org.apache.camel.AggregationStrategy getAggregationStrategy(org.apache.camel.Exchange exchange)

setAggregationStrategyOnExchange

protected void setAggregationStrategyOnExchange(org.apache.camel.Exchange exchange,
                                                org.apache.camel.AggregationStrategy aggregationStrategy)

Sets the given AggregationStrategy on the Exchange.

Parameters:

exchange - the exchange

aggregationStrategy - the strategy

removeAggregationStrategyFromExchange

protected void removeAggregationStrategyFromExchange(org.apache.camel.Exchange exchange)

Removes the associated AggregationStrategy from the Exchange which must be done after use.

Parameters:

exchange - the current exchange

isStreaming

public boolean isStreaming()

Is the multicast processor working in streaming mode?

In streaming mode:

• we use Iterable to ensure we can send messages as soon as the data becomes available
• for parallel processing, we start aggregating responses as they get send back to the processor; this means the AggregationStrategy has to take care of handling out-of-order arrival of exchanges

isStopOnException

public boolean isStopOnException()

Should the multicast processor stop processing further exchanges in case of an exception occurred?

getProcessors

public Collection<org.apache.camel.Processor> getProcessors()

Returns the producers to multicast to

getTimeout

public long getTimeout()

An optional timeout in millis when using parallel processing

getAggregationStrategy

public org.apache.camel.AggregationStrategy getAggregationStrategy()

Use getAggregationStrategy(org.apache.camel.Exchange) instead.

isParallelProcessing

public boolean isParallelProcessing()

isParallelAggregate

public boolean isParallelAggregate()

isStopOnAggregateException

public boolean isStopOnAggregateException()

isShareUnitOfWork

public boolean isShareUnitOfWork()

getAggregateExecutorService

public ExecutorService getAggregateExecutorService()

setAggregateExecutorService

public void setAggregateExecutorService(ExecutorService aggregateExecutorService)

next

public List<org.apache.camel.Processor> next()

Specified by:

next in interface org.apache.camel.Navigate<org.apache.camel.Processor>

hasNext

public boolean hasNext()

Specified by:

hasNext in interface org.apache.camel.Navigate<org.apache.camel.Processor>