// and wrap the processor in the transacted error handler as we can have transacted routes that change
// propagation behavior, eg: from A required -> B -> requiresNew C (advanced use-case)
// if we should not support this we do not need to wrap the processor as we only need one transacted error handler
// find the existing error handler builder
ErrorHandlerBuilder builder = routeContext.getRoute().getErrorHandlerBuilder();
// check if its a ref if so then do a lookup
if (builder instanceof ErrorHandlerBuilderRef) {
// its a reference to a error handler so lookup the reference
ErrorHandlerBuilderRef builderRef = (ErrorHandlerBuilderRef) builder;
String ref = builderRef.getRef();
// only lookup if there was explicit an error handler builder configured
// otherwise its just the "default" that has not explicit been configured
// and if so then we can safely replace that with our transacted error handler
if (ErrorHandlerBuilderRef.isErrorHandlerBuilderConfigured(ref)) {
if (LOG.isDebugEnabled()) {
LOG.debug("Looking up ErrorHandlerBuilder with ref: " + ref);
}
builder = ErrorHandlerBuilderRef.lookupErrorHandlerBuilder(routeContext, ref);
}
}
if (builder != null && builder.supportTransacted()) {
// already a TX error handler then we are good to go
if (LOG.isDebugEnabled()) {
LOG.debug("The ErrorHandlerBuilder configured is already a TransactionErrorHandlerBuilder: " + builder);
}
answer = createTransactionErrorHandler(routeContext, processor, builder);
answer.setExceptionPolicy(builder.getExceptionPolicyStrategy());
// configure our answer based on the existing error handler
builder.configure(answer);
} else {
// no transaction error handler builder configure so create a temporary one as we got all
// the needed information form the configured builder anyway this allow us to use transacted
// routes anyway even though the error handler is not transactional, eg ease of configuration
if (LOG.isDebugEnabled()) {
if (builder != null) {
LOG.debug("The ErrorHandlerBuilder configured is not a TransactionErrorHandlerBuilder: " + builder);
} else {
LOG.debug("No ErrorHandlerBuilder configured, will use default TransactionErrorHandlerBuilder settings");
}
}
TransactionErrorHandlerBuilder txBuilder = new TransactionErrorHandlerBuilder();
txBuilder.setTransactionTemplate(getTransactionTemplate());
txBuilder.setSpringTransactionPolicy(this);
if (builder != null) {
// use error handlers from the configured builder
txBuilder.setErrorHandlers(builder.getErrorHandlers());
}
answer = createTransactionErrorHandler(routeContext, processor, txBuilder);
answer.setExceptionPolicy(txBuilder.getExceptionPolicyStrategy());
// configure our answer based on the existing error handler
txBuilder.configure(answer);