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 default Object getSource() { 081 return getContext(); 082 } 083 084 } 085 086 interface CamelContextResumedEvent extends CamelContextEvent { 087 default Type getType() { 088 return Type.CamelContextResumed; 089 } 090 } 091 092 interface CamelContextResumeFailureEvent extends CamelContextEvent, FailureEvent { 093 default Type getType() { 094 return Type.CamelContextResumeFailure; 095 } 096 } 097 098 interface CamelContextResumingEvent extends CamelContextEvent { 099 default Type getType() { 100 return Type.CamelContextResuming; 101 } 102 } 103 104 interface CamelContextStartedEvent extends CamelContextEvent { 105 default Type getType() { 106 return Type.CamelContextStarted; 107 } 108 } 109 110 interface CamelContextStartingEvent extends CamelContextEvent { 111 default Type getType() { 112 return Type.CamelContextStarting; 113 } 114 } 115 116 interface CamelContextStartupFailureEvent extends CamelContextEvent, FailureEvent { 117 default Type getType() { 118 return Type.CamelContextStartupFailure; 119 } 120 } 121 122 interface CamelContextStopFailureEvent extends CamelContextEvent, FailureEvent { 123 default Type getType() { 124 return Type.CamelContextStopFailure; 125 } 126 } 127 128 interface CamelContextStoppedEvent extends CamelContextEvent { 129 default Type getType() { 130 return Type.CamelContextStopped; 131 } 132 } 133 134 interface CamelContextStoppingEvent extends CamelContextEvent { 135 default Type getType() { 136 return Type.CamelContextStopping; 137 } 138 } 139 140 interface CamelContextSuspendedEvent extends CamelContextEvent { 141 default Type getType() { 142 return Type.CamelContextSuspended; 143 } 144 } 145 146 interface CamelContextSuspendingEvent extends CamelContextEvent { 147 default Type getType() { 148 return Type.CamelContextSuspending; 149 } 150 } 151 152 interface ExchangeEvent extends CamelEvent { 153 154 Exchange getExchange(); 155 156 default Object getSource() { 157 return getExchange(); 158 } 159 } 160 161 interface ExchangeCompletedEvent extends ExchangeEvent { 162 default Type getType() { 163 return Type.ExchangeCompleted; 164 } 165 } 166 167 interface ExchangeCreatedEvent extends ExchangeEvent { 168 default Type getType() { 169 return Type.ExchangeCreated; 170 } 171 } 172 173 interface ExchangeFailedEvent extends ExchangeEvent, FailureEvent { 174 default Type getType() { 175 return Type.ExchangeFailed; 176 } 177 } 178 179 interface ExchangeFailureEvent extends ExchangeEvent { 180 181 Processor getFailureHandler(); 182 183 boolean isDeadLetterChannel(); 184 185 String getDeadLetterUri(); 186 187 } 188 189 interface ExchangeFailureHandledEvent extends ExchangeFailureEvent { 190 default Type getType() { 191 return Type.ExchangeFailureHandled; 192 } 193 } 194 195 interface ExchangeFailureHandlingEvent extends ExchangeFailureEvent { 196 default Type getType() { 197 return Type.ExchangeFailureHandling; 198 } 199 } 200 201 interface ExchangeRedeliveryEvent extends ExchangeEvent { 202 203 int getAttempt(); 204 205 default Type getType() { 206 return Type.ExchangeRedelivery; 207 } 208 } 209 210 interface ExchangeSendingEvent extends ExchangeEvent { 211 212 Endpoint getEndpoint(); 213 214 default Type getType() { 215 return Type.ExchangeSending; 216 } 217 } 218 219 interface ExchangeSentEvent extends ExchangeEvent { 220 221 Endpoint getEndpoint(); 222 223 long getTimeTaken(); 224 225 default Type getType() { 226 return Type.ExchangeSent; 227 } 228 } 229 230 interface StepEvent extends ExchangeEvent { 231 String getStepId(); 232 } 233 234 interface StepStartedEvent extends StepEvent { 235 default Type getType() { 236 return Type.StepStarted; 237 } 238 } 239 240 interface StepCompletedEvent extends StepEvent { 241 default Type getType() { 242 return Type.StepCompleted; 243 } 244 } 245 246 interface StepFailedEvent extends StepEvent, FailureEvent { 247 default Type getType() { 248 return Type.StepFailed; 249 } 250 } 251 252 interface RouteEvent extends CamelEvent { 253 254 Route getRoute(); 255 256 default Object getSource() { 257 return getRoute(); 258 } 259 } 260 261 interface RouteAddedEvent extends RouteEvent { 262 default Type getType() { 263 return Type.RouteAdded; 264 } 265 } 266 267 interface RouteRemovedEvent extends RouteEvent { 268 default Type getType() { 269 return Type.RouteRemoved; 270 } 271 } 272 273 interface RouteStartedEvent extends RouteEvent { 274 default Type getType() { 275 return Type.RouteStarted; 276 } 277 } 278 279 interface RouteStoppedEvent extends RouteEvent { 280 default Type getType() { 281 return Type.RouteStopped; 282 } 283 } 284 285 interface ServiceEvent extends CamelEvent { 286 287 Object getService(); 288 289 default Object getSource() { 290 return getService(); 291 } 292 } 293 294 interface ServiceStartupFailureEvent extends ServiceEvent, FailureEvent { 295 default Type getType() { 296 return Type.ServiceStartupFailure; 297 } 298 } 299 300 interface ServiceStopFailureEvent extends ServiceEvent, FailureEvent { 301 default Type getType() { 302 return Type.ServiceStopFailure; 303 } 304 } 305 306}