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}