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