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.model; 018 019 import javax.xml.bind.annotation.XmlAccessType; 020 import javax.xml.bind.annotation.XmlAccessorType; 021 import javax.xml.bind.annotation.XmlAttribute; 022 import javax.xml.bind.annotation.XmlRootElement; 023 024 import org.apache.camel.CamelContext; 025 import org.apache.camel.LoggingLevel; 026 import org.apache.camel.processor.RedeliveryPolicy; 027 import org.apache.camel.util.CamelContextHelper; 028 import org.apache.camel.util.ObjectHelper; 029 030 /** 031 * Represents an XML <redeliveryPolicy/> element 032 * 033 * @version 034 */ 035 @XmlRootElement(name = "redeliveryPolicy") 036 @XmlAccessorType(XmlAccessType.FIELD) 037 public class RedeliveryPolicyDefinition { 038 @XmlAttribute 039 private String maximumRedeliveries; 040 @XmlAttribute 041 private String redeliveryDelay; 042 @XmlAttribute 043 private String asyncDelayedRedelivery; 044 @XmlAttribute 045 private String backOffMultiplier; 046 @XmlAttribute 047 private String useExponentialBackOff; 048 @XmlAttribute 049 private String collisionAvoidanceFactor; 050 @XmlAttribute 051 private String useCollisionAvoidance; 052 @XmlAttribute 053 private String maximumRedeliveryDelay; 054 @XmlAttribute 055 private LoggingLevel retriesExhaustedLogLevel; 056 @XmlAttribute 057 private LoggingLevel retryAttemptedLogLevel; 058 @XmlAttribute 059 private String logRetryAttempted; 060 @XmlAttribute 061 private String logStackTrace; 062 @XmlAttribute 063 private String logRetryStackTrace; 064 @XmlAttribute 065 private String logHandled; 066 @XmlAttribute 067 private String logContinued; 068 @XmlAttribute 069 private String logExhausted; 070 @XmlAttribute 071 private String disableRedelivery; 072 @XmlAttribute 073 private String delayPattern; 074 075 public RedeliveryPolicy createRedeliveryPolicy(CamelContext context, RedeliveryPolicy parentPolicy) { 076 077 RedeliveryPolicy answer; 078 if (parentPolicy != null) { 079 answer = parentPolicy.copy(); 080 } else { 081 answer = new RedeliveryPolicy(); 082 } 083 084 try { 085 086 // copy across the properties - if they are set 087 if (maximumRedeliveries != null) { 088 answer.setMaximumRedeliveries(CamelContextHelper.parseInteger(context, maximumRedeliveries)); 089 } 090 if (redeliveryDelay != null) { 091 answer.setRedeliveryDelay(CamelContextHelper.parseLong(context, redeliveryDelay)); 092 } 093 if (asyncDelayedRedelivery != null) { 094 if (CamelContextHelper.parseBoolean(context, asyncDelayedRedelivery)) { 095 answer.asyncDelayedRedelivery(); 096 } 097 } 098 if (retriesExhaustedLogLevel != null) { 099 answer.setRetriesExhaustedLogLevel(retriesExhaustedLogLevel); 100 } 101 if (retryAttemptedLogLevel != null) { 102 answer.setRetryAttemptedLogLevel(retryAttemptedLogLevel); 103 } 104 if (backOffMultiplier != null) { 105 answer.setBackOffMultiplier(CamelContextHelper.parseDouble(context, backOffMultiplier)); 106 } 107 if (useExponentialBackOff != null) { 108 answer.setUseExponentialBackOff(CamelContextHelper.parseBoolean(context, useExponentialBackOff)); 109 } 110 if (collisionAvoidanceFactor != null) { 111 answer.setCollisionAvoidanceFactor(CamelContextHelper.parseDouble(context, collisionAvoidanceFactor)); 112 } 113 if (useCollisionAvoidance != null) { 114 answer.setUseCollisionAvoidance(CamelContextHelper.parseBoolean(context, useCollisionAvoidance)); 115 } 116 if (maximumRedeliveryDelay != null) { 117 answer.setMaximumRedeliveryDelay(CamelContextHelper.parseLong(context, maximumRedeliveryDelay)); 118 } 119 if (logStackTrace != null) { 120 answer.setLogStackTrace(CamelContextHelper.parseBoolean(context, logStackTrace)); 121 } 122 if (logRetryStackTrace != null) { 123 answer.setLogRetryStackTrace(CamelContextHelper.parseBoolean(context, logRetryStackTrace)); 124 } 125 if (logHandled != null) { 126 answer.setLogHandled(CamelContextHelper.parseBoolean(context, logHandled)); 127 } 128 if (logContinued != null) { 129 answer.setLogContinued(CamelContextHelper.parseBoolean(context, logContinued)); 130 } 131 if (logRetryAttempted != null) { 132 answer.setLogRetryAttempted(CamelContextHelper.parseBoolean(context, logRetryAttempted)); 133 } 134 if (logExhausted != null) { 135 answer.setLogExhausted(CamelContextHelper.parseBoolean(context, logExhausted)); 136 } 137 if (disableRedelivery != null) { 138 if (CamelContextHelper.parseBoolean(context, disableRedelivery)) { 139 answer.setMaximumRedeliveries(0); 140 } 141 } 142 if (delayPattern != null) { 143 answer.setDelayPattern(delayPattern); 144 } 145 } catch (Exception e) { 146 throw ObjectHelper.wrapRuntimeCamelException(e); 147 } 148 149 return answer; 150 } 151 152 @Override 153 public String toString() { 154 return "RedeliveryPolicy[maximumRedeliveries: " + maximumRedeliveries + "]"; 155 } 156 157 // Fluent API 158 //------------------------------------------------------------------------- 159 160 /** 161 * Allow synchronous delayed redelivery. 162 */ 163 public RedeliveryPolicyDefinition asyncDelayedRedelivery() { 164 setAsyncDelayedRedelivery("true"); 165 return this; 166 } 167 168 /** 169 * Sets the back off multiplier 170 * 171 * @param backOffMultiplier the back off multiplier 172 * @return the builder 173 */ 174 public RedeliveryPolicyDefinition backOffMultiplier(double backOffMultiplier) { 175 return backOffMultiplier(Double.toString(backOffMultiplier)); 176 } 177 178 /** 179 * Sets the back off multiplier (supports property placeholders) 180 * 181 * @param backOffMultiplier the back off multiplier 182 * @return the builder 183 */ 184 public RedeliveryPolicyDefinition backOffMultiplier(String backOffMultiplier) { 185 setBackOffMultiplier(backOffMultiplier); 186 return this; 187 } 188 189 /** 190 * Sets the collision avoidance percentage 191 * 192 * @param collisionAvoidancePercent the percentage 193 * @return the builder 194 */ 195 public RedeliveryPolicyDefinition collisionAvoidancePercent(double collisionAvoidancePercent) { 196 setCollisionAvoidanceFactor(Double.toString(collisionAvoidancePercent * 0.01d)); 197 return this; 198 } 199 200 /** 201 * Sets the collision avoidance factor 202 * 203 * @param collisionAvoidanceFactor the factor 204 * @return the builder 205 */ 206 public RedeliveryPolicyDefinition collisionAvoidanceFactor(double collisionAvoidanceFactor) { 207 return collisionAvoidanceFactor(Double.toString(collisionAvoidanceFactor)); 208 } 209 210 /** 211 * Sets the collision avoidance factor (supports property placeholders) 212 * 213 * @param collisionAvoidanceFactor the factor 214 * @return the builder 215 */ 216 public RedeliveryPolicyDefinition collisionAvoidanceFactor(String collisionAvoidanceFactor) { 217 setCollisionAvoidanceFactor(collisionAvoidanceFactor); 218 return this; 219 } 220 221 /** 222 * Sets the initial redelivery delay 223 * 224 * @param delay delay in millis 225 * @return the builder 226 */ 227 public RedeliveryPolicyDefinition redeliveryDelay(long delay) { 228 return redeliveryDelay(Long.toString(delay)); 229 } 230 231 /** 232 * Sets the initial redelivery delay (supports property placeholders) 233 * 234 * @param delay delay in millis 235 * @return the builder 236 */ 237 public RedeliveryPolicyDefinition redeliveryDelay(String delay) { 238 setRedeliveryDelay(delay); 239 return this; 240 } 241 242 /** 243 * Sets the logging level to use when retries has exhausted 244 * 245 * @param retriesExhaustedLogLevel the logging level 246 * @return the builder 247 */ 248 public RedeliveryPolicyDefinition retriesExhaustedLogLevel(LoggingLevel retriesExhaustedLogLevel) { 249 setRetriesExhaustedLogLevel(retriesExhaustedLogLevel); 250 return this; 251 } 252 253 /** 254 * Sets the logging level to use for logging retry attempts 255 * 256 * @param retryAttemptedLogLevel the logging level 257 * @return the builder 258 */ 259 public RedeliveryPolicyDefinition retryAttemptedLogLevel(LoggingLevel retryAttemptedLogLevel) { 260 setRetryAttemptedLogLevel(retryAttemptedLogLevel); 261 return this; 262 } 263 264 /** 265 * Sets whether stack traces should be logged. 266 * Can be used to include or reduce verbose. 267 * 268 * @param logStackTrace whether stack traces should be logged or not 269 * @return the builder 270 */ 271 public RedeliveryPolicyDefinition logStackTrace(boolean logStackTrace) { 272 return logStackTrace(Boolean.toString(logStackTrace)); 273 } 274 275 /** 276 * Sets whether stack traces should be logged (supports property placeholders) 277 * Can be used to include or reduce verbose. 278 * 279 * @param logStackTrace whether stack traces should be logged or not 280 * @return the builder 281 */ 282 public RedeliveryPolicyDefinition logStackTrace(String logStackTrace) { 283 setLogStackTrace(logStackTrace); 284 return this; 285 } 286 287 /** 288 * Sets whether stack traces should be logged when an retry attempt failed. 289 * Can be used to include or reduce verbose. 290 * 291 * @param logRetryStackTrace whether stack traces should be logged or not 292 * @return the builder 293 */ 294 public RedeliveryPolicyDefinition logRetryStackTrace(boolean logRetryStackTrace) { 295 return logRetryStackTrace(Boolean.toString(logRetryStackTrace)); 296 } 297 298 /** 299 * Sets whether stack traces should be logged when an retry attempt failed (supports property placeholders). 300 * Can be used to include or reduce verbose. 301 * 302 * @param logRetryStackTrace whether stack traces should be logged or not 303 * @return the builder 304 */ 305 public RedeliveryPolicyDefinition logRetryStackTrace(String logRetryStackTrace) { 306 setLogRetryStackTrace(logRetryStackTrace); 307 return this; 308 } 309 310 /** 311 * Sets whether retry attempts should be logged or not. 312 * Can be used to include or reduce verbose. 313 * 314 * @param logRetryAttempted whether retry attempts should be logged or not 315 * @return the builder 316 */ 317 public RedeliveryPolicyDefinition logRetryAttempted(boolean logRetryAttempted) { 318 return logRetryAttempted(Boolean.toString(logRetryAttempted)); 319 } 320 321 /** 322 * Sets whether retry attempts should be logged or not (supports property placeholders). 323 * Can be used to include or reduce verbose. 324 * 325 * @param logRetryAttempted whether retry attempts should be logged or not 326 * @return the builder 327 */ 328 public RedeliveryPolicyDefinition logRetryAttempted(String logRetryAttempted) { 329 setLogRetryAttempted(logRetryAttempted); 330 return this; 331 } 332 333 /** 334 * Sets whether handled exceptions should be logged or not. 335 * Can be used to include or reduce verbose. 336 * 337 * @param logHandled whether handled exceptions should be logged or not 338 * @return the builder 339 */ 340 public RedeliveryPolicyDefinition logHandled(boolean logHandled) { 341 return logHandled(Boolean.toString(logHandled)); 342 } 343 344 /** 345 * Sets whether handled exceptions should be logged or not (supports property placeholders). 346 * Can be used to include or reduce verbose. 347 * 348 * @param logHandled whether handled exceptions should be logged or not 349 * @return the builder 350 */ 351 public RedeliveryPolicyDefinition logHandled(String logHandled) { 352 setLogHandled(logHandled); 353 return this; 354 } 355 356 /** 357 * Sets whether continued exceptions should be logged or not. 358 * Can be used to include or reduce verbose. 359 * 360 * @param logContinued whether continued exceptions should be logged or not 361 * @return the builder 362 */ 363 public RedeliveryPolicyDefinition logContinued(boolean logContinued) { 364 return logContinued(Boolean.toString(logContinued)); 365 } 366 367 /** 368 * Sets whether continued exceptions should be logged or not (supports property placeholders). 369 * Can be used to include or reduce verbose. 370 * 371 * @param logContinued whether continued exceptions should be logged or not 372 * @return the builder 373 */ 374 public RedeliveryPolicyDefinition logContinued(String logContinued) { 375 setLogContinued(logContinued); 376 return this; 377 } 378 379 /** 380 * Sets whether exhausted exceptions should be logged or not. 381 * Can be used to include or reduce verbose. 382 * 383 * @param logExhausted whether exhausted exceptions should be logged or not 384 * @return the builder 385 */ 386 public RedeliveryPolicyDefinition logExhausted(boolean logExhausted) { 387 return logExhausted(Boolean.toString(logExhausted)); 388 } 389 390 /** 391 * Sets whether exhausted exceptions should be logged or not (supports property placeholders). 392 * Can be used to include or reduce verbose. 393 * 394 * @param logExhausted whether exhausted exceptions should be logged or not 395 * @return the builder 396 */ 397 public RedeliveryPolicyDefinition logExhausted(String logExhausted) { 398 setLogExhausted(logExhausted); 399 return this; 400 } 401 402 /** 403 * Sets the maximum redeliveries 404 * <ul> 405 * <li>x = redeliver at most x times</li> 406 * <li>0 = no redeliveries</li> 407 * <li>-1 = redeliver forever</li> 408 * </ul> 409 * 410 * @param maximumRedeliveries the value 411 * @return the builder 412 */ 413 public RedeliveryPolicyDefinition maximumRedeliveries(int maximumRedeliveries) { 414 return maximumRedeliveries(Integer.toString(maximumRedeliveries)); 415 } 416 417 /** 418 * Sets the maximum redeliveries (supports property placeholders) 419 * <ul> 420 * <li>x = redeliver at most x times</li> 421 * <li>0 = no redeliveries</li> 422 * <li>-1 = redeliver forever</li> 423 * </ul> 424 * 425 * @param maximumRedeliveries the value 426 * @return the builder 427 */ 428 public RedeliveryPolicyDefinition maximumRedeliveries(String maximumRedeliveries) { 429 setMaximumRedeliveries(maximumRedeliveries); 430 return this; 431 } 432 433 /** 434 * Turn on collision avoidance. 435 * 436 * @return the builder 437 */ 438 public RedeliveryPolicyDefinition useCollisionAvoidance() { 439 setUseCollisionAvoidance("true"); 440 return this; 441 } 442 443 /** 444 * Turn on exponential backk off 445 * 446 * @return the builder 447 */ 448 public RedeliveryPolicyDefinition useExponentialBackOff() { 449 setUseExponentialBackOff("true"); 450 return this; 451 } 452 453 /** 454 * Sets the maximum delay between redelivery 455 * 456 * @param maximumRedeliveryDelay the delay in millis 457 * @return the builder 458 */ 459 public RedeliveryPolicyDefinition maximumRedeliveryDelay(long maximumRedeliveryDelay) { 460 return maximumRedeliveryDelay(Long.toString(maximumRedeliveryDelay)); 461 } 462 463 /** 464 * Sets the maximum delay between redelivery (supports property placeholders) 465 * 466 * @param maximumRedeliveryDelay the delay in millis 467 * @return the builder 468 */ 469 public RedeliveryPolicyDefinition maximumRedeliveryDelay(String maximumRedeliveryDelay) { 470 setMaximumRedeliveryDelay(maximumRedeliveryDelay); 471 return this; 472 } 473 474 /** 475 * Sets the delay pattern with delay intervals. 476 * 477 * @param delayPattern the delay pattern 478 * @return the builder 479 */ 480 public RedeliveryPolicyDefinition delayPattern(String delayPattern) { 481 setDelayPattern(delayPattern); 482 return this; 483 } 484 485 // Properties 486 //------------------------------------------------------------------------- 487 488 public String getMaximumRedeliveries() { 489 return maximumRedeliveries; 490 } 491 492 public void setMaximumRedeliveries(String maximumRedeliveries) { 493 this.maximumRedeliveries = maximumRedeliveries; 494 } 495 496 public String getRedeliveryDelay() { 497 return redeliveryDelay; 498 } 499 500 public void setRedeliveryDelay(String redeliveryDelay) { 501 this.redeliveryDelay = redeliveryDelay; 502 } 503 504 public String getAsyncDelayedRedelivery() { 505 return asyncDelayedRedelivery; 506 } 507 508 public boolean isAsyncDelayedRedelivery(CamelContext context) { 509 if (getAsyncDelayedRedelivery() == null) { 510 return false; 511 } 512 513 try { 514 return CamelContextHelper.parseBoolean(context, getAsyncDelayedRedelivery()); 515 } catch (Exception e) { 516 throw ObjectHelper.wrapRuntimeCamelException(e); 517 } 518 } 519 520 public void setAsyncDelayedRedelivery(String asyncDelayedRedelivery) { 521 this.asyncDelayedRedelivery = asyncDelayedRedelivery; 522 } 523 524 public String getBackOffMultiplier() { 525 return backOffMultiplier; 526 } 527 528 public void setBackOffMultiplier(String backOffMultiplier) { 529 this.backOffMultiplier = backOffMultiplier; 530 } 531 532 public String getUseExponentialBackOff() { 533 return useExponentialBackOff; 534 } 535 536 public void setUseExponentialBackOff(String useExponentialBackOff) { 537 this.useExponentialBackOff = useExponentialBackOff; 538 } 539 540 public String getCollisionAvoidanceFactor() { 541 return collisionAvoidanceFactor; 542 } 543 544 public void setCollisionAvoidanceFactor(String collisionAvoidanceFactor) { 545 this.collisionAvoidanceFactor = collisionAvoidanceFactor; 546 } 547 548 public String getUseCollisionAvoidance() { 549 return useCollisionAvoidance; 550 } 551 552 public void setUseCollisionAvoidance(String useCollisionAvoidance) { 553 this.useCollisionAvoidance = useCollisionAvoidance; 554 } 555 556 public String getMaximumRedeliveryDelay() { 557 return maximumRedeliveryDelay; 558 } 559 560 public void setMaximumRedeliveryDelay(String maximumRedeliveryDelay) { 561 this.maximumRedeliveryDelay = maximumRedeliveryDelay; 562 } 563 564 public LoggingLevel getRetriesExhaustedLogLevel() { 565 return retriesExhaustedLogLevel; 566 } 567 568 public void setRetriesExhaustedLogLevel(LoggingLevel retriesExhaustedLogLevel) { 569 this.retriesExhaustedLogLevel = retriesExhaustedLogLevel; 570 } 571 572 public LoggingLevel getRetryAttemptedLogLevel() { 573 return retryAttemptedLogLevel; 574 } 575 576 public void setRetryAttemptedLogLevel(LoggingLevel retryAttemptedLogLevel) { 577 this.retryAttemptedLogLevel = retryAttemptedLogLevel; 578 } 579 580 public String getLogRetryAttempted() { 581 return logRetryAttempted; 582 } 583 584 public void setLogRetryAttempted(String logRetryAttempted) { 585 this.logRetryAttempted = logRetryAttempted; 586 } 587 588 public String getLogStackTrace() { 589 return logStackTrace; 590 } 591 592 public void setLogStackTrace(String logStackTrace) { 593 this.logStackTrace = logStackTrace; 594 } 595 596 public String getLogRetryStackTrace() { 597 return logRetryStackTrace; 598 } 599 600 public void setLogRetryStackTrace(String logRetryStackTrace) { 601 this.logRetryStackTrace = logRetryStackTrace; 602 } 603 604 public String getLogHandled() { 605 return logHandled; 606 } 607 608 public void setLogHandled(String logHandled) { 609 this.logHandled = logHandled; 610 } 611 612 public String getLogContinued() { 613 return logContinued; 614 } 615 616 public void setLogContinued(String logContinued) { 617 this.logContinued = logContinued; 618 } 619 620 public String getLogExhausted() { 621 return logExhausted; 622 } 623 624 public void setLogExhausted(String logExhausted) { 625 this.logExhausted = logExhausted; 626 } 627 628 public String getDisableRedelivery() { 629 return disableRedelivery; 630 } 631 632 public void setDisableRedelivery(String disableRedelivery) { 633 this.disableRedelivery = disableRedelivery; 634 } 635 636 public String getDelayPattern() { 637 return delayPattern; 638 } 639 640 public void setDelayPattern(String delayPattern) { 641 this.delayPattern = delayPattern; 642 } 643 }