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.util;
018
019 import java.util.EventObject;
020 import java.util.List;
021
022 import org.apache.camel.CamelContext;
023 import org.apache.camel.Endpoint;
024 import org.apache.camel.Exchange;
025 import org.apache.camel.Processor;
026 import org.apache.camel.Route;
027 import org.apache.camel.StatefulService;
028 import org.apache.camel.spi.EventFactory;
029 import org.apache.camel.spi.EventNotifier;
030 import org.slf4j.Logger;
031 import org.slf4j.LoggerFactory;
032
033 /**
034 * Helper for easily sending event notifications in a single line of code
035 *
036 * @version
037 */
038 public final class EventHelper {
039
040 private static final Logger LOG = LoggerFactory.getLogger(EventHelper.class);
041
042 private EventHelper() {
043 }
044
045 public static void notifyCamelContextStarting(CamelContext context) {
046 List<EventNotifier> notifiers = context.getManagementStrategy().getEventNotifiers();
047 if (notifiers == null || notifiers.isEmpty()) {
048 return;
049 }
050
051 for (EventNotifier notifier : notifiers) {
052 if (notifier.isIgnoreCamelContextEvents()) {
053 continue;
054 }
055
056 EventFactory factory = context.getManagementStrategy().getEventFactory();
057 if (factory == null) {
058 return;
059 }
060 EventObject event = factory.createCamelContextStartingEvent(context);
061 if (event == null) {
062 return;
063 }
064 doNotifyEvent(notifier, event);
065 }
066 }
067
068 public static void notifyCamelContextStarted(CamelContext context) {
069 List<EventNotifier> notifiers = context.getManagementStrategy().getEventNotifiers();
070 if (notifiers == null || notifiers.isEmpty()) {
071 return;
072 }
073
074 for (EventNotifier notifier : notifiers) {
075 if (notifier.isIgnoreCamelContextEvents()) {
076 continue;
077 }
078
079 EventFactory factory = context.getManagementStrategy().getEventFactory();
080 if (factory == null) {
081 return;
082 }
083 EventObject event = factory.createCamelContextStartedEvent(context);
084 if (event == null) {
085 return;
086 }
087 doNotifyEvent(notifier, event);
088 }
089 }
090
091 public static void notifyCamelContextStartupFailed(CamelContext context, Throwable cause) {
092 List<EventNotifier> notifiers = context.getManagementStrategy().getEventNotifiers();
093 if (notifiers == null || notifiers.isEmpty()) {
094 return;
095 }
096
097 for (EventNotifier notifier : notifiers) {
098 if (notifier.isIgnoreCamelContextEvents()) {
099 continue;
100 }
101
102 EventFactory factory = context.getManagementStrategy().getEventFactory();
103 if (factory == null) {
104 return;
105 }
106 EventObject event = factory.createCamelContextStartupFailureEvent(context, cause);
107 if (event == null) {
108 return;
109 }
110 doNotifyEvent(notifier, event);
111 }
112 }
113
114 public static void notifyCamelContextStopping(CamelContext context) {
115 List<EventNotifier> notifiers = context.getManagementStrategy().getEventNotifiers();
116 if (notifiers == null || notifiers.isEmpty()) {
117 return;
118 }
119
120 for (EventNotifier notifier : notifiers) {
121 if (notifier.isIgnoreCamelContextEvents()) {
122 return;
123 }
124
125 EventFactory factory = context.getManagementStrategy().getEventFactory();
126 if (factory == null) {
127 return;
128 }
129 EventObject event = factory.createCamelContextStoppingEvent(context);
130 if (event == null) {
131 return;
132 }
133 doNotifyEvent(notifier, event);
134 }
135 }
136
137 public static void notifyCamelContextStopped(CamelContext context) {
138 List<EventNotifier> notifiers = context.getManagementStrategy().getEventNotifiers();
139 if (notifiers == null || notifiers.isEmpty()) {
140 return;
141 }
142
143 for (EventNotifier notifier : notifiers) {
144 if (notifier.isIgnoreCamelContextEvents()) {
145 continue;
146 }
147
148 EventFactory factory = context.getManagementStrategy().getEventFactory();
149 if (factory == null) {
150 return;
151 }
152 EventObject event = factory.createCamelContextStoppedEvent(context);
153 if (event == null) {
154 return;
155 }
156 doNotifyEvent(notifier, event);
157 }
158 }
159
160 public static void notifyCamelContextStopFailed(CamelContext context, Throwable cause) {
161 List<EventNotifier> notifiers = context.getManagementStrategy().getEventNotifiers();
162 if (notifiers == null || notifiers.isEmpty()) {
163 return;
164 }
165
166 for (EventNotifier notifier : notifiers) {
167 if (notifier.isIgnoreCamelContextEvents()) {
168 continue;
169 }
170
171 EventFactory factory = context.getManagementStrategy().getEventFactory();
172 if (factory == null) {
173 return;
174 }
175 EventObject event = factory.createCamelContextStopFailureEvent(context, cause);
176 if (event == null) {
177 return;
178 }
179 doNotifyEvent(notifier, event);
180 }
181 }
182
183 public static void notifyServiceStopFailure(CamelContext context, Object service, Throwable cause) {
184 List<EventNotifier> notifiers = context.getManagementStrategy().getEventNotifiers();
185 if (notifiers == null || notifiers.isEmpty()) {
186 return;
187 }
188
189 for (EventNotifier notifier : notifiers) {
190 if (notifier.isIgnoreServiceEvents()) {
191 continue;
192 }
193
194 EventFactory factory = context.getManagementStrategy().getEventFactory();
195 if (factory == null) {
196 return;
197 }
198 EventObject event = factory.createServiceStopFailureEvent(context, service, cause);
199 if (event == null) {
200 return;
201 }
202 doNotifyEvent(notifier, event);
203 }
204 }
205
206 public static void notifyServiceStartupFailure(CamelContext context, Object service, Throwable cause) {
207 List<EventNotifier> notifiers = context.getManagementStrategy().getEventNotifiers();
208 if (notifiers == null || notifiers.isEmpty()) {
209 return;
210 }
211
212 for (EventNotifier notifier : notifiers) {
213 if (notifier.isIgnoreServiceEvents()) {
214 continue;
215 }
216
217 EventFactory factory = context.getManagementStrategy().getEventFactory();
218 if (factory == null) {
219 return;
220 }
221 EventObject event = factory.createServiceStartupFailureEvent(context, service, cause);
222 if (event == null) {
223 return;
224 }
225 doNotifyEvent(notifier, event);
226 }
227 }
228
229 public static void notifyRouteStarted(CamelContext context, Route route) {
230 List<EventNotifier> notifiers = context.getManagementStrategy().getEventNotifiers();
231 if (notifiers == null || notifiers.isEmpty()) {
232 return;
233 }
234
235 for (EventNotifier notifier : notifiers) {
236 if (notifier.isIgnoreRouteEvents()) {
237 return;
238 }
239
240 EventFactory factory = context.getManagementStrategy().getEventFactory();
241 if (factory == null) {
242 return;
243 }
244 EventObject event = factory.createRouteStartedEvent(route);
245 if (event == null) {
246 return;
247 }
248 doNotifyEvent(notifier, event);
249 }
250 }
251
252 public static void notifyRouteStopped(CamelContext context, Route route) {
253 List<EventNotifier> notifiers = context.getManagementStrategy().getEventNotifiers();
254 if (notifiers == null || notifiers.isEmpty()) {
255 return;
256 }
257
258 for (EventNotifier notifier : notifiers) {
259 if (notifier.isIgnoreRouteEvents()) {
260 continue;
261 }
262
263 EventFactory factory = context.getManagementStrategy().getEventFactory();
264 if (factory == null) {
265 return;
266 }
267 EventObject event = factory.createRouteStoppedEvent(route);
268 if (event == null) {
269 return;
270 }
271 doNotifyEvent(notifier, event);
272 }
273 }
274
275 public static void notifyExchangeCreated(CamelContext context, Exchange exchange) {
276 if (exchange.getProperty(Exchange.NOTIFY_EVENT, false, Boolean.class)) {
277 // do not generate events for an notify event
278 return;
279 }
280
281 List<EventNotifier> notifiers = context.getManagementStrategy().getEventNotifiers();
282 if (notifiers == null || notifiers.isEmpty()) {
283 return;
284 }
285
286 for (EventNotifier notifier : notifiers) {
287 if (notifier.isIgnoreExchangeEvents() || notifier.isIgnoreExchangeCreatedEvent()) {
288 continue;
289 }
290
291 EventFactory factory = context.getManagementStrategy().getEventFactory();
292 if (factory == null) {
293 return;
294 }
295 EventObject event = factory.createExchangeCreatedEvent(exchange);
296 if (event == null) {
297 return;
298 }
299 doNotifyEvent(notifier, event);
300 }
301 }
302
303 public static void notifyExchangeDone(CamelContext context, Exchange exchange) {
304 if (exchange.getProperty(Exchange.NOTIFY_EVENT, false, Boolean.class)) {
305 // do not generate events for an notify event
306 return;
307 }
308
309 List<EventNotifier> notifiers = context.getManagementStrategy().getEventNotifiers();
310 if (notifiers == null || notifiers.isEmpty()) {
311 return;
312 }
313
314 for (EventNotifier notifier : notifiers) {
315 if (notifier.isIgnoreExchangeEvents() || notifier.isIgnoreExchangeCompletedEvent()) {
316 continue;
317 }
318
319 EventFactory factory = context.getManagementStrategy().getEventFactory();
320 if (factory == null) {
321 return;
322 }
323 EventObject event = factory.createExchangeCompletedEvent(exchange);
324 if (event == null) {
325 return;
326 }
327 doNotifyEvent(notifier, event);
328 }
329 }
330
331 public static void notifyExchangeFailed(CamelContext context, Exchange exchange) {
332 if (exchange.getProperty(Exchange.NOTIFY_EVENT, false, Boolean.class)) {
333 // do not generate events for an notify event
334 return;
335 }
336
337 List<EventNotifier> notifiers = context.getManagementStrategy().getEventNotifiers();
338 if (notifiers == null || notifiers.isEmpty()) {
339 return;
340 }
341
342 for (EventNotifier notifier : notifiers) {
343 if (notifier.isIgnoreExchangeEvents() || notifier.isIgnoreExchangeFailedEvents()) {
344 continue;
345 }
346
347 EventFactory factory = context.getManagementStrategy().getEventFactory();
348 if (factory == null) {
349 return;
350 }
351 EventObject event = factory.createExchangeFailedEvent(exchange);
352 if (event == null) {
353 return;
354 }
355 doNotifyEvent(notifier, event);
356 }
357 }
358
359 public static void notifyExchangeFailureHandled(CamelContext context, Exchange exchange, Processor failureHandler,
360 boolean deadLetterChannel) {
361 if (exchange.getProperty(Exchange.NOTIFY_EVENT, false, Boolean.class)) {
362 // do not generate events for an notify event
363 return;
364 }
365
366 List<EventNotifier> notifiers = context.getManagementStrategy().getEventNotifiers();
367 if (notifiers == null || notifiers.isEmpty()) {
368 return;
369 }
370
371 for (EventNotifier notifier : notifiers) {
372 if (notifier.isIgnoreExchangeEvents() || notifier.isIgnoreExchangeFailedEvents()) {
373 continue;
374 }
375
376 EventFactory factory = context.getManagementStrategy().getEventFactory();
377 if (factory == null) {
378 return;
379 }
380 EventObject event = factory.createExchangeFailureHandledEvent(exchange, failureHandler, deadLetterChannel);
381 if (event == null) {
382 return;
383 }
384 doNotifyEvent(notifier, event);
385 }
386 }
387
388 public static void notifyExchangeRedelivery(CamelContext context, Exchange exchange, int attempt) {
389 if (exchange.getProperty(Exchange.NOTIFY_EVENT, false, Boolean.class)) {
390 // do not generate events for an notify event
391 return;
392 }
393
394 List<EventNotifier> notifiers = context.getManagementStrategy().getEventNotifiers();
395 if (notifiers == null || notifiers.isEmpty()) {
396 return;
397 }
398
399 for (EventNotifier notifier : notifiers) {
400 if (notifier.isIgnoreExchangeEvents() || notifier.isIgnoreExchangeFailedEvents()) {
401 continue;
402 }
403
404 EventFactory factory = context.getManagementStrategy().getEventFactory();
405 if (factory == null) {
406 return;
407 }
408 EventObject event = factory.createExchangeRedeliveryEvent(exchange, attempt);
409 if (event == null) {
410 return;
411 }
412 doNotifyEvent(notifier, event);
413 }
414 }
415
416 public static void notifyExchangeSending(CamelContext context, Exchange exchange, Endpoint endpoint) {
417 if (exchange.getProperty(Exchange.NOTIFY_EVENT, false, Boolean.class)) {
418 // do not generate events for an notify event
419 return;
420 }
421
422 List<EventNotifier> notifiers = context.getManagementStrategy().getEventNotifiers();
423 if (notifiers == null || notifiers.isEmpty()) {
424 return;
425 }
426
427 for (EventNotifier notifier : notifiers) {
428 if (notifier.isIgnoreExchangeEvents() || notifier.isIgnoreExchangeSentEvents()) {
429 continue;
430 }
431
432 EventFactory factory = context.getManagementStrategy().getEventFactory();
433 if (factory == null) {
434 return;
435 }
436 EventObject event = factory.createExchangeSendingEvent(exchange, endpoint);
437 if (event == null) {
438 return;
439 }
440 doNotifyEvent(notifier, event);
441 }
442 }
443
444 public static void notifyExchangeSent(CamelContext context, Exchange exchange, Endpoint endpoint, long timeTaken) {
445 if (exchange.getProperty(Exchange.NOTIFY_EVENT, false, Boolean.class)) {
446 // do not generate events for an notify event
447 return;
448 }
449
450 List<EventNotifier> notifiers = context.getManagementStrategy().getEventNotifiers();
451 if (notifiers == null || notifiers.isEmpty()) {
452 return;
453 }
454
455 for (EventNotifier notifier : notifiers) {
456 if (notifier.isIgnoreExchangeEvents() || notifier.isIgnoreExchangeSentEvents()) {
457 continue;
458 }
459
460 EventFactory factory = context.getManagementStrategy().getEventFactory();
461 if (factory == null) {
462 return;
463 }
464 EventObject event = factory.createExchangeSentEvent(exchange, endpoint, timeTaken);
465 if (event == null) {
466 return;
467 }
468 doNotifyEvent(notifier, event);
469 }
470 }
471
472 public static void notifyCamelContextSuspending(CamelContext context) {
473 List<EventNotifier> notifiers = context.getManagementStrategy().getEventNotifiers();
474 if (notifiers == null || notifiers.isEmpty()) {
475 return;
476 }
477
478 for (EventNotifier notifier : notifiers) {
479 if (notifier.isIgnoreCamelContextEvents()) {
480 continue;
481 }
482
483 EventFactory factory = context.getManagementStrategy().getEventFactory();
484 if (factory == null) {
485 return;
486 }
487 EventObject event = factory.createCamelContextSuspendingEvent(context);
488 if (event == null) {
489 return;
490 }
491 doNotifyEvent(notifier, event);
492 }
493 }
494
495 public static void notifyCamelContextSuspended(CamelContext context) {
496 List<EventNotifier> notifiers = context.getManagementStrategy().getEventNotifiers();
497 if (notifiers == null || notifiers.isEmpty()) {
498 return;
499 }
500
501 for (EventNotifier notifier : notifiers) {
502 if (notifier.isIgnoreCamelContextEvents()) {
503 continue;
504 }
505
506 EventFactory factory = context.getManagementStrategy().getEventFactory();
507 if (factory == null) {
508 return;
509 }
510 EventObject event = factory.createCamelContextSuspendedEvent(context);
511 if (event == null) {
512 return;
513 }
514 doNotifyEvent(notifier, event);
515 }
516 }
517
518 public static void notifyCamelContextResuming(CamelContext context) {
519 List<EventNotifier> notifiers = context.getManagementStrategy().getEventNotifiers();
520 if (notifiers == null || notifiers.isEmpty()) {
521 return;
522 }
523
524 for (EventNotifier notifier : notifiers) {
525 if (notifier.isIgnoreCamelContextEvents()) {
526 continue;
527 }
528
529 EventFactory factory = context.getManagementStrategy().getEventFactory();
530 if (factory == null) {
531 return;
532 }
533 EventObject event = factory.createCamelContextResumingEvent(context);
534 if (event == null) {
535 return;
536 }
537 doNotifyEvent(notifier, event);
538 }
539 }
540
541 public static void notifyCamelContextResumed(CamelContext context) {
542 List<EventNotifier> notifiers = context.getManagementStrategy().getEventNotifiers();
543 if (notifiers == null || notifiers.isEmpty()) {
544 return;
545 }
546
547 for (EventNotifier notifier : notifiers) {
548 if (notifier.isIgnoreCamelContextEvents()) {
549 continue;
550 }
551
552 EventFactory factory = context.getManagementStrategy().getEventFactory();
553 if (factory == null) {
554 return;
555 }
556 EventObject event = factory.createCamelContextResumedEvent(context);
557 if (event == null) {
558 return;
559 }
560 doNotifyEvent(notifier, event);
561 }
562 }
563
564 public static void notifyCamelContextResumeFailed(CamelContext context, Throwable cause) {
565 List<EventNotifier> notifiers = context.getManagementStrategy().getEventNotifiers();
566 if (notifiers == null || notifiers.isEmpty()) {
567 return;
568 }
569
570 for (EventNotifier notifier : notifiers) {
571 if (notifier.isIgnoreCamelContextEvents()) {
572 continue;
573 }
574
575 EventFactory factory = context.getManagementStrategy().getEventFactory();
576 if (factory == null) {
577 return;
578 }
579 EventObject event = factory.createCamelContextResumeFailureEvent(context, cause);
580 if (event == null) {
581 return;
582 }
583 doNotifyEvent(notifier, event);
584 }
585 }
586
587 private static void doNotifyEvent(EventNotifier notifier, EventObject event) {
588 // only notify if notifier is started
589 boolean started = true;
590 if (notifier instanceof StatefulService) {
591 started = ((StatefulService) notifier).isStarted();
592 }
593 if (!started) {
594 LOG.debug("Ignoring notifying event {}. The EventNotifier has not been started yet: {}", event, notifier);
595 return;
596 }
597
598 if (!notifier.isEnabled(event)) {
599 LOG.trace("Notification of event is disabled: {}", event);
600 return;
601 }
602
603 try {
604 notifier.notify(event);
605 } catch (Throwable e) {
606 LOG.warn("Error notifying event " + event + ". This exception will be ignored. ", e);
607 }
608 }
609
610 }