You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@camel.apache.org by da...@apache.org on 2020/11/11 17:16:33 UTC
[camel] branch master updated: CAMEL-15802: Untangle model and
reifier from processor for error handlers. CAMEL-15839: camel-core - Do not
list error handlers in JMX
This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git
The following commit(s) were added to refs/heads/master by this push:
new d1be1a6 CAMEL-15802: Untangle model and reifier from processor for error handlers. CAMEL-15839: camel-core - Do not list error handlers in JMX
d1be1a6 is described below
commit d1be1a6bbc11d87d19a52ffcda25f0187a4b4055
Author: Claus Ibsen <cl...@gmail.com>
AuthorDate: Wed Nov 11 18:07:49 2020 +0100
CAMEL-15802: Untangle model and reifier from processor for error handlers.
CAMEL-15839: camel-core - Do not list error handlers in JMX
---
.../apache/camel/component/bean/BeanHolder.java | 7 +
.../apache/camel/component/bean/BeanProcessor.java | 16 +-
.../camel/component/bean/ConstantBeanHolder.java | 7 +
.../component/bean/ConstantTypeBeanHolder.java | 7 +
.../apache/camel/component/bean/MethodInfo.java | 15 +
.../apache/camel/component/bean/RegistryBean.java | 22 +-
.../camel/component/bean/RequestBeanHolder.java | 5 +
.../camel/jta/JtaTransactionErrorHandler.java | 46 +-
.../jta/JtaTransactionErrorHandlerReifier.java | 1 -
.../org/apache/camel/jta/JtaTransactionPolicy.java | 2 +-
.../apache/camel/jta/TransactionErrorHandler.java | 51 +-
.../camel/spring/spi/TransactionErrorHandler.java | 17 +-
.../spring/spi/TransactionErrorHandlerReifier.java | 2 +-
.../spring/config/DummyErrorHandlerBuilder.java | 1 -
.../management/SpringManagedErrorHandlerTest.xml | 48 --
.../org/apache/camel/spi/BeanProcessorFactory.java | 1 +
.../org/apache/camel/spi/ErrorHandlerAware.java} | 28 +-
.../org/apache/camel/spi/LifecycleStrategy.java | 20 -
.../camel/spi/ManagementObjectNameStrategy.java | 4 -
.../apache/camel/spi/ManagementObjectStrategy.java | 5 -
.../org/apache/camel/impl/engine/DefaultRoute.java | 11 +-
.../org/apache/camel/impl/engine/RouteService.java | 14 +-
.../camel/builder/DeadLetterChannelBuilder.java | 11 +-
.../camel/builder/DefaultErrorHandlerBuilder.java | 144 +++---
.../camel/builder/ErrorHandlerBuilderRef.java | 30 +-
.../camel/builder/ErrorHandlerBuilderSupport.java | 53 --
.../camel/builder/NoErrorHandlerBuilder.java | 8 +-
.../DeadLetterChannelConfiguration.java | 35 +-
.../errorhandler/DeadLetterChannelProperties.java | 18 +-
.../DefaultErrorHandlerConfiguration.java | 244 ++++++---
...ion.java => DefaultErrorHandlerProperties.java} | 11 +-
.../model/errorhandler/ErrorHandlerHelper.java | 17 +-
.../errorhandler/ErrorHandlerRefConfiguration.java | 28 +-
...uration.java => ErrorHandlerRefProperties.java} | 2 +-
...aiton.java => NoErrorHandlerConfiguration.java} | 7 +-
...guraiton.java => NoErrorHandlerProperties.java} | 2 +-
.../apache/camel/processor/MulticastProcessor.java | 33 +-
.../org/apache/camel/processor/RecipientList.java | 24 +-
.../camel/processor/RecipientListProcessor.java | 2 +-
.../processor/errorhandler/DeadLetterChannel.java | 18 +-
.../errorhandler/DefaultErrorHandler.java | 18 +-
.../DefaultExceptionPolicyStrategy.java | 2 +-
.../errorhandler/ErrorHandlerSupport.java | 19 +-
.../processor/errorhandler/NoErrorHandler.java | 45 +-
.../errorhandler/RedeliveryErrorHandler.java | 11 +-
.../java/org/apache/camel/reifier/BeanReifier.java | 3 +-
.../apache/camel/reifier/DynamicRouterReifier.java | 2 +-
.../org/apache/camel/reifier/ProcessorReifier.java | 14 +-
.../apache/camel/reifier/RecipientListReifier.java | 2 +-
.../org/apache/camel/reifier/RouteReifier.java | 20 +
.../apache/camel/reifier/RoutingSlipReifier.java | 2 +-
.../org/apache/camel/reifier/WireTapReifier.java | 2 +-
.../errorhandler/DeadLetterChannelReifier.java | 6 +-
.../errorhandler/DefaultErrorHandlerReifier.java | 7 +-
.../errorhandler/ErrorHandlerRefReifier.java | 6 +-
.../reifier/errorhandler/ErrorHandlerReifier.java | 16 +-
.../errorhandler/NoErrorHandlerReifier.java | 6 +-
.../apache/camel/impl/DummyLifecycleStrategy.java | 14 +-
.../errorhandler/ErrorHandlerSupportTest.java | 6 +
.../CustomExceptionPolicyStrategyTest.java | 105 ----
.../management/mbean/ManagedErrorHandlerMBean.java | 173 -------
.../DefaultManagementObjectNameStrategy.java | 59 ---
.../DefaultManagementObjectStrategy.java | 11 -
.../management/JmxManagementLifecycleStrategy.java | 47 --
.../management/mbean/ManagedErrorHandler.java | 543 ---------------------
.../management/ManagedErrorHandlerOptionsTest.java | 155 ------
.../ManagedErrorHandlerRedeliveryTest.java | 155 ------
.../camel/management/ManagedErrorHandlerTest.java | 72 ---
...edRouteRemoveContextScopedErrorHandlerTest.java | 10 +-
...emoveRouteAndContextScopedErrorHandlerTest.java | 20 +-
...agedRouteRemoveRouteScopedErrorHandlerTest.java | 10 +-
.../camel/support/LifecycleStrategySupport.java | 12 -
.../ROOT/pages/camel-3x-upgrade-guide-3_7.adoc | 6 +
73 files changed, 688 insertions(+), 1908 deletions(-)
diff --git a/components/camel-bean/src/main/java/org/apache/camel/component/bean/BeanHolder.java b/components/camel-bean/src/main/java/org/apache/camel/component/bean/BeanHolder.java
index 7b7758a..0e4b90a 100644
--- a/components/camel-bean/src/main/java/org/apache/camel/component/bean/BeanHolder.java
+++ b/components/camel-bean/src/main/java/org/apache/camel/component/bean/BeanHolder.java
@@ -28,6 +28,13 @@ import org.apache.camel.Processor;
public interface BeanHolder {
/**
+ * Sets error handler used by @RecipientList EIP
+ *
+ * @param errorHandler the error handler
+ */
+ void setErrorHandler(Processor errorHandler);
+
+ /**
* Additional options that should be configured on the bean
*/
Map<String, Object> getOptions();
diff --git a/components/camel-bean/src/main/java/org/apache/camel/component/bean/BeanProcessor.java b/components/camel-bean/src/main/java/org/apache/camel/component/bean/BeanProcessor.java
index f8706ad..7105b09 100644
--- a/components/camel-bean/src/main/java/org/apache/camel/component/bean/BeanProcessor.java
+++ b/components/camel-bean/src/main/java/org/apache/camel/component/bean/BeanProcessor.java
@@ -24,9 +24,10 @@ import org.apache.camel.BeanScope;
import org.apache.camel.CamelContext;
import org.apache.camel.Exchange;
import org.apache.camel.Processor;
+import org.apache.camel.spi.ErrorHandlerAware;
import org.apache.camel.support.service.ServiceSupport;
-public class BeanProcessor extends ServiceSupport implements AsyncProcessor {
+public class BeanProcessor extends ServiceSupport implements AsyncProcessor, ErrorHandlerAware {
private final DelegateBeanProcessor delegate;
@@ -45,6 +46,19 @@ public class BeanProcessor extends ServiceSupport implements AsyncProcessor {
}
@Override
+ public Processor getErrorHandler() {
+ return null;
+ }
+
+ @Override
+ public void setErrorHandler(Processor errorHandler) {
+ BeanHolder holder = delegate.getBeanHolder();
+ if (holder != null) {
+ holder.setErrorHandler(errorHandler);
+ }
+ }
+
+ @Override
public void process(Exchange exchange) throws Exception {
delegate.process(exchange);
}
diff --git a/components/camel-bean/src/main/java/org/apache/camel/component/bean/ConstantBeanHolder.java b/components/camel-bean/src/main/java/org/apache/camel/component/bean/ConstantBeanHolder.java
index e4fdb54..31b0017 100644
--- a/components/camel-bean/src/main/java/org/apache/camel/component/bean/ConstantBeanHolder.java
+++ b/components/camel-bean/src/main/java/org/apache/camel/component/bean/ConstantBeanHolder.java
@@ -51,6 +51,13 @@ public class ConstantBeanHolder implements BeanHolder {
}
@Override
+ public void setErrorHandler(Processor errorHandler) {
+ for (MethodInfo mi : beanInfo.getMethods()) {
+ mi.setErrorHandler(errorHandler);
+ }
+ }
+
+ @Override
public Map<String, Object> getOptions() {
return options;
}
diff --git a/components/camel-bean/src/main/java/org/apache/camel/component/bean/ConstantTypeBeanHolder.java b/components/camel-bean/src/main/java/org/apache/camel/component/bean/ConstantTypeBeanHolder.java
index 0662aa9..2ddbfa1 100644
--- a/components/camel-bean/src/main/java/org/apache/camel/component/bean/ConstantTypeBeanHolder.java
+++ b/components/camel-bean/src/main/java/org/apache/camel/component/bean/ConstantTypeBeanHolder.java
@@ -46,6 +46,13 @@ public class ConstantTypeBeanHolder implements BeanTypeHolder {
}
@Override
+ public void setErrorHandler(Processor errorHandler) {
+ for (MethodInfo mi : beanInfo.getMethods()) {
+ mi.setErrorHandler(errorHandler);
+ }
+ }
+
+ @Override
public Map<String, Object> getOptions() {
return options;
}
diff --git a/components/camel-bean/src/main/java/org/apache/camel/component/bean/MethodInfo.java b/components/camel-bean/src/main/java/org/apache/camel/component/bean/MethodInfo.java
index 70d9110..529168a 100644
--- a/components/camel-bean/src/main/java/org/apache/camel/component/bean/MethodInfo.java
+++ b/components/camel-bean/src/main/java/org/apache/camel/component/bean/MethodInfo.java
@@ -44,9 +44,11 @@ import org.apache.camel.InOut;
import org.apache.camel.Message;
import org.apache.camel.NoTypeConversionAvailableException;
import org.apache.camel.Pattern;
+import org.apache.camel.Processor;
import org.apache.camel.RuntimeCamelException;
import org.apache.camel.RuntimeExchangeException;
import org.apache.camel.StreamCache;
+import org.apache.camel.spi.ErrorHandlerAware;
import org.apache.camel.support.DefaultMessage;
import org.apache.camel.support.ExchangeHelper;
import org.apache.camel.support.ExpressionAdapter;
@@ -239,6 +241,19 @@ public class MethodInfo {
return method.toString();
}
+ /**
+ * For fine grained error handling for outputs of this EIP. The base error handler is used as base and then cloned
+ * for each output processor.
+ *
+ * This is used internally only by Camel - not for end users.
+ */
+ public void setErrorHandler(Processor errorHandler) {
+ // special for @RecipientList which needs to be injected with error handler it should use
+ if (recipientList instanceof ErrorHandlerAware) {
+ ((ErrorHandlerAware) recipientList).setErrorHandler(errorHandler);
+ }
+ }
+
public MethodInvocation createMethodInvocation(final Object pojo, boolean hasParameters, final Exchange exchange) {
final Object[] arguments;
if (hasParameters) {
diff --git a/components/camel-bean/src/main/java/org/apache/camel/component/bean/RegistryBean.java b/components/camel-bean/src/main/java/org/apache/camel/component/bean/RegistryBean.java
index 8914464..c41e717 100644
--- a/components/camel-bean/src/main/java/org/apache/camel/component/bean/RegistryBean.java
+++ b/components/camel-bean/src/main/java/org/apache/camel/component/bean/RegistryBean.java
@@ -36,6 +36,7 @@ public class RegistryBean implements BeanHolder {
private final ParameterMappingStrategy parameterMappingStrategy;
private final BeanComponent beanComponent;
private volatile BeanInfo beanInfo;
+ private volatile Processor errorHandler;
private volatile Class<?> clazz;
private Map<String, Object> options;
@@ -66,6 +67,18 @@ public class RegistryBean implements BeanHolder {
}
@Override
+ public void setErrorHandler(Processor errorHandler) {
+ if (beanInfo != null) {
+ for (MethodInfo mi : beanInfo.getMethods()) {
+ mi.setErrorHandler(errorHandler);
+ }
+ } else {
+ // need to store it temporary until bean info is created
+ this.errorHandler = errorHandler;
+ }
+ }
+
+ @Override
public Map<String, Object> getOptions() {
return options;
}
@@ -164,7 +177,14 @@ public class RegistryBean implements BeanHolder {
// Implementation methods
//-------------------------------------------------------------------------
protected BeanInfo createBeanInfo(Object bean) {
- return new BeanInfo(context, bean.getClass(), parameterMappingStrategy, beanComponent);
+ BeanInfo bi = new BeanInfo(context, bean.getClass(), parameterMappingStrategy, beanComponent);
+ if (errorHandler != null) {
+ for (MethodInfo mi : bi.getMethods()) {
+ mi.setErrorHandler(errorHandler);
+ }
+ errorHandler = null;
+ }
+ return bi;
}
protected Object lookupBean() {
diff --git a/components/camel-bean/src/main/java/org/apache/camel/component/bean/RequestBeanHolder.java b/components/camel-bean/src/main/java/org/apache/camel/component/bean/RequestBeanHolder.java
index a17b766..afec5c5 100644
--- a/components/camel-bean/src/main/java/org/apache/camel/component/bean/RequestBeanHolder.java
+++ b/components/camel-bean/src/main/java/org/apache/camel/component/bean/RequestBeanHolder.java
@@ -36,6 +36,11 @@ public class RequestBeanHolder implements BeanHolder {
}
@Override
+ public void setErrorHandler(Processor errorHandler) {
+ holder.setErrorHandler(errorHandler);
+ }
+
+ @Override
public Map<String, Object> getOptions() {
return holder.getOptions();
}
diff --git a/components/camel-jta/src/main/java/org/apache/camel/jta/JtaTransactionErrorHandler.java b/components/camel-jta/src/main/java/org/apache/camel/jta/JtaTransactionErrorHandler.java
index 4b3912f..03ca157 100644
--- a/components/camel-jta/src/main/java/org/apache/camel/jta/JtaTransactionErrorHandler.java
+++ b/components/camel-jta/src/main/java/org/apache/camel/jta/JtaTransactionErrorHandler.java
@@ -22,10 +22,10 @@ import org.apache.camel.CamelContext;
import org.apache.camel.LoggingLevel;
import org.apache.camel.Predicate;
import org.apache.camel.Processor;
-import org.apache.camel.processor.errorhandler.ExceptionPolicyStrategy;
import org.apache.camel.processor.errorhandler.RedeliveryErrorHandler;
import org.apache.camel.processor.errorhandler.RedeliveryPolicy;
import org.apache.camel.spi.CamelLogger;
+import org.apache.camel.spi.ErrorHandler;
/**
* This error handler does redelivering. If the transaction fails it can be retried if configured to do so. In the
@@ -34,32 +34,34 @@ import org.apache.camel.spi.CamelLogger;
*/
public class JtaTransactionErrorHandler extends RedeliveryErrorHandler {
+ private final JtaTransactionPolicy transactionPolicy;
+ private final LoggingLevel rollbackLoggingLevel;
+
public JtaTransactionErrorHandler(CamelContext camelContext, Processor output, CamelLogger logger,
Processor redeliveryProcessor, RedeliveryPolicy redeliveryPolicy,
- ExceptionPolicyStrategy exceptionPolicyStrategy, JtaTransactionPolicy transactionPolicy,
+ JtaTransactionPolicy transactionPolicy,
Predicate retryWhile, ScheduledExecutorService executorService,
LoggingLevel rollbackLoggingLevel,
Processor onExceptionOccurredProcessor) {
-
super(camelContext,
- new TransactionErrorHandler(
- camelContext,
- output,
- exceptionPolicyStrategy,
- transactionPolicy,
- executorService,
- rollbackLoggingLevel),
- logger,
- redeliveryProcessor,
- redeliveryPolicy,
- null,
- null,
- false,
- false,
- false,
- retryWhile,
- executorService,
- null,
- onExceptionOccurredProcessor);
+ new TransactionErrorHandler(camelContext, output, transactionPolicy, rollbackLoggingLevel),
+ logger, redeliveryProcessor, redeliveryPolicy,
+ null, null, false, false, false,
+ retryWhile, executorService, null, onExceptionOccurredProcessor);
+ this.transactionPolicy = transactionPolicy;
+ this.rollbackLoggingLevel = rollbackLoggingLevel;
}
+
+ @Override
+ public ErrorHandler clone(Processor output) {
+ JtaTransactionErrorHandler answer = new JtaTransactionErrorHandler(
+ camelContext, output, logger, redeliveryProcessor, redeliveryPolicy, transactionPolicy, retryWhilePolicy,
+ executorService, rollbackLoggingLevel, onExceptionProcessor);
+ // shallow clone is okay as we do not mutate these
+ if (exceptionPolicies != null) {
+ answer.exceptionPolicies = exceptionPolicies;
+ }
+ return answer;
+ }
+
}
diff --git a/components/camel-jta/src/main/java/org/apache/camel/jta/JtaTransactionErrorHandlerReifier.java b/components/camel-jta/src/main/java/org/apache/camel/jta/JtaTransactionErrorHandlerReifier.java
index edda25a..4667235 100644
--- a/components/camel-jta/src/main/java/org/apache/camel/jta/JtaTransactionErrorHandlerReifier.java
+++ b/components/camel-jta/src/main/java/org/apache/camel/jta/JtaTransactionErrorHandlerReifier.java
@@ -110,7 +110,6 @@ public class JtaTransactionErrorHandlerReifier extends ErrorHandlerReifier<JtaTr
definition.getLogger(),
definition.getOnRedelivery(),
definition.getRedeliveryPolicy(),
- definition.getExceptionPolicyStrategy(),
transactionPolicy,
definition.getRetryWhilePolicy(camelContext),
getExecutorService(),
diff --git a/components/camel-jta/src/main/java/org/apache/camel/jta/JtaTransactionPolicy.java b/components/camel-jta/src/main/java/org/apache/camel/jta/JtaTransactionPolicy.java
index caf5c05..b7f38c0 100644
--- a/components/camel-jta/src/main/java/org/apache/camel/jta/JtaTransactionPolicy.java
+++ b/components/camel-jta/src/main/java/org/apache/camel/jta/JtaTransactionPolicy.java
@@ -31,7 +31,7 @@ import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
- * Sets a proper error handler. This class is based on {@link org.apache.camel.spring.spi.SpringTransactionPolicy}.
+ * Sets a proper error handler. This class is based on org.apache.camel.spring.spi.SpringTransactionPolicy.
* <p>
* This class requires the resource {@link TransactionManager} to be available through JNDI url
* "java:/TransactionManager"
diff --git a/components/camel-jta/src/main/java/org/apache/camel/jta/TransactionErrorHandler.java b/components/camel-jta/src/main/java/org/apache/camel/jta/TransactionErrorHandler.java
index a070a1e..b5ad600 100644
--- a/components/camel-jta/src/main/java/org/apache/camel/jta/TransactionErrorHandler.java
+++ b/components/camel-jta/src/main/java/org/apache/camel/jta/TransactionErrorHandler.java
@@ -19,7 +19,6 @@ package org.apache.camel.jta;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ScheduledExecutorService;
import javax.transaction.TransactionRolledbackException;
@@ -32,7 +31,7 @@ import org.apache.camel.Navigate;
import org.apache.camel.Processor;
import org.apache.camel.RuntimeCamelException;
import org.apache.camel.processor.errorhandler.ErrorHandlerSupport;
-import org.apache.camel.processor.errorhandler.ExceptionPolicyStrategy;
+import org.apache.camel.spi.ErrorHandler;
import org.apache.camel.spi.ShutdownPrepared;
import org.apache.camel.support.AsyncCallbackToCompletableFutureAdapter;
import org.apache.camel.support.ExchangeHelper;
@@ -43,47 +42,48 @@ import org.slf4j.LoggerFactory;
/**
* Does transactional execution according given policy. This class is based on
- * {@link org.apache.camel.spring.spi.TransactionErrorHandler} excluding redelivery functionality. In the Spring
- * implementation redelivering is done within the transaction which is not appropriate in JTA since every error breaks
- * the current transaction.
+ * org.apache.camel.spring.spi.TransactionErrorHandler excluding redelivery functionality. In the Spring implementation
+ * redelivering is done within the transaction which is not appropriate in JTA since every error breaks the current
+ * transaction.
*/
public class TransactionErrorHandler extends ErrorHandlerSupport
implements AsyncProcessor, ShutdownPrepared, Navigate<Processor> {
private static final Logger LOG = LoggerFactory.getLogger(TransactionErrorHandler.class);
+ protected final CamelContext camelContext;
protected final Processor output;
-
protected volatile boolean preparingShutdown;
-
- private ExceptionPolicyStrategy exceptionPolicy;
-
private JtaTransactionPolicy transactionPolicy;
-
private final String transactionKey;
-
private final LoggingLevel rollbackLoggingLevel;
/**
* Creates the transaction error handler.
*
- * @param camelContext the camel context
- * @param output outer processor that should use this default error handler
- * @param exceptionPolicyStrategy strategy for onException handling
- * @param transactionPolicy the transaction policy
- * @param executorService the {@link java.util.concurrent.ScheduledExecutorService} to be used for
- * redelivery thread pool. Can be <tt>null</tt>.
- * @param rollbackLoggingLevel logging level to use for logging transaction rollback occurred
+ * @param camelContext the camel context
+ * @param output outer processor that should use this default error handler
+ * @param transactionPolicy the transaction policy
+ * @param rollbackLoggingLevel logging level to use for logging transaction rollback occurred
*/
public TransactionErrorHandler(CamelContext camelContext, Processor output,
- ExceptionPolicyStrategy exceptionPolicyStrategy, JtaTransactionPolicy transactionPolicy,
- ScheduledExecutorService executorService, LoggingLevel rollbackLoggingLevel) {
+ JtaTransactionPolicy transactionPolicy, LoggingLevel rollbackLoggingLevel) {
+ this.camelContext = camelContext;
this.output = output;
this.transactionPolicy = transactionPolicy;
this.rollbackLoggingLevel = rollbackLoggingLevel;
this.transactionKey = ObjectHelper.getIdentityHashCode(transactionPolicy);
+ }
- setExceptionPolicy(exceptionPolicyStrategy);
+ @Override
+ public ErrorHandler clone(Processor output) {
+ TransactionErrorHandler answer = new TransactionErrorHandler(
+ camelContext, output, transactionPolicy, rollbackLoggingLevel);
+ // shallow clone is okay as we do not mutate these
+ if (exceptionPolicies != null) {
+ answer.exceptionPolicies = exceptionPolicies;
+ }
+ return answer;
}
@Override
@@ -318,15 +318,6 @@ public class TransactionErrorHandler extends ErrorHandlerSupport
}
@Override
- public void setExceptionPolicy(ExceptionPolicyStrategy exceptionPolicy) {
- this.exceptionPolicy = exceptionPolicy;
- }
-
- public ExceptionPolicyStrategy getExceptionPolicy() {
- return exceptionPolicy;
- }
-
- @Override
public Processor getOutput() {
return output;
}
diff --git a/components/camel-spring/src/main/java/org/apache/camel/spring/spi/TransactionErrorHandler.java b/components/camel-spring/src/main/java/org/apache/camel/spring/spi/TransactionErrorHandler.java
index 62c34e4..15d1db9 100644
--- a/components/camel-spring/src/main/java/org/apache/camel/spring/spi/TransactionErrorHandler.java
+++ b/components/camel-spring/src/main/java/org/apache/camel/spring/spi/TransactionErrorHandler.java
@@ -25,10 +25,10 @@ import org.apache.camel.LoggingLevel;
import org.apache.camel.Predicate;
import org.apache.camel.Processor;
import org.apache.camel.RuntimeCamelException;
-import org.apache.camel.processor.errorhandler.ExceptionPolicyStrategy;
import org.apache.camel.processor.errorhandler.RedeliveryErrorHandler;
import org.apache.camel.processor.errorhandler.RedeliveryPolicy;
import org.apache.camel.spi.CamelLogger;
+import org.apache.camel.spi.ErrorHandler;
import org.apache.camel.support.AsyncProcessorSupport;
import org.apache.camel.support.ExchangeHelper;
import org.apache.camel.util.ObjectHelper;
@@ -58,7 +58,6 @@ public class TransactionErrorHandler extends RedeliveryErrorHandler {
* @param logger logger to use for logging failures and redelivery attempts
* @param redeliveryProcessor an optional processor to run before redelivery attempt
* @param redeliveryPolicy policy for redelivery
- * @param exceptionPolicyStrategy strategy for onException handling
* @param transactionTemplate the transaction template
* @param retryWhile retry while
* @param executorService the {@link java.util.concurrent.ScheduledExecutorService} to be used for
@@ -69,20 +68,30 @@ public class TransactionErrorHandler extends RedeliveryErrorHandler {
*/
public TransactionErrorHandler(CamelContext camelContext, Processor output, CamelLogger logger,
Processor redeliveryProcessor, RedeliveryPolicy redeliveryPolicy,
- ExceptionPolicyStrategy exceptionPolicyStrategy,
TransactionTemplate transactionTemplate, Predicate retryWhile,
ScheduledExecutorService executorService,
LoggingLevel rollbackLoggingLevel, Processor onExceptionOccurredProcessor) {
super(camelContext, output, logger, redeliveryProcessor, redeliveryPolicy, null, null, false, false, false, retryWhile,
executorService, null, onExceptionOccurredProcessor);
- setExceptionPolicy(exceptionPolicyStrategy);
this.transactionTemplate = transactionTemplate;
this.rollbackLoggingLevel = rollbackLoggingLevel;
this.transactionKey = ObjectHelper.getIdentityHashCode(transactionTemplate);
}
@Override
+ public ErrorHandler clone(Processor output) {
+ TransactionErrorHandler answer = new TransactionErrorHandler(
+ camelContext, output, logger, redeliveryProcessor, redeliveryPolicy, transactionTemplate, retryWhilePolicy,
+ executorService, rollbackLoggingLevel, onExceptionProcessor);
+ // shallow clone is okay as we do not mutate these
+ if (exceptionPolicies != null) {
+ answer.exceptionPolicies = exceptionPolicies;
+ }
+ return answer;
+ }
+
+ @Override
public boolean supportTransacted() {
return true;
}
diff --git a/components/camel-spring/src/main/java/org/apache/camel/spring/spi/TransactionErrorHandlerReifier.java b/components/camel-spring/src/main/java/org/apache/camel/spring/spi/TransactionErrorHandlerReifier.java
index 7f1bede..d9253a9 100644
--- a/components/camel-spring/src/main/java/org/apache/camel/spring/spi/TransactionErrorHandlerReifier.java
+++ b/components/camel-spring/src/main/java/org/apache/camel/spring/spi/TransactionErrorHandlerReifier.java
@@ -98,7 +98,7 @@ public class TransactionErrorHandlerReifier extends DefaultErrorHandlerReifier<T
TransactionErrorHandler answer = new TransactionErrorHandler(
camelContext, processor,
definition.getLogger(), definition.getOnRedelivery(),
- definition.getRedeliveryPolicy(), definition.getExceptionPolicyStrategy(), transactionTemplate,
+ definition.getRedeliveryPolicy(), transactionTemplate,
definition.getRetryWhilePolicy(camelContext),
getExecutorService(definition.getExecutorService(), definition.getExecutorServiceRef()),
definition.getRollbackLoggingLevel(), definition.getOnExceptionOccurred());
diff --git a/components/camel-spring/src/test/java/org/apache/camel/spring/config/DummyErrorHandlerBuilder.java b/components/camel-spring/src/test/java/org/apache/camel/spring/config/DummyErrorHandlerBuilder.java
index 176813b..eef9686 100644
--- a/components/camel-spring/src/test/java/org/apache/camel/spring/config/DummyErrorHandlerBuilder.java
+++ b/components/camel-spring/src/test/java/org/apache/camel/spring/config/DummyErrorHandlerBuilder.java
@@ -51,7 +51,6 @@ public class DummyErrorHandlerBuilder extends ErrorHandlerBuilderSupport impleme
@Override
public ErrorHandlerBuilder cloneBuilder() {
DummyErrorHandlerBuilder answer = new DummyErrorHandlerBuilder();
- super.cloneBuilder(answer);
answer.beanName = beanName;
return answer;
}
diff --git a/components/camel-spring/src/test/resources/org/apache/camel/spring/management/SpringManagedErrorHandlerTest.xml b/components/camel-spring/src/test/resources/org/apache/camel/spring/management/SpringManagedErrorHandlerTest.xml
deleted file mode 100644
index 4f7a319..0000000
--- a/components/camel-spring/src/test/resources/org/apache/camel/spring/management/SpringManagedErrorHandlerTest.xml
+++ /dev/null
@@ -1,48 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-
- Licensed to the Apache Software Foundation (ASF) under one or more
- contributor license agreements. See the NOTICE file distributed with
- this work for additional information regarding copyright ownership.
- The ASF licenses this file to You under the Apache License, Version 2.0
- (the "License"); you may not use this file except in compliance with
- the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
-
--->
-<beans xmlns="http://www.springframework.org/schema/beans"
- xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
- xsi:schemaLocation="
- http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
- http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring.xsd
- ">
-
- <bean id="dlc" class="org.apache.camel.builder.DeadLetterChannelBuilder">
- <property name="deadLetterUri" value="mock:read"/>
- </bean>
-
- <camelContext xmlns="http://camel.apache.org/schema/spring">
- <route>
- <from uri="direct:foo"/>
- <to uri="mock:foo"/>
- </route>
-
- <route errorHandlerRef="dlc">
- <from uri="direct:bar"/>
- <to uri="mock:bar"/>
- </route>
-
- <route>
- <from uri="direct:baz"/>
- <to uri="mock:baz"/>
- </route>
- </camelContext>
-
-</beans>
diff --git a/core/camel-api/src/main/java/org/apache/camel/spi/BeanProcessorFactory.java b/core/camel-api/src/main/java/org/apache/camel/spi/BeanProcessorFactory.java
index 298d83c..89c9fa6 100644
--- a/core/camel-api/src/main/java/org/apache/camel/spi/BeanProcessorFactory.java
+++ b/core/camel-api/src/main/java/org/apache/camel/spi/BeanProcessorFactory.java
@@ -64,4 +64,5 @@ public interface BeanProcessorFactory {
CamelContext camelContext, Object bean, String beanType, Class<?> beanClass, String ref,
String method, BeanScope scope)
throws Exception;
+
}
diff --git a/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/ErrorHandlerRefConfiguration.java b/core/camel-api/src/main/java/org/apache/camel/spi/ErrorHandlerAware.java
similarity index 58%
copy from core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/ErrorHandlerRefConfiguration.java
copy to core/camel-api/src/main/java/org/apache/camel/spi/ErrorHandlerAware.java
index 274f266..9d7f61e 100644
--- a/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/ErrorHandlerRefConfiguration.java
+++ b/core/camel-api/src/main/java/org/apache/camel/spi/ErrorHandlerAware.java
@@ -14,19 +14,27 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.apache.camel.model.errorhandler;
+package org.apache.camel.spi;
-import org.apache.camel.ErrorHandlerFactory;
+import org.apache.camel.Processor;
-public interface ErrorHandlerRefConfiguration extends ErrorHandlerFactory {
-
- String DEFAULT_ERROR_HANDLER_BUILDER = "CamelDefaultErrorHandlerBuilder";
-
- String getRef();
+/**
+ * An interface for {@link Processor} aware of its {@link ErrorHandler} which are wrapped via the
+ * {@link org.apache.camel.Channel} during route initialization, or specially used by
+ * {@link org.apache.camel.RecipientList} EIP annotation.
+ */
+public interface ErrorHandlerAware {
- void setRef(String ref);
+ /**
+ * Sets the error handler
+ *
+ * @param errorHandler the error handler
+ */
+ void setErrorHandler(Processor errorHandler);
- boolean isSupportTransacted();
+ /**
+ * Gets the error handler
+ */
+ Processor getErrorHandler();
- void setSupportTransacted(boolean supportTransacted);
}
diff --git a/core/camel-api/src/main/java/org/apache/camel/spi/LifecycleStrategy.java b/core/camel-api/src/main/java/org/apache/camel/spi/LifecycleStrategy.java
index f837cae..5af5175 100644
--- a/core/camel-api/src/main/java/org/apache/camel/spi/LifecycleStrategy.java
+++ b/core/camel-api/src/main/java/org/apache/camel/spi/LifecycleStrategy.java
@@ -22,8 +22,6 @@ import java.util.concurrent.ThreadPoolExecutor;
import org.apache.camel.CamelContext;
import org.apache.camel.Component;
import org.apache.camel.Endpoint;
-import org.apache.camel.ErrorHandlerFactory;
-import org.apache.camel.Processor;
import org.apache.camel.Route;
import org.apache.camel.Service;
import org.apache.camel.VetoCamelContextStartException;
@@ -201,24 +199,6 @@ public interface LifecycleStrategy {
void onRouteContextCreate(Route route);
/**
- * Notification on adding error handler.
- *
- * @param route the added route context
- * @param errorHandler the error handler
- * @param errorHandlerBuilder the error handler builder
- */
- void onErrorHandlerAdd(Route route, Processor errorHandler, ErrorHandlerFactory errorHandlerBuilder);
-
- /**
- * Notification on removing error handler.
- *
- * @param route the removed route context
- * @param errorHandler the error handler
- * @param errorHandlerBuilder the error handler builder
- */
- void onErrorHandlerRemove(Route route, Processor errorHandler, ErrorHandlerFactory errorHandlerBuilder);
-
- /**
* Notification on adding a thread pool.
*
* @param camelContext the camel context
diff --git a/core/camel-api/src/main/java/org/apache/camel/spi/ManagementObjectNameStrategy.java b/core/camel-api/src/main/java/org/apache/camel/spi/ManagementObjectNameStrategy.java
index bc0c267..ee4bfe5 100644
--- a/core/camel-api/src/main/java/org/apache/camel/spi/ManagementObjectNameStrategy.java
+++ b/core/camel-api/src/main/java/org/apache/camel/spi/ManagementObjectNameStrategy.java
@@ -25,7 +25,6 @@ import org.apache.camel.CamelContext;
import org.apache.camel.Component;
import org.apache.camel.Consumer;
import org.apache.camel.Endpoint;
-import org.apache.camel.ErrorHandlerFactory;
import org.apache.camel.NamedNode;
import org.apache.camel.Processor;
import org.apache.camel.Producer;
@@ -55,9 +54,6 @@ public interface ManagementObjectNameStrategy {
ObjectName getObjectNameForDataFormat(CamelContext context, DataFormat endpoint) throws MalformedObjectNameException;
- ObjectName getObjectNameForErrorHandler(Route route, Processor errorHandler, ErrorHandlerFactory builder)
- throws MalformedObjectNameException;
-
ObjectName getObjectNameForProcessor(CamelContext context, Processor processor, NamedNode definition)
throws MalformedObjectNameException;
diff --git a/core/camel-api/src/main/java/org/apache/camel/spi/ManagementObjectStrategy.java b/core/camel-api/src/main/java/org/apache/camel/spi/ManagementObjectStrategy.java
index 1295446..5d7abc5 100644
--- a/core/camel-api/src/main/java/org/apache/camel/spi/ManagementObjectStrategy.java
+++ b/core/camel-api/src/main/java/org/apache/camel/spi/ManagementObjectStrategy.java
@@ -22,7 +22,6 @@ import org.apache.camel.CamelContext;
import org.apache.camel.Component;
import org.apache.camel.Consumer;
import org.apache.camel.Endpoint;
-import org.apache.camel.ErrorHandlerFactory;
import org.apache.camel.NamedNode;
import org.apache.camel.Processor;
import org.apache.camel.Producer;
@@ -46,10 +45,6 @@ public interface ManagementObjectStrategy {
Object getManagedObjectForEndpoint(CamelContext context, Endpoint endpoint);
- Object getManagedObjectForErrorHandler(
- CamelContext context, Route route,
- Processor errorHandler, ErrorHandlerFactory errorHandlerBuilder);
-
Object getManagedObjectForRouteController(CamelContext context, RouteController routeController);
Object getManagedObjectForRoute(CamelContext context, Route route);
diff --git a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultRoute.java b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultRoute.java
index beb92c1..0c5e2d0 100644
--- a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultRoute.java
+++ b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultRoute.java
@@ -82,9 +82,12 @@ public class DefaultRoute extends ServiceSupport implements Route {
private ShutdownRunningTask shutdownRunningTask;
private final Map<String, Processor> onCompletions = new HashMap<>();
private final Map<String, Processor> onExceptions = new HashMap<>();
+
+ // camel-core-model
private ErrorHandlerFactory errorHandlerFactory;
- // must be concurrent as error handlers can be mutated concurrently via multicast/recipientlist EIPs
+ // camel-core-model: must be concurrent as error handlers can be mutated concurrently via multicast/recipientlist EIPs
private final ConcurrentMap<ErrorHandlerFactory, Set<NamedNode>> errorHandlers = new ConcurrentHashMap<>();
+
private final Endpoint endpoint;
private final Map<String, Object> properties = new HashMap<>();
private final List<Service> services = new ArrayList<>();
@@ -229,14 +232,17 @@ public class DefaultRoute extends ServiceSupport implements Route {
this.startupOrder = startupOrder;
}
+ @Override
public RouteController getRouteController() {
return routeController;
}
+ @Override
public void setRouteController(RouteController routeController) {
this.routeController = routeController;
}
+ @Override
public Boolean isAutoStartup() {
return autoStartup;
}
@@ -254,6 +260,8 @@ public class DefaultRoute extends ServiceSupport implements Route {
@Override
public void clearRouteModel() {
route = null;
+ errorHandlerFactory = null;
+ errorHandlers.clear();
}
@Override
@@ -266,6 +274,7 @@ public class DefaultRoute extends ServiceSupport implements Route {
return routeDescription;
}
+ @Override
public List<Processor> getEventDrivenProcessors() {
return eventDrivenProcessors;
}
diff --git a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/RouteService.java b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/RouteService.java
index cb9aab0..a26a7b5 100644
--- a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/RouteService.java
+++ b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/RouteService.java
@@ -31,7 +31,6 @@ import org.apache.camel.Channel;
import org.apache.camel.Consumer;
import org.apache.camel.Endpoint;
import org.apache.camel.EndpointAware;
-import org.apache.camel.ErrorHandlerFactory;
import org.apache.camel.ExtendedCamelContext;
import org.apache.camel.FailedToStartRouteException;
import org.apache.camel.Processor;
@@ -39,7 +38,6 @@ import org.apache.camel.Route;
import org.apache.camel.RouteAware;
import org.apache.camel.RuntimeCamelException;
import org.apache.camel.Service;
-import org.apache.camel.spi.ErrorHandler;
import org.apache.camel.spi.LifecycleStrategy;
import org.apache.camel.spi.RouteIdAware;
import org.apache.camel.spi.RoutePolicy;
@@ -337,16 +335,8 @@ public class RouteService extends ChildServiceSupport {
protected void stopChildService(Route route, Set<Service> services, boolean shutdown) {
for (Service service : services) {
- if (service instanceof ErrorHandler) {
- // special for error handlers
- for (LifecycleStrategy strategy : camelContext.getLifecycleStrategies()) {
- ErrorHandlerFactory errorHandlerFactory = route.getErrorHandlerFactory();
- strategy.onErrorHandlerRemove(route, (Processor) service, errorHandlerFactory);
- }
- } else {
- for (LifecycleStrategy strategy : camelContext.getLifecycleStrategies()) {
- strategy.onServiceRemove(camelContext, service, route);
- }
+ for (LifecycleStrategy strategy : camelContext.getLifecycleStrategies()) {
+ strategy.onServiceRemove(camelContext, service, route);
}
if (shutdown) {
ServiceHelper.stopAndShutdownService(service);
diff --git a/core/camel-core-model/src/main/java/org/apache/camel/builder/DeadLetterChannelBuilder.java b/core/camel-core-model/src/main/java/org/apache/camel/builder/DeadLetterChannelBuilder.java
index 069f88b..e7c10f9 100644
--- a/core/camel-core-model/src/main/java/org/apache/camel/builder/DeadLetterChannelBuilder.java
+++ b/core/camel-core-model/src/main/java/org/apache/camel/builder/DeadLetterChannelBuilder.java
@@ -19,6 +19,8 @@ package org.apache.camel.builder;
import org.apache.camel.Endpoint;
import org.apache.camel.LoggingLevel;
import org.apache.camel.model.errorhandler.DeadLetterChannelConfiguration;
+import org.apache.camel.model.errorhandler.DeadLetterChannelProperties;
+import org.apache.camel.model.errorhandler.DefaultErrorHandlerConfiguration;
import org.apache.camel.processor.errorhandler.DeadLetterChannel;
import org.apache.camel.spi.CamelLogger;
import org.slf4j.LoggerFactory;
@@ -26,7 +28,7 @@ import org.slf4j.LoggerFactory;
/**
* A builder of a <a href="http://camel.apache.org/dead-letter-channel.html">Dead Letter Channel</a>
*/
-public class DeadLetterChannelBuilder extends DefaultErrorHandlerBuilder implements DeadLetterChannelConfiguration {
+public class DeadLetterChannelBuilder extends DefaultErrorHandlerBuilder implements DeadLetterChannelProperties {
public DeadLetterChannelBuilder() {
// no-arg constructor used by Spring DSL
@@ -43,6 +45,11 @@ public class DeadLetterChannelBuilder extends DefaultErrorHandlerBuilder impleme
}
@Override
+ DefaultErrorHandlerConfiguration createConfiguration() {
+ return new DeadLetterChannelConfiguration();
+ }
+
+ @Override
public ErrorHandlerBuilder cloneBuilder() {
DeadLetterChannelBuilder answer = new DeadLetterChannelBuilder();
super.cloneBuilder(answer);
@@ -59,6 +66,6 @@ public class DeadLetterChannelBuilder extends DefaultErrorHandlerBuilder impleme
@Override
public String toString() {
- return "DeadLetterChannelBuilder(" + deadLetterUri + ")";
+ return "DeadLetterChannelBuilder(" + getDeadLetterUri() + ")";
}
}
diff --git a/core/camel-core-model/src/main/java/org/apache/camel/builder/DefaultErrorHandlerBuilder.java b/core/camel-core-model/src/main/java/org/apache/camel/builder/DefaultErrorHandlerBuilder.java
index 68d30ef..45dcbfc 100644
--- a/core/camel-core-model/src/main/java/org/apache/camel/builder/DefaultErrorHandlerBuilder.java
+++ b/core/camel-core-model/src/main/java/org/apache/camel/builder/DefaultErrorHandlerBuilder.java
@@ -24,6 +24,7 @@ import org.apache.camel.LoggingLevel;
import org.apache.camel.Predicate;
import org.apache.camel.Processor;
import org.apache.camel.model.errorhandler.DefaultErrorHandlerConfiguration;
+import org.apache.camel.model.errorhandler.DefaultErrorHandlerProperties;
import org.apache.camel.processor.errorhandler.DefaultErrorHandler;
import org.apache.camel.processor.errorhandler.RedeliveryPolicy;
import org.apache.camel.spi.CamelLogger;
@@ -34,27 +35,16 @@ import org.slf4j.LoggerFactory;
/**
* The default error handler builder.
*/
-public class DefaultErrorHandlerBuilder extends ErrorHandlerBuilderSupport implements DefaultErrorHandlerConfiguration {
-
- protected CamelLogger logger;
- protected RedeliveryPolicy redeliveryPolicy;
- protected Processor onRedelivery;
- protected String onRedeliveryRef;
- protected Predicate retryWhile;
- protected String retryWhileRef;
- protected String deadLetterUri;
- protected boolean deadLetterHandleNewException = true;
- protected boolean useOriginalMessage;
- protected boolean useOriginalBody;
- protected boolean asyncDelayedRedelivery;
- protected ScheduledExecutorService executorService;
- protected String executorServiceRef;
- protected Processor onPrepareFailure;
- protected String onPrepareFailureRef;
- protected Processor onExceptionOccurred;
- protected String onExceptionOccurredRef;
+public class DefaultErrorHandlerBuilder extends ErrorHandlerBuilderSupport implements DefaultErrorHandlerProperties {
+
+ private final DefaultErrorHandlerConfiguration configuration;
public DefaultErrorHandlerBuilder() {
+ configuration = createConfiguration();
+ }
+
+ DefaultErrorHandlerConfiguration createConfiguration() {
+ return new DefaultErrorHandlerConfiguration();
}
@Override
@@ -70,26 +60,24 @@ public class DefaultErrorHandlerBuilder extends ErrorHandlerBuilderSupport imple
}
protected void cloneBuilder(DefaultErrorHandlerBuilder other) {
- super.cloneBuilder(other);
-
- other.logger = logger;
- if (redeliveryPolicy != null) {
- other.redeliveryPolicy = redeliveryPolicy.copy();
+ other.setLogger(configuration.getLogger());
+ if (configuration.getRedeliveryPolicy() != null) {
+ other.setRedeliveryPolicy(configuration.getRedeliveryPolicy().copy());
}
- other.setOnRedelivery(onRedelivery);
- other.setOnRedeliveryRef(onRedeliveryRef);
- other.setRetryWhile(retryWhile);
- other.setRetryWhileRef(retryWhileRef);
- other.setDeadLetterUri(deadLetterUri);
- other.setOnPrepareFailure(onPrepareFailure);
- other.setOnPrepareFailureRef(onPrepareFailureRef);
- other.setOnExceptionOccurred(onExceptionOccurred);
- other.setOnExceptionOccurredRef(onExceptionOccurredRef);
- other.setDeadLetterHandleNewException(deadLetterHandleNewException);
- other.setUseOriginalMessage(useOriginalMessage);
- other.setUseOriginalBody(useOriginalBody);
- other.setAsyncDelayedRedelivery(asyncDelayedRedelivery);
- other.setExecutorServiceRef(executorServiceRef);
+ other.setOnRedelivery(configuration.getOnRedelivery());
+ other.setOnRedeliveryRef(configuration.getOnRedeliveryRef());
+ other.setRetryWhile(configuration.getRetryWhile());
+ other.setRetryWhileRef(configuration.getRetryWhileRef());
+ other.setDeadLetterUri(configuration.getDeadLetterUri());
+ other.setOnPrepareFailure(configuration.getOnPrepareFailure());
+ other.setOnPrepareFailureRef(configuration.getOnPrepareFailureRef());
+ other.setOnExceptionOccurred(configuration.getOnExceptionOccurred());
+ other.setOnExceptionOccurredRef(configuration.getOnExceptionOccurredRef());
+ other.setDeadLetterHandleNewException(configuration.isDeadLetterHandleNewException());
+ other.setUseOriginalMessage(configuration.isUseOriginalMessage());
+ other.setUseOriginalBody(configuration.isUseOriginalBody());
+ other.setAsyncDelayedRedelivery(configuration.isAsyncDelayedRedelivery());
+ other.setExecutorServiceRef(configuration.getExecutorServiceRef());
}
// Builder methods
@@ -490,7 +478,7 @@ public class DefaultErrorHandlerBuilder extends ErrorHandlerBuilderSupport imple
@Override
public boolean hasRedeliveryPolicy() {
- return redeliveryPolicy != null;
+ return configuration.getRedeliveryPolicy() != null;
}
@Override
@@ -499,49 +487,49 @@ public class DefaultErrorHandlerBuilder extends ErrorHandlerBuilderSupport imple
}
public RedeliveryPolicy getRedeliveryPolicy() {
- if (redeliveryPolicy == null) {
- redeliveryPolicy = createRedeliveryPolicy();
+ if (configuration.getRedeliveryPolicy() == null) {
+ configuration.setRedeliveryPolicy(createRedeliveryPolicy());
}
- return redeliveryPolicy;
+ return configuration.getRedeliveryPolicy();
}
/**
* Sets the redelivery policy
*/
public void setRedeliveryPolicy(RedeliveryPolicy redeliveryPolicy) {
- this.redeliveryPolicy = redeliveryPolicy;
+ configuration.setRedeliveryPolicy(redeliveryPolicy);
}
@Override
public boolean hasLogger() {
- return logger != null;
+ return configuration.hasLogger();
}
public CamelLogger getLogger() {
- if (logger == null) {
- logger = createLogger();
+ if (configuration.getLogger() == null) {
+ configuration.setLogger(createLogger());
}
- return logger;
+ return configuration.getLogger();
}
public void setLogger(CamelLogger logger) {
- this.logger = logger;
+ configuration.setLogger(logger);
}
public Processor getOnRedelivery() {
- return onRedelivery;
+ return configuration.getOnRedelivery();
}
public void setOnRedelivery(Processor onRedelivery) {
- this.onRedelivery = onRedelivery;
+ configuration.setOnRedelivery(onRedelivery);
}
public String getOnRedeliveryRef() {
- return onRedeliveryRef;
+ return configuration.getOnRedeliveryRef();
}
public void setOnRedeliveryRef(String onRedeliveryRef) {
- this.onRedeliveryRef = onRedeliveryRef;
+ configuration.setOnRedeliveryRef(onRedeliveryRef);
}
public Predicate getRetryWhilePolicy(CamelContext context) {
@@ -557,107 +545,107 @@ public class DefaultErrorHandlerBuilder extends ErrorHandlerBuilderSupport imple
}
public Predicate getRetryWhile() {
- return retryWhile;
+ return configuration.getRetryWhile();
}
public void setRetryWhile(Predicate retryWhile) {
- this.retryWhile = retryWhile;
+ configuration.setRetryWhile(retryWhile);
}
public String getRetryWhileRef() {
- return retryWhileRef;
+ return configuration.getRetryWhileRef();
}
public void setRetryWhileRef(String retryWhileRef) {
- this.retryWhileRef = retryWhileRef;
+ configuration.setRetryWhileRef(retryWhileRef);
}
public String getDeadLetterUri() {
- return deadLetterUri;
+ return configuration.getDeadLetterUri();
}
public void setDeadLetterUri(String deadLetterUri) {
- this.deadLetterUri = deadLetterUri;
+ configuration.setDeadLetterUri(deadLetterUri);
}
public boolean isDeadLetterHandleNewException() {
- return deadLetterHandleNewException;
+ return configuration.isDeadLetterHandleNewException();
}
public void setDeadLetterHandleNewException(boolean deadLetterHandleNewException) {
- this.deadLetterHandleNewException = deadLetterHandleNewException;
+ configuration.setDeadLetterHandleNewException(deadLetterHandleNewException);
}
public boolean isUseOriginalMessage() {
- return useOriginalMessage;
+ return configuration.isUseOriginalMessage();
}
public void setUseOriginalMessage(boolean useOriginalMessage) {
- this.useOriginalMessage = useOriginalMessage;
+ configuration.setUseOriginalMessage(useOriginalMessage);
}
public boolean isUseOriginalBody() {
- return useOriginalBody;
+ return configuration.isUseOriginalBody();
}
public void setUseOriginalBody(boolean useOriginalBody) {
- this.useOriginalBody = useOriginalBody;
+ configuration.setUseOriginalBody(useOriginalBody);
}
public boolean isAsyncDelayedRedelivery() {
- return asyncDelayedRedelivery;
+ return configuration.isAsyncDelayedRedelivery();
}
public void setAsyncDelayedRedelivery(boolean asyncDelayedRedelivery) {
- this.asyncDelayedRedelivery = asyncDelayedRedelivery;
+ configuration.setAsyncDelayedRedelivery(asyncDelayedRedelivery);
}
public ScheduledExecutorService getExecutorService() {
- return executorService;
+ return configuration.getExecutorService();
}
public void setExecutorService(ScheduledExecutorService executorService) {
- this.executorService = executorService;
+ configuration.setExecutorService(executorService);
}
public String getExecutorServiceRef() {
- return executorServiceRef;
+ return configuration.getExecutorServiceRef();
}
public void setExecutorServiceRef(String executorServiceRef) {
- this.executorServiceRef = executorServiceRef;
+ configuration.setExecutorServiceRef(executorServiceRef);
}
public Processor getOnPrepareFailure() {
- return onPrepareFailure;
+ return configuration.getOnPrepareFailure();
}
public void setOnPrepareFailure(Processor onPrepareFailure) {
- this.onPrepareFailure = onPrepareFailure;
+ configuration.setOnPrepareFailure(onPrepareFailure);
}
public String getOnPrepareFailureRef() {
- return onPrepareFailureRef;
+ return configuration.getOnPrepareFailureRef();
}
public void setOnPrepareFailureRef(String onPrepareFailureRef) {
- this.onPrepareFailureRef = onPrepareFailureRef;
+ configuration.setOnPrepareFailureRef(onPrepareFailureRef);
}
public Processor getOnExceptionOccurred() {
- return onExceptionOccurred;
+ return configuration.getOnExceptionOccurred();
}
public void setOnExceptionOccurred(Processor onExceptionOccurred) {
- this.onExceptionOccurred = onExceptionOccurred;
+ configuration.setOnExceptionOccurred(onExceptionOccurred);
}
public String getOnExceptionOccurredRef() {
- return onExceptionOccurredRef;
+ return configuration.getOnExceptionOccurredRef();
}
public void setOnExceptionOccurredRef(String onExceptionOccurredRef) {
- this.onExceptionOccurredRef = onExceptionOccurredRef;
+ configuration.setOnExceptionOccurredRef(onExceptionOccurredRef);
}
protected RedeliveryPolicy createRedeliveryPolicy() {
diff --git a/core/camel-core-model/src/main/java/org/apache/camel/builder/ErrorHandlerBuilderRef.java b/core/camel-core-model/src/main/java/org/apache/camel/builder/ErrorHandlerBuilderRef.java
index e68f7c2..a89433e 100644
--- a/core/camel-core-model/src/main/java/org/apache/camel/builder/ErrorHandlerBuilderRef.java
+++ b/core/camel-core-model/src/main/java/org/apache/camel/builder/ErrorHandlerBuilderRef.java
@@ -17,62 +17,58 @@
package org.apache.camel.builder;
import org.apache.camel.model.errorhandler.ErrorHandlerRefConfiguration;
+import org.apache.camel.model.errorhandler.ErrorHandlerRefProperties;
/**
* Represents a proxy to an error handler builder which is resolved by named reference
*/
-public class ErrorHandlerBuilderRef extends ErrorHandlerBuilderSupport implements ErrorHandlerRefConfiguration {
+public class ErrorHandlerBuilderRef extends ErrorHandlerBuilderSupport implements ErrorHandlerRefProperties {
- public static final String DEFAULT_ERROR_HANDLER_BUILDER = ErrorHandlerRefConfiguration.DEFAULT_ERROR_HANDLER_BUILDER;
+ public static final String DEFAULT_ERROR_HANDLER_BUILDER = ErrorHandlerRefProperties.DEFAULT_ERROR_HANDLER_BUILDER;
- private String ref;
- private boolean supportTransacted;
+ private final ErrorHandlerRefConfiguration configuration = new ErrorHandlerRefConfiguration();
public ErrorHandlerBuilderRef(String ref) {
- this.ref = ref;
+ this.configuration.setRef(ref);
}
@Override
public boolean supportTransacted() {
- return supportTransacted;
+ return configuration.isSupportTransacted();
}
@Override
public ErrorHandlerBuilder cloneBuilder() {
- ErrorHandlerBuilderRef answer = new ErrorHandlerBuilderRef(ref);
+ ErrorHandlerBuilderRef answer = new ErrorHandlerBuilderRef(configuration.getRef());
cloneBuilder(answer);
return answer;
}
protected void cloneBuilder(ErrorHandlerBuilderRef other) {
- super.cloneBuilder(other);
-
- // no need to copy the handlers
-
- other.supportTransacted = supportTransacted;
+ other.setSupportTransacted(configuration.isSupportTransacted());
}
public String getRef() {
- return ref;
+ return configuration.getRef();
}
@Override
public void setRef(String ref) {
- this.ref = ref;
+ configuration.setRef(ref);
}
@Override
public boolean isSupportTransacted() {
- return supportTransacted;
+ return configuration.isSupportTransacted();
}
@Override
public void setSupportTransacted(boolean supportTransacted) {
- this.supportTransacted = supportTransacted;
+ configuration.setSupportTransacted(supportTransacted);
}
@Override
public String toString() {
- return "ErrorHandlerBuilderRef[" + ref + "]";
+ return "ErrorHandlerBuilderRef[" + configuration.getRef() + "]";
}
}
diff --git a/core/camel-core-model/src/main/java/org/apache/camel/builder/ErrorHandlerBuilderSupport.java b/core/camel-core-model/src/main/java/org/apache/camel/builder/ErrorHandlerBuilderSupport.java
index 654235f..07122de 100644
--- a/core/camel-core-model/src/main/java/org/apache/camel/builder/ErrorHandlerBuilderSupport.java
+++ b/core/camel-core-model/src/main/java/org/apache/camel/builder/ErrorHandlerBuilderSupport.java
@@ -16,67 +16,14 @@
*/
package org.apache.camel.builder;
-import org.apache.camel.processor.errorhandler.ExceptionPolicyStrategy;
-import org.apache.camel.util.ObjectHelper;
-
/**
* Base class for builders of error handling.
*/
public abstract class ErrorHandlerBuilderSupport implements ErrorHandlerBuilder {
- private ExceptionPolicyStrategy exceptionPolicyStrategy;
- private String exceptionPolicyStrategyRef;
@Override
public boolean supportTransacted() {
return false;
}
- protected void cloneBuilder(ErrorHandlerBuilderSupport other) {
- other.exceptionPolicyStrategy = exceptionPolicyStrategy;
- other.exceptionPolicyStrategyRef = exceptionPolicyStrategyRef;
- }
-
- /**
- * Sets the exception policy to use
- */
- public ErrorHandlerBuilderSupport exceptionPolicyStrategy(ExceptionPolicyStrategy exceptionPolicyStrategy) {
- setExceptionPolicyStrategy(exceptionPolicyStrategy);
- return this;
- }
-
- /**
- * Sets the exception policy to use
- */
- public ErrorHandlerBuilderSupport exceptionPolicyStrategy(String exceptionPolicyStrategyRef) {
- setExceptionPolicyStrategyRef(exceptionPolicyStrategyRef);
- return this;
- }
-
- /**
- * Gets the exception policy strategy
- */
- public ExceptionPolicyStrategy getExceptionPolicyStrategy() {
- return exceptionPolicyStrategy;
- }
-
- /**
- * Sets the exception policy strategy to use for resolving the {@link org.apache.camel.model.OnExceptionDefinition}
- * to use for a given thrown exception
- *
- * @param exceptionPolicyStrategy the exception policy strategy
- */
- public void setExceptionPolicyStrategy(ExceptionPolicyStrategy exceptionPolicyStrategy) {
- ObjectHelper.notNull(exceptionPolicyStrategy, "ExceptionPolicyStrategy");
- this.exceptionPolicyStrategy = exceptionPolicyStrategy;
- }
-
- public String getExceptionPolicyStrategyRef() {
- return exceptionPolicyStrategyRef;
- }
-
- public void setExceptionPolicyStrategyRef(String exceptionPolicyStrategyRef) {
- ObjectHelper.notNull(exceptionPolicyStrategyRef, "ExceptionPolicyStrategyRef");
- this.exceptionPolicyStrategyRef = exceptionPolicyStrategyRef;
- }
-
}
diff --git a/core/camel-core-model/src/main/java/org/apache/camel/builder/NoErrorHandlerBuilder.java b/core/camel-core-model/src/main/java/org/apache/camel/builder/NoErrorHandlerBuilder.java
index 64b9b37..f1ee293 100644
--- a/core/camel-core-model/src/main/java/org/apache/camel/builder/NoErrorHandlerBuilder.java
+++ b/core/camel-core-model/src/main/java/org/apache/camel/builder/NoErrorHandlerBuilder.java
@@ -17,7 +17,7 @@
package org.apache.camel.builder;
import org.apache.camel.Processor;
-import org.apache.camel.model.errorhandler.NoErrorHandlerConfiguraiton;
+import org.apache.camel.model.errorhandler.NoErrorHandlerProperties;
/**
* A builder to disable the use of an error handler so that any exceptions are thrown. This not recommended in general,
@@ -25,7 +25,7 @@ import org.apache.camel.model.errorhandler.NoErrorHandlerConfiguraiton;
* unsure; however it can be useful sometimes to disable an error handler inside a complex route so that exceptions
* bubble up to the parent {@link Processor}
*/
-public class NoErrorHandlerBuilder extends ErrorHandlerBuilderSupport implements NoErrorHandlerConfiguraiton {
+public class NoErrorHandlerBuilder extends ErrorHandlerBuilderSupport implements NoErrorHandlerProperties {
@Override
public boolean supportTransacted() {
@@ -34,8 +34,6 @@ public class NoErrorHandlerBuilder extends ErrorHandlerBuilderSupport implements
@Override
public ErrorHandlerBuilder cloneBuilder() {
- NoErrorHandlerBuilder answer = new NoErrorHandlerBuilder();
- cloneBuilder(answer);
- return answer;
+ return new NoErrorHandlerBuilder();
}
}
diff --git a/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/DeadLetterChannelConfiguration.java b/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/DeadLetterChannelConfiguration.java
index e60f1d6..e3aee85 100644
--- a/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/DeadLetterChannelConfiguration.java
+++ b/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/DeadLetterChannelConfiguration.java
@@ -1,28 +1,27 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
package org.apache.camel.model.errorhandler;
+import javax.xml.bind.annotation.XmlTransient;
+
import org.apache.camel.CamelContext;
import org.apache.camel.Predicate;
+import org.apache.camel.spi.Language;
-public interface DeadLetterChannelConfiguration extends DefaultErrorHandlerConfiguration {
+@XmlTransient
+public class DeadLetterChannelConfiguration extends DefaultErrorHandlerConfiguration implements DeadLetterChannelProperties {
// has no additional configurations
- Predicate getRetryWhilePolicy(CamelContext context);
+ @Override
+ public Predicate getRetryWhilePolicy(CamelContext context) {
+ Predicate answer = getRetryWhile();
+
+ if (getRetryWhileRef() != null) {
+ // its a bean expression
+ Language bean = context.resolveLanguage("bean");
+ answer = bean.createPredicate(getRetryWhileRef());
+ }
+
+ return answer;
+ }
}
diff --git a/components/camel-spring/src/test/java/org/apache/camel/spring/management/SpringManagedErrorHandlerTest.java b/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/DeadLetterChannelProperties.java
similarity index 60%
rename from components/camel-spring/src/test/java/org/apache/camel/spring/management/SpringManagedErrorHandlerTest.java
rename to core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/DeadLetterChannelProperties.java
index 1cf1c44..8ce8e04 100644
--- a/components/camel-spring/src/test/java/org/apache/camel/spring/management/SpringManagedErrorHandlerTest.java
+++ b/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/DeadLetterChannelProperties.java
@@ -14,23 +14,15 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.apache.camel.spring.management;
+package org.apache.camel.model.errorhandler;
import org.apache.camel.CamelContext;
-import org.apache.camel.management.ManagedErrorHandlerTest;
+import org.apache.camel.Predicate;
-import static org.apache.camel.spring.processor.SpringTestHelper.createSpringCamelContext;
+public interface DeadLetterChannelProperties extends DefaultErrorHandlerProperties {
-public class SpringManagedErrorHandlerTest extends ManagedErrorHandlerTest {
+ // has no additional configurations
- @Override
- protected boolean useJmx() {
- return true;
- }
-
- @Override
- protected CamelContext createCamelContext() throws Exception {
- return createSpringCamelContext(this, "org/apache/camel/spring/management/SpringManagedErrorHandlerTest.xml");
- }
+ Predicate getRetryWhilePolicy(CamelContext context);
}
diff --git a/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/DefaultErrorHandlerConfiguration.java b/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/DefaultErrorHandlerConfiguration.java
index b7ca571..a28f22b 100644
--- a/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/DefaultErrorHandlerConfiguration.java
+++ b/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/DefaultErrorHandlerConfiguration.java
@@ -18,94 +18,182 @@ package org.apache.camel.model.errorhandler;
import java.util.concurrent.ScheduledExecutorService;
-import org.apache.camel.ErrorHandlerFactory;
+import javax.xml.bind.annotation.XmlTransient;
+
import org.apache.camel.Predicate;
import org.apache.camel.Processor;
-import org.apache.camel.processor.errorhandler.ExceptionPolicyStrategy;
import org.apache.camel.processor.errorhandler.RedeliveryPolicy;
import org.apache.camel.spi.CamelLogger;
-public interface DefaultErrorHandlerConfiguration extends ErrorHandlerFactory {
-
- ExceptionPolicyStrategy getExceptionPolicyStrategy();
-
- void setExceptionPolicyStrategy(ExceptionPolicyStrategy exceptionPolicyStrategy);
-
- String getExceptionPolicyStrategyRef();
-
- void setExceptionPolicyStrategyRef(String exceptionPolicyStrategyRef);
-
- boolean hasLogger();
-
- CamelLogger getLogger();
-
- void setLogger(CamelLogger logger);
-
- boolean hasRedeliveryPolicy();
-
- RedeliveryPolicy getRedeliveryPolicy();
-
- RedeliveryPolicy getDefaultRedeliveryPolicy();
-
- void setRedeliveryPolicy(RedeliveryPolicy redeliveryPolicy);
-
- Processor getOnRedelivery();
-
- void setOnRedelivery(Processor onRedelivery);
-
- String getOnRedeliveryRef();
-
- void setOnRedeliveryRef(String onRedeliveryRef);
-
- Predicate getRetryWhile();
-
- void setRetryWhile(Predicate retryWhile);
-
- String getRetryWhileRef();
-
- void setRetryWhileRef(String retryWhileRef);
-
- String getDeadLetterUri();
-
- void setDeadLetterUri(String deadLetterUri);
-
- boolean isDeadLetterHandleNewException();
-
- void setDeadLetterHandleNewException(boolean deadLetterHandleNewException);
-
- boolean isUseOriginalMessage();
-
- void setUseOriginalMessage(boolean useOriginalMessage);
-
- boolean isUseOriginalBody();
-
- void setUseOriginalBody(boolean useOriginalBody);
-
- boolean isAsyncDelayedRedelivery();
-
- void setAsyncDelayedRedelivery(boolean asyncDelayedRedelivery);
-
- ScheduledExecutorService getExecutorService();
-
- void setExecutorService(ScheduledExecutorService executorService);
-
- String getExecutorServiceRef();
-
- void setExecutorServiceRef(String executorServiceRef);
-
- Processor getOnPrepareFailure();
+@XmlTransient
+public class DefaultErrorHandlerConfiguration implements DefaultErrorHandlerProperties {
+
+ private CamelLogger logger;
+ private RedeliveryPolicy redeliveryPolicy;
+ private Processor onRedelivery;
+ private String onRedeliveryRef;
+ private Predicate retryWhile;
+ private String retryWhileRef;
+ private String deadLetterUri;
+ private boolean deadLetterHandleNewException = true;
+ private boolean useOriginalMessage;
+ private boolean useOriginalBody;
+ private boolean asyncDelayedRedelivery;
+ private ScheduledExecutorService executorService;
+ private String executorServiceRef;
+ private Processor onPrepareFailure;
+ private String onPrepareFailureRef;
+ private Processor onExceptionOccurred;
+ private String onExceptionOccurredRef;
+
+ @Override
+ public boolean hasLogger() {
+ return logger != null;
+ }
+
+ public CamelLogger getLogger() {
+ return logger;
+ }
+
+ public void setLogger(CamelLogger logger) {
+ this.logger = logger;
+ }
+
+ @Override
+ public RedeliveryPolicy getDefaultRedeliveryPolicy() {
+ return RedeliveryPolicy.DEFAULT_POLICY;
+ }
+
+ @Override
+ public boolean hasRedeliveryPolicy() {
+ return redeliveryPolicy != null;
+ }
+
+ public RedeliveryPolicy getRedeliveryPolicy() {
+ return redeliveryPolicy;
+ }
+
+ public void setRedeliveryPolicy(RedeliveryPolicy redeliveryPolicy) {
+ this.redeliveryPolicy = redeliveryPolicy;
+ }
+
+ public Processor getOnRedelivery() {
+ return onRedelivery;
+ }
+
+ public void setOnRedelivery(Processor onRedelivery) {
+ this.onRedelivery = onRedelivery;
+ }
+
+ public String getOnRedeliveryRef() {
+ return onRedeliveryRef;
+ }
+
+ public void setOnRedeliveryRef(String onRedeliveryRef) {
+ this.onRedeliveryRef = onRedeliveryRef;
+ }
+
+ public Predicate getRetryWhile() {
+ return retryWhile;
+ }
+
+ public void setRetryWhile(Predicate retryWhile) {
+ this.retryWhile = retryWhile;
+ }
+
+ public String getRetryWhileRef() {
+ return retryWhileRef;
+ }
+
+ public void setRetryWhileRef(String retryWhileRef) {
+ this.retryWhileRef = retryWhileRef;
+ }
+
+ public String getDeadLetterUri() {
+ return deadLetterUri;
+ }
+
+ public void setDeadLetterUri(String deadLetterUri) {
+ this.deadLetterUri = deadLetterUri;
+ }
+
+ public boolean isDeadLetterHandleNewException() {
+ return deadLetterHandleNewException;
+ }
+
+ public void setDeadLetterHandleNewException(boolean deadLetterHandleNewException) {
+ this.deadLetterHandleNewException = deadLetterHandleNewException;
+ }
+
+ public boolean isUseOriginalMessage() {
+ return useOriginalMessage;
+ }
+
+ public void setUseOriginalMessage(boolean useOriginalMessage) {
+ this.useOriginalMessage = useOriginalMessage;
+ }
+
+ public boolean isUseOriginalBody() {
+ return useOriginalBody;
+ }
+
+ public void setUseOriginalBody(boolean useOriginalBody) {
+ this.useOriginalBody = useOriginalBody;
+ }
+
+ public boolean isAsyncDelayedRedelivery() {
+ return asyncDelayedRedelivery;
+ }
+
+ public void setAsyncDelayedRedelivery(boolean asyncDelayedRedelivery) {
+ this.asyncDelayedRedelivery = asyncDelayedRedelivery;
+ }
+
+ public ScheduledExecutorService getExecutorService() {
+ return executorService;
+ }
+
+ public void setExecutorService(ScheduledExecutorService executorService) {
+ this.executorService = executorService;
+ }
+
+ public String getExecutorServiceRef() {
+ return executorServiceRef;
+ }
+
+ public void setExecutorServiceRef(String executorServiceRef) {
+ this.executorServiceRef = executorServiceRef;
+ }
+
+ public Processor getOnPrepareFailure() {
+ return onPrepareFailure;
+ }
- void setOnPrepareFailure(Processor onPrepareFailure);
+ public void setOnPrepareFailure(Processor onPrepareFailure) {
+ this.onPrepareFailure = onPrepareFailure;
+ }
- String getOnPrepareFailureRef();
+ public String getOnPrepareFailureRef() {
+ return onPrepareFailureRef;
+ }
- void setOnPrepareFailureRef(String onPrepareFailureRef);
+ public void setOnPrepareFailureRef(String onPrepareFailureRef) {
+ this.onPrepareFailureRef = onPrepareFailureRef;
+ }
- Processor getOnExceptionOccurred();
+ public Processor getOnExceptionOccurred() {
+ return onExceptionOccurred;
+ }
- void setOnExceptionOccurred(Processor onExceptionOccurred);
+ public void setOnExceptionOccurred(Processor onExceptionOccurred) {
+ this.onExceptionOccurred = onExceptionOccurred;
+ }
- String getOnExceptionOccurredRef();
+ public String getOnExceptionOccurredRef() {
+ return onExceptionOccurredRef;
+ }
- void setOnExceptionOccurredRef(String onExceptionOccurredRef);
+ public void setOnExceptionOccurredRef(String onExceptionOccurredRef) {
+ this.onExceptionOccurredRef = onExceptionOccurredRef;
+ }
}
diff --git a/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/DefaultErrorHandlerConfiguration.java b/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/DefaultErrorHandlerProperties.java
similarity index 87%
copy from core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/DefaultErrorHandlerConfiguration.java
copy to core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/DefaultErrorHandlerProperties.java
index b7ca571..4688c8c 100644
--- a/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/DefaultErrorHandlerConfiguration.java
+++ b/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/DefaultErrorHandlerProperties.java
@@ -21,19 +21,10 @@ import java.util.concurrent.ScheduledExecutorService;
import org.apache.camel.ErrorHandlerFactory;
import org.apache.camel.Predicate;
import org.apache.camel.Processor;
-import org.apache.camel.processor.errorhandler.ExceptionPolicyStrategy;
import org.apache.camel.processor.errorhandler.RedeliveryPolicy;
import org.apache.camel.spi.CamelLogger;
-public interface DefaultErrorHandlerConfiguration extends ErrorHandlerFactory {
-
- ExceptionPolicyStrategy getExceptionPolicyStrategy();
-
- void setExceptionPolicyStrategy(ExceptionPolicyStrategy exceptionPolicyStrategy);
-
- String getExceptionPolicyStrategyRef();
-
- void setExceptionPolicyStrategyRef(String exceptionPolicyStrategyRef);
+public interface DefaultErrorHandlerProperties extends ErrorHandlerFactory {
boolean hasLogger();
diff --git a/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/ErrorHandlerHelper.java b/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/ErrorHandlerHelper.java
index 2ab9750..1642ff4 100644
--- a/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/ErrorHandlerHelper.java
+++ b/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/ErrorHandlerHelper.java
@@ -40,7 +40,8 @@ public final class ErrorHandlerHelper {
* @return the error handler
*/
public static ErrorHandlerFactory lookupErrorHandlerFactory(Route route, String ref, boolean mandatory) {
- ErrorHandlerFactory answer;
+ ErrorHandlerFactory source;
+ ErrorHandlerFactory answer = null;
CamelContext camelContext = route.getCamelContext();
// if the ref is the default then we do not have any explicit error
@@ -51,10 +52,10 @@ public final class ErrorHandlerHelper {
// so we should use that one
if (!isErrorHandlerFactoryConfigured(ref)) {
// see if there has been configured a error handler builder on the route
- answer = route.getErrorHandlerFactory();
+ source = route.getErrorHandlerFactory();
// check if its also a ref with no error handler configuration like me
- if (answer instanceof ErrorHandlerRefConfiguration) {
- ErrorHandlerRefConfiguration other = (ErrorHandlerRefConfiguration) answer;
+ if (source instanceof ErrorHandlerRefProperties) {
+ ErrorHandlerRefProperties other = (ErrorHandlerRefProperties) source;
String otherRef = other.getRef();
if (!isErrorHandlerFactoryConfigured(otherRef)) {
// the other has also no explicit error handler configured
@@ -73,7 +74,7 @@ public final class ErrorHandlerHelper {
// shared
// this is needed by camel-spring when none error handler has
// been explicit configured
- route.addErrorHandlerFactoryReference(other, answer);
+ route.addErrorHandlerFactoryReference(source, answer);
}
} else {
// use specific configured error handler
@@ -89,8 +90,8 @@ public final class ErrorHandlerHelper {
protected static ErrorHandlerFactory lookupErrorHandlerFactory(CamelContext camelContext) {
ErrorHandlerFactory answer = camelContext.adapt(ExtendedCamelContext.class).getErrorHandlerFactory();
- if (answer instanceof ErrorHandlerRefConfiguration) {
- ErrorHandlerRefConfiguration other = (ErrorHandlerRefConfiguration) answer;
+ if (answer instanceof ErrorHandlerRefProperties) {
+ ErrorHandlerRefProperties other = (ErrorHandlerRefProperties) answer;
String otherRef = other.getRef();
if (isErrorHandlerFactoryConfigured(otherRef)) {
answer = CamelContextHelper.lookup(camelContext, otherRef, ErrorHandlerFactory.class);
@@ -111,7 +112,7 @@ public final class ErrorHandlerHelper {
* This is for instance used by the transacted policy to setup a TransactedErrorHandlerBuilder in camel-spring.
*/
public static boolean isErrorHandlerFactoryConfigured(String ref) {
- return !ErrorHandlerRefConfiguration.DEFAULT_ERROR_HANDLER_BUILDER.equals(ref);
+ return !ErrorHandlerRefProperties.DEFAULT_ERROR_HANDLER_BUILDER.equals(ref);
}
}
diff --git a/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/ErrorHandlerRefConfiguration.java b/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/ErrorHandlerRefConfiguration.java
index 274f266..c1abd2c 100644
--- a/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/ErrorHandlerRefConfiguration.java
+++ b/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/ErrorHandlerRefConfiguration.java
@@ -16,17 +16,31 @@
*/
package org.apache.camel.model.errorhandler;
-import org.apache.camel.ErrorHandlerFactory;
+import javax.xml.bind.annotation.XmlTransient;
-public interface ErrorHandlerRefConfiguration extends ErrorHandlerFactory {
+@XmlTransient
+public class ErrorHandlerRefConfiguration implements ErrorHandlerRefProperties {
- String DEFAULT_ERROR_HANDLER_BUILDER = "CamelDefaultErrorHandlerBuilder";
+ private String ref;
+ private boolean supportTransacted;
- String getRef();
+ @Override
+ public String getRef() {
+ return ref;
+ }
- void setRef(String ref);
+ @Override
+ public void setRef(String ref) {
+ this.ref = ref;
+ }
- boolean isSupportTransacted();
+ @Override
+ public boolean isSupportTransacted() {
+ return supportTransacted;
+ }
- void setSupportTransacted(boolean supportTransacted);
+ @Override
+ public void setSupportTransacted(boolean supportTransacted) {
+ this.supportTransacted = supportTransacted;
+ }
}
diff --git a/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/ErrorHandlerRefConfiguration.java b/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/ErrorHandlerRefProperties.java
similarity index 93%
copy from core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/ErrorHandlerRefConfiguration.java
copy to core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/ErrorHandlerRefProperties.java
index 274f266..d9ce780 100644
--- a/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/ErrorHandlerRefConfiguration.java
+++ b/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/ErrorHandlerRefProperties.java
@@ -18,7 +18,7 @@ package org.apache.camel.model.errorhandler;
import org.apache.camel.ErrorHandlerFactory;
-public interface ErrorHandlerRefConfiguration extends ErrorHandlerFactory {
+public interface ErrorHandlerRefProperties extends ErrorHandlerFactory {
String DEFAULT_ERROR_HANDLER_BUILDER = "CamelDefaultErrorHandlerBuilder";
diff --git a/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/NoErrorHandlerConfiguraiton.java b/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/NoErrorHandlerConfiguration.java
similarity index 82%
copy from core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/NoErrorHandlerConfiguraiton.java
copy to core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/NoErrorHandlerConfiguration.java
index f5ebfce..e37c39d 100644
--- a/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/NoErrorHandlerConfiguraiton.java
+++ b/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/NoErrorHandlerConfiguration.java
@@ -16,9 +16,12 @@
*/
package org.apache.camel.model.errorhandler;
-import org.apache.camel.ErrorHandlerFactory;
+// TODO: Maybe not needed
+// TODO: Maybe not needed
+import javax.xml.bind.annotation.XmlTransient;
-public interface NoErrorHandlerConfiguraiton extends ErrorHandlerFactory {
+@XmlTransient
+public class NoErrorHandlerConfiguration implements NoErrorHandlerProperties {
// no configuration
diff --git a/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/NoErrorHandlerConfiguraiton.java b/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/NoErrorHandlerProperties.java
similarity index 92%
rename from core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/NoErrorHandlerConfiguraiton.java
rename to core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/NoErrorHandlerProperties.java
index f5ebfce..babb993 100644
--- a/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/NoErrorHandlerConfiguraiton.java
+++ b/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/NoErrorHandlerProperties.java
@@ -18,7 +18,7 @@ package org.apache.camel.model.errorhandler;
import org.apache.camel.ErrorHandlerFactory;
-public interface NoErrorHandlerConfiguraiton extends ErrorHandlerFactory {
+public interface NoErrorHandlerProperties extends ErrorHandlerFactory {
// no configuration
diff --git a/core/camel-core-processor/src/main/java/org/apache/camel/processor/MulticastProcessor.java b/core/camel-core-processor/src/main/java/org/apache/camel/processor/MulticastProcessor.java
index a38c399..c8c4559 100644
--- a/core/camel-core-processor/src/main/java/org/apache/camel/processor/MulticastProcessor.java
+++ b/core/camel-core-processor/src/main/java/org/apache/camel/processor/MulticastProcessor.java
@@ -51,6 +51,8 @@ import org.apache.camel.Route;
import org.apache.camel.RuntimeCamelException;
import org.apache.camel.StreamCache;
import org.apache.camel.Traceable;
+import org.apache.camel.processor.errorhandler.ErrorHandlerSupport;
+import org.apache.camel.spi.ErrorHandlerAware;
import org.apache.camel.spi.IdAware;
import org.apache.camel.spi.InternalProcessorFactory;
import org.apache.camel.spi.ReactiveExecutor;
@@ -76,7 +78,8 @@ import static org.apache.camel.util.ObjectHelper.notNull;
* Implements the Multicast pattern to send a message exchange to a number of endpoints, each endpoint receiving a copy
* of the message exchange.
*/
-public class MulticastProcessor extends AsyncProcessorSupport implements Navigate<Processor>, Traceable, IdAware, RouteIdAware {
+public class MulticastProcessor extends AsyncProcessorSupport
+ implements Navigate<Processor>, Traceable, IdAware, RouteIdAware, ErrorHandlerAware {
private static final Logger LOG = LoggerFactory.getLogger(MulticastProcessor.class);
@@ -149,6 +152,7 @@ public class MulticastProcessor extends AsyncProcessorSupport implements Navigat
private final InternalProcessorFactory internalProcessorFactory;
private final Route route;
private final ReactiveExecutor reactiveExecutor;
+ private Processor errorHandler;
private String id;
private String routeId;
private Collection<Processor> processors;
@@ -237,6 +241,16 @@ public class MulticastProcessor extends AsyncProcessorSupport implements Navigat
}
@Override
+ public void setErrorHandler(Processor errorHandler) {
+ this.errorHandler = errorHandler;
+ }
+
+ @Override
+ public Processor getErrorHandler() {
+ return errorHandler;
+ }
+
+ @Override
public String getTraceLabel() {
return "multicast";
}
@@ -250,7 +264,7 @@ public class MulticastProcessor extends AsyncProcessorSupport implements Navigat
if (route != null) {
Exchange exchange = new DefaultExchange(getCamelContext());
for (Processor processor : getProcessors()) {
- createErrorHandler(route, exchange, processor);
+ wrapInErrorHandler(route, exchange, processor);
}
}
}
@@ -719,7 +733,7 @@ public class MulticastProcessor extends AsyncProcessorSupport implements Navigat
setToEndpoint(exchange, prepared);
// rework error handling to support fine grained error handling
- prepared = createErrorHandler(route, exchange, prepared);
+ prepared = wrapInErrorHandler(route, exchange, prepared);
// invoke on prepare on the exchange if specified
if (onPrepare != null) {
@@ -732,7 +746,7 @@ public class MulticastProcessor extends AsyncProcessorSupport implements Navigat
return new DefaultProcessorExchangePair(index, processor, prepared, exchange);
}
- protected Processor createErrorHandler(Route route, Exchange exchange, Processor processor) {
+ protected Processor wrapInErrorHandler(Route route, Exchange exchange, Processor processor) {
Processor answer;
if (route != this.route && this.route != null) {
@@ -759,7 +773,7 @@ public class MulticastProcessor extends AsyncProcessorSupport implements Navigat
LOG.trace("Creating error handler for: {}", processor);
try {
- processor = camelContext.adapt(ExtendedCamelContext.class).createErrorHandler(route, processor);
+ processor = wrapInErrorHandler(route, processor);
// and wrap in unit of work processor so the copy exchange also can run under UoW
answer = createUnitOfWorkProcessor(route, processor, exchange);
@@ -786,6 +800,15 @@ public class MulticastProcessor extends AsyncProcessorSupport implements Navigat
return answer;
}
+ private Processor wrapInErrorHandler(Route route, Processor processor) throws Exception {
+ // use the error handler from multicast and clone it to use the new processor as its output
+ if (errorHandler instanceof ErrorHandlerSupport) {
+ return ((ErrorHandlerSupport) errorHandler).clone(processor);
+ }
+ // fallback and use reifier to create the error handler
+ return camelContext.adapt(ExtendedCamelContext.class).createErrorHandler(route, processor);
+ }
+
/**
* Strategy to create the unit of work to be used for the sub route
*
diff --git a/core/camel-core-processor/src/main/java/org/apache/camel/processor/RecipientList.java b/core/camel-core-processor/src/main/java/org/apache/camel/processor/RecipientList.java
index a53392a..f64d50b 100644
--- a/core/camel-core-processor/src/main/java/org/apache/camel/processor/RecipientList.java
+++ b/core/camel-core-processor/src/main/java/org/apache/camel/processor/RecipientList.java
@@ -27,7 +27,9 @@ import org.apache.camel.Exchange;
import org.apache.camel.Expression;
import org.apache.camel.Processor;
import org.apache.camel.processor.aggregate.UseLatestAggregationStrategy;
+import org.apache.camel.processor.errorhandler.NoErrorHandler;
import org.apache.camel.spi.EndpointUtilizationStatistics;
+import org.apache.camel.spi.ErrorHandlerAware;
import org.apache.camel.spi.IdAware;
import org.apache.camel.spi.ProducerCache;
import org.apache.camel.spi.RouteIdAware;
@@ -46,7 +48,7 @@ import static org.apache.camel.util.ObjectHelper.notNull;
* Implements a dynamic <a href="http://camel.apache.org/recipient-list.html">Recipient List</a> pattern where the list
* of actual endpoints to send a message exchange to are dependent on some dynamic expression.
*/
-public class RecipientList extends AsyncProcessorSupport implements IdAware, RouteIdAware {
+public class RecipientList extends AsyncProcessorSupport implements IdAware, RouteIdAware, ErrorHandlerAware {
private static final Logger LOG = LoggerFactory.getLogger(RecipientList.class);
@@ -54,6 +56,7 @@ public class RecipientList extends AsyncProcessorSupport implements IdAware, Rou
private final CamelContext camelContext;
private String id;
private String routeId;
+ private Processor errorHandler;
private ProducerCache producerCache;
private Expression expression;
private final String delimiter;
@@ -157,6 +160,16 @@ public class RecipientList extends AsyncProcessorSupport implements IdAware, Rou
}
@Override
+ public void setErrorHandler(Processor errorHandler) {
+ this.errorHandler = errorHandler;
+ }
+
+ @Override
+ public Processor getErrorHandler() {
+ return errorHandler;
+ }
+
+ @Override
public boolean process(Exchange exchange, AsyncCallback callback) {
if (!isStarted()) {
throw new IllegalStateException("RecipientList has not been started: " + this);
@@ -189,6 +202,7 @@ public class RecipientList extends AsyncProcessorSupport implements IdAware, Rou
isParallelProcessing(), getExecutorService(), isShutdownExecutorService(),
isStreaming(), isStopOnException(), getTimeout(), getOnPrepare(), isShareUnitOfWork(), isParallelAggregate(),
isStopOnAggregateException());
+ rlp.setErrorHandler(errorHandler);
rlp.setAggregateExecutorService(aggregateExecutorService);
rlp.setIgnoreInvalidEndpoints(isIgnoreInvalidEndpoints());
rlp.setCacheSize(getCacheSize());
@@ -213,6 +227,14 @@ public class RecipientList extends AsyncProcessorSupport implements IdAware, Rou
}
@Override
+ protected void doInit() throws Exception {
+ if (errorHandler == null) {
+ // NoErrorHandler is the default base error handler if none has been configured
+ errorHandler = new NoErrorHandler(null);
+ }
+ }
+
+ @Override
protected void doStart() throws Exception {
if (producerCache == null) {
if (cacheSize < 0) {
diff --git a/core/camel-core-processor/src/main/java/org/apache/camel/processor/RecipientListProcessor.java b/core/camel-core-processor/src/main/java/org/apache/camel/processor/RecipientListProcessor.java
index 66aa62f..2f457ca 100644
--- a/core/camel-core-processor/src/main/java/org/apache/camel/processor/RecipientListProcessor.java
+++ b/core/camel-core-processor/src/main/java/org/apache/camel/processor/RecipientListProcessor.java
@@ -253,7 +253,7 @@ public class RecipientListProcessor extends MulticastProcessor {
// rework error handling to support fine grained error handling
Route route = ExchangeHelper.getRoute(exchange);
- Processor prepared = createErrorHandler(route, copy, producer);
+ Processor prepared = wrapInErrorHandler(route, copy, producer);
// invoke on prepare on the exchange if specified
if (onPrepare != null) {
diff --git a/core/camel-core-processor/src/main/java/org/apache/camel/processor/errorhandler/DeadLetterChannel.java b/core/camel-core-processor/src/main/java/org/apache/camel/processor/errorhandler/DeadLetterChannel.java
index f4ce08f..05b325b 100644
--- a/core/camel-core-processor/src/main/java/org/apache/camel/processor/errorhandler/DeadLetterChannel.java
+++ b/core/camel-core-processor/src/main/java/org/apache/camel/processor/errorhandler/DeadLetterChannel.java
@@ -23,6 +23,7 @@ import org.apache.camel.LoggingLevel;
import org.apache.camel.Predicate;
import org.apache.camel.Processor;
import org.apache.camel.spi.CamelLogger;
+import org.apache.camel.spi.ErrorHandler;
import org.slf4j.LoggerFactory;
/**
@@ -42,7 +43,6 @@ public class DeadLetterChannel extends RedeliveryErrorHandler {
* @param logger logger to use for logging failures and redelivery attempts
* @param redeliveryProcessor an optional processor to run before redelivery attempt
* @param redeliveryPolicy policy for redelivery
- * @param exceptionPolicyStrategy strategy for onException handling
* @param deadLetter the failure processor to send failed exchanges to
* @param deadLetterUri an optional uri for logging purpose
* @param deadLetterHandleException whether dead letter channel should handle (and ignore) exceptions which may
@@ -62,7 +62,7 @@ public class DeadLetterChannel extends RedeliveryErrorHandler {
*/
public DeadLetterChannel(CamelContext camelContext, Processor output, CamelLogger logger, Processor redeliveryProcessor,
RedeliveryPolicy redeliveryPolicy,
- ExceptionPolicyStrategy exceptionPolicyStrategy, Processor deadLetter, String deadLetterUri,
+ Processor deadLetter, String deadLetterUri,
boolean deadLetterHandleException,
boolean useOriginalMessagePolicy, boolean useOriginalBodyPolicy, Predicate retryWhile,
ScheduledExecutorService executorService, Processor onPrepareProcessor,
@@ -73,7 +73,19 @@ public class DeadLetterChannel extends RedeliveryErrorHandler {
deadLetterHandleException,
useOriginalMessagePolicy, useOriginalBodyPolicy, retryWhile, executorService, onPrepareProcessor,
onExceptionOccurredProcessor);
- setExceptionPolicy(exceptionPolicyStrategy);
+ }
+
+ @Override
+ public ErrorHandler clone(Processor output) {
+ DeadLetterChannel answer = new DeadLetterChannel(
+ camelContext, output, logger, redeliveryProcessor, redeliveryPolicy, deadLetter, deadLetterUri,
+ deadLetterHandleNewException, useOriginalMessagePolicy, useOriginalBodyPolicy, retryWhilePolicy,
+ executorService, onPrepareProcessor, onExceptionProcessor);
+ // shallow clone is okay as we do not mutate these
+ if (exceptionPolicies != null) {
+ answer.exceptionPolicies = exceptionPolicies;
+ }
+ return answer;
}
@Override
diff --git a/core/camel-core-processor/src/main/java/org/apache/camel/processor/errorhandler/DefaultErrorHandler.java b/core/camel-core-processor/src/main/java/org/apache/camel/processor/errorhandler/DefaultErrorHandler.java
index d4cbef7..7d5ffd5 100644
--- a/core/camel-core-processor/src/main/java/org/apache/camel/processor/errorhandler/DefaultErrorHandler.java
+++ b/core/camel-core-processor/src/main/java/org/apache/camel/processor/errorhandler/DefaultErrorHandler.java
@@ -23,6 +23,7 @@ import org.apache.camel.LoggingLevel;
import org.apache.camel.Predicate;
import org.apache.camel.Processor;
import org.apache.camel.spi.CamelLogger;
+import org.apache.camel.spi.ErrorHandler;
import org.slf4j.LoggerFactory;
/**
@@ -41,7 +42,6 @@ public class DefaultErrorHandler extends RedeliveryErrorHandler {
* @param logger logger to use for logging failures and redelivery attempts
* @param redeliveryProcessor an optional processor to run before redelivery attempt
* @param redeliveryPolicy policy for redelivery
- * @param exceptionPolicyStrategy strategy for onException handling
* @param retryWhile retry while
* @param executorService the {@link java.util.concurrent.ScheduledExecutorService} to be used for
* redelivery thread pool. Can be <tt>null</tt>.
@@ -52,15 +52,25 @@ public class DefaultErrorHandler extends RedeliveryErrorHandler {
* {@link org.apache.camel.Exchange} just after an exception was thrown.
*/
public DefaultErrorHandler(CamelContext camelContext, Processor output, CamelLogger logger, Processor redeliveryProcessor,
- RedeliveryPolicy redeliveryPolicy, ExceptionPolicyStrategy exceptionPolicyStrategy,
- Predicate retryWhile,
+ RedeliveryPolicy redeliveryPolicy, Predicate retryWhile,
ScheduledExecutorService executorService, Processor onPrepareProcessor,
Processor onExceptionOccurredProcessor) {
super(camelContext, output, logger != null ? logger : DEFAULT_LOGGER, redeliveryProcessor, redeliveryPolicy, null, null,
true, false, false, retryWhile,
executorService, onPrepareProcessor, onExceptionOccurredProcessor);
- setExceptionPolicy(exceptionPolicyStrategy);
+ }
+
+ @Override
+ public ErrorHandler clone(Processor output) {
+ DefaultErrorHandler answer = new DefaultErrorHandler(
+ camelContext, output, logger, redeliveryProcessor, redeliveryPolicy, retryWhilePolicy, executorService,
+ onPrepareProcessor, onExceptionProcessor);
+ // shallow clone is okay as we do not mutate these
+ if (exceptionPolicies != null) {
+ answer.exceptionPolicies = exceptionPolicies;
+ }
+ return answer;
}
@Override
diff --git a/core/camel-core-processor/src/main/java/org/apache/camel/processor/errorhandler/DefaultExceptionPolicyStrategy.java b/core/camel-core-processor/src/main/java/org/apache/camel/processor/errorhandler/DefaultExceptionPolicyStrategy.java
index 31513d3..9eb210b 100644
--- a/core/camel-core-processor/src/main/java/org/apache/camel/processor/errorhandler/DefaultExceptionPolicyStrategy.java
+++ b/core/camel-core-processor/src/main/java/org/apache/camel/processor/errorhandler/DefaultExceptionPolicyStrategy.java
@@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory;
* for more fine grained matching, so you can e.g. define multiple sets of exception types with the same exception
* class(es) but have a predicate attached to select which to select at runtime.
*/
-public class DefaultExceptionPolicyStrategy implements ExceptionPolicyStrategy {
+public final class DefaultExceptionPolicyStrategy implements ExceptionPolicyStrategy {
// thread safe so we can use a shared instance
public static final DefaultExceptionPolicyStrategy INSTANCE = new DefaultExceptionPolicyStrategy();
diff --git a/core/camel-core-processor/src/main/java/org/apache/camel/processor/errorhandler/ErrorHandlerSupport.java b/core/camel-core-processor/src/main/java/org/apache/camel/processor/errorhandler/ErrorHandlerSupport.java
index d6425ff..acec522 100644
--- a/core/camel-core-processor/src/main/java/org/apache/camel/processor/errorhandler/ErrorHandlerSupport.java
+++ b/core/camel-core-processor/src/main/java/org/apache/camel/processor/errorhandler/ErrorHandlerSupport.java
@@ -39,7 +39,7 @@ public abstract class ErrorHandlerSupport extends ChildServiceSupport implements
DEFAULT_EXCHANGE_FORMATTER.setStyle(DefaultExchangeFormatter.OutputStyle.Fixed);
}
// optimize to use a shared instance
- protected ExceptionPolicyStrategy exceptionPolicy = DefaultExceptionPolicyStrategy.INSTANCE;
+ protected final ExceptionPolicyStrategy exceptionPolicy = DefaultExceptionPolicyStrategy.INSTANCE;
protected Map<ExceptionPolicyKey, ExceptionPolicy> exceptionPolicies;
public void addErrorHandler(Processor errorHandler) {
@@ -54,8 +54,7 @@ public abstract class ErrorHandlerSupport extends ChildServiceSupport implements
}
/**
- * CamelContextHelper Attempts to find the best suited {@link ExceptionPolicy} to be used for handling the given
- * thrown exception.
+ * Attempts to find the best suited {@link ExceptionPolicy} to be used for handling the given thrown exception.
*
* @param exchange the exchange
* @param exception the exception that was thrown
@@ -73,15 +72,6 @@ public abstract class ErrorHandlerSupport extends ChildServiceSupport implements
}
/**
- * Sets the strategy to use for resolving the {@link ExceptionPolicy} to use for handling thrown exceptions.
- */
- public void setExceptionPolicy(ExceptionPolicyStrategy exceptionPolicy) {
- if (exceptionPolicy != null) {
- this.exceptionPolicy = exceptionPolicy;
- }
- }
-
- /**
* Whether this error handler supports transacted exchanges or not.
*/
public abstract boolean supportTransacted();
@@ -98,4 +88,9 @@ public abstract class ErrorHandlerSupport extends ChildServiceSupport implements
*/
public abstract Processor getOutput();
+ /**
+ * Clones the current error handler and changes the output
+ */
+ public abstract ErrorHandler clone(Processor output);
+
}
diff --git a/core/camel-core-processor/src/main/java/org/apache/camel/processor/errorhandler/NoErrorHandler.java b/core/camel-core-processor/src/main/java/org/apache/camel/processor/errorhandler/NoErrorHandler.java
index 27fce6d..22f4e9f 100644
--- a/core/camel-core-processor/src/main/java/org/apache/camel/processor/errorhandler/NoErrorHandler.java
+++ b/core/camel-core-processor/src/main/java/org/apache/camel/processor/errorhandler/NoErrorHandler.java
@@ -16,22 +16,34 @@
*/
package org.apache.camel.processor.errorhandler;
+import java.util.concurrent.CompletableFuture;
+
import org.apache.camel.AsyncCallback;
+import org.apache.camel.AsyncProcessor;
import org.apache.camel.Exchange;
import org.apache.camel.ExtendedExchange;
import org.apache.camel.Processor;
import org.apache.camel.spi.ErrorHandler;
-import org.apache.camel.support.processor.DelegateAsyncProcessor;
+import org.apache.camel.support.AsyncCallbackToCompletableFutureAdapter;
+import org.apache.camel.support.AsyncProcessorConverterHelper;
+import org.apache.camel.support.AsyncProcessorHelper;
+
+public class NoErrorHandler extends ErrorHandlerSupport implements AsyncProcessor, ErrorHandler {
-public class NoErrorHandler extends DelegateAsyncProcessor implements ErrorHandler {
+ private final AsyncProcessor output;
public NoErrorHandler(Processor processor) {
- super(processor);
+ this.output = AsyncProcessorConverterHelper.convert(processor);
+ }
+
+ @Override
+ public void process(Exchange exchange) throws Exception {
+ AsyncProcessorHelper.process(this, exchange);
}
@Override
public boolean process(Exchange exchange, final AsyncCallback callback) {
- return super.process(exchange, new AsyncCallback() {
+ return output.process(exchange, new AsyncCallback() {
@Override
public void done(boolean doneSync) {
exchange.adapt(ExtendedExchange.class).setRedeliveryExhausted(false);
@@ -41,12 +53,33 @@ public class NoErrorHandler extends DelegateAsyncProcessor implements ErrorHandl
}
@Override
+ public CompletableFuture<Exchange> processAsync(Exchange exchange) {
+ AsyncCallbackToCompletableFutureAdapter<Exchange> callback = new AsyncCallbackToCompletableFutureAdapter<>(exchange);
+ process(exchange, callback);
+ return callback.getFuture();
+ }
+
+ @Override
public String toString() {
- if (processor == null) {
+ if (output == null) {
// if no output then dont do any description
return "";
}
- return "NoErrorHandler[" + processor + "]";
+ return "NoErrorHandler[" + output + "]";
}
+ @Override
+ public boolean supportTransacted() {
+ return false;
+ }
+
+ @Override
+ public Processor getOutput() {
+ return output;
+ }
+
+ @Override
+ public ErrorHandler clone(Processor output) {
+ return new NoErrorHandler(output);
+ }
}
diff --git a/core/camel-core-processor/src/main/java/org/apache/camel/processor/errorhandler/RedeliveryErrorHandler.java b/core/camel-core-processor/src/main/java/org/apache/camel/processor/errorhandler/RedeliveryErrorHandler.java
index 4b25f0f..f8956e6 100644
--- a/core/camel-core-processor/src/main/java/org/apache/camel/processor/errorhandler/RedeliveryErrorHandler.java
+++ b/core/camel-core-processor/src/main/java/org/apache/camel/processor/errorhandler/RedeliveryErrorHandler.java
@@ -69,8 +69,16 @@ public abstract class RedeliveryErrorHandler extends ErrorHandlerSupport
private static final Logger LOG = LoggerFactory.getLogger(RedeliveryErrorHandler.class);
+ // state
protected final AtomicInteger redeliverySleepCounter = new AtomicInteger();
protected ScheduledExecutorService executorService;
+ protected volatile boolean preparingShutdown;
+
+ // output
+ protected Processor output;
+ protected AsyncProcessor outputAsync;
+
+ // configuration
protected final ExtendedCamelContext camelContext;
protected final ReactiveExecutor reactiveExecutor;
protected final AsyncProcessorAwaitManager awaitManager;
@@ -78,8 +86,6 @@ public abstract class RedeliveryErrorHandler extends ErrorHandlerSupport
protected final Processor deadLetter;
protected final String deadLetterUri;
protected final boolean deadLetterHandleNewException;
- protected Processor output;
- protected AsyncProcessor outputAsync;
protected final Processor redeliveryProcessor;
protected final RedeliveryPolicy redeliveryPolicy;
protected final Predicate retryWhilePolicy;
@@ -88,7 +94,6 @@ public abstract class RedeliveryErrorHandler extends ErrorHandlerSupport
protected final boolean useOriginalBodyPolicy;
protected boolean redeliveryEnabled;
protected boolean simpleTask;
- protected volatile boolean preparingShutdown;
protected final ExchangeFormatter exchangeFormatter;
protected final boolean customExchangeFormatter;
protected final Processor onPrepareProcessor;
diff --git a/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/BeanReifier.java b/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/BeanReifier.java
index 8e32da5..6274594 100644
--- a/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/BeanReifier.java
+++ b/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/BeanReifier.java
@@ -44,7 +44,8 @@ public class BeanReifier extends ProcessorReifier<BeanDefinition> {
if (definition.getScope() != null) {
scope = parse(BeanScope.class, definition.getScope());
}
- return fac.createBeanProcessor(camelContext, bean, beanType, beanClass, ref, method, scope);
+ Processor answer = fac.createBeanProcessor(camelContext, bean, beanType, beanClass, ref, method, scope);
+ return answer;
}
}
diff --git a/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/DynamicRouterReifier.java b/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/DynamicRouterReifier.java
index f33a0d8..bc760e0 100644
--- a/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/DynamicRouterReifier.java
+++ b/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/DynamicRouterReifier.java
@@ -45,7 +45,7 @@ public class DynamicRouterReifier extends ExpressionReifier<DynamicRouterDefinit
}
AsyncProcessor errorHandler
- = (AsyncProcessor) wrapInErrorHandler(dynamicRouter.newRoutingSlipProcessorForErrorHandler(), false);
+ = (AsyncProcessor) wrapInErrorHandler(dynamicRouter.newRoutingSlipProcessorForErrorHandler());
dynamicRouter.setErrorHandler(errorHandler);
return dynamicRouter;
diff --git a/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/ProcessorReifier.java b/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/ProcessorReifier.java
index 68b5ac1..202fc8a 100644
--- a/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/ProcessorReifier.java
+++ b/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/ProcessorReifier.java
@@ -104,10 +104,10 @@ import org.apache.camel.model.WireTapDefinition;
import org.apache.camel.model.cloud.ServiceCallDefinition;
import org.apache.camel.processor.InterceptEndpointProcessor;
import org.apache.camel.processor.Pipeline;
+import org.apache.camel.spi.ErrorHandlerAware;
import org.apache.camel.spi.ExecutorServiceManager;
import org.apache.camel.spi.IdAware;
import org.apache.camel.spi.InterceptStrategy;
-import org.apache.camel.spi.LifecycleStrategy;
import org.apache.camel.spi.ReifierStrategy;
import org.apache.camel.spi.RouteIdAware;
import org.apache.camel.util.ObjectHelper;
@@ -719,7 +719,7 @@ public abstract class ProcessorReifier<T extends ProcessorDefinition<?>> extends
if (inheritErrorHandler == null || inheritErrorHandler) {
LOG.trace("{} is configured to inheritErrorHandler", definition);
Processor output = channel.getOutput();
- Processor errorHandler = wrapInErrorHandler(output, true);
+ Processor errorHandler = wrapInErrorHandler(output);
// set error handler on channel
channel.setErrorHandler(errorHandler);
} else {
@@ -731,22 +731,18 @@ public abstract class ProcessorReifier<T extends ProcessorDefinition<?>> extends
* Wraps the given output in an error handler
*
* @param output the output
- * @param longLived if the processor is longLived or not
* @return the output wrapped with the error handler
* @throws Exception can be thrown if failed to create error handler builder
*/
- protected Processor wrapInErrorHandler(Processor output, boolean longLived) throws Exception {
+ protected Processor wrapInErrorHandler(Processor output) throws Exception {
ErrorHandlerFactory builder = route.getErrorHandlerFactory();
// create error handler
Processor errorHandler = camelContext.adapt(ModelCamelContext.class).getModelReifierFactory().createErrorHandler(route,
builder, output);
- if (longLived) {
- // invoke lifecycles so we can manage this error handler builder
- for (LifecycleStrategy strategy : camelContext.getLifecycleStrategies()) {
- strategy.onErrorHandlerAdd(route, errorHandler, builder);
- }
+ if (output instanceof ErrorHandlerAware) {
+ ((ErrorHandlerAware) output).setErrorHandler(errorHandler);
}
return errorHandler;
diff --git a/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/RecipientListReifier.java b/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/RecipientListReifier.java
index 8ccff00..3d44191 100644
--- a/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/RecipientListReifier.java
+++ b/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/RecipientListReifier.java
@@ -99,7 +99,7 @@ public class RecipientListReifier extends ProcessorReifier<RecipientListDefiniti
// special error handling
// when sending to the recipients individually
Processor evalProcessor = new EvaluateExpressionProcessor(expression);
- evalProcessor = wrapInErrorHandler(evalProcessor, true);
+ evalProcessor = wrapInErrorHandler(evalProcessor);
pipe.add(evalProcessor);
pipe.add(answer);
diff --git a/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/RouteReifier.java b/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/RouteReifier.java
index 06e7b20..7d5e068 100644
--- a/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/RouteReifier.java
+++ b/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/RouteReifier.java
@@ -25,6 +25,7 @@ import java.util.StringTokenizer;
import org.apache.camel.CamelContext;
import org.apache.camel.Endpoint;
import org.apache.camel.EndpointConsumerResolver;
+import org.apache.camel.ErrorHandlerFactory;
import org.apache.camel.ExtendedCamelContext;
import org.apache.camel.FailedToCreateRouteException;
import org.apache.camel.Processor;
@@ -32,6 +33,7 @@ import org.apache.camel.Route;
import org.apache.camel.RuntimeCamelException;
import org.apache.camel.ShutdownRoute;
import org.apache.camel.ShutdownRunningTask;
+import org.apache.camel.model.ModelCamelContext;
import org.apache.camel.model.ProcessorDefinition;
import org.apache.camel.model.PropertyDefinition;
import org.apache.camel.model.RouteDefinition;
@@ -39,6 +41,7 @@ import org.apache.camel.processor.ContractAdvice;
import org.apache.camel.processor.Pipeline;
import org.apache.camel.reifier.rest.RestBindingReifier;
import org.apache.camel.spi.Contract;
+import org.apache.camel.spi.ErrorHandlerAware;
import org.apache.camel.spi.InternalProcessor;
import org.apache.camel.spi.LifecycleStrategy;
import org.apache.camel.spi.ManagementInterceptStrategy;
@@ -320,12 +323,29 @@ public class RouteReifier extends ProcessorReifier<RouteDefinition> {
}
}
+ // inject the route error handler for processors that are error handler aware
+ // this needs to be done here at the end because the route may be transactional and have a transaction error handler
+ // automatic be configured which some EIPs like Multicast/RecipientList needs to be using for special fine grained error handling
+ ErrorHandlerFactory builder = route.getErrorHandlerFactory();
+ Processor errorHandler = camelContext.adapt(ModelCamelContext.class).getModelReifierFactory().createErrorHandler(route,
+ builder, null);
+ prepareErrorHandlerAware(route, errorHandler);
+
// okay route has been created from the model, then the model is no longer needed and we can de-reference
route.clearRouteModel();
return route;
}
+ private void prepareErrorHandlerAware(Route route, Processor errorHandler) {
+ List<Processor> processors = route.filter("*");
+ for (Processor p : processors) {
+ if (p instanceof ErrorHandlerAware) {
+ ((ErrorHandlerAware) p).setErrorHandler(errorHandler);
+ }
+ }
+ }
+
protected Map<String, Object> computeRouteProperties() {
Map<String, Object> routeProperties = new HashMap<>();
routeProperties.put(Route.ID_PROPERTY, definition.getId());
diff --git a/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/RoutingSlipReifier.java b/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/RoutingSlipReifier.java
index c7b7027..6a871ba 100644
--- a/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/RoutingSlipReifier.java
+++ b/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/RoutingSlipReifier.java
@@ -50,7 +50,7 @@ public class RoutingSlipReifier extends ExpressionReifier<RoutingSlipDefinition<
// and wrap this in an error handler
AsyncProcessor processor = routingSlip.newRoutingSlipProcessorForErrorHandler();
- AsyncProcessor errorHandler = (AsyncProcessor) wrapInErrorHandler(processor, false);
+ AsyncProcessor errorHandler = (AsyncProcessor) wrapInErrorHandler(processor);
routingSlip.setErrorHandler(errorHandler);
return routingSlip;
diff --git a/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/WireTapReifier.java b/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/WireTapReifier.java
index 78517fb..d8f1dfd 100644
--- a/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/WireTapReifier.java
+++ b/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/WireTapReifier.java
@@ -49,7 +49,7 @@ public class WireTapReifier extends ToDynamicReifier<WireTapDefinition<?>> {
SendDynamicProcessor dynamicTo = (SendDynamicProcessor) super.createProcessor();
// create error handler we need to use for processing the wire tapped
- Processor childProcessor = wrapInErrorHandler(dynamicTo, true);
+ Processor childProcessor = wrapInErrorHandler(dynamicTo);
// and wrap in unit of work
AsyncProcessor target = camelContext.adapt(ExtendedCamelContext.class).getInternalProcessorFactory()
diff --git a/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/errorhandler/DeadLetterChannelReifier.java b/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/errorhandler/DeadLetterChannelReifier.java
index 1dabfe2..8cb6a59 100644
--- a/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/errorhandler/DeadLetterChannelReifier.java
+++ b/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/errorhandler/DeadLetterChannelReifier.java
@@ -20,7 +20,7 @@ import org.apache.camel.ErrorHandlerFactory;
import org.apache.camel.ExchangePattern;
import org.apache.camel.Processor;
import org.apache.camel.Route;
-import org.apache.camel.model.errorhandler.DeadLetterChannelConfiguration;
+import org.apache.camel.model.errorhandler.DeadLetterChannelProperties;
import org.apache.camel.processor.FatalFallbackErrorHandler;
import org.apache.camel.processor.SendProcessor;
import org.apache.camel.processor.errorhandler.DeadLetterChannel;
@@ -28,7 +28,7 @@ import org.apache.camel.processor.errorhandler.RedeliveryPolicy;
import org.apache.camel.spi.CamelLogger;
import org.apache.camel.util.ObjectHelper;
-public class DeadLetterChannelReifier extends DefaultErrorHandlerReifier<DeadLetterChannelConfiguration> {
+public class DeadLetterChannelReifier extends DefaultErrorHandlerReifier<DeadLetterChannelProperties> {
public DeadLetterChannelReifier(Route route, ErrorHandlerFactory definition) {
super(route, definition);
@@ -48,7 +48,7 @@ public class DeadLetterChannelReifier extends DefaultErrorHandlerReifier<DeadLet
DeadLetterChannel answer = new DeadLetterChannel(
camelContext, processor, logger,
getBean(Processor.class, definition.getOnRedelivery(), definition.getOnRedeliveryRef()),
- redeliveryPolicy, definition.getExceptionPolicyStrategy(), deadLetterProcessor,
+ redeliveryPolicy, deadLetterProcessor,
definition.getDeadLetterUri(), definition.isDeadLetterHandleNewException(), definition.isUseOriginalMessage(),
definition.isUseOriginalBody(),
definition.getRetryWhilePolicy(camelContext),
diff --git a/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/errorhandler/DefaultErrorHandlerReifier.java b/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/errorhandler/DefaultErrorHandlerReifier.java
index 86234fa..55f37b9 100644
--- a/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/errorhandler/DefaultErrorHandlerReifier.java
+++ b/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/errorhandler/DefaultErrorHandlerReifier.java
@@ -21,15 +21,14 @@ import java.util.concurrent.ScheduledExecutorService;
import org.apache.camel.ErrorHandlerFactory;
import org.apache.camel.Processor;
import org.apache.camel.Route;
-import org.apache.camel.model.errorhandler.DefaultErrorHandlerConfiguration;
+import org.apache.camel.model.errorhandler.DefaultErrorHandlerProperties;
import org.apache.camel.processor.errorhandler.DefaultErrorHandler;
-import org.apache.camel.processor.errorhandler.ExceptionPolicyStrategy;
import org.apache.camel.processor.errorhandler.RedeliveryPolicy;
import org.apache.camel.spi.CamelLogger;
import org.apache.camel.spi.ExecutorServiceManager;
import org.apache.camel.spi.ThreadPoolProfile;
-public class DefaultErrorHandlerReifier<T extends DefaultErrorHandlerConfiguration> extends ErrorHandlerReifier<T> {
+public class DefaultErrorHandlerReifier<T extends DefaultErrorHandlerProperties> extends ErrorHandlerReifier<T> {
public DefaultErrorHandlerReifier(Route route, ErrorHandlerFactory definition) {
super(route, (T) definition);
@@ -46,8 +45,6 @@ public class DefaultErrorHandlerReifier<T extends DefaultErrorHandlerConfigurati
camelContext, processor, logger,
getBean(Processor.class, definition.getOnRedelivery(), definition.getOnRedeliveryRef()),
redeliveryPolicy,
- getBean(ExceptionPolicyStrategy.class, definition.getExceptionPolicyStrategy(),
- definition.getExceptionPolicyStrategyRef()),
getPredicate(definition.getRetryWhile(), definition.getRetryWhileRef()),
getExecutorService(definition.getExecutorService(), definition.getExecutorServiceRef()),
getBean(Processor.class, definition.getOnPrepareFailure(), definition.getOnPrepareFailureRef()),
diff --git a/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/errorhandler/ErrorHandlerRefReifier.java b/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/errorhandler/ErrorHandlerRefReifier.java
index 547f712..186773c 100644
--- a/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/errorhandler/ErrorHandlerRefReifier.java
+++ b/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/errorhandler/ErrorHandlerRefReifier.java
@@ -21,13 +21,13 @@ import org.apache.camel.Processor;
import org.apache.camel.Route;
import org.apache.camel.model.ModelCamelContext;
import org.apache.camel.model.errorhandler.ErrorHandlerHelper;
-import org.apache.camel.model.errorhandler.ErrorHandlerRefConfiguration;
+import org.apache.camel.model.errorhandler.ErrorHandlerRefProperties;
import org.apache.camel.util.ObjectHelper;
-public class ErrorHandlerRefReifier extends ErrorHandlerReifier<ErrorHandlerRefConfiguration> {
+public class ErrorHandlerRefReifier extends ErrorHandlerReifier<ErrorHandlerRefProperties> {
public ErrorHandlerRefReifier(Route route, ErrorHandlerFactory definition) {
- super(route, (ErrorHandlerRefConfiguration) definition);
+ super(route, (ErrorHandlerRefProperties) definition);
}
@Override
diff --git a/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/errorhandler/ErrorHandlerReifier.java b/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/errorhandler/ErrorHandlerReifier.java
index be7e68e..1bfeb16 100644
--- a/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/errorhandler/ErrorHandlerReifier.java
+++ b/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/errorhandler/ErrorHandlerReifier.java
@@ -33,10 +33,10 @@ import org.apache.camel.Route;
import org.apache.camel.RuntimeCamelException;
import org.apache.camel.model.OnExceptionDefinition;
import org.apache.camel.model.RedeliveryPolicyDefinition;
-import org.apache.camel.model.errorhandler.DeadLetterChannelConfiguration;
-import org.apache.camel.model.errorhandler.DefaultErrorHandlerConfiguration;
-import org.apache.camel.model.errorhandler.ErrorHandlerRefConfiguration;
-import org.apache.camel.model.errorhandler.NoErrorHandlerConfiguraiton;
+import org.apache.camel.model.errorhandler.DeadLetterChannelProperties;
+import org.apache.camel.model.errorhandler.DefaultErrorHandlerProperties;
+import org.apache.camel.model.errorhandler.ErrorHandlerRefProperties;
+import org.apache.camel.model.errorhandler.NoErrorHandlerProperties;
import org.apache.camel.processor.errorhandler.ErrorHandlerSupport;
import org.apache.camel.processor.errorhandler.ExceptionPolicy;
import org.apache.camel.processor.errorhandler.ExceptionPolicy.RedeliveryOption;
@@ -90,13 +90,13 @@ public abstract class ErrorHandlerReifier<T extends ErrorHandlerFactory> extends
}
private static ErrorHandlerReifier<? extends ErrorHandlerFactory> coreReifier(Route route, ErrorHandlerFactory definition) {
- if (definition instanceof DeadLetterChannelConfiguration) {
+ if (definition instanceof DeadLetterChannelProperties) {
return new DeadLetterChannelReifier(route, definition);
- } else if (definition instanceof DefaultErrorHandlerConfiguration) {
+ } else if (definition instanceof DefaultErrorHandlerProperties) {
return new DefaultErrorHandlerReifier<>(route, definition);
- } else if (definition instanceof ErrorHandlerRefConfiguration) {
+ } else if (definition instanceof ErrorHandlerRefProperties) {
return new ErrorHandlerRefReifier(route, definition);
- } else if (definition instanceof NoErrorHandlerConfiguraiton) {
+ } else if (definition instanceof NoErrorHandlerProperties) {
return new NoErrorHandlerReifier(route, definition);
}
return null;
diff --git a/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/errorhandler/NoErrorHandlerReifier.java b/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/errorhandler/NoErrorHandlerReifier.java
index ee1183d..35d1ac5 100644
--- a/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/errorhandler/NoErrorHandlerReifier.java
+++ b/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/errorhandler/NoErrorHandlerReifier.java
@@ -19,14 +19,14 @@ package org.apache.camel.reifier.errorhandler;
import org.apache.camel.ErrorHandlerFactory;
import org.apache.camel.Processor;
import org.apache.camel.Route;
-import org.apache.camel.model.errorhandler.NoErrorHandlerConfiguraiton;
+import org.apache.camel.model.errorhandler.NoErrorHandlerProperties;
import org.apache.camel.processor.errorhandler.NoErrorHandler;
import org.apache.camel.spi.ErrorHandler;
-public class NoErrorHandlerReifier extends ErrorHandlerReifier<NoErrorHandlerConfiguraiton> {
+public class NoErrorHandlerReifier extends ErrorHandlerReifier<NoErrorHandlerProperties> {
public NoErrorHandlerReifier(Route route, ErrorHandlerFactory definition) {
- super(route, (NoErrorHandlerConfiguraiton) definition);
+ super(route, (NoErrorHandlerProperties) definition);
}
@Override
diff --git a/core/camel-core/src/test/java/org/apache/camel/impl/DummyLifecycleStrategy.java b/core/camel-core/src/test/java/org/apache/camel/impl/DummyLifecycleStrategy.java
index 468680d..d1dca89 100644
--- a/core/camel-core/src/test/java/org/apache/camel/impl/DummyLifecycleStrategy.java
+++ b/core/camel-core/src/test/java/org/apache/camel/impl/DummyLifecycleStrategy.java
@@ -24,8 +24,6 @@ import java.util.concurrent.ThreadPoolExecutor;
import org.apache.camel.CamelContext;
import org.apache.camel.Component;
import org.apache.camel.Endpoint;
-import org.apache.camel.ErrorHandlerFactory;
-import org.apache.camel.Processor;
import org.apache.camel.Route;
import org.apache.camel.Service;
import org.apache.camel.VetoCamelContextStartException;
@@ -33,7 +31,7 @@ import org.apache.camel.support.LifecycleStrategySupport;
public class DummyLifecycleStrategy extends LifecycleStrategySupport {
- private List<String> events = new ArrayList<>();
+ private final List<String> events = new ArrayList<>();
@Override
public void onContextStart(CamelContext context) throws VetoCamelContextStartException {
@@ -91,16 +89,6 @@ public class DummyLifecycleStrategy extends LifecycleStrategySupport {
}
@Override
- public void onErrorHandlerAdd(Route route, Processor errorHandler, ErrorHandlerFactory errorHandlerBuilder) {
- events.add("onErrorHandlerAdd");
- }
-
- @Override
- public void onErrorHandlerRemove(Route route, Processor errorHandler, ErrorHandlerFactory errorHandlerBuilder) {
- events.add("onErrorHandlerRemove");
- }
-
- @Override
public void onThreadPoolAdd(
CamelContext camelContext, ThreadPoolExecutor threadPool, String id, String sourceId, String routeId,
String threadPoolProfileId) {
diff --git a/core/camel-core/src/test/java/org/apache/camel/processor/errorhandler/ErrorHandlerSupportTest.java b/core/camel-core/src/test/java/org/apache/camel/processor/errorhandler/ErrorHandlerSupportTest.java
index 68607a8..72a4231 100644
--- a/core/camel-core/src/test/java/org/apache/camel/processor/errorhandler/ErrorHandlerSupportTest.java
+++ b/core/camel-core/src/test/java/org/apache/camel/processor/errorhandler/ErrorHandlerSupportTest.java
@@ -26,6 +26,7 @@ import org.apache.camel.Route;
import org.apache.camel.builder.RouteBuilder;
import org.apache.camel.model.OnExceptionDefinition;
import org.apache.camel.reifier.errorhandler.DefaultErrorHandlerReifier;
+import org.apache.camel.spi.ErrorHandler;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
@@ -116,6 +117,11 @@ public class ErrorHandlerSupportTest extends ContextTestSupport {
}
@Override
+ public ErrorHandler clone(Processor output) {
+ return null;
+ }
+
+ @Override
public void process(Exchange exchange) throws Exception {
}
}
diff --git a/core/camel-core/src/test/java/org/apache/camel/processor/exceptionpolicy/CustomExceptionPolicyStrategyTest.java b/core/camel-core/src/test/java/org/apache/camel/processor/exceptionpolicy/CustomExceptionPolicyStrategyTest.java
deleted file mode 100644
index 548d81a..0000000
--- a/core/camel-core/src/test/java/org/apache/camel/processor/exceptionpolicy/CustomExceptionPolicyStrategyTest.java
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.camel.processor.exceptionpolicy;
-
-import java.util.Set;
-
-import org.apache.camel.CamelException;
-import org.apache.camel.CamelExchangeException;
-import org.apache.camel.ContextTestSupport;
-import org.apache.camel.Exchange;
-import org.apache.camel.Processor;
-import org.apache.camel.builder.RouteBuilder;
-import org.apache.camel.component.mock.MockEndpoint;
-import org.apache.camel.processor.errorhandler.ExceptionPolicyKey;
-import org.apache.camel.processor.errorhandler.ExceptionPolicyStrategy;
-import org.junit.jupiter.api.Test;
-
-import static org.junit.jupiter.api.Assertions.fail;
-
-/**
- * Unit test with a user plugged in exception policy to use instead of default.
- */
-public class CustomExceptionPolicyStrategyTest extends ContextTestSupport {
-
- private static final String MESSAGE_INFO = "messageInfo";
- private static final String ERROR_QUEUE = "mock:error";
-
- public static class MyPolicyException extends Exception {
- private static final long serialVersionUID = 1L;
- }
-
- // START SNIPPET e2
- public static class MyPolicy implements ExceptionPolicyStrategy {
-
- @Override
- public ExceptionPolicyKey getExceptionPolicy(
- Set<ExceptionPolicyKey> exceptionPolicices, Exchange exchange, Throwable exception) {
- // This is just an example that always forces the exception type
- // configured
- // with MyPolicyException to win.
- return new ExceptionPolicyKey(null, MyPolicyException.class, null);
- }
- }
- // END SNIPPET e2
-
- @Test
- public void testCustomPolicy() throws Exception {
- MockEndpoint mock = getMockEndpoint(ERROR_QUEUE);
- mock.expectedMessageCount(1);
- mock.expectedHeaderReceived(MESSAGE_INFO, "Damm my policy exception");
-
- try {
- template.sendBody("direct:a", "Hello Camel");
- fail("Should have thrown an exception");
- } catch (Exception e) {
- // expected
- }
-
- mock.assertIsSatisfied();
- }
-
- @Override
- protected RouteBuilder createRouteBuilder() throws Exception {
- return new RouteBuilder() {
- // START SNIPPET e1
- public void configure() throws Exception {
- // configure the error handler to use my policy instead of the
- // default from Camel
- errorHandler(deadLetterChannel("mock:error").exceptionPolicyStrategy(new MyPolicy()));
-
- onException(MyPolicyException.class).maximumRedeliveries(1).redeliveryDelay(0)
- .setHeader(MESSAGE_INFO, constant("Damm my policy exception")).to(ERROR_QUEUE);
-
- onException(CamelException.class).maximumRedeliveries(3).redeliveryDelay(0)
- .setHeader(MESSAGE_INFO, constant("Damm a Camel exception")).to(ERROR_QUEUE);
- // END SNIPPET e1
-
- from("direct:a").process(new Processor() {
- public void process(Exchange exchange) throws Exception {
- String s = exchange.getIn().getBody(String.class);
- if ("Hello Camel".equals(s)) {
- throw new CamelExchangeException("Forced for testing", exchange);
- }
- exchange.getMessage().setBody("Hello World");
- }
- }).to("mock:result");
- }
- };
- }
-
-}
diff --git a/core/camel-management-api/src/main/java/org/apache/camel/api/management/mbean/ManagedErrorHandlerMBean.java b/core/camel-management-api/src/main/java/org/apache/camel/api/management/mbean/ManagedErrorHandlerMBean.java
deleted file mode 100644
index 9995db6..0000000
--- a/core/camel-management-api/src/main/java/org/apache/camel/api/management/mbean/ManagedErrorHandlerMBean.java
+++ /dev/null
@@ -1,173 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.camel.api.management.mbean;
-
-import org.apache.camel.api.management.ManagedAttribute;
-
-public interface ManagedErrorHandlerMBean {
-
- @ManagedAttribute(description = "Camel ID")
- String getCamelId();
-
- @ManagedAttribute(description = "Camel ManagementName")
- String getCamelManagementName();
-
- @ManagedAttribute(description = "Does the error handler support redelivery")
- boolean isSupportRedelivery();
-
- @ManagedAttribute(description = "Is this error handler a dead letter channel")
- boolean isDeadLetterChannel();
-
- @ManagedAttribute(description = "When a message is moved to dead letter channel is it the original message or recent message")
- boolean isDeadLetterUseOriginalMessage();
-
- @ManagedAttribute(description = "When a message is moved to dead letter channel is it the original message body or recent message body")
- boolean isDeadLetterUseOriginalBody();
-
- @ManagedAttribute(description = "Does this error handler handle new exceptions which may occur during error handling")
- boolean isDeadLetterHandleNewException();
-
- @ManagedAttribute(description = "Does this error handler support transactions")
- boolean isSupportTransactions();
-
- @ManagedAttribute(description = "Endpoint Uri for the dead letter channel where dead message is move to", mask = true)
- String getDeadLetterChannelEndpointUri();
-
- @ManagedAttribute(description = "Number of Exchanges scheduled for redelivery (waiting to be redelivered in the future)")
- Integer getPendingRedeliveryCount();
-
- @ManagedAttribute(description = "RedeliveryPolicy for maximum redeliveries")
- Integer getMaximumRedeliveries();
-
- @ManagedAttribute(description = "RedeliveryPolicy for maximum redeliveries")
- void setMaximumRedeliveries(Integer maximum);
-
- @ManagedAttribute(description = "RedeliveryPolicy for maximum redelivery delay")
- Long getMaximumRedeliveryDelay();
-
- @ManagedAttribute(description = "RedeliveryPolicy for maximum redelivery delay")
- void setMaximumRedeliveryDelay(Long delay);
-
- @ManagedAttribute(description = "RedeliveryPolicy for redelivery delay")
- Long getRedeliveryDelay();
-
- @ManagedAttribute(description = "RedeliveryPolicy for redelivery delay")
- void setRedeliveryDelay(Long delay);
-
- @ManagedAttribute(description = "RedeliveryPolicy for backoff multiplier")
- Double getBackOffMultiplier();
-
- @ManagedAttribute(description = "RedeliveryPolicy for backoff multiplier")
- void setBackOffMultiplier(Double multiplier);
-
- @ManagedAttribute(description = "RedeliveryPolicy for collision avoidance factor")
- Double getCollisionAvoidanceFactor();
-
- @ManagedAttribute(description = "RedeliveryPolicy for collision avoidance factor")
- void setCollisionAvoidanceFactor(Double factor);
-
- @ManagedAttribute(description = "RedeliveryPolicy for collision avoidance percent")
- Double getCollisionAvoidancePercent();
-
- @ManagedAttribute(description = "RedeliveryPolicy for collision avoidance percent")
- void setCollisionAvoidancePercent(Double percent);
-
- @ManagedAttribute(description = "RedeliveryPolicy for delay pattern")
- String getDelayPattern();
-
- @ManagedAttribute(description = "RedeliveryPolicy for delay pattern")
- void setDelayPattern(String pattern);
-
- @ManagedAttribute(description = "RedeliveryPolicy for logging level when retries exhausted")
- String getRetriesExhaustedLogLevel();
-
- @ManagedAttribute(description = "RedeliveryPolicy for logging level when retries exhausted")
- void setRetriesExhaustedLogLevel(String level);
-
- @ManagedAttribute(description = "RedeliveryPolicy for logging level when attempting retry")
- String getRetryAttemptedLogLevel();
-
- @ManagedAttribute(description = "RedeliveryPolicy for logging level when attempting retry")
- void setRetryAttemptedLogLevel(String level);
-
- @ManagedAttribute(description = "RedeliveryPolicy for logging stack traces")
- Boolean getLogStackTrace();
-
- @ManagedAttribute(description = "RedeliveryPolicy for logging stack traces")
- void setLogStackTrace(Boolean log);
-
- @ManagedAttribute(description = "RedeliveryPolicy for logging redelivery stack traces")
- Boolean getLogRetryStackTrace();
-
- @ManagedAttribute(description = "RedeliveryPolicy for logging redelivery stack traces")
- void setLogRetryStackTrace(Boolean log);
-
- @ManagedAttribute(description = "RedeliveryPolicy for logging handled exceptions")
- Boolean getLogHandled();
-
- @ManagedAttribute(description = "RedeliveryPolicy for logging handled exceptions")
- void setLogHandled(Boolean log);
-
- @ManagedAttribute(description = "RedeliveryPolicy for logging new exceptions")
- Boolean getLogNewException();
-
- @ManagedAttribute(description = "RedeliveryPolicy for logging new exceptions")
- void setLogNewException(Boolean log);
-
- @ManagedAttribute(description = "RedeliveryPolicy for logging exhausted with message history")
- Boolean getLogExhaustedMessageHistory();
-
- @ManagedAttribute(description = "RedeliveryPolicy for logging exhausted with message history")
- void setLogExhaustedMessageHistory(Boolean log);
-
- @ManagedAttribute(description = "RedeliveryPolicy for logging exhausted with message history")
- Boolean getLogExhaustedMessageBody();
-
- @ManagedAttribute(description = "RedeliveryPolicy for logging exhausted with message body")
- void setLogExhaustedMessageBody(Boolean log);
-
- @ManagedAttribute(description = "RedeliveryPolicy for logging handled and continued exceptions")
- Boolean getLogContinued();
-
- @ManagedAttribute(description = "RedeliveryPolicy for logging handled and continued exceptions")
- void setLogContinued(Boolean log);
-
- @ManagedAttribute(description = "RedeliveryPolicy for logging exhausted exceptions")
- Boolean getLogExhausted();
-
- @ManagedAttribute(description = "RedeliveryPolicy for logging exhausted exceptions")
- void setLogExhausted(Boolean log);
-
- @ManagedAttribute(description = "RedeliveryPolicy for using collision avoidance")
- Boolean getUseCollisionAvoidance();
-
- @ManagedAttribute(description = "RedeliveryPolicy for using collision avoidance")
- void setUseCollisionAvoidance(Boolean avoidance);
-
- @ManagedAttribute(description = "RedeliveryPolicy for using exponential backoff")
- Boolean getUseExponentialBackOff();
-
- @ManagedAttribute(description = "RedeliveryPolicy for using exponential backoff")
- void setUseExponentialBackOff(Boolean backoff);
-
- @ManagedAttribute(description = "RedeliveryPolicy for allow redelivery while stopping")
- Boolean getAllowRedeliveryWhileStopping();
-
- @ManagedAttribute(description = "RedeliveryPolicy for allow redelivery while stopping")
- void setAllowRedeliveryWhileStopping(Boolean allow);
-
-}
diff --git a/core/camel-management/src/main/java/org/apache/camel/management/DefaultManagementObjectNameStrategy.java b/core/camel-management/src/main/java/org/apache/camel/management/DefaultManagementObjectNameStrategy.java
index 02ad3da..0a26706 100644
--- a/core/camel-management/src/main/java/org/apache/camel/management/DefaultManagementObjectNameStrategy.java
+++ b/core/camel-management/src/main/java/org/apache/camel/management/DefaultManagementObjectNameStrategy.java
@@ -27,11 +27,9 @@ import org.apache.camel.CamelContextAware;
import org.apache.camel.Component;
import org.apache.camel.Consumer;
import org.apache.camel.Endpoint;
-import org.apache.camel.ErrorHandlerFactory;
import org.apache.camel.NamedNode;
import org.apache.camel.Processor;
import org.apache.camel.Producer;
-import org.apache.camel.Route;
import org.apache.camel.Service;
import org.apache.camel.StaticService;
import org.apache.camel.cluster.CamelClusterService;
@@ -44,7 +42,6 @@ import org.apache.camel.management.mbean.ManagedComponent;
import org.apache.camel.management.mbean.ManagedConsumer;
import org.apache.camel.management.mbean.ManagedDataFormat;
import org.apache.camel.management.mbean.ManagedEndpoint;
-import org.apache.camel.management.mbean.ManagedErrorHandler;
import org.apache.camel.management.mbean.ManagedEventNotifier;
import org.apache.camel.management.mbean.ManagedProcessor;
import org.apache.camel.management.mbean.ManagedProducer;
@@ -55,8 +52,6 @@ import org.apache.camel.management.mbean.ManagedStep;
import org.apache.camel.management.mbean.ManagedSupervisingRouteController;
import org.apache.camel.management.mbean.ManagedThreadPool;
import org.apache.camel.management.mbean.ManagedTracer;
-import org.apache.camel.model.errorhandler.ErrorHandlerHelper;
-import org.apache.camel.model.errorhandler.ErrorHandlerRefConfiguration;
import org.apache.camel.spi.DataFormat;
import org.apache.camel.spi.EventNotifier;
import org.apache.camel.spi.ManagementObjectNameStrategy;
@@ -86,7 +81,6 @@ public class DefaultManagementObjectNameStrategy implements ManagementObjectName
public static final String TYPE_STEP = "steps";
public static final String TYPE_TRACER = "tracer";
public static final String TYPE_EVENT_NOTIFIER = "eventnotifiers";
- public static final String TYPE_ERRORHANDLER = "errorhandlers";
public static final String TYPE_THREAD_POOL = "threadpools";
public static final String TYPE_SERVICE = "services";
public static final String TYPE_HA = "clusterservices";
@@ -151,9 +145,6 @@ public class DefaultManagementObjectNameStrategy implements ManagementObjectName
} else if (managedObject instanceof ManagedRoute) {
ManagedRoute mr = (ManagedRoute) managedObject;
objectName = getObjectNameForRoute(mr.getRoute());
- } else if (managedObject instanceof ManagedErrorHandler) {
- ManagedErrorHandler meh = (ManagedErrorHandler) managedObject;
- objectName = getObjectNameForErrorHandler(meh.getRoute(), meh.getErrorHandler(), meh.getErrorHandlerBuilder());
} else if (managedObject instanceof ManagedStep) {
ManagedStep mp = (ManagedStep) managedObject;
objectName = getObjectNameForStep(mp.getContext(), mp.getProcessor(), mp.getDefinition());
@@ -310,56 +301,6 @@ public class DefaultManagementObjectNameStrategy implements ManagementObjectName
}
@Override
- public ObjectName getObjectNameForErrorHandler(Route route, Processor errorHandler, ErrorHandlerFactory builder)
- throws MalformedObjectNameException {
- StringBuilder buffer = new StringBuilder();
- buffer.append(domainName).append(":");
- buffer.append(KEY_CONTEXT + "=").append(getContextId(route.getCamelContext())).append(",");
- buffer.append(KEY_TYPE + "=").append(TYPE_ERRORHANDLER + ",");
-
- // we want to only register one instance of the various error handler types and thus do some lookup
- // if its a ErrorHandlerBuildRef. We need a bit of work to do that as there are potential indirection.
- String ref = null;
- if (builder instanceof ErrorHandlerRefConfiguration) {
- ErrorHandlerRefConfiguration builderRef = (ErrorHandlerRefConfiguration) builder;
-
- // it has not then its an indirection and we should do some work to lookup the real builder
- ref = builderRef.getRef();
- ErrorHandlerFactory refBuilder = ErrorHandlerHelper.lookupErrorHandlerFactory(route, builderRef.getRef(), false);
- if (refBuilder != null) {
- builder = refBuilder;
- }
-
- // must do a 2nd lookup in case this is also a reference
- // (this happens with spring DSL using errorHandlerRef on <route> as it gets a bit
- // complex with indirections for error handler references
- if (builder instanceof ErrorHandlerRefConfiguration) {
- builderRef = (ErrorHandlerRefConfiguration) builder;
- // does it refer to a non default error handler then do a 2nd lookup
- if (!builderRef.getRef().equals(ErrorHandlerRefConfiguration.DEFAULT_ERROR_HANDLER_BUILDER)) {
- refBuilder = ErrorHandlerHelper.lookupErrorHandlerFactory(route, builderRef.getRef(), false);
- if (refBuilder != null) {
- ref = builderRef.getRef();
- builder = refBuilder;
- }
- }
- }
- }
-
- if (ref != null) {
- String name = builder.getClass().getSimpleName() + "(ref:" + ref + ")";
- buffer.append(KEY_NAME + "=").append(ObjectName.quote(name));
- } else {
- // create a name based on its instance
- buffer.append(KEY_NAME + "=")
- .append(builder.getClass().getSimpleName())
- .append("(").append(ObjectHelper.getIdentityHashCode(builder)).append(")");
- }
-
- return createObjectName(buffer);
- }
-
- @Override
public ObjectName getObjectNameForConsumer(CamelContext context, Consumer consumer) throws MalformedObjectNameException {
StringBuilder buffer = new StringBuilder();
buffer.append(domainName).append(":");
diff --git a/core/camel-management/src/main/java/org/apache/camel/management/DefaultManagementObjectStrategy.java b/core/camel-management/src/main/java/org/apache/camel/management/DefaultManagementObjectStrategy.java
index 8565de8..08a9aa6 100644
--- a/core/camel-management/src/main/java/org/apache/camel/management/DefaultManagementObjectStrategy.java
+++ b/core/camel-management/src/main/java/org/apache/camel/management/DefaultManagementObjectStrategy.java
@@ -24,7 +24,6 @@ import org.apache.camel.Component;
import org.apache.camel.Consumer;
import org.apache.camel.DelegateProcessor;
import org.apache.camel.Endpoint;
-import org.apache.camel.ErrorHandlerFactory;
import org.apache.camel.NamedNode;
import org.apache.camel.Processor;
import org.apache.camel.Producer;
@@ -51,7 +50,6 @@ import org.apache.camel.management.mbean.ManagedDelayer;
import org.apache.camel.management.mbean.ManagedDynamicRouter;
import org.apache.camel.management.mbean.ManagedEndpoint;
import org.apache.camel.management.mbean.ManagedEnricher;
-import org.apache.camel.management.mbean.ManagedErrorHandler;
import org.apache.camel.management.mbean.ManagedEventNotifier;
import org.apache.camel.management.mbean.ManagedFailoverLoadBalancer;
import org.apache.camel.management.mbean.ManagedFilter;
@@ -239,15 +237,6 @@ public class DefaultManagementObjectStrategy implements ManagementObjectStrategy
}
@Override
- public Object getManagedObjectForErrorHandler(
- CamelContext context, Route route,
- Processor errorHandler, ErrorHandlerFactory errorHandlerBuilder) {
- ManagedErrorHandler me = new ManagedErrorHandler(route, errorHandler, errorHandlerBuilder);
- me.init(context.getManagementStrategy());
- return me;
- }
-
- @Override
public Object getManagedObjectForRouteController(CamelContext context, RouteController routeController) {
ManagedService mrc;
if (routeController instanceof SupervisingRouteController) {
diff --git a/core/camel-management/src/main/java/org/apache/camel/management/JmxManagementLifecycleStrategy.java b/core/camel-management/src/main/java/org/apache/camel/management/JmxManagementLifecycleStrategy.java
index ae088a4..aae3e70 100644
--- a/core/camel-management/src/main/java/org/apache/camel/management/JmxManagementLifecycleStrategy.java
+++ b/core/camel-management/src/main/java/org/apache/camel/management/JmxManagementLifecycleStrategy.java
@@ -36,7 +36,6 @@ import org.apache.camel.Channel;
import org.apache.camel.Component;
import org.apache.camel.Consumer;
import org.apache.camel.Endpoint;
-import org.apache.camel.ErrorHandlerFactory;
import org.apache.camel.ExtendedCamelContext;
import org.apache.camel.ManagementStatisticsLevel;
import org.apache.camel.NamedNode;
@@ -691,52 +690,6 @@ public class JmxManagementLifecycleStrategy extends ServiceSupport implements Li
}
@Override
- public void onErrorHandlerAdd(Route route, Processor errorHandler, ErrorHandlerFactory errorHandlerBuilder) {
- if (!initialized) {
- // pre register so we can register later when we have been initialized
- preServices.add(lf -> lf.onErrorHandlerAdd(route, errorHandler, errorHandlerBuilder));
- return;
- }
-
- if (!shouldRegister(errorHandler, null)) {
- // avoid registering if not needed
- return;
- }
-
- Object me = getManagementObjectStrategy().getManagedObjectForErrorHandler(camelContext, route, errorHandler,
- errorHandlerBuilder);
-
- // skip already managed services, for example if a route has been restarted
- if (getManagementStrategy().isManaged(me)) {
- LOG.trace("The error handler builder is already managed: {}", errorHandlerBuilder);
- return;
- }
-
- try {
- manageObject(me);
- } catch (Exception e) {
- LOG.warn("Could not register error handler builder: " + errorHandlerBuilder + " as ErrorHandler MBean.", e);
- }
- }
-
- @Override
- public void onErrorHandlerRemove(Route route, Processor errorHandler, ErrorHandlerFactory errorHandlerBuilder) {
- if (!initialized) {
- return;
- }
-
- Object me = getManagementObjectStrategy().getManagedObjectForErrorHandler(camelContext, route, errorHandler,
- errorHandlerBuilder);
- if (me != null) {
- try {
- unmanageObject(me);
- } catch (Exception e) {
- LOG.warn("Could not unregister error handler: " + me + " as ErrorHandler MBean.", e);
- }
- }
- }
-
- @Override
public void onThreadPoolAdd(
CamelContext camelContext, ThreadPoolExecutor threadPool, String id,
String sourceId, String routeId, String threadPoolProfileId) {
diff --git a/core/camel-management/src/main/java/org/apache/camel/management/mbean/ManagedErrorHandler.java b/core/camel-management/src/main/java/org/apache/camel/management/mbean/ManagedErrorHandler.java
deleted file mode 100644
index a89fc39..0000000
--- a/core/camel-management/src/main/java/org/apache/camel/management/mbean/ManagedErrorHandler.java
+++ /dev/null
@@ -1,543 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.camel.management.mbean;
-
-import org.apache.camel.ErrorHandlerFactory;
-import org.apache.camel.LoggingLevel;
-import org.apache.camel.Processor;
-import org.apache.camel.Route;
-import org.apache.camel.api.management.ManagedResource;
-import org.apache.camel.api.management.mbean.ManagedErrorHandlerMBean;
-import org.apache.camel.processor.errorhandler.ErrorHandlerSupport;
-import org.apache.camel.processor.errorhandler.RedeliveryErrorHandler;
-import org.apache.camel.spi.ManagementStrategy;
-
-@ManagedResource(description = "Managed ErrorHandler")
-public class ManagedErrorHandler implements ManagedErrorHandlerMBean {
- private final Route route;
- private final Processor errorHandler;
- private final ErrorHandlerFactory errorHandlerBuilder;
-
- public ManagedErrorHandler(Route route, Processor errorHandler, ErrorHandlerFactory builder) {
- this.route = route;
- this.errorHandler = errorHandler;
- this.errorHandlerBuilder = builder;
- }
-
- public void init(ManagementStrategy strategy) {
- // do nothing
- }
-
- public Route getRoute() {
- return route;
- }
-
- public Processor getErrorHandler() {
- return errorHandler;
- }
-
- public ErrorHandlerFactory getErrorHandlerBuilder() {
- return errorHandlerBuilder;
- }
-
- @Override
- public String getCamelId() {
- return route.getCamelContext().getName();
- }
-
- @Override
- public String getCamelManagementName() {
- return route.getCamelContext().getManagementName();
- }
-
- @Override
- public boolean isSupportRedelivery() {
- return errorHandler instanceof RedeliveryErrorHandler;
- }
-
- @Override
- public boolean isDeadLetterChannel() {
- if (!isSupportRedelivery()) {
- return false;
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- return redelivery.getDeadLetter() != null;
- }
-
- @Override
- public boolean isDeadLetterUseOriginalMessage() {
- if (!isSupportRedelivery()) {
- return false;
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- return redelivery.isUseOriginalMessagePolicy();
- }
-
- @Override
- public boolean isDeadLetterUseOriginalBody() {
- if (!isSupportRedelivery()) {
- return false;
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- return redelivery.isUseOriginalBodyPolicy();
- }
-
- @Override
- public boolean isDeadLetterHandleNewException() {
- if (!isSupportRedelivery()) {
- return false;
- }
-
- // must be a dead letter channel
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- return isDeadLetterChannel() && redelivery.isDeadLetterHandleNewException();
- }
-
- @Override
- public boolean isSupportTransactions() {
- if (errorHandler instanceof ErrorHandlerSupport) {
- ErrorHandlerSupport ehs = (ErrorHandlerSupport) errorHandler;
- return ehs.supportTransacted();
- } else {
- return false;
- }
- }
-
- @Override
- public String getDeadLetterChannelEndpointUri() {
- if (!isSupportRedelivery()) {
- return null;
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- return redelivery.getDeadLetterUri();
- }
-
- @Override
- public Integer getMaximumRedeliveries() {
- if (!isSupportRedelivery()) {
- return null;
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- return redelivery.getRedeliveryPolicy().getMaximumRedeliveries();
- }
-
- @Override
- public void setMaximumRedeliveries(Integer maximum) {
- if (!isSupportRedelivery()) {
- throw new IllegalArgumentException("This error handler does not support redelivery");
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- redelivery.getRedeliveryPolicy().setMaximumRedeliveries(maximum);
- }
-
- @Override
- public Long getMaximumRedeliveryDelay() {
- if (!isSupportRedelivery()) {
- return null;
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- return redelivery.getRedeliveryPolicy().getMaximumRedeliveryDelay();
- }
-
- @Override
- public void setMaximumRedeliveryDelay(Long delay) {
- if (!isSupportRedelivery()) {
- throw new IllegalArgumentException("This error handler does not support redelivery");
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- redelivery.getRedeliveryPolicy().setMaximumRedeliveryDelay(delay);
- }
-
- @Override
- public Long getRedeliveryDelay() {
- if (!isSupportRedelivery()) {
- return null;
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- return redelivery.getRedeliveryPolicy().getRedeliveryDelay();
- }
-
- @Override
- public void setRedeliveryDelay(Long delay) {
- if (!isSupportRedelivery()) {
- throw new IllegalArgumentException("This error handler does not support redelivery");
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- redelivery.getRedeliveryPolicy().setRedeliveryDelay(delay);
- }
-
- @Override
- public Double getBackOffMultiplier() {
- if (!isSupportRedelivery()) {
- return null;
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- return redelivery.getRedeliveryPolicy().getBackOffMultiplier();
- }
-
- @Override
- public void setBackOffMultiplier(Double multiplier) {
- if (!isSupportRedelivery()) {
- throw new IllegalArgumentException("This error handler does not support redelivery");
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- redelivery.getRedeliveryPolicy().setBackOffMultiplier(multiplier);
- }
-
- @Override
- public Double getCollisionAvoidanceFactor() {
- if (!isSupportRedelivery()) {
- return null;
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- return redelivery.getRedeliveryPolicy().getCollisionAvoidanceFactor();
- }
-
- @Override
- public void setCollisionAvoidanceFactor(Double factor) {
- if (!isSupportRedelivery()) {
- throw new IllegalArgumentException("This error handler does not support redelivery");
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- redelivery.getRedeliveryPolicy().setCollisionAvoidanceFactor(factor);
- }
-
- @Override
- public Double getCollisionAvoidancePercent() {
- if (!isSupportRedelivery()) {
- return null;
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- return (double) redelivery.getRedeliveryPolicy().getCollisionAvoidancePercent();
- }
-
- @Override
- public void setCollisionAvoidancePercent(Double percent) {
- if (!isSupportRedelivery()) {
- throw new IllegalArgumentException("This error handler does not support redelivery");
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- redelivery.getRedeliveryPolicy().setCollisionAvoidancePercent(percent);
- }
-
- @Override
- public String getDelayPattern() {
- if (!isSupportRedelivery()) {
- return null;
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- return redelivery.getRedeliveryPolicy().getDelayPattern();
- }
-
- @Override
- public void setDelayPattern(String pattern) {
- if (!isSupportRedelivery()) {
- throw new IllegalArgumentException("This error handler does not support redelivery");
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- redelivery.getRedeliveryPolicy().setDelayPattern(pattern);
- }
-
- @Override
- public String getRetriesExhaustedLogLevel() {
- if (!isSupportRedelivery()) {
- return null;
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- return redelivery.getRedeliveryPolicy().getRetriesExhaustedLogLevel().name();
- }
-
- @Override
- public void setRetriesExhaustedLogLevel(String level) {
- if (!isSupportRedelivery()) {
- throw new IllegalArgumentException("This error handler does not support redelivery");
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- redelivery.getRedeliveryPolicy().setRetriesExhaustedLogLevel(LoggingLevel.valueOf(level));
- }
-
- @Override
- public String getRetryAttemptedLogLevel() {
- if (!isSupportRedelivery()) {
- return null;
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- return redelivery.getRedeliveryPolicy().getRetryAttemptedLogLevel().name();
- }
-
- @Override
- public void setRetryAttemptedLogLevel(String level) {
- if (!isSupportRedelivery()) {
- throw new IllegalArgumentException("This error handler does not support redelivery");
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- redelivery.getRedeliveryPolicy().setRetryAttemptedLogLevel(LoggingLevel.valueOf(level));
- }
-
- @Override
- public Boolean getLogStackTrace() {
- if (!isSupportRedelivery()) {
- return null;
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- return redelivery.getRedeliveryPolicy().isLogStackTrace();
- }
-
- @Override
- public void setLogStackTrace(Boolean log) {
- if (!isSupportRedelivery()) {
- throw new IllegalArgumentException("This error handler does not support redelivery");
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- redelivery.getRedeliveryPolicy().setLogStackTrace(log);
- }
-
- @Override
- public Boolean getLogRetryStackTrace() {
- if (!isSupportRedelivery()) {
- return null;
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- return redelivery.getRedeliveryPolicy().isLogRetryStackTrace();
- }
-
- @Override
- public void setLogRetryStackTrace(Boolean log) {
- if (!isSupportRedelivery()) {
- throw new IllegalArgumentException("This error handler does not support redelivery");
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- redelivery.getRedeliveryPolicy().setLogRetryStackTrace(log);
- }
-
- @Override
- public Boolean getLogHandled() {
- if (!isSupportRedelivery()) {
- return null;
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- return redelivery.getRedeliveryPolicy().isLogHandled();
- }
-
- @Override
- public void setLogHandled(Boolean log) {
- if (!isSupportRedelivery()) {
- throw new IllegalArgumentException("This error handler does not support redelivery");
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- redelivery.getRedeliveryPolicy().setLogHandled(log);
- }
-
- @Override
- public Boolean getLogNewException() {
- if (!isSupportRedelivery()) {
- return null;
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- return redelivery.getRedeliveryPolicy().isLogNewException();
- }
-
- @Override
- public void setLogNewException(Boolean log) {
- if (!isSupportRedelivery()) {
- throw new IllegalArgumentException("This error handler does not support redelivery");
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- redelivery.getRedeliveryPolicy().setLogNewException(log);
- }
-
- @Override
- public Boolean getLogExhaustedMessageHistory() {
- if (!isSupportRedelivery()) {
- throw new IllegalArgumentException("This error handler does not support redelivery");
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- return redelivery.getRedeliveryPolicy().isLogExhaustedMessageHistory();
- }
-
- @Override
- public void setLogExhaustedMessageHistory(Boolean log) {
- if (!isSupportRedelivery()) {
- throw new IllegalArgumentException("This error handler does not support redelivery");
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- redelivery.getRedeliveryPolicy().setLogExhaustedMessageHistory(log);
- }
-
- @Override
- public Boolean getLogExhaustedMessageBody() {
- if (!isSupportRedelivery()) {
- throw new IllegalArgumentException("This error handler does not support redelivery");
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- return redelivery.getRedeliveryPolicy().isLogExhaustedMessageBody();
- }
-
- @Override
- public void setLogExhaustedMessageBody(Boolean log) {
- if (!isSupportRedelivery()) {
- throw new IllegalArgumentException("This error handler does not support redelivery");
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- redelivery.getRedeliveryPolicy().setLogExhaustedMessageBody(log);
- }
-
- @Override
- public Boolean getLogContinued() {
- if (!isSupportRedelivery()) {
- return null;
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- return redelivery.getRedeliveryPolicy().isLogHandled();
- }
-
- @Override
- public void setLogContinued(Boolean log) {
- if (!isSupportRedelivery()) {
- throw new IllegalArgumentException("This error handler does not support redelivery");
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- redelivery.getRedeliveryPolicy().setLogContinued(log);
- }
-
- @Override
- public Boolean getLogExhausted() {
- if (!isSupportRedelivery()) {
- return null;
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- return redelivery.getRedeliveryPolicy().isLogExhausted();
- }
-
- @Override
- public void setLogExhausted(Boolean log) {
- if (!isSupportRedelivery()) {
- throw new IllegalArgumentException("This error handler does not support redelivery");
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- redelivery.getRedeliveryPolicy().setLogExhausted(log);
- }
-
- @Override
- public Boolean getUseCollisionAvoidance() {
- if (!isSupportRedelivery()) {
- return null;
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- return redelivery.getRedeliveryPolicy().isUseCollisionAvoidance();
- }
-
- @Override
- public void setUseCollisionAvoidance(Boolean avoidance) {
- if (!isSupportRedelivery()) {
- throw new IllegalArgumentException("This error handler does not support redelivery");
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- redelivery.getRedeliveryPolicy().setUseCollisionAvoidance(avoidance);
- }
-
- @Override
- public Boolean getUseExponentialBackOff() {
- if (!isSupportRedelivery()) {
- return null;
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- return redelivery.getRedeliveryPolicy().isUseExponentialBackOff();
- }
-
- @Override
- public void setUseExponentialBackOff(Boolean backoff) {
- if (!isSupportRedelivery()) {
- throw new IllegalArgumentException("This error handler does not support redelivery");
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- redelivery.getRedeliveryPolicy().setUseExponentialBackOff(backoff);
- }
-
- @Override
- public Boolean getAllowRedeliveryWhileStopping() {
- if (!isSupportRedelivery()) {
- return null;
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- return redelivery.getRedeliveryPolicy().isAllowRedeliveryWhileStopping();
- }
-
- @Override
- public void setAllowRedeliveryWhileStopping(Boolean allow) {
- if (!isSupportRedelivery()) {
- throw new IllegalArgumentException("This error handler does not support redelivery");
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- redelivery.getRedeliveryPolicy().setAllowRedeliveryWhileStopping(allow);
- }
-
- @Override
- public Integer getPendingRedeliveryCount() {
- if (!isSupportRedelivery()) {
- return null;
- }
-
- RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
- return redelivery.getPendingRedeliveryCount();
- }
-
-}
diff --git a/core/camel-management/src/test/java/org/apache/camel/management/ManagedErrorHandlerOptionsTest.java b/core/camel-management/src/test/java/org/apache/camel/management/ManagedErrorHandlerOptionsTest.java
deleted file mode 100644
index 0c3c2f8..0000000
--- a/core/camel-management/src/test/java/org/apache/camel/management/ManagedErrorHandlerOptionsTest.java
+++ /dev/null
@@ -1,155 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.camel.management;
-
-import java.util.Set;
-
-import javax.management.Attribute;
-import javax.management.MBeanServer;
-import javax.management.ObjectName;
-
-import org.apache.camel.CamelExecutionException;
-import org.apache.camel.LoggingLevel;
-import org.apache.camel.builder.RouteBuilder;
-import org.apache.camel.component.mock.MockEndpoint;
-import org.junit.jupiter.api.Test;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.jupiter.api.Assertions.fail;
-
-public class ManagedErrorHandlerOptionsTest extends ManagementTestSupport {
-
- private static int counter;
-
- @Test
- public void testManagedErrorHandlerOptions() throws Exception {
- // JMX tests dont work well on AIX CI servers (hangs them)
- if (isPlatform("aix")) {
- return;
- }
-
- counter = 0;
-
- MBeanServer mbeanServer = getMBeanServer();
-
- Set<ObjectName> set = mbeanServer.queryNames(new ObjectName("*:type=errorhandlers,*"), null);
- assertEquals(1, set.size());
- ObjectName on = set.iterator().next();
-
- mbeanServer.setAttribute(on, new Attribute("MaximumRedeliveries", 3));
- Integer max = (Integer) mbeanServer.getAttribute(on, "MaximumRedeliveries");
- assertEquals(3, max.intValue());
-
- mbeanServer.setAttribute(on, new Attribute("MaximumRedeliveryDelay", Long.valueOf("20000")));
- Long delay = (Long) mbeanServer.getAttribute(on, "MaximumRedeliveryDelay");
- assertEquals(20000, delay.longValue());
-
- mbeanServer.setAttribute(on, new Attribute("RedeliveryDelay", Long.valueOf("250")));
- delay = (Long) mbeanServer.getAttribute(on, "RedeliveryDelay");
- assertEquals(250, delay.longValue());
-
- String camelId = (String) mbeanServer.getAttribute(on, "CamelId");
- assertEquals("camel-1", camelId);
-
- mbeanServer.setAttribute(on, new Attribute("BackOffMultiplier", Double.valueOf("3.5")));
- Double backoff = (Double) mbeanServer.getAttribute(on, "BackOffMultiplier");
- assertNotNull(backoff);
-
- mbeanServer.setAttribute(on, new Attribute("CollisionAvoidanceFactor", Double.valueOf("1.5")));
- Double cf = (Double) mbeanServer.getAttribute(on, "CollisionAvoidanceFactor");
- assertNotNull(cf);
-
- mbeanServer.setAttribute(on, new Attribute("CollisionAvoidancePercent", Double.valueOf("75")));
- Double cp = (Double) mbeanServer.getAttribute(on, "CollisionAvoidancePercent");
- assertNotNull(cp);
-
- mbeanServer.setAttribute(on, new Attribute("DelayPattern", "0:1000;5:5000"));
- String dp = (String) mbeanServer.getAttribute(on, "DelayPattern");
- assertNotNull(dp);
-
- mbeanServer.setAttribute(on, new Attribute("RetriesExhaustedLogLevel", "WARN"));
- String ell = (String) mbeanServer.getAttribute(on, "RetriesExhaustedLogLevel");
- assertEquals(LoggingLevel.WARN.name(), ell);
-
- mbeanServer.setAttribute(on, new Attribute("RetryAttemptedLogLevel", "WARN"));
- String rll = (String) mbeanServer.getAttribute(on, "RetryAttemptedLogLevel");
- assertEquals(LoggingLevel.WARN.name(), rll);
-
- mbeanServer.setAttribute(on, new Attribute("LogStackTrace", Boolean.TRUE));
- Boolean lst = (Boolean) mbeanServer.getAttribute(on, "LogStackTrace");
- assertEquals(true, lst.booleanValue());
-
- mbeanServer.setAttribute(on, new Attribute("UseCollisionAvoidance", Boolean.TRUE));
- Boolean uca = (Boolean) mbeanServer.getAttribute(on, "UseCollisionAvoidance");
- assertEquals(true, uca.booleanValue());
-
- mbeanServer.setAttribute(on, new Attribute("UseExponentialBackOff", Boolean.TRUE));
- Boolean uebf = (Boolean) mbeanServer.getAttribute(on, "UseExponentialBackOff");
- assertEquals(true, uebf.booleanValue());
-
- Boolean ne = (Boolean) mbeanServer.getAttribute(on, "DeadLetterHandleNewException");
- assertEquals(false, ne.booleanValue());
-
- MockEndpoint mock = getMockEndpoint("mock:result");
- mock.expectedMessageCount(1);
-
- template.sendBody("direct:start", "Hello World");
-
- assertEquals(3, counter);
-
- assertMockEndpointsSatisfied();
-
- // now change to 0 attempts and try again
- counter = 0;
- mock.reset();
- mock.expectedMessageCount(0);
- mbeanServer.setAttribute(on, new Attribute("MaximumRedeliveries", 0));
-
- try {
- template.sendBody("direct:start", "Bye World");
- fail("Should have thrown exception");
- } catch (CamelExecutionException e) {
- IllegalArgumentException cause = assertIsInstanceOf(IllegalArgumentException.class, e.getCause());
- assertEquals("Forced", cause.getMessage());
-
- }
-
- assertEquals(1, counter);
-
- // and should now be 0
- max = (Integer) mbeanServer.getAttribute(on, "MaximumRedeliveries");
- assertEquals(0, max.intValue());
- }
-
- @Override
- protected RouteBuilder createRouteBuilder() throws Exception {
- return new RouteBuilder() {
- @Override
- public void configure() throws Exception {
- errorHandler(defaultErrorHandler().maximumRedeliveries(5));
-
- from("direct:start").process(exchange -> {
- counter++;
- if (counter < 3) {
- throw new IllegalArgumentException("Forced");
- }
- }).to("mock:result");
- }
- };
- }
-}
diff --git a/core/camel-management/src/test/java/org/apache/camel/management/ManagedErrorHandlerRedeliveryTest.java b/core/camel-management/src/test/java/org/apache/camel/management/ManagedErrorHandlerRedeliveryTest.java
deleted file mode 100644
index 0cbddc1..0000000
--- a/core/camel-management/src/test/java/org/apache/camel/management/ManagedErrorHandlerRedeliveryTest.java
+++ /dev/null
@@ -1,155 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.camel.management;
-
-import java.util.Set;
-
-import javax.management.Attribute;
-import javax.management.MBeanServer;
-import javax.management.ObjectName;
-
-import org.apache.camel.CamelExecutionException;
-import org.apache.camel.LoggingLevel;
-import org.apache.camel.builder.RouteBuilder;
-import org.apache.camel.component.mock.MockEndpoint;
-import org.junit.jupiter.api.Test;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.jupiter.api.Assertions.assertNull;
-import static org.junit.jupiter.api.Assertions.fail;
-
-public class ManagedErrorHandlerRedeliveryTest extends ManagementTestSupport {
-
- private static int counter;
-
- @Test
- public void testManagedErrorHandlerRedelivery() throws Exception {
- // JMX tests dont work well on AIX CI servers (hangs them)
- if (isPlatform("aix")) {
- return;
- }
-
- counter = 0;
-
- MBeanServer mbeanServer = getMBeanServer();
-
- Set<ObjectName> set = mbeanServer.queryNames(new ObjectName("*:type=errorhandlers,*"), null);
- assertEquals(1, set.size());
- ObjectName on = set.iterator().next();
-
- Integer max = (Integer) mbeanServer.getAttribute(on, "MaximumRedeliveries");
- assertEquals(5, max.intValue());
-
- Long delay = (Long) mbeanServer.getAttribute(on, "MaximumRedeliveryDelay");
- assertEquals(60000, delay.longValue());
-
- delay = (Long) mbeanServer.getAttribute(on, "RedeliveryDelay");
- assertEquals(1000, delay.longValue());
-
- String camelId = (String) mbeanServer.getAttribute(on, "CamelId");
- assertEquals("camel-1", camelId);
-
- Boolean dlc = (Boolean) mbeanServer.getAttribute(on, "DeadLetterChannel");
- assertEquals(Boolean.FALSE, dlc);
-
- Boolean dlcom = (Boolean) mbeanServer.getAttribute(on, "DeadLetterUseOriginalMessage");
- assertEquals(Boolean.FALSE, dlcom);
-
- Boolean tx = (Boolean) mbeanServer.getAttribute(on, "SupportTransactions");
- assertEquals(Boolean.FALSE, tx);
-
- String dlcUri = (String) mbeanServer.getAttribute(on, "DeadLetterChannelEndpointUri");
- assertNull(dlcUri);
-
- Double backoff = (Double) mbeanServer.getAttribute(on, "BackOffMultiplier");
- assertNotNull(backoff);
-
- Double cf = (Double) mbeanServer.getAttribute(on, "CollisionAvoidanceFactor");
- assertNotNull(cf);
-
- Double cp = (Double) mbeanServer.getAttribute(on, "CollisionAvoidancePercent");
- assertNotNull(cp);
-
- String dp = (String) mbeanServer.getAttribute(on, "DelayPattern");
- assertNull(dp);
-
- String ell = (String) mbeanServer.getAttribute(on, "RetriesExhaustedLogLevel");
- assertEquals(LoggingLevel.ERROR.name(), ell);
-
- String rll = (String) mbeanServer.getAttribute(on, "RetryAttemptedLogLevel");
- assertEquals(LoggingLevel.DEBUG.name(), rll);
-
- Boolean lst = (Boolean) mbeanServer.getAttribute(on, "LogStackTrace");
- assertEquals(true, lst.booleanValue());
-
- Boolean lrst = (Boolean) mbeanServer.getAttribute(on, "LogRetryStackTrace");
- assertEquals(false, lrst.booleanValue());
-
- Boolean uca = (Boolean) mbeanServer.getAttribute(on, "UseCollisionAvoidance");
- assertEquals(false, uca.booleanValue());
-
- Boolean uebf = (Boolean) mbeanServer.getAttribute(on, "UseExponentialBackOff");
- assertEquals(false, uebf.booleanValue());
-
- MockEndpoint mock = getMockEndpoint("mock:result");
- mock.expectedMessageCount(1);
-
- template.sendBody("direct:start", "Hello World");
-
- assertEquals(3, counter);
-
- assertMockEndpointsSatisfied();
-
- // now change to 0 attempts and try again
- counter = 0;
- mock.reset();
- mock.expectedMessageCount(0);
- mbeanServer.setAttribute(on, new Attribute("MaximumRedeliveries", 0));
-
- try {
- template.sendBody("direct:start", "Bye World");
- fail("Should have thrown exception");
- } catch (CamelExecutionException e) {
- IllegalArgumentException cause = assertIsInstanceOf(IllegalArgumentException.class, e.getCause());
- assertEquals("Forced", cause.getMessage());
- }
-
- assertEquals(1, counter);
-
- // and should now be 0
- max = (Integer) mbeanServer.getAttribute(on, "MaximumRedeliveries");
- assertEquals(0, max.intValue());
- }
-
- @Override
- protected RouteBuilder createRouteBuilder() throws Exception {
- return new RouteBuilder() {
- @Override
- public void configure() throws Exception {
- errorHandler(defaultErrorHandler().maximumRedeliveries(5));
-
- from("direct:start").process(exchange -> {
- counter++;
- if (counter < 3) {
- throw new IllegalArgumentException("Forced");
- }
- }).to("mock:result");
- }
- };
- }
-}
diff --git a/core/camel-management/src/test/java/org/apache/camel/management/ManagedErrorHandlerTest.java b/core/camel-management/src/test/java/org/apache/camel/management/ManagedErrorHandlerTest.java
deleted file mode 100644
index 3cacc7b..0000000
--- a/core/camel-management/src/test/java/org/apache/camel/management/ManagedErrorHandlerTest.java
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.camel.management;
-
-import java.util.Iterator;
-import java.util.Set;
-
-import javax.management.MBeanServer;
-import javax.management.ObjectName;
-
-import org.apache.camel.builder.RouteBuilder;
-import org.junit.jupiter.api.Test;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-public class ManagedErrorHandlerTest extends ManagementTestSupport {
-
- @Test
- public void testManagedErrorHandler() throws Exception {
- // JMX tests dont work well on AIX CI servers (hangs them)
- if (isPlatform("aix")) {
- return;
- }
-
- MBeanServer mbeanServer = getMBeanServer();
-
- Set<ObjectName> set = mbeanServer.queryNames(new ObjectName("*:type=errorhandlers,*"), null);
- // there should only be 2 error handler types as route 1 and route 3 uses the same default error handler
- assertEquals(2, set.size());
-
- Iterator<ObjectName> it = set.iterator();
- ObjectName on1 = it.next();
- ObjectName on2 = it.next();
-
- String name1 = on1.getCanonicalName();
- String name2 = on2.getCanonicalName();
-
- assertTrue(name1.contains("CamelDefaultErrorHandlerBuilder") || name2.contains("CamelDefaultErrorHandlerBuilder"),
- "Should be a default error handler");
- assertTrue(name1.contains("DeadLetterChannelBuilder") || name2.contains("DeadLetterChannelBuilder"),
- "Should be a dead letter error handler");
- }
-
- @Override
- protected RouteBuilder createRouteBuilder() throws Exception {
- return new RouteBuilder() {
- @Override
- public void configure() throws Exception {
- from("direct:foo").to("mock:foo");
-
- from("direct:bar").errorHandler(deadLetterChannel("mock:dead")).to("mock:bar");
-
- from("direct:baz").to("mock:baz");
- }
- };
- }
-}
diff --git a/core/camel-management/src/test/java/org/apache/camel/management/ManagedRouteRemoveContextScopedErrorHandlerTest.java b/core/camel-management/src/test/java/org/apache/camel/management/ManagedRouteRemoveContextScopedErrorHandlerTest.java
index ae5de8f..5631b2d 100644
--- a/core/camel-management/src/test/java/org/apache/camel/management/ManagedRouteRemoveContextScopedErrorHandlerTest.java
+++ b/core/camel-management/src/test/java/org/apache/camel/management/ManagedRouteRemoveContextScopedErrorHandlerTest.java
@@ -52,10 +52,6 @@ public class ManagedRouteRemoveContextScopedErrorHandlerTest extends ManagementT
String state = (String) mbeanServer.getAttribute(on, "State");
assertEquals(ServiceStatus.Started.name(), state, "Should be started");
- // and one context scoped error handler
- Set<ObjectName> set = mbeanServer.queryNames(new ObjectName("*:type=errorhandlers,*"), null);
- assertEquals(1, set.size());
-
// stop
mbeanServer.invoke(on, "stop", null, null);
@@ -70,11 +66,7 @@ public class ManagedRouteRemoveContextScopedErrorHandlerTest extends ManagementT
assertFalse(registered, "Route mbean should have been unregistered");
// and no more routes
- set = mbeanServer.queryNames(new ObjectName("*:type=routes,*"), null);
- assertEquals(0, set.size());
-
- // no more error handlers
- set = mbeanServer.queryNames(new ObjectName("*:type=errorhandlers,*"), null);
+ Set set = mbeanServer.queryNames(new ObjectName("*:type=routes,*"), null);
assertEquals(0, set.size());
}
diff --git a/core/camel-management/src/test/java/org/apache/camel/management/ManagedRouteRemoveRouteAndContextScopedErrorHandlerTest.java b/core/camel-management/src/test/java/org/apache/camel/management/ManagedRouteRemoveRouteAndContextScopedErrorHandlerTest.java
index 23fb22e..88febaa 100644
--- a/core/camel-management/src/test/java/org/apache/camel/management/ManagedRouteRemoveRouteAndContextScopedErrorHandlerTest.java
+++ b/core/camel-management/src/test/java/org/apache/camel/management/ManagedRouteRemoveRouteAndContextScopedErrorHandlerTest.java
@@ -53,10 +53,6 @@ public class ManagedRouteRemoveRouteAndContextScopedErrorHandlerTest extends Man
String state = (String) mbeanServer.getAttribute(on, "State");
assertEquals(ServiceStatus.Started.name(), state, "Should be started");
- // and 1 context scoped and 1 route scoped error handler
- Set<ObjectName> set = mbeanServer.queryNames(new ObjectName("*:type=errorhandlers,*"), null);
- assertEquals(2, set.size());
-
// stop
mbeanServer.invoke(on, "stop", null, null);
@@ -71,11 +67,7 @@ public class ManagedRouteRemoveRouteAndContextScopedErrorHandlerTest extends Man
assertFalse(registered, "Route mbean should have been unregistered");
// and only the other route
- set = mbeanServer.queryNames(new ObjectName("*:type=routes,*"), null);
- assertEquals(1, set.size());
-
- // and the route scoped error handler should be removed
- set = mbeanServer.queryNames(new ObjectName("*:type=errorhandlers,*"), null);
+ Set set = mbeanServer.queryNames(new ObjectName("*:type=routes,*"), null);
assertEquals(1, set.size());
}
@@ -100,10 +92,6 @@ public class ManagedRouteRemoveRouteAndContextScopedErrorHandlerTest extends Man
String state = (String) mbeanServer.getAttribute(on, "State");
assertEquals(ServiceStatus.Started.name(), state, "Should be started");
- // and 1 context scoped and 1 route scoped error handler
- Set<ObjectName> set = mbeanServer.queryNames(new ObjectName("*:type=errorhandlers,*"), null);
- assertEquals(2, set.size());
-
// stop
mbeanServer.invoke(on, "stop", null, null);
@@ -118,11 +106,7 @@ public class ManagedRouteRemoveRouteAndContextScopedErrorHandlerTest extends Man
assertFalse(registered, "Route mbean should have been unregistered");
// and only the other route
- set = mbeanServer.queryNames(new ObjectName("*:type=routes,*"), null);
- assertEquals(1, set.size());
-
- // should still be one error handler
- set = mbeanServer.queryNames(new ObjectName("*:type=errorhandlers,*"), null);
+ Set set = mbeanServer.queryNames(new ObjectName("*:type=routes,*"), null);
assertEquals(1, set.size());
}
diff --git a/core/camel-management/src/test/java/org/apache/camel/management/ManagedRouteRemoveRouteScopedErrorHandlerTest.java b/core/camel-management/src/test/java/org/apache/camel/management/ManagedRouteRemoveRouteScopedErrorHandlerTest.java
index 04c7ba6..f87cac9 100644
--- a/core/camel-management/src/test/java/org/apache/camel/management/ManagedRouteRemoveRouteScopedErrorHandlerTest.java
+++ b/core/camel-management/src/test/java/org/apache/camel/management/ManagedRouteRemoveRouteScopedErrorHandlerTest.java
@@ -52,10 +52,6 @@ public class ManagedRouteRemoveRouteScopedErrorHandlerTest extends ManagementTes
String state = (String) mbeanServer.getAttribute(on, "State");
assertEquals(ServiceStatus.Started.name(), state, "Should be started");
- // and one context scoped error handler
- Set<ObjectName> set = mbeanServer.queryNames(new ObjectName("*:type=errorhandlers,*"), null);
- assertEquals(1, set.size());
-
// stop
mbeanServer.invoke(on, "stop", null, null);
@@ -70,11 +66,7 @@ public class ManagedRouteRemoveRouteScopedErrorHandlerTest extends ManagementTes
assertFalse(registered, "Route mbean should have been unregistered");
// and no more routes
- set = mbeanServer.queryNames(new ObjectName("*:type=routes,*"), null);
- assertEquals(0, set.size());
-
- // and the route scoped error handler should be removed
- set = mbeanServer.queryNames(new ObjectName("*:type=errorhandlers,*"), null);
+ Set set = mbeanServer.queryNames(new ObjectName("*:type=routes,*"), null);
assertEquals(0, set.size());
}
diff --git a/core/camel-support/src/main/java/org/apache/camel/support/LifecycleStrategySupport.java b/core/camel-support/src/main/java/org/apache/camel/support/LifecycleStrategySupport.java
index 4e8d7ba..ef482f6 100644
--- a/core/camel-support/src/main/java/org/apache/camel/support/LifecycleStrategySupport.java
+++ b/core/camel-support/src/main/java/org/apache/camel/support/LifecycleStrategySupport.java
@@ -23,8 +23,6 @@ import java.util.function.Consumer;
import org.apache.camel.CamelContext;
import org.apache.camel.Component;
import org.apache.camel.Endpoint;
-import org.apache.camel.ErrorHandlerFactory;
-import org.apache.camel.Processor;
import org.apache.camel.Route;
import org.apache.camel.Service;
import org.apache.camel.VetoCamelContextStartException;
@@ -294,16 +292,6 @@ public abstract class LifecycleStrategySupport implements LifecycleStrategy {
}
@Override
- public void onErrorHandlerAdd(Route route, Processor errorHandler, ErrorHandlerFactory errorHandlerBuilder) {
- // noop
- }
-
- @Override
- public void onErrorHandlerRemove(Route route, Processor errorHandler, ErrorHandlerFactory errorHandlerBuilder) {
- // noop
- }
-
- @Override
public void onThreadPoolAdd(
CamelContext camelContext, ThreadPoolExecutor threadPool, String id,
String sourceId, String routeId, String threadPoolProfileId) {
diff --git a/docs/user-manual/modules/ROOT/pages/camel-3x-upgrade-guide-3_7.adoc b/docs/user-manual/modules/ROOT/pages/camel-3x-upgrade-guide-3_7.adoc
index 951beb5..e419a26 100644
--- a/docs/user-manual/modules/ROOT/pages/camel-3x-upgrade-guide-3_7.adoc
+++ b/docs/user-manual/modules/ROOT/pages/camel-3x-upgrade-guide-3_7.adoc
@@ -45,6 +45,8 @@ The class `org.apache.camel.impl.engine.ProducerServicePool` is moved to `org.ap
The class `org.apache.camel.impl.engine.PollingConsumerServicePool` is moved to `org.apache.camel.support.cache.PollingConsumerServicePool`.
The class `org.apache.camel.impl.engine.EventNotifierCallback` is moved to `org.apache.camel.support.cache.EventNotifierCallback`.
+The interface `org.apache.camel.spi.LifecycleStrategy` has two methods removed related to adding and removing error handlers.
+
=== Type Converters
Camel 3.7 has optimized its type converter system, which can impact 3rd party components which has type converters.
@@ -62,6 +64,10 @@ Support for using unites as `days`, `hours`, `minutes`, `seconds`, and `millis`
Units must now also be one of `d` for days, `h` for hours, `m` for minutes, `s` for seconds, and `ms` for millis (can be omitted).
So you can use `1h12m37s42ms` for 1 hour, 12 minutes, 37 seconds and 42 milli seconds.
+=== JMX
+
+The MBeans for error handlers has been removed.
+
=== ProcessorFactory
If a custom `org.apache.camel.spi.ProcessorFactory` is in use, then the factory should extend the default implementation