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.spi;
018
019import org.apache.camel.CamelContext;
020import org.apache.camel.Endpoint;
021import org.apache.camel.Exchange;
022import org.apache.camel.Processor;
023import org.apache.camel.Route;
024
025/**
026 * This interface is implemented by all events.
027 */
028public interface CamelEvent {
029
030    enum Type {
031        CamelContextResumed,
032        CamelContextResumeFailure,
033        CamelContextResuming,
034        CamelContextStarted,
035        CamelContextStarting,
036        CamelContextStartupFailure,
037        CamelContextStopFailure,
038        CamelContextStopped,
039        CamelContextStopping,
040        CamelContextSuspended,
041        CamelContextSuspending,
042        CamelContextRoutesStarting,
043        CamelContextRoutesStarted,
044        CamelContextRoutesStopping,
045        CamelContextRoutesStopped,
046        ExchangeCompleted,
047        ExchangeCreated,
048        ExchangeFailed,
049        ExchangeFailureHandled,
050        ExchangeFailureHandling,
051        ExchangeRedelivery,
052        ExchangeSending,
053        ExchangeSent,
054        StepStarted,
055        StepCompleted,
056        StepFailed,
057        RouteAdded,
058        RouteRemoved,
059        RouteStarted,
060        RouteStopped,
061        ServiceStartupFailure,
062        ServiceStopFailure,
063        Custom
064    }
065
066    Type getType();
067
068    Object getSource();
069
070    /**
071     * This interface is implemented by all events that contain an exception and is used to
072     * retrieve the exception in a universal way.
073     */
074    interface FailureEvent extends CamelEvent {
075
076        Throwable getCause();
077
078    }
079
080    interface CamelContextEvent extends CamelEvent {
081
082        CamelContext getContext();
083
084        @Override
085        default Object getSource() {
086            return getContext();
087        }
088
089    }
090
091    interface CamelContextResumedEvent extends CamelContextEvent {
092        @Override
093        default Type getType() {
094            return Type.CamelContextResumed;
095        }
096    }
097
098    interface CamelContextResumeFailureEvent extends CamelContextEvent, FailureEvent {
099        @Override
100        default Type getType() {
101            return Type.CamelContextResumeFailure;
102        }
103    }
104
105    interface CamelContextResumingEvent extends CamelContextEvent {
106        @Override
107        default Type getType() {
108            return Type.CamelContextResuming;
109        }
110    }
111
112    interface CamelContextStartedEvent extends CamelContextEvent {
113        @Override
114        default Type getType() {
115            return Type.CamelContextStarted;
116        }
117    }
118
119    interface CamelContextStartingEvent extends CamelContextEvent {
120        @Override
121        default Type getType() {
122            return Type.CamelContextStarting;
123        }
124    }
125
126    interface CamelContextStartupFailureEvent extends CamelContextEvent, FailureEvent {
127        @Override
128        default Type getType() {
129            return Type.CamelContextStartupFailure;
130        }
131    }
132
133    interface CamelContextStopFailureEvent extends CamelContextEvent, FailureEvent {
134        @Override
135        default Type getType() {
136            return Type.CamelContextStopFailure;
137        }
138    }
139
140    interface CamelContextStoppedEvent extends CamelContextEvent {
141        @Override
142        default Type getType() {
143            return Type.CamelContextStopped;
144        }
145    }
146
147    interface CamelContextStoppingEvent extends CamelContextEvent {
148        @Override
149        default Type getType() {
150            return Type.CamelContextStopping;
151        }
152    }
153
154    interface CamelContextSuspendedEvent extends CamelContextEvent {
155        @Override
156        default Type getType() {
157            return Type.CamelContextSuspended;
158        }
159    }
160
161    interface CamelContextSuspendingEvent extends CamelContextEvent {
162        @Override
163        default Type getType() {
164            return Type.CamelContextSuspending;
165        }
166    }
167
168    interface CamelContextRoutesStartingEvent extends CamelContextEvent {
169        @Override
170        default Type getType() {
171            return Type.CamelContextRoutesStarting;
172        }
173    }
174
175    interface CamelContextRoutesStartedEvent extends CamelContextEvent {
176        @Override
177        default Type getType() {
178            return Type.CamelContextRoutesStarted;
179        }
180    }
181
182    interface CamelContextRoutesStoppingEvent extends CamelContextEvent {
183        @Override
184        default Type getType() {
185            return Type.CamelContextRoutesStopping;
186        }
187    }
188
189    interface CamelContextRoutesStoppedEvent extends CamelContextEvent {
190        @Override
191        default Type getType() {
192            return Type.CamelContextRoutesStopped;
193        }
194    }
195
196    interface ExchangeEvent extends CamelEvent {
197
198        Exchange getExchange();
199
200        @Override
201        default Object getSource() {
202            return getExchange();
203        }
204    }
205
206    interface ExchangeCompletedEvent extends ExchangeEvent {
207        @Override
208        default Type getType() {
209            return Type.ExchangeCompleted;
210        }
211    }
212
213    interface ExchangeCreatedEvent extends ExchangeEvent {
214        @Override
215        default Type getType() {
216            return Type.ExchangeCreated;
217        }
218    }
219
220    interface ExchangeFailedEvent extends ExchangeEvent, FailureEvent {
221        @Override
222        default Type getType() {
223            return Type.ExchangeFailed;
224        }
225    }
226
227    interface ExchangeFailureEvent extends ExchangeEvent {
228
229        Processor getFailureHandler();
230
231        boolean isDeadLetterChannel();
232
233        String getDeadLetterUri();
234
235    }
236
237    interface ExchangeFailureHandledEvent extends ExchangeFailureEvent {
238        @Override
239        default Type getType() {
240            return Type.ExchangeFailureHandled;
241        }
242    }
243
244    interface ExchangeFailureHandlingEvent extends ExchangeFailureEvent {
245        @Override
246        default Type getType() {
247            return Type.ExchangeFailureHandling;
248        }
249    }
250
251    interface ExchangeRedeliveryEvent extends ExchangeEvent {
252
253        int getAttempt();
254
255        @Override
256        default Type getType() {
257            return Type.ExchangeRedelivery;
258        }
259    }
260
261    interface ExchangeSendingEvent extends ExchangeEvent {
262
263        Endpoint getEndpoint();
264
265        @Override
266        default Type getType() {
267            return Type.ExchangeSending;
268        }
269    }
270
271    interface ExchangeSentEvent extends ExchangeEvent {
272
273        Endpoint getEndpoint();
274
275        long getTimeTaken();
276
277        @Override
278        default Type getType() {
279            return Type.ExchangeSent;
280        }
281    }
282
283    interface StepEvent extends ExchangeEvent {
284        String getStepId();
285    }
286
287    interface StepStartedEvent extends StepEvent {
288        @Override
289        default Type getType() {
290            return Type.StepStarted;
291        }
292    }
293
294    interface StepCompletedEvent extends StepEvent {
295        @Override
296        default Type getType() {
297            return Type.StepCompleted;
298        }
299    }
300
301    interface StepFailedEvent extends StepEvent, FailureEvent {
302        @Override
303        default Type getType() {
304            return Type.StepFailed;
305        }
306    }
307
308    interface RouteEvent extends CamelEvent {
309
310        Route getRoute();
311
312        @Override
313        default Object getSource() {
314            return getRoute();
315        }
316    }
317
318    interface RouteAddedEvent extends RouteEvent {
319        @Override
320        default Type getType() {
321            return Type.RouteAdded;
322        }
323    }
324
325    interface RouteRemovedEvent extends RouteEvent {
326        @Override
327        default Type getType() {
328            return Type.RouteRemoved;
329        }
330    }
331
332    interface RouteStartedEvent extends RouteEvent {
333        @Override
334        default Type getType() {
335            return Type.RouteStarted;
336        }
337    }
338
339    interface RouteStoppedEvent extends RouteEvent {
340        @Override
341        default Type getType() {
342            return Type.RouteStopped;
343        }
344    }
345
346    interface ServiceEvent extends CamelEvent {
347
348        Object getService();
349
350        @Override
351        default Object getSource() {
352            return getService();
353        }
354    }
355
356    interface ServiceStartupFailureEvent extends ServiceEvent, FailureEvent {
357        @Override
358        default Type getType() {
359            return Type.ServiceStartupFailure;
360        }
361    }
362
363    interface ServiceStopFailureEvent extends ServiceEvent, FailureEvent {
364        @Override
365        default Type getType() {
366            return Type.ServiceStopFailure;
367        }
368    }
369
370}