return wrapChannel(routeContext, processor, null);
}
protected Processor wrapChannel(RouteContext routeContext, Processor processor, ProcessorDefinition child) throws Exception {
// put a channel in between this and each output to control the route flow logic
Channel channel = createChannel(routeContext);
channel.setNextProcessor(processor);
// add interceptor strategies to the channel must be in this order: camel context, route context, local
addInterceptStrategies(routeContext, channel, routeContext.getCamelContext().getInterceptStrategies());
addInterceptStrategies(routeContext, channel, routeContext.getInterceptStrategies());
addInterceptStrategies(routeContext, channel, this.getInterceptStrategies());
// must do this ugly cast to avoid compiler error on AIX/HP-UX
ProcessorDefinition defn = (ProcessorDefinition) this;
// set the child before init the channel
channel.setChildDefinition(child);
channel.initChannel(defn, routeContext);
// set the error handler, must be done after init as we can set the error handler as first in the chain
if (defn instanceof TryDefinition || defn instanceof CatchDefinition || defn instanceof FinallyDefinition) {
// do not use error handler for try .. catch .. finally blocks as it will handle errors itself
log.trace("{} is part of doTry .. doCatch .. doFinally so no error handler is applied", defn);
} else if (ProcessorDefinitionHelper.isParentOfType(TryDefinition.class, defn, true)
|| ProcessorDefinitionHelper.isParentOfType(CatchDefinition.class, defn, true)
|| ProcessorDefinitionHelper.isParentOfType(FinallyDefinition.class, defn, true)) {
// do not use error handler for try .. catch .. finally blocks as it will handle errors itself
// by checking that any of our parent(s) is not a try .. catch or finally type
log.trace("{} is part of doTry .. doCatch .. doFinally so no error handler is applied", defn);
} else if (defn instanceof OnExceptionDefinition || ProcessorDefinitionHelper.isParentOfType(OnExceptionDefinition.class, defn, true)) {
log.trace("{} is part of OnException so no error handler is applied", defn);
// do not use error handler for onExceptions blocks as it will handle errors itself
} else if (defn instanceof MulticastDefinition) {
// do not use error handler for multicast as it offers fine grained error handlers for its outputs
// however if share unit of work is enabled, we need to wrap an error handler on the multicast parent
MulticastDefinition def = (MulticastDefinition) defn;
if (def.isShareUnitOfWork() && child == null) {
// only wrap the parent (not the children of the multicast)
wrapChannelInErrorHandler(channel, routeContext);
} else {
log.trace("{} is part of multicast which have special error handling so no error handler is applied", defn);
}
} else {
// use error handler by default or if configured to do so
wrapChannelInErrorHandler(channel, routeContext);
}
// do post init at the end
channel.postInitChannel(defn, routeContext);
log.trace("{} wrapped in Channel: {}", defn, channel);
return channel;
}