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 */ 017package org.apache.camel.util; 018 019import java.util.EventObject; 020import java.util.List; 021 022import org.apache.camel.CamelContext; 023import org.apache.camel.Endpoint; 024import org.apache.camel.Exchange; 025import org.apache.camel.Processor; 026import org.apache.camel.Route; 027import org.apache.camel.StatefulService; 028import org.apache.camel.spi.EventFactory; 029import org.apache.camel.spi.EventNotifier; 030import org.apache.camel.spi.ManagementStrategy; 031import org.slf4j.Logger; 032import org.slf4j.LoggerFactory; 033 034/** 035 * Helper for easily sending event notifications in a single line of code 036 * 037 * @version 038 */ 039public final class EventHelper { 040 041 private static final Logger LOG = LoggerFactory.getLogger(EventHelper.class); 042 043 private EventHelper() { 044 } 045 046 public static void notifyCamelContextStarting(CamelContext context) { 047 ManagementStrategy management = context.getManagementStrategy(); 048 if (management == null) { 049 return; 050 } 051 052 List<EventNotifier> notifiers = management.getEventNotifiers(); 053 if (notifiers == null || notifiers.isEmpty()) { 054 return; 055 } 056 057 for (EventNotifier notifier : notifiers) { 058 if (notifier.isIgnoreCamelContextEvents()) { 059 continue; 060 } 061 062 EventFactory factory = management.getEventFactory(); 063 if (factory == null) { 064 return; 065 } 066 EventObject event = factory.createCamelContextStartingEvent(context); 067 if (event == null) { 068 return; 069 } 070 doNotifyEvent(notifier, event); 071 } 072 } 073 074 public static void notifyCamelContextStarted(CamelContext context) { 075 ManagementStrategy management = context.getManagementStrategy(); 076 if (management == null) { 077 return; 078 } 079 080 List<EventNotifier> notifiers = management.getEventNotifiers(); 081 if (notifiers == null || notifiers.isEmpty()) { 082 return; 083 } 084 085 for (EventNotifier notifier : notifiers) { 086 if (notifier.isIgnoreCamelContextEvents()) { 087 continue; 088 } 089 090 EventFactory factory = management.getEventFactory(); 091 if (factory == null) { 092 return; 093 } 094 EventObject event = factory.createCamelContextStartedEvent(context); 095 if (event == null) { 096 return; 097 } 098 doNotifyEvent(notifier, event); 099 } 100 } 101 102 public static void notifyCamelContextStartupFailed(CamelContext context, Throwable cause) { 103 ManagementStrategy management = context.getManagementStrategy(); 104 if (management == null) { 105 return; 106 } 107 108 List<EventNotifier> notifiers = management.getEventNotifiers(); 109 if (notifiers == null || notifiers.isEmpty()) { 110 return; 111 } 112 113 for (EventNotifier notifier : notifiers) { 114 if (notifier.isIgnoreCamelContextEvents()) { 115 continue; 116 } 117 118 EventFactory factory = management.getEventFactory(); 119 if (factory == null) { 120 return; 121 } 122 EventObject event = factory.createCamelContextStartupFailureEvent(context, cause); 123 if (event == null) { 124 return; 125 } 126 doNotifyEvent(notifier, event); 127 } 128 } 129 130 public static void notifyCamelContextStopping(CamelContext context) { 131 ManagementStrategy management = context.getManagementStrategy(); 132 if (management == null) { 133 return; 134 } 135 136 List<EventNotifier> notifiers = management.getEventNotifiers(); 137 if (notifiers == null || notifiers.isEmpty()) { 138 return; 139 } 140 141 for (EventNotifier notifier : notifiers) { 142 if (notifier.isIgnoreCamelContextEvents()) { 143 continue; 144 } 145 146 EventFactory factory = management.getEventFactory(); 147 if (factory == null) { 148 return; 149 } 150 EventObject event = factory.createCamelContextStoppingEvent(context); 151 if (event == null) { 152 return; 153 } 154 doNotifyEvent(notifier, event); 155 } 156 } 157 158 public static void notifyCamelContextStopped(CamelContext context) { 159 ManagementStrategy management = context.getManagementStrategy(); 160 if (management == null) { 161 return; 162 } 163 164 List<EventNotifier> notifiers = management.getEventNotifiers(); 165 if (notifiers == null || notifiers.isEmpty()) { 166 return; 167 } 168 169 for (EventNotifier notifier : notifiers) { 170 if (notifier.isIgnoreCamelContextEvents()) { 171 continue; 172 } 173 174 EventFactory factory = management.getEventFactory(); 175 if (factory == null) { 176 return; 177 } 178 EventObject event = factory.createCamelContextStoppedEvent(context); 179 if (event == null) { 180 return; 181 } 182 doNotifyEvent(notifier, event); 183 } 184 } 185 186 public static void notifyCamelContextStopFailed(CamelContext context, Throwable cause) { 187 ManagementStrategy management = context.getManagementStrategy(); 188 if (management == null) { 189 return; 190 } 191 192 List<EventNotifier> notifiers = management.getEventNotifiers(); 193 if (notifiers == null || notifiers.isEmpty()) { 194 return; 195 } 196 197 for (EventNotifier notifier : notifiers) { 198 if (notifier.isIgnoreCamelContextEvents()) { 199 continue; 200 } 201 202 EventFactory factory = management.getEventFactory(); 203 if (factory == null) { 204 return; 205 } 206 EventObject event = factory.createCamelContextStopFailureEvent(context, cause); 207 if (event == null) { 208 return; 209 } 210 doNotifyEvent(notifier, event); 211 } 212 } 213 214 public static void notifyServiceStopFailure(CamelContext context, Object service, Throwable cause) { 215 ManagementStrategy management = context.getManagementStrategy(); 216 if (management == null) { 217 return; 218 } 219 220 List<EventNotifier> notifiers = management.getEventNotifiers(); 221 if (notifiers == null || notifiers.isEmpty()) { 222 return; 223 } 224 225 for (EventNotifier notifier : notifiers) { 226 if (notifier.isIgnoreServiceEvents()) { 227 continue; 228 } 229 230 EventFactory factory = management.getEventFactory(); 231 if (factory == null) { 232 return; 233 } 234 EventObject event = factory.createServiceStopFailureEvent(context, service, cause); 235 if (event == null) { 236 return; 237 } 238 doNotifyEvent(notifier, event); 239 } 240 } 241 242 public static void notifyServiceStartupFailure(CamelContext context, Object service, Throwable cause) { 243 ManagementStrategy management = context.getManagementStrategy(); 244 if (management == null) { 245 return; 246 } 247 248 List<EventNotifier> notifiers = management.getEventNotifiers(); 249 if (notifiers == null || notifiers.isEmpty()) { 250 return; 251 } 252 253 for (EventNotifier notifier : notifiers) { 254 if (notifier.isIgnoreServiceEvents()) { 255 continue; 256 } 257 258 EventFactory factory = management.getEventFactory(); 259 if (factory == null) { 260 return; 261 } 262 EventObject event = factory.createServiceStartupFailureEvent(context, service, cause); 263 if (event == null) { 264 return; 265 } 266 doNotifyEvent(notifier, event); 267 } 268 } 269 270 public static void notifyRouteStarted(CamelContext context, Route route) { 271 ManagementStrategy management = context.getManagementStrategy(); 272 if (management == null) { 273 return; 274 } 275 276 List<EventNotifier> notifiers = management.getEventNotifiers(); 277 if (notifiers == null || notifiers.isEmpty()) { 278 return; 279 } 280 281 for (EventNotifier notifier : notifiers) { 282 if (notifier.isIgnoreRouteEvents()) { 283 continue; 284 } 285 286 EventFactory factory = management.getEventFactory(); 287 if (factory == null) { 288 return; 289 } 290 EventObject event = factory.createRouteStartedEvent(route); 291 if (event == null) { 292 return; 293 } 294 doNotifyEvent(notifier, event); 295 } 296 } 297 298 public static void notifyRouteStopped(CamelContext context, Route route) { 299 ManagementStrategy management = context.getManagementStrategy(); 300 if (management == null) { 301 return; 302 } 303 304 List<EventNotifier> notifiers = management.getEventNotifiers(); 305 if (notifiers == null || notifiers.isEmpty()) { 306 return; 307 } 308 309 for (EventNotifier notifier : notifiers) { 310 if (notifier.isIgnoreRouteEvents()) { 311 continue; 312 } 313 314 EventFactory factory = management.getEventFactory(); 315 if (factory == null) { 316 return; 317 } 318 EventObject event = factory.createRouteStoppedEvent(route); 319 if (event == null) { 320 return; 321 } 322 doNotifyEvent(notifier, event); 323 } 324 } 325 326 public static void notifyRouteAdded(CamelContext context, Route route) { 327 ManagementStrategy management = context.getManagementStrategy(); 328 if (management == null) { 329 return; 330 } 331 332 List<EventNotifier> notifiers = management.getEventNotifiers(); 333 if (notifiers == null || notifiers.isEmpty()) { 334 return; 335 } 336 337 for (EventNotifier notifier : notifiers) { 338 if (notifier.isIgnoreRouteEvents()) { 339 continue; 340 } 341 342 EventFactory factory = management.getEventFactory(); 343 if (factory == null) { 344 return; 345 } 346 EventObject event = factory.createRouteAddedEvent(route); 347 if (event == null) { 348 return; 349 } 350 doNotifyEvent(notifier, event); 351 } 352 } 353 354 public static void notifyRouteRemoved(CamelContext context, Route route) { 355 ManagementStrategy management = context.getManagementStrategy(); 356 if (management == null) { 357 return; 358 } 359 360 List<EventNotifier> notifiers = management.getEventNotifiers(); 361 if (notifiers == null || notifiers.isEmpty()) { 362 return; 363 } 364 365 for (EventNotifier notifier : notifiers) { 366 if (notifier.isIgnoreRouteEvents()) { 367 continue; 368 } 369 370 EventFactory factory = management.getEventFactory(); 371 if (factory == null) { 372 return; 373 } 374 EventObject event = factory.createRouteRemovedEvent(route); 375 if (event == null) { 376 return; 377 } 378 doNotifyEvent(notifier, event); 379 } 380 } 381 382 public static void notifyExchangeCreated(CamelContext context, Exchange exchange) { 383 if (exchange.getProperty(Exchange.NOTIFY_EVENT, false, Boolean.class)) { 384 // do not generate events for an notify event 385 return; 386 } 387 388 ManagementStrategy management = context.getManagementStrategy(); 389 if (management == null) { 390 return; 391 } 392 393 List<EventNotifier> notifiers = management.getEventNotifiers(); 394 if (notifiers == null || notifiers.isEmpty()) { 395 return; 396 } 397 398 for (EventNotifier notifier : notifiers) { 399 if (notifier.isIgnoreExchangeEvents() || notifier.isIgnoreExchangeCreatedEvent()) { 400 continue; 401 } 402 403 EventFactory factory = management.getEventFactory(); 404 if (factory == null) { 405 return; 406 } 407 EventObject event = factory.createExchangeCreatedEvent(exchange); 408 if (event == null) { 409 return; 410 } 411 doNotifyEvent(notifier, event); 412 } 413 } 414 415 public static void notifyExchangeDone(CamelContext context, Exchange exchange) { 416 if (exchange.getProperty(Exchange.NOTIFY_EVENT, false, Boolean.class)) { 417 // do not generate events for an notify event 418 return; 419 } 420 421 ManagementStrategy management = context.getManagementStrategy(); 422 if (management == null) { 423 return; 424 } 425 426 List<EventNotifier> notifiers = management.getEventNotifiers(); 427 if (notifiers == null || notifiers.isEmpty()) { 428 return; 429 } 430 431 for (EventNotifier notifier : notifiers) { 432 if (notifier.isIgnoreExchangeEvents() || notifier.isIgnoreExchangeCompletedEvent()) { 433 continue; 434 } 435 436 EventFactory factory = management.getEventFactory(); 437 if (factory == null) { 438 return; 439 } 440 EventObject event = factory.createExchangeCompletedEvent(exchange); 441 if (event == null) { 442 return; 443 } 444 doNotifyEvent(notifier, event); 445 } 446 } 447 448 public static void notifyExchangeFailed(CamelContext context, Exchange exchange) { 449 if (exchange.getProperty(Exchange.NOTIFY_EVENT, false, Boolean.class)) { 450 // do not generate events for an notify event 451 return; 452 } 453 454 ManagementStrategy management = context.getManagementStrategy(); 455 if (management == null) { 456 return; 457 } 458 459 List<EventNotifier> notifiers = management.getEventNotifiers(); 460 if (notifiers == null || notifiers.isEmpty()) { 461 return; 462 } 463 464 for (EventNotifier notifier : notifiers) { 465 if (notifier.isIgnoreExchangeEvents() || notifier.isIgnoreExchangeFailedEvents()) { 466 continue; 467 } 468 469 EventFactory factory = management.getEventFactory(); 470 if (factory == null) { 471 return; 472 } 473 EventObject event = factory.createExchangeFailedEvent(exchange); 474 if (event == null) { 475 return; 476 } 477 doNotifyEvent(notifier, event); 478 } 479 } 480 481 public static void notifyExchangeFailureHandling(CamelContext context, Exchange exchange, Processor failureHandler, 482 boolean deadLetterChannel, String deadLetterUri) { 483 if (exchange.getProperty(Exchange.NOTIFY_EVENT, false, Boolean.class)) { 484 // do not generate events for an notify event 485 return; 486 } 487 488 ManagementStrategy management = context.getManagementStrategy(); 489 if (management == null) { 490 return; 491 } 492 493 List<EventNotifier> notifiers = management.getEventNotifiers(); 494 if (notifiers == null || notifiers.isEmpty()) { 495 return; 496 } 497 498 for (EventNotifier notifier : notifiers) { 499 if (notifier.isIgnoreExchangeEvents() || notifier.isIgnoreExchangeFailedEvents()) { 500 continue; 501 } 502 503 EventFactory factory = management.getEventFactory(); 504 if (factory == null) { 505 return; 506 } 507 EventObject event = factory.createExchangeFailureHandlingEvent(exchange, failureHandler, deadLetterChannel, deadLetterUri); 508 if (event == null) { 509 return; 510 } 511 doNotifyEvent(notifier, event); 512 } 513 } 514 515 public static void notifyExchangeFailureHandled(CamelContext context, Exchange exchange, Processor failureHandler, 516 boolean deadLetterChannel, String deadLetterUri) { 517 if (exchange.getProperty(Exchange.NOTIFY_EVENT, false, Boolean.class)) { 518 // do not generate events for an notify event 519 return; 520 } 521 522 ManagementStrategy management = context.getManagementStrategy(); 523 if (management == null) { 524 return; 525 } 526 527 List<EventNotifier> notifiers = management.getEventNotifiers(); 528 if (notifiers == null || notifiers.isEmpty()) { 529 return; 530 } 531 532 for (EventNotifier notifier : notifiers) { 533 if (notifier.isIgnoreExchangeEvents() || notifier.isIgnoreExchangeFailedEvents()) { 534 continue; 535 } 536 537 EventFactory factory = management.getEventFactory(); 538 if (factory == null) { 539 return; 540 } 541 EventObject event = factory.createExchangeFailureHandledEvent(exchange, failureHandler, deadLetterChannel, deadLetterUri); 542 if (event == null) { 543 return; 544 } 545 doNotifyEvent(notifier, event); 546 } 547 } 548 549 public static void notifyExchangeRedelivery(CamelContext context, Exchange exchange, int attempt) { 550 if (exchange.getProperty(Exchange.NOTIFY_EVENT, false, Boolean.class)) { 551 // do not generate events for an notify event 552 return; 553 } 554 555 ManagementStrategy management = context.getManagementStrategy(); 556 if (management == null) { 557 return; 558 } 559 560 List<EventNotifier> notifiers = management.getEventNotifiers(); 561 if (notifiers == null || notifiers.isEmpty()) { 562 return; 563 } 564 565 for (EventNotifier notifier : notifiers) { 566 if (notifier.isIgnoreExchangeEvents() || notifier.isIgnoreExchangeFailedEvents()) { 567 continue; 568 } 569 570 EventFactory factory = management.getEventFactory(); 571 if (factory == null) { 572 return; 573 } 574 EventObject event = factory.createExchangeRedeliveryEvent(exchange, attempt); 575 if (event == null) { 576 return; 577 } 578 doNotifyEvent(notifier, event); 579 } 580 } 581 582 public static void notifyExchangeSending(CamelContext context, Exchange exchange, Endpoint endpoint) { 583 if (exchange.getProperty(Exchange.NOTIFY_EVENT, false, Boolean.class)) { 584 // do not generate events for an notify event 585 return; 586 } 587 588 ManagementStrategy management = context.getManagementStrategy(); 589 if (management == null) { 590 return; 591 } 592 593 List<EventNotifier> notifiers = management.getEventNotifiers(); 594 if (notifiers == null || notifiers.isEmpty()) { 595 return; 596 } 597 598 for (EventNotifier notifier : notifiers) { 599 if (notifier.isIgnoreExchangeEvents() || notifier.isIgnoreExchangeSentEvents()) { 600 continue; 601 } 602 603 EventFactory factory = management.getEventFactory(); 604 if (factory == null) { 605 return; 606 } 607 EventObject event = factory.createExchangeSendingEvent(exchange, endpoint); 608 if (event == null) { 609 return; 610 } 611 doNotifyEvent(notifier, event); 612 } 613 } 614 615 public static void notifyExchangeSent(CamelContext context, Exchange exchange, Endpoint endpoint, long timeTaken) { 616 if (exchange.getProperty(Exchange.NOTIFY_EVENT, false, Boolean.class)) { 617 // do not generate events for an notify event 618 return; 619 } 620 621 ManagementStrategy management = context.getManagementStrategy(); 622 if (management == null) { 623 return; 624 } 625 626 List<EventNotifier> notifiers = management.getEventNotifiers(); 627 if (notifiers == null || notifiers.isEmpty()) { 628 return; 629 } 630 631 for (EventNotifier notifier : notifiers) { 632 if (notifier.isIgnoreExchangeEvents() || notifier.isIgnoreExchangeSentEvents()) { 633 continue; 634 } 635 636 EventFactory factory = management.getEventFactory(); 637 if (factory == null) { 638 return; 639 } 640 EventObject event = factory.createExchangeSentEvent(exchange, endpoint, timeTaken); 641 if (event == null) { 642 return; 643 } 644 doNotifyEvent(notifier, event); 645 } 646 } 647 648 public static void notifyCamelContextSuspending(CamelContext context) { 649 ManagementStrategy management = context.getManagementStrategy(); 650 if (management == null) { 651 return; 652 } 653 654 List<EventNotifier> notifiers = management.getEventNotifiers(); 655 if (notifiers == null || notifiers.isEmpty()) { 656 return; 657 } 658 659 for (EventNotifier notifier : notifiers) { 660 if (notifier.isIgnoreCamelContextEvents()) { 661 continue; 662 } 663 664 EventFactory factory = management.getEventFactory(); 665 if (factory == null) { 666 return; 667 } 668 EventObject event = factory.createCamelContextSuspendingEvent(context); 669 if (event == null) { 670 return; 671 } 672 doNotifyEvent(notifier, event); 673 } 674 } 675 676 public static void notifyCamelContextSuspended(CamelContext context) { 677 ManagementStrategy management = context.getManagementStrategy(); 678 if (management == null) { 679 return; 680 } 681 682 List<EventNotifier> notifiers = management.getEventNotifiers(); 683 if (notifiers == null || notifiers.isEmpty()) { 684 return; 685 } 686 687 for (EventNotifier notifier : notifiers) { 688 if (notifier.isIgnoreCamelContextEvents()) { 689 continue; 690 } 691 692 EventFactory factory = management.getEventFactory(); 693 if (factory == null) { 694 return; 695 } 696 EventObject event = factory.createCamelContextSuspendedEvent(context); 697 if (event == null) { 698 return; 699 } 700 doNotifyEvent(notifier, event); 701 } 702 } 703 704 public static void notifyCamelContextResuming(CamelContext context) { 705 ManagementStrategy management = context.getManagementStrategy(); 706 if (management == null) { 707 return; 708 } 709 710 List<EventNotifier> notifiers = management.getEventNotifiers(); 711 if (notifiers == null || notifiers.isEmpty()) { 712 return; 713 } 714 715 for (EventNotifier notifier : notifiers) { 716 if (notifier.isIgnoreCamelContextEvents()) { 717 continue; 718 } 719 720 EventFactory factory = management.getEventFactory(); 721 if (factory == null) { 722 return; 723 } 724 EventObject event = factory.createCamelContextResumingEvent(context); 725 if (event == null) { 726 return; 727 } 728 doNotifyEvent(notifier, event); 729 } 730 } 731 732 public static void notifyCamelContextResumed(CamelContext context) { 733 ManagementStrategy management = context.getManagementStrategy(); 734 if (management == null) { 735 return; 736 } 737 738 List<EventNotifier> notifiers = management.getEventNotifiers(); 739 if (notifiers == null || notifiers.isEmpty()) { 740 return; 741 } 742 743 for (EventNotifier notifier : notifiers) { 744 if (notifier.isIgnoreCamelContextEvents()) { 745 continue; 746 } 747 748 EventFactory factory = management.getEventFactory(); 749 if (factory == null) { 750 return; 751 } 752 EventObject event = factory.createCamelContextResumedEvent(context); 753 if (event == null) { 754 return; 755 } 756 doNotifyEvent(notifier, event); 757 } 758 } 759 760 public static void notifyCamelContextResumeFailed(CamelContext context, Throwable cause) { 761 ManagementStrategy management = context.getManagementStrategy(); 762 if (management == null) { 763 return; 764 } 765 766 List<EventNotifier> notifiers = management.getEventNotifiers(); 767 if (notifiers == null || notifiers.isEmpty()) { 768 return; 769 } 770 771 for (EventNotifier notifier : notifiers) { 772 if (notifier.isIgnoreCamelContextEvents()) { 773 continue; 774 } 775 776 EventFactory factory = management.getEventFactory(); 777 if (factory == null) { 778 return; 779 } 780 EventObject event = factory.createCamelContextResumeFailureEvent(context, cause); 781 if (event == null) { 782 return; 783 } 784 doNotifyEvent(notifier, event); 785 } 786 } 787 788 private static void doNotifyEvent(EventNotifier notifier, EventObject event) { 789 // only notify if notifier is started 790 boolean started = true; 791 if (notifier instanceof StatefulService) { 792 started = ((StatefulService) notifier).isStarted(); 793 } 794 if (!started) { 795 LOG.debug("Ignoring notifying event {}. The EventNotifier has not been started yet: {}", event, notifier); 796 return; 797 } 798 799 if (!notifier.isEnabled(event)) { 800 LOG.trace("Notifier: {} is not enabled for the event: {}", notifier, event); 801 return; 802 } 803 804 try { 805 notifier.notify(event); 806 } catch (Throwable e) { 807 LOG.warn("Error notifying event " + event + ". This exception will be ignored. ", e); 808 } 809 } 810 811}