001 /** 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017 package org.apache.camel.processor; 018 019 import java.util.Timer; 020 import java.util.TimerTask; 021 import java.util.concurrent.RejectedExecutionException; 022 023 import org.apache.camel.AsyncCallback; 024 import org.apache.camel.AsyncProcessor; 025 import org.apache.camel.Exchange; 026 import org.apache.camel.Message; 027 import org.apache.camel.Predicate; 028 import org.apache.camel.Processor; 029 import org.apache.camel.impl.converter.AsyncProcessorTypeConverter; 030 import org.apache.camel.model.ExceptionType; 031 import org.apache.camel.model.LoggingLevel; 032 import org.apache.camel.processor.exceptionpolicy.ExceptionPolicyStrategy; 033 import org.apache.camel.util.AsyncProcessorHelper; 034 import org.apache.camel.util.ServiceHelper; 035 import org.apache.commons.logging.Log; 036 import org.apache.commons.logging.LogFactory; 037 038 /** 039 * Implements a <a 040 * href="http://activemq.apache.org/camel/dead-letter-channel.html">Dead Letter 041 * Channel</a> after attempting to redeliver the message using the 042 * {@link RedeliveryPolicy} 043 * 044 * @version $Revision: 63653 $ 045 */ 046 public class DeadLetterChannel extends ErrorHandlerSupport implements AsyncProcessor { 047 public static final String REDELIVERY_COUNTER = "org.apache.camel.RedeliveryCounter"; 048 public static final String REDELIVERED = "org.apache.camel.Redelivered"; 049 public static final String EXCEPTION_CAUSE_PROPERTY = "CamelCauseException"; 050 public static final String CAUGHT_EXCEPTION_HEADER = "org.apache.camel.CamelCaughtException"; 051 052 private static final transient Log LOG = LogFactory.getLog(DeadLetterChannel.class); 053 private static final String FAILURE_HANDLED_PROPERTY = DeadLetterChannel.class.getName() + ".FAILURE_HANDLED"; 054 055 private static Timer timer = new Timer(); 056 private Processor output; 057 private Processor deadLetter; 058 private AsyncProcessor outputAsync; 059 private RedeliveryPolicy redeliveryPolicy; 060 private Logger logger; 061 062 private class RedeliveryData { 063 int redeliveryCounter; 064 long redeliveryDelay; 065 boolean sync = true; 066 Predicate handledPredicate; 067 068 // default behavior which can be overloaded on a per exception basis 069 RedeliveryPolicy currentRedeliveryPolicy = redeliveryPolicy; 070 Processor failureProcessor = deadLetter; 071 } 072 073 private class RedeliverTimerTask extends TimerTask { 074 private final Exchange exchange; 075 private final AsyncCallback callback; 076 private final RedeliveryData data; 077 078 public RedeliverTimerTask(Exchange exchange, AsyncCallback callback, RedeliveryData data) { 079 this.exchange = exchange; 080 this.callback = callback; 081 this.data = data; 082 } 083 084 @Override 085 public void run() { 086 //only handle the real AsyncProcess the exchange 087 outputAsync.process(exchange, new AsyncCallback() { 088 public void done(boolean sync) { 089 // Only handle the async case... 090 if (sync) { 091 return; 092 } 093 data.sync = false; 094 // only process if the exchange hasn't failed 095 // and it has not been handled by the error processor 096 if (exchange.getException() != null && !isFailureHandled(exchange)) { 097 // if we are redelivering then sleep before trying again 098 asyncProcess(exchange, callback, data); 099 } else { 100 callback.done(sync); 101 } 102 } 103 }); 104 } 105 } 106 107 public DeadLetterChannel(Processor output, Processor deadLetter) { 108 this(output, deadLetter, new RedeliveryPolicy(), DeadLetterChannel.createDefaultLogger(), 109 ErrorHandlerSupport.createDefaultExceptionPolicyStrategy()); 110 } 111 112 public DeadLetterChannel(Processor output, Processor deadLetter, RedeliveryPolicy redeliveryPolicy, Logger logger, ExceptionPolicyStrategy exceptionPolicyStrategy) { 113 this.deadLetter = deadLetter; 114 this.output = output; 115 this.outputAsync = AsyncProcessorTypeConverter.convert(output); 116 117 this.redeliveryPolicy = redeliveryPolicy; 118 this.logger = logger; 119 setExceptionPolicy(exceptionPolicyStrategy); 120 } 121 122 public static <E extends Exchange> Logger createDefaultLogger() { 123 return new Logger(LOG, LoggingLevel.ERROR); 124 } 125 126 @Override 127 public String toString() { 128 return "DeadLetterChannel[" + output + ", " + deadLetter + "]"; 129 } 130 131 public boolean process(Exchange exchange, final AsyncCallback callback) { 132 return process(exchange, callback, new RedeliveryData()); 133 } 134 135 public boolean process(final Exchange exchange, final AsyncCallback callback, final RedeliveryData data) { 136 137 while (true) { 138 // we can't keep retrying if the route is being shutdown. 139 if (!isRunAllowed()) { 140 if (exchange.getException() == null) { 141 exchange.setException(new RejectedExecutionException()); 142 } 143 callback.done(data.sync); 144 return data.sync; 145 } 146 147 // if the exchange is transacted then let the underlying system handle the redelivery etc. 148 // this DeadLetterChannel is only for non transacted exchanges 149 if (exchange.isTransacted() && exchange.getException() != null) { 150 if (LOG.isDebugEnabled()) { 151 LOG.debug("This is a transacted exchange, bypassing this DeadLetterChannel: " + this + " for exchange: " + exchange); 152 } 153 return data.sync; 154 } 155 156 // did previous processing caused an exception? 157 if (exchange.getException() != null) { 158 handleException(exchange, data); 159 } 160 161 // should we redeliver or not? 162 if (!data.currentRedeliveryPolicy.shouldRedeliver(data.redeliveryCounter)) { 163 return deliverToFaultProcessor(exchange, callback, data); 164 } 165 166 // should we redeliver 167 if (data.redeliveryCounter > 0) { 168 // okay we will give it another go so clear the exception so we can try again 169 if (exchange.getException() != null) { 170 exchange.setException(null); 171 } 172 173 // wait until we should redeliver 174 data.redeliveryDelay = data.currentRedeliveryPolicy.sleep(data.redeliveryDelay); 175 } 176 177 // process the exchange 178 boolean sync = outputAsync.process(exchange, new AsyncCallback() { 179 public void done(boolean sync) { 180 // Only handle the async case... 181 if (sync) { 182 return; 183 } 184 data.sync = false; 185 // only process if the exchange hasn't failed 186 // and it has not been handled by the error processor 187 if (exchange.getException() != null && !isFailureHandled(exchange)) { 188 //TODO Call the Timer for the asyncProcessor 189 asyncProcess(exchange, callback, data); 190 } else { 191 callback.done(sync); 192 } 193 } 194 }); 195 if (!sync) { 196 // It is going to be processed async.. 197 return false; 198 } 199 if (exchange.getException() == null || isFailureHandled(exchange)) { 200 // If everything went well.. then we exit here.. 201 callback.done(true); 202 return true; 203 } 204 // error occurred so loop back around..... 205 } 206 207 } 208 209 private void logFailedDelivery(String message, RedeliveryData data, Throwable e) { 210 LoggingLevel newLogLevel = null; 211 if (data.currentRedeliveryPolicy.shouldRedeliver(data.redeliveryCounter)) { 212 newLogLevel = data.currentRedeliveryPolicy.getRetryAttemptedLogLevel(); 213 } else { 214 newLogLevel = data.currentRedeliveryPolicy.getRetriesExhaustedLogLevel(); 215 } 216 if (e != null) { 217 logger.log(message, e, newLogLevel); 218 } else { 219 logger.log(message, newLogLevel); 220 } 221 } 222 223 protected void asyncProcess(final Exchange exchange, final AsyncCallback callback, final RedeliveryData data) { 224 // set the timer here 225 if (!isRunAllowed()) { 226 if (exchange.getException() == null) { 227 exchange.setException(new RejectedExecutionException()); 228 } 229 callback.done(data.sync); 230 return; 231 } 232 233 // if the exchange is transacted then let the underlying system handle the redelivery etc. 234 // this DeadLetterChannel is only for non transacted exchanges 235 if (exchange.isTransacted() && exchange.getException() != null) { 236 if (LOG.isDebugEnabled()) { 237 LOG.debug("This is a transacted exchange, bypassing this DeadLetterChannel: " + this + " for exchange: " + exchange); 238 } 239 return; 240 } 241 242 // did previous processing caused an exception? 243 if (exchange.getException() != null) { 244 handleException(exchange, data); 245 } 246 247 if (!data.currentRedeliveryPolicy.shouldRedeliver(data.redeliveryCounter)) { 248 deliverToFaultProcessor(exchange, callback, data); 249 return; 250 } 251 252 // process the next try 253 // if we are redelivering then sleep before trying again 254 if (data.redeliveryCounter > 0) { 255 // okay we will give it another go so clear the exception so we can try again 256 if (exchange.getException() != null) { 257 exchange.setException(null); 258 } 259 // wait until we should redeliver 260 data.redeliveryDelay = data.currentRedeliveryPolicy.getRedeliveryDelay(data.redeliveryDelay); 261 timer.schedule(new RedeliverTimerTask(exchange, callback, data), data.redeliveryDelay); 262 } 263 } 264 265 private void handleException(Exchange exchange, RedeliveryData data) { 266 Throwable e = exchange.getException(); 267 // set the original caused exception 268 exchange.setProperty(EXCEPTION_CAUSE_PROPERTY, e); 269 270 // find the error handler to use (if any) 271 ExceptionType exceptionPolicy = getExceptionPolicy(exchange, e); 272 if (exceptionPolicy != null) { 273 data.currentRedeliveryPolicy = exceptionPolicy.createRedeliveryPolicy(exchange.getContext(), data.currentRedeliveryPolicy); 274 data.handledPredicate = exceptionPolicy.getHandledPolicy(); 275 Processor processor = exceptionPolicy.getErrorHandler(); 276 if (processor != null) { 277 data.failureProcessor = processor; 278 } 279 } 280 281 logFailedDelivery("Failed delivery for exchangeId: " + exchange.getExchangeId() + ". On delivery attempt: " + data.redeliveryCounter + " caught: " + e, data, e); 282 data.redeliveryCounter = incrementRedeliveryCounter(exchange, e); 283 284 } 285 286 private boolean deliverToFaultProcessor(final Exchange exchange, final AsyncCallback callback, 287 final RedeliveryData data) { 288 // we did not success with the redelivery so now we let the failure processor handle it 289 setFailureHandled(exchange); 290 // must decrement the redelivery counter as we didn't process the redelivery but is 291 // handling by the failure handler. So we must -1 to not let the counter be out-of-sync 292 decrementRedeliveryCounter(exchange); 293 294 AsyncProcessor afp = AsyncProcessorTypeConverter.convert(data.failureProcessor); 295 boolean sync = afp.process(exchange, new AsyncCallback() { 296 public void done(boolean sync) { 297 restoreExceptionOnExchange(exchange, data.handledPredicate); 298 callback.done(data.sync); 299 } 300 }); 301 302 // The line below shouldn't be needed, it is invoked by the AsyncCallback above 303 //restoreExceptionOnExchange(exchange, data.handledPredicate); 304 logFailedDelivery("Failed delivery for exchangeId: " + exchange.getExchangeId() + ". Handled by the failure processor: " + data.failureProcessor, data, null); 305 return sync; 306 } 307 308 public static boolean isFailureHandled(Exchange exchange) { 309 return exchange.getProperty(FAILURE_HANDLED_PROPERTY) != null 310 || exchange.getIn().getHeader(CAUGHT_EXCEPTION_HEADER) != null; 311 } 312 313 public static void setFailureHandled(Exchange exchange) { 314 exchange.setProperty(FAILURE_HANDLED_PROPERTY, exchange.getException()); 315 exchange.getIn().setHeader(CAUGHT_EXCEPTION_HEADER, exchange.getException()); 316 exchange.setException(null); 317 } 318 319 protected static void restoreExceptionOnExchange(Exchange exchange, Predicate handledPredicate) { 320 if (handledPredicate == null || !handledPredicate.matches(exchange)) { 321 if (LOG.isDebugEnabled()) { 322 LOG.debug("This exchange is not handled so its marked as failed: " + exchange); 323 } 324 // exception not handled, put exception back in the exchange 325 exchange.setException(exchange.getProperty(FAILURE_HANDLED_PROPERTY, Throwable.class)); 326 } else { 327 if (LOG.isDebugEnabled()) { 328 LOG.debug("This exchange is handled so its marked as not failed: " + exchange); 329 } 330 exchange.setProperty(Exchange.EXCEPTION_HANDLED_PROPERTY, Boolean.TRUE); 331 } 332 } 333 334 public void process(Exchange exchange) throws Exception { 335 AsyncProcessorHelper.process(this, exchange); 336 } 337 338 // Properties 339 // ------------------------------------------------------------------------- 340 341 /** 342 * Returns the output processor 343 */ 344 public Processor getOutput() { 345 return output; 346 } 347 348 /** 349 * Returns the dead letter that message exchanges will be sent to if the 350 * redelivery attempts fail 351 */ 352 public Processor getDeadLetter() { 353 return deadLetter; 354 } 355 356 public RedeliveryPolicy getRedeliveryPolicy() { 357 return redeliveryPolicy; 358 } 359 360 /** 361 * Sets the redelivery policy 362 */ 363 public void setRedeliveryPolicy(RedeliveryPolicy redeliveryPolicy) { 364 this.redeliveryPolicy = redeliveryPolicy; 365 } 366 367 public Logger getLogger() { 368 return logger; 369 } 370 371 /** 372 * Sets the logger strategy; which {@link Log} to use and which 373 * {@link LoggingLevel} to use 374 */ 375 public void setLogger(Logger logger) { 376 this.logger = logger; 377 } 378 379 // Implementation methods 380 // ------------------------------------------------------------------------- 381 382 /** 383 * Increments the redelivery counter and adds the redelivered flag if the 384 * message has been redelivered 385 */ 386 protected int incrementRedeliveryCounter(Exchange exchange, Throwable e) { 387 Message in = exchange.getIn(); 388 Integer counter = in.getHeader(REDELIVERY_COUNTER, Integer.class); 389 int next = 1; 390 if (counter != null) { 391 next = counter + 1; 392 } 393 in.setHeader(REDELIVERY_COUNTER, next); 394 in.setHeader(REDELIVERED, Boolean.TRUE); 395 return next; 396 } 397 398 /** 399 * Prepares the redelivery counter and boolean flag for the failure handle processor 400 */ 401 private void decrementRedeliveryCounter(Exchange exchange) { 402 Message in = exchange.getIn(); 403 Integer counter = in.getHeader(REDELIVERY_COUNTER, Integer.class); 404 if (counter != null) { 405 int prev = counter - 1; 406 in.setHeader(REDELIVERY_COUNTER, prev); 407 // set boolean flag according to counter 408 in.setHeader(REDELIVERED, prev > 0 ? Boolean.TRUE : Boolean.FALSE); 409 } else { 410 // not redelivered 411 in.setHeader(REDELIVERY_COUNTER, 0); 412 in.setHeader(REDELIVERED, Boolean.FALSE); 413 } 414 } 415 416 @Override 417 protected void doStart() throws Exception { 418 ServiceHelper.startServices(output, deadLetter); 419 } 420 421 @Override 422 protected void doStop() throws Exception { 423 ServiceHelper.stopServices(deadLetter, output); 424 } 425 426 }