Source code

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 boolean notifyCamelContextStarting(CamelContext context) {
047        ManagementStrategy management = context.getManagementStrategy();
048        if (management == null) {
049            return false;
050        }
051
052        EventFactory factory = management.getEventFactory();
053        if (factory == null) {
054            return false;
055        }
056
057        List<EventNotifier> notifiers = management.getEventNotifiers();
058        if (notifiers == null || notifiers.isEmpty()) {
059            return false;
060        }
061
062        boolean answer = false;
063        EventObject event = null;
064        for (EventNotifier notifier : notifiers) {
065            if (notifier.isDisabled()) {
066                continue;
067            }
068            if (notifier.isIgnoreCamelContextEvents()) {
069                continue;
070            }
071
072            if (event == null) {
073                // only create event once
074                event = factory.createCamelContextStartingEvent(context);
075                if (event == null) {
076                    // factory could not create event so exit
077                    return false;
078                }
079            }
080            answer |= doNotifyEvent(notifier, event);
081        }
082        return answer;
083    }
084
085    public static boolean notifyCamelContextStarted(CamelContext context) {
086        ManagementStrategy management = context.getManagementStrategy();
087        if (management == null) {
088            return false;
089        }
090
091        EventFactory factory = management.getEventFactory();
092        if (factory == null) {
093            return false;
094        }
095
096        List<EventNotifier> notifiers = management.getEventNotifiers();
097        if (notifiers == null || notifiers.isEmpty()) {
098            return false;
099        }
100
101        boolean answer = false;
102        EventObject event = null;
103        for (EventNotifier notifier : notifiers) {
104            if (notifier.isDisabled()) {
105                continue;
106            }
107            if (notifier.isIgnoreCamelContextEvents()) {
108                continue;
109            }
110
111            if (event == null) {
112                // only create event once
113                event = factory.createCamelContextStartedEvent(context);
114                if (event == null) {
115                    // factory could not create event so exit
116                    return false;
117                }
118            }
119            answer |= doNotifyEvent(notifier, event);
120        }
121        return answer;
122    }
123
124    public static boolean notifyCamelContextStartupFailed(CamelContext context, Throwable cause) {
125        ManagementStrategy management = context.getManagementStrategy();
126        if (management == null) {
127            return false;
128        }
129
130        EventFactory factory = management.getEventFactory();
131        if (factory == null) {
132            return false;
133        }
134
135        List<EventNotifier> notifiers = management.getEventNotifiers();
136        if (notifiers == null || notifiers.isEmpty()) {
137            return false;
138        }
139
140        boolean answer = false;
141        EventObject event = null;
142        for (EventNotifier notifier : notifiers) {
143            if (notifier.isDisabled()) {
144                continue;
145            }
146            if (notifier.isIgnoreCamelContextEvents()) {
147                continue;
148            }
149
150            if (event == null) {
151                // only create event once
152                event = factory.createCamelContextStartupFailureEvent(context, cause);
153                if (event == null) {
154                    // factory could not create event so exit
155                    return false;
156                }
157            }
158            answer |= doNotifyEvent(notifier, event);
159        }
160        return answer;
161    }
162
163    public static boolean notifyCamelContextStopping(CamelContext context) {
164        ManagementStrategy management = context.getManagementStrategy();
165        if (management == null) {
166            return false;
167        }
168
169        EventFactory factory = management.getEventFactory();
170        if (factory == null) {
171            return false;
172        }
173
174        List<EventNotifier> notifiers = management.getEventNotifiers();
175        if (notifiers == null || notifiers.isEmpty()) {
176            return false;
177        }
178
179        boolean answer = false;
180        EventObject event = null;
181        for (EventNotifier notifier : notifiers) {
182            if (notifier.isDisabled()) {
183                continue;
184            }
185            if (notifier.isIgnoreCamelContextEvents()) {
186                continue;
187            }
188
189            if (event == null) {
190                // only create event once
191                event = factory.createCamelContextStoppingEvent(context);
192                if (event == null) {
193                    // factory could not create event so exit
194                    return false;
195                }
196            }
197            answer |= doNotifyEvent(notifier, event);
198        }
199        return answer;
200    }
201
202    public static boolean notifyCamelContextStopped(CamelContext context) {
203        ManagementStrategy management = context.getManagementStrategy();
204        if (management == null) {
205            return false;
206        }
207
208        EventFactory factory = management.getEventFactory();
209        if (factory == null) {
210            return false;
211        }
212
213        List<EventNotifier> notifiers = management.getEventNotifiers();
214        if (notifiers == null || notifiers.isEmpty()) {
215            return false;
216        }
217
218        boolean answer = false;
219        EventObject event = null;
220        for (EventNotifier notifier : notifiers) {
221            if (notifier.isDisabled()) {
222                continue;
223            }
224            if (notifier.isIgnoreCamelContextEvents()) {
225                continue;
226            }
227
228            if (event == null) {
229                // only create event once
230                event = factory.createCamelContextStoppedEvent(context);
231                if (event == null) {
232                    // factory could not create event so exit
233                    return false;
234                }
235            }
236            answer |= doNotifyEvent(notifier, event);
237        }
238        return answer;
239    }
240
241    public static boolean notifyCamelContextStopFailed(CamelContext context, Throwable cause) {
242        ManagementStrategy management = context.getManagementStrategy();
243        if (management == null) {
244            return false;
245        }
246
247        EventFactory factory = management.getEventFactory();
248        if (factory == null) {
249            return false;
250        }
251
252        List<EventNotifier> notifiers = management.getEventNotifiers();
253        if (notifiers == null || notifiers.isEmpty()) {
254            return false;
255        }
256
257        boolean answer = false;
258        EventObject event = null;
259        for (EventNotifier notifier : notifiers) {
260            if (notifier.isDisabled()) {
261                continue;
262            }
263            if (notifier.isIgnoreCamelContextEvents()) {
264                continue;
265            }
266
267            if (event == null) {
268                // only create event once
269                event = factory.createCamelContextStopFailureEvent(context, cause);
270                if (event == null) {
271                    // factory could not create event so exit
272                    return false;
273                }
274            }
275            answer |= doNotifyEvent(notifier, event);
276        }
277        return answer;
278    }
279
280    public static boolean notifyServiceStopFailure(CamelContext context, Object service, Throwable cause) {
281        ManagementStrategy management = context.getManagementStrategy();
282        if (management == null) {
283            return false;
284        }
285
286        EventFactory factory = management.getEventFactory();
287        if (factory == null) {
288            return false;
289        }
290
291        List<EventNotifier> notifiers = management.getEventNotifiers();
292        if (notifiers == null || notifiers.isEmpty()) {
293            return false;
294        }
295
296        boolean answer = false;
297        EventObject event = null;
298        for (EventNotifier notifier : notifiers) {
299            if (notifier.isDisabled()) {
300                continue;
301            }
302            if (notifier.isIgnoreServiceEvents()) {
303                continue;
304            }
305
306            if (event == null) {
307                // only create event once
308                event = factory.createServiceStopFailureEvent(context, service, cause);
309                if (event == null) {
310                    // factory could not create event so exit
311                    return false;
312                }
313            }
314            answer |= doNotifyEvent(notifier, event);
315        }
316        return answer;
317    }
318
319    public static boolean notifyServiceStartupFailure(CamelContext context, Object service, Throwable cause) {
320        ManagementStrategy management = context.getManagementStrategy();
321        if (management == null) {
322            return false;
323        }
324
325        EventFactory factory = management.getEventFactory();
326        if (factory == null) {
327            return false;
328        }
329
330        List<EventNotifier> notifiers = management.getEventNotifiers();
331        if (notifiers == null || notifiers.isEmpty()) {
332            return false;
333        }
334
335        boolean answer = false;
336        EventObject event = null;
337        for (EventNotifier notifier : notifiers) {
338            if (notifier.isDisabled()) {
339                continue;
340            }
341            if (notifier.isIgnoreServiceEvents()) {
342                continue;
343            }
344
345            if (event == null) {
346                // only create event once
347                event = factory.createServiceStartupFailureEvent(context, service, cause);
348                if (event == null) {
349                    // factory could not create event so exit
350                    return false;
351                }
352            }
353            answer |= doNotifyEvent(notifier, event);
354        }
355        return answer;
356    }
357
358    public static boolean notifyRouteStarted(CamelContext context, Route route) {
359        ManagementStrategy management = context.getManagementStrategy();
360        if (management == null) {
361            return false;
362        }
363
364        EventFactory factory = management.getEventFactory();
365        if (factory == null) {
366            return false;
367        }
368
369        List<EventNotifier> notifiers = management.getEventNotifiers();
370        if (notifiers == null || notifiers.isEmpty()) {
371            return false;
372        }
373
374        boolean answer = false;
375        EventObject event = null;
376        for (EventNotifier notifier : notifiers) {
377            if (notifier.isDisabled()) {
378                continue;
379            }
380            if (notifier.isIgnoreRouteEvents()) {
381                continue;
382            }
383
384            if (event == null) {
385                // only create event once
386                event = factory.createRouteStartedEvent(route);
387                if (event == null) {
388                    // factory could not create event so exit
389                    return false;
390                }
391            }
392            answer |= doNotifyEvent(notifier, event);
393        }
394        return answer;
395    }
396
397    public static boolean notifyRouteStopped(CamelContext context, Route route) {
398        ManagementStrategy management = context.getManagementStrategy();
399        if (management == null) {
400            return false;
401        }
402
403        EventFactory factory = management.getEventFactory();
404        if (factory == null) {
405            return false;
406        }
407
408        List<EventNotifier> notifiers = management.getEventNotifiers();
409        if (notifiers == null || notifiers.isEmpty()) {
410            return false;
411        }
412
413        boolean answer = false;
414        EventObject event = null;
415        for (EventNotifier notifier : notifiers) {
416            if (notifier.isDisabled()) {
417                continue;
418            }
419            if (notifier.isIgnoreRouteEvents()) {
420                continue;
421            }
422
423            if (event == null) {
424                // only create event once
425                event = factory.createRouteStoppedEvent(route);
426                if (event == null) {
427                    // factory could not create event so exit
428                    return false;
429                }
430            }
431            answer |= doNotifyEvent(notifier, event);
432        }
433        return answer;
434    }
435
436    public static boolean notifyRouteAdded(CamelContext context, Route route) {
437        ManagementStrategy management = context.getManagementStrategy();
438        if (management == null) {
439            return false;
440        }
441
442        EventFactory factory = management.getEventFactory();
443        if (factory == null) {
444            return false;
445        }
446
447        List<EventNotifier> notifiers = management.getEventNotifiers();
448        if (notifiers == null || notifiers.isEmpty()) {
449            return false;
450        }
451
452        boolean answer = false;
453        EventObject event = null;
454        for (EventNotifier notifier : notifiers) {
455            if (notifier.isDisabled()) {
456                continue;
457            }
458            if (notifier.isIgnoreRouteEvents()) {
459                continue;
460            }
461
462            if (event == null) {
463                // only create event once
464                event = factory.createRouteAddedEvent(route);
465                if (event == null) {
466                    // factory could not create event so exit
467                    return false;
468                }
469            }
470            answer |= doNotifyEvent(notifier, event);
471        }
472        return answer;
473    }
474
475    public static boolean notifyRouteRemoved(CamelContext context, Route route) {
476        ManagementStrategy management = context.getManagementStrategy();
477        if (management == null) {
478            return false;
479        }
480
481        EventFactory factory = management.getEventFactory();
482        if (factory == null) {
483            return false;
484        }
485
486        List<EventNotifier> notifiers = management.getEventNotifiers();
487        if (notifiers == null || notifiers.isEmpty()) {
488            return false;
489        }
490
491        boolean answer = false;
492        EventObject event = null;
493        for (EventNotifier notifier : notifiers) {
494            if (notifier.isDisabled()) {
495                continue;
496            }
497            if (notifier.isIgnoreRouteEvents()) {
498                continue;
499            }
500
501            if (event == null) {
502                // only create event once
503                event = factory.createRouteRemovedEvent(route);
504                if (event == null) {
505                    // factory could not create event so exit
506                    return false;
507                }
508            }
509            answer |= doNotifyEvent(notifier, event);
510        }
511        return answer;
512    }
513
514    public static boolean notifyExchangeCreated(CamelContext context, Exchange exchange) {
515        if (exchange.getProperty(Exchange.NOTIFY_EVENT, false, Boolean.class)) {
516            // do not generate events for an notify event
517            return false;
518        }
519
520        ManagementStrategy management = context.getManagementStrategy();
521        if (management == null) {
522            return false;
523        }
524
525        EventFactory factory = management.getEventFactory();
526        if (factory == null) {
527            return false;
528        }
529
530        List<EventNotifier> notifiers = management.getEventNotifiers();
531        if (notifiers == null || notifiers.isEmpty()) {
532            return false;
533        }
534
535        boolean answer = false;
536        EventObject event = null;
537        // optimise for loop using index access to avoid creating iterator object
538        for (int i = 0; i < notifiers.size(); i++) {
539            EventNotifier notifier = notifiers.get(i);
540            if (notifier.isDisabled()) {
541                continue;
542            }
543            if (notifier.isIgnoreExchangeEvents() || notifier.isIgnoreExchangeCreatedEvent()) {
544                continue;
545            }
546
547            if (event == null) {
548                // only create event once
549                event = factory.createExchangeCreatedEvent(exchange);
550                if (event == null) {
551                    // factory could not create event so exit
552                    return false;
553                }
554            }
555            answer |= doNotifyEvent(notifier, event);
556        }
557        return answer;
558    }
559
560    public static boolean notifyExchangeDone(CamelContext context, Exchange exchange) {
561        if (exchange.getProperty(Exchange.NOTIFY_EVENT, false, Boolean.class)) {
562            // do not generate events for an notify event
563            return false;
564        }
565
566        ManagementStrategy management = context.getManagementStrategy();
567        if (management == null) {
568            return false;
569        }
570
571        EventFactory factory = management.getEventFactory();
572        if (factory == null) {
573            return false;
574        }
575
576        List<EventNotifier> notifiers = management.getEventNotifiers();
577        if (notifiers == null || notifiers.isEmpty()) {
578            return false;
579        }
580
581        boolean answer = false;
582        EventObject event = null;
583        // optimise for loop using index access to avoid creating iterator object
584        for (int i = 0; i < notifiers.size(); i++) {
585            EventNotifier notifier = notifiers.get(i);
586            if (notifier.isDisabled()) {
587                continue;
588            }
589            if (notifier.isIgnoreExchangeEvents() || notifier.isIgnoreExchangeCompletedEvent()) {
590                continue;
591            }
592
593            if (event == null) {
594                // only create event once
595                event = factory.createExchangeCompletedEvent(exchange);
596                if (event == null) {
597                    // factory could not create event so exit
598                    return false;
599                }
600            }
601            answer |= doNotifyEvent(notifier, event);
602        }
603        return answer;
604    }
605
606    public static boolean notifyExchangeFailed(CamelContext context, Exchange exchange) {
607        if (exchange.getProperty(Exchange.NOTIFY_EVENT, false, Boolean.class)) {
608            // do not generate events for an notify event
609            return false;
610        }
611
612        ManagementStrategy management = context.getManagementStrategy();
613        if (management == null) {
614            return false;
615        }
616
617        EventFactory factory = management.getEventFactory();
618        if (factory == null) {
619            return false;
620        }
621
622        List<EventNotifier> notifiers = management.getEventNotifiers();
623        if (notifiers == null || notifiers.isEmpty()) {
624            return false;
625        }
626
627        boolean answer = false;
628        EventObject event = null;
629        // optimise for loop using index access to avoid creating iterator object
630        for (int i = 0; i < notifiers.size(); i++) {
631            EventNotifier notifier = notifiers.get(i);
632            if (notifier.isDisabled()) {
633                continue;
634            }
635            if (notifier.isIgnoreExchangeEvents() || notifier.isIgnoreExchangeFailedEvents()) {
636                continue;
637            }
638
639            if (event == null) {
640                // only create event once
641                event = factory.createExchangeFailedEvent(exchange);
642                if (event == null) {
643                    // factory could not create event so exit
644                    return false;
645                }
646            }
647            answer |= doNotifyEvent(notifier, event);
648        }
649        return answer;
650    }
651
652    public static boolean notifyExchangeFailureHandling(CamelContext context, Exchange exchange, Processor failureHandler,
653                                                     boolean deadLetterChannel, String deadLetterUri) {
654        if (exchange.getProperty(Exchange.NOTIFY_EVENT, false, Boolean.class)) {
655            // do not generate events for an notify event
656            return false;
657        }
658
659        ManagementStrategy management = context.getManagementStrategy();
660        if (management == null) {
661            return false;
662        }
663
664        EventFactory factory = management.getEventFactory();
665        if (factory == null) {
666            return false;
667        }
668
669        List<EventNotifier> notifiers = management.getEventNotifiers();
670        if (notifiers == null || notifiers.isEmpty()) {
671            return false;
672        }
673
674        boolean answer = false;
675        EventObject event = null;
676        // optimise for loop using index access to avoid creating iterator object
677        for (int i = 0; i < notifiers.size(); i++) {
678            EventNotifier notifier = notifiers.get(i);
679            if (notifier.isDisabled()) {
680                continue;
681            }
682            if (notifier.isIgnoreExchangeEvents() || notifier.isIgnoreExchangeFailedEvents()) {
683                continue;
684            }
685
686            if (event == null) {
687                // only create event once
688                event = factory.createExchangeFailureHandlingEvent(exchange, failureHandler, deadLetterChannel, deadLetterUri);
689                if (event == null) {
690                    // factory could not create event so exit
691                    return false;
692                }
693            }
694            answer |= doNotifyEvent(notifier, event);
695        }
696        return answer;
697    }
698
699    public static boolean notifyExchangeFailureHandled(CamelContext context, Exchange exchange, Processor failureHandler,
700                                                    boolean deadLetterChannel, String deadLetterUri) {
701        if (exchange.getProperty(Exchange.NOTIFY_EVENT, false, Boolean.class)) {
702            // do not generate events for an notify event
703            return false;
704        }
705
706        ManagementStrategy management = context.getManagementStrategy();
707        if (management == null) {
708            return false;
709        }
710
711        EventFactory factory = management.getEventFactory();
712        if (factory == null) {
713            return false;
714        }
715
716        List<EventNotifier> notifiers = management.getEventNotifiers();
717        if (notifiers == null || notifiers.isEmpty()) {
718            return false;
719        }
720
721        boolean answer = false;
722        EventObject event = null;
723        // optimise for loop using index access to avoid creating iterator object
724        for (int i = 0; i < notifiers.size(); i++) {
725            EventNotifier notifier = notifiers.get(i);
726            if (notifier.isDisabled()) {
727                continue;
728            }
729            if (notifier.isIgnoreExchangeEvents() || notifier.isIgnoreExchangeFailedEvents()) {
730                continue;
731            }
732
733            if (event == null) {
734                // only create event once
735                event = factory.createExchangeFailureHandledEvent(exchange, failureHandler, deadLetterChannel, deadLetterUri);
736                if (event == null) {
737                    // factory could not create event so exit
738                    return false;
739                }
740            }
741            answer |= doNotifyEvent(notifier, event);
742        }
743        return answer;
744    }
745
746    public static boolean notifyExchangeRedelivery(CamelContext context, Exchange exchange, int attempt) {
747        if (exchange.getProperty(Exchange.NOTIFY_EVENT, false, Boolean.class)) {
748            // do not generate events for an notify event
749            return false;
750        }
751
752        ManagementStrategy management = context.getManagementStrategy();
753        if (management == null) {
754            return false;
755        }
756
757        EventFactory factory = management.getEventFactory();
758        if (factory == null) {
759            return false;
760        }
761
762        List<EventNotifier> notifiers = management.getEventNotifiers();
763        if (notifiers == null || notifiers.isEmpty()) {
764            return false;
765        }
766
767        boolean answer = false;
768        EventObject event = null;
769        // optimise for loop using index access to avoid creating iterator object
770        for (int i = 0; i < notifiers.size(); i++) {
771            EventNotifier notifier = notifiers.get(i);
772            if (notifier.isDisabled()) {
773                continue;
774            }
775            if (notifier.isIgnoreExchangeEvents() || notifier.isIgnoreExchangeFailedEvents()) {
776                continue;
777            }
778
779            if (event == null) {
780                // only create event once
781                event = factory.createExchangeRedeliveryEvent(exchange, attempt);
782                if (event == null) {
783                    // factory could not create event so exit
784                    return false;
785                }
786            }
787            answer |= doNotifyEvent(notifier, event);
788        }
789        return answer;
790    }
791
792    public static boolean notifyExchangeSending(CamelContext context, Exchange exchange, Endpoint endpoint) {
793        if (exchange.getProperty(Exchange.NOTIFY_EVENT, false, Boolean.class)) {
794            // do not generate events for an notify event
795            return false;
796        }
797
798        ManagementStrategy management = context.getManagementStrategy();
799        if (management == null) {
800            return false;
801        }
802
803        EventFactory factory = management.getEventFactory();
804        if (factory == null) {
805            return false;
806        }
807
808        List<EventNotifier> notifiers = management.getEventNotifiers();
809        if (notifiers == null || notifiers.isEmpty()) {
810            return false;
811        }
812
813        boolean answer = false;
814        EventObject event = null;
815        // optimise for loop using index access to avoid creating iterator object
816        for (int i = 0; i < notifiers.size(); i++) {
817            EventNotifier notifier = notifiers.get(i);
818            if (notifier.isDisabled()) {
819                continue;
820            }
821            if (notifier.isIgnoreExchangeEvents() || notifier.isIgnoreExchangeSendingEvents()) {
822                continue;
823            }
824
825            if (event == null) {
826                // only create event once
827                event = factory.createExchangeSendingEvent(exchange, endpoint);
828                if (event == null) {
829                    // factory could not create event so exit
830                    return false;
831                }
832            }
833            answer |= doNotifyEvent(notifier, event);
834        }
835        return answer;
836    }
837
838    public static boolean notifyExchangeSent(CamelContext context, Exchange exchange, Endpoint endpoint, long timeTaken) {
839        if (exchange.getProperty(Exchange.NOTIFY_EVENT, false, Boolean.class)) {
840            // do not generate events for an notify event
841            return false;
842        }
843
844        ManagementStrategy management = context.getManagementStrategy();
845        if (management == null) {
846            return false;
847        }
848
849        EventFactory factory = management.getEventFactory();
850        if (factory == null) {
851            return false;
852        }
853
854        List<EventNotifier> notifiers = management.getEventNotifiers();
855        if (notifiers == null || notifiers.isEmpty()) {
856            return false;
857        }
858
859        boolean answer = false;
860        EventObject event = null;
861        // optimise for loop using index access to avoid creating iterator object
862        for (int i = 0; i < notifiers.size(); i++) {
863            EventNotifier notifier = notifiers.get(i);
864            if (notifier.isDisabled()) {
865                continue;
866            }
867            if (notifier.isIgnoreExchangeEvents() || notifier.isIgnoreExchangeSentEvents()) {
868                continue;
869            }
870
871            if (event == null) {
872                // only create event once
873                event = factory.createExchangeSentEvent(exchange, endpoint, timeTaken);
874                if (event == null) {
875                    // factory could not create event so exit
876                    return false;
877                }
878            }
879            answer |= doNotifyEvent(notifier, event);
880        }
881        return answer;
882    }
883
884    public static boolean notifyCamelContextSuspending(CamelContext context) {
885        ManagementStrategy management = context.getManagementStrategy();
886        if (management == null) {
887            return false;
888        }
889
890        EventFactory factory = management.getEventFactory();
891        if (factory == null) {
892            return false;
893        }
894
895        List<EventNotifier> notifiers = management.getEventNotifiers();
896        if (notifiers == null || notifiers.isEmpty()) {
897            return false;
898        }
899
900        boolean answer = false;
901        EventObject event = null;
902        for (EventNotifier notifier : notifiers) {
903            if (notifier.isDisabled()) {
904                continue;
905            }
906            if (notifier.isIgnoreCamelContextEvents()) {
907                continue;
908            }
909
910            if (event == null) {
911                // only create event once
912                event = factory.createCamelContextSuspendingEvent(context);
913                if (event == null) {
914                    // factory could not create event so exit
915                    return false;
916                }
917            }
918            answer |= doNotifyEvent(notifier, event);
919        }
920        return answer;
921    }
922
923    public static boolean notifyCamelContextSuspended(CamelContext context) {
924        ManagementStrategy management = context.getManagementStrategy();
925        if (management == null) {
926            return false;
927        }
928
929        EventFactory factory = management.getEventFactory();
930        if (factory == null) {
931            return false;
932        }
933
934        List<EventNotifier> notifiers = management.getEventNotifiers();
935        if (notifiers == null || notifiers.isEmpty()) {
936            return false;
937        }
938
939        boolean answer = false;
940        EventObject event = null;
941        for (EventNotifier notifier : notifiers) {
942            if (notifier.isDisabled()) {
943                continue;
944            }
945            if (notifier.isIgnoreCamelContextEvents()) {
946                continue;
947            }
948
949            if (event == null) {
950                // only create event once
951                event = factory.createCamelContextSuspendedEvent(context);
952                if (event == null) {
953                    // factory could not create event so exit
954                    return false;
955                }
956            }
957            answer |= doNotifyEvent(notifier, event);
958        }
959        return answer;
960    }
961
962    public static boolean notifyCamelContextResuming(CamelContext context) {
963        ManagementStrategy management = context.getManagementStrategy();
964        if (management == null) {
965            return false;
966        }
967
968        EventFactory factory = management.getEventFactory();
969        if (factory == null) {
970            return false;
971        }
972
973        List<EventNotifier> notifiers = management.getEventNotifiers();
974        if (notifiers == null || notifiers.isEmpty()) {
975            return false;
976        }
977
978        boolean answer = false;
979        EventObject event = null;
980        for (EventNotifier notifier : notifiers) {
981            if (notifier.isDisabled()) {
982                continue;
983            }
984            if (notifier.isIgnoreCamelContextEvents()) {
985                continue;
986            }
987
988            if (event == null) {
989                // only create event once
990                event = factory.createCamelContextResumingEvent(context);
991                if (event == null) {
992                    // factory could not create event so exit
993                    return false;
994                }
995            }
996            answer |= doNotifyEvent(notifier, event);
997        }
998        return answer;
999    }
1000
1001    public static boolean notifyCamelContextResumed(CamelContext context) {
1002        ManagementStrategy management = context.getManagementStrategy();
1003        if (management == null) {
1004            return false;
1005        }
1006
1007        EventFactory factory = management.getEventFactory();
1008        if (factory == null) {
1009            return false;
1010        }
1011
1012        List<EventNotifier> notifiers = management.getEventNotifiers();
1013        if (notifiers == null || notifiers.isEmpty()) {
1014            return false;
1015        }
1016
1017        boolean answer = false;
1018        EventObject event = null;
1019        for (EventNotifier notifier : notifiers) {
1020            if (notifier.isDisabled()) {
1021                continue;
1022            }
1023            if (notifier.isIgnoreCamelContextEvents()) {
1024                continue;
1025            }
1026
1027            if (event == null) {
1028                // only create event once
1029                event = factory.createCamelContextResumedEvent(context);
1030                if (event == null) {
1031                    // factory could not create event so exit
1032                    return false;
1033                }
1034            }
1035            answer |= doNotifyEvent(notifier, event);
1036        }
1037        return answer;
1038    }
1039
1040    public static boolean notifyCamelContextResumeFailed(CamelContext context, Throwable cause) {
1041        ManagementStrategy management = context.getManagementStrategy();
1042        if (management == null) {
1043            return false;
1044        }
1045
1046        EventFactory factory = management.getEventFactory();
1047        if (factory == null) {
1048            return false;
1049        }
1050
1051        List<EventNotifier> notifiers = management.getEventNotifiers();
1052        if (notifiers == null || notifiers.isEmpty()) {
1053            return false;
1054        }
1055
1056        boolean answer = false;
1057        EventObject event = null;
1058        for (EventNotifier notifier : notifiers) {
1059            if (notifier.isDisabled()) {
1060                continue;
1061            }
1062            if (notifier.isIgnoreCamelContextEvents()) {
1063                continue;
1064            }
1065
1066            if (event == null) {
1067                // only create event once
1068                event = factory.createCamelContextResumeFailureEvent(context, cause);
1069                if (event == null) {
1070                    // factory could not create event so exit
1071                    return false;
1072                }
1073            }
1074            answer |= doNotifyEvent(notifier, event);
1075        }
1076        return answer;
1077    }
1078
1079    private static boolean doNotifyEvent(EventNotifier notifier, EventObject event) {
1080        // only notify if notifier is started
1081        boolean started = true;
1082        if (notifier instanceof StatefulService) {
1083            started = ((StatefulService) notifier).isStarted();
1084        }
1085        if (!started) {
1086            LOG.debug("Ignoring notifying event {}. The EventNotifier has not been started yet: {}", event, notifier);
1087            return false;
1088        }
1089
1090        if (!notifier.isEnabled(event)) {
1091            LOG.trace("Notifier: {} is not enabled for the event: {}", notifier, event);
1092            return false;
1093        }
1094
1095        try {
1096            notifier.notify(event);
1097        } catch (Throwable e) {
1098            LOG.warn("Error notifying event " + event + ". This exception will be ignored. ", e);
1099        }
1100
1101        return true;
1102    }
1103
1104}