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.management.mbean;
018
019import org.apache.camel.ErrorHandlerFactory;
020import org.apache.camel.LoggingLevel;
021import org.apache.camel.Processor;
022import org.apache.camel.api.management.ManagedResource;
023import org.apache.camel.api.management.mbean.ManagedErrorHandlerMBean;
024import org.apache.camel.processor.ErrorHandlerSupport;
025import org.apache.camel.processor.RedeliveryErrorHandler;
026import org.apache.camel.spi.ManagementStrategy;
027import org.apache.camel.spi.RouteContext;
028
029@ManagedResource(description = "Managed ErrorHandler")
030public class ManagedErrorHandler implements ManagedErrorHandlerMBean {
031    private final RouteContext routeContext;
032    private final Processor errorHandler;
033    private final ErrorHandlerFactory errorHandlerBuilder;
034
035    public ManagedErrorHandler(RouteContext routeContext, Processor errorHandler, ErrorHandlerFactory builder) {
036        this.routeContext = routeContext;
037        this.errorHandler = errorHandler;
038        this.errorHandlerBuilder = builder;
039    }
040
041    public void init(ManagementStrategy strategy) {
042        // do nothing
043    }
044
045    public RouteContext getRouteContext() {
046        return routeContext;
047    }
048
049    public Processor getErrorHandler() {
050        return errorHandler;
051    }
052
053    public ErrorHandlerFactory getErrorHandlerBuilder() {
054        return errorHandlerBuilder;
055    }
056
057    public String getCamelId() {
058        return routeContext.getCamelContext().getName();
059    }
060
061    public String getCamelManagementName() {
062        return routeContext.getCamelContext().getManagementName();
063    }
064
065    public boolean isSupportRedelivery() {
066        return errorHandler instanceof RedeliveryErrorHandler;
067    }
068
069    public boolean isDeadLetterChannel() {
070        if (!isSupportRedelivery()) {
071            return false;
072        }
073
074        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
075        return redelivery.getDeadLetter() != null;
076    }
077
078    public boolean isDeadLetterUseOriginalMessage() {
079        if (!isSupportRedelivery()) {
080            return false;
081        }
082
083        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
084        return redelivery.isUseOriginalMessagePolicy();
085    }
086
087    public boolean isDeadLetterHandleNewException() {
088        if (!isSupportRedelivery()) {
089            return false;
090        }
091
092        // must be a dead letter channel
093        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
094        return isDeadLetterChannel() && redelivery.isDeadLetterHandleNewException();
095    }
096
097    public boolean isSupportTransactions() {
098        if (errorHandler instanceof ErrorHandlerSupport) {
099            ErrorHandlerSupport ehs = (ErrorHandlerSupport) errorHandler;
100            return ehs.supportTransacted();
101        } else {
102            return false;
103        }
104    }
105
106    public String getDeadLetterChannelEndpointUri() {
107        if (!isSupportRedelivery()) {
108            return null;
109        }
110
111        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
112        return redelivery.getDeadLetterUri();
113    }
114
115    public Integer getMaximumRedeliveries() {
116        if (!isSupportRedelivery()) {
117            return null;
118        }
119
120        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
121        return redelivery.getRedeliveryPolicy().getMaximumRedeliveries();
122    }
123
124    public void setMaximumRedeliveries(Integer maximum) {
125        if (!isSupportRedelivery()) {
126            throw new IllegalArgumentException("This error handler does not support redelivery");
127        }
128
129        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
130        redelivery.getRedeliveryPolicy().setMaximumRedeliveries(maximum);
131    }
132
133    public Long getMaximumRedeliveryDelay() {
134        if (!isSupportRedelivery()) {
135            return null;
136        }
137
138        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
139        return redelivery.getRedeliveryPolicy().getMaximumRedeliveryDelay();
140    }
141
142    public void setMaximumRedeliveryDelay(Long delay) {
143        if (!isSupportRedelivery()) {
144            throw new IllegalArgumentException("This error handler does not support redelivery");
145        }
146
147        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
148        redelivery.getRedeliveryPolicy().setMaximumRedeliveryDelay(delay);
149    }
150
151    public Long getRedeliveryDelay() {
152        if (!isSupportRedelivery()) {
153            return null;
154        }
155
156        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
157        return redelivery.getRedeliveryPolicy().getRedeliveryDelay();
158    }
159
160    public void setRedeliveryDelay(Long delay) {
161        if (!isSupportRedelivery()) {
162            throw new IllegalArgumentException("This error handler does not support redelivery");
163        }
164
165        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
166        redelivery.getRedeliveryPolicy().setRedeliveryDelay(delay);
167    }
168
169    public Double getBackOffMultiplier() {
170        if (!isSupportRedelivery()) {
171            return null;
172        }
173
174        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
175        return redelivery.getRedeliveryPolicy().getBackOffMultiplier();
176    }
177
178    public void setBackOffMultiplier(Double multiplier) {
179        if (!isSupportRedelivery()) {
180            throw new IllegalArgumentException("This error handler does not support redelivery");
181        }
182
183        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
184        redelivery.getRedeliveryPolicy().setBackOffMultiplier(multiplier);
185    }
186
187    public Double getCollisionAvoidanceFactor() {
188        if (!isSupportRedelivery()) {
189            return null;
190        }
191
192        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
193        return redelivery.getRedeliveryPolicy().getCollisionAvoidanceFactor();
194    }
195
196    public void setCollisionAvoidanceFactor(Double factor) {
197        if (!isSupportRedelivery()) {
198            throw new IllegalArgumentException("This error handler does not support redelivery");
199        }
200
201        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
202        redelivery.getRedeliveryPolicy().setCollisionAvoidanceFactor(factor);
203    }
204
205    public Double getCollisionAvoidancePercent() {
206        if (!isSupportRedelivery()) {
207            return null;
208        }
209
210        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
211        return (double) redelivery.getRedeliveryPolicy().getCollisionAvoidancePercent();  
212    }
213
214    public void setCollisionAvoidancePercent(Double percent) {
215        if (!isSupportRedelivery()) {
216            throw new IllegalArgumentException("This error handler does not support redelivery");
217        }
218
219        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
220        redelivery.getRedeliveryPolicy().setCollisionAvoidancePercent(percent);
221    }
222
223    public String getDelayPattern() {
224        if (!isSupportRedelivery()) {
225            return null;
226        }
227
228        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
229        return redelivery.getRedeliveryPolicy().getDelayPattern();
230    }
231
232    public void setDelayPattern(String pattern) {
233        if (!isSupportRedelivery()) {
234            throw new IllegalArgumentException("This error handler does not support redelivery");
235        }
236
237        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
238        redelivery.getRedeliveryPolicy().setDelayPattern(pattern);
239    }
240
241    public String getRetriesExhaustedLogLevel() {
242        if (!isSupportRedelivery()) {
243            return null;
244        }
245
246        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
247        return redelivery.getRedeliveryPolicy().getRetriesExhaustedLogLevel().name();
248    }
249
250    public void setRetriesExhaustedLogLevel(String level) {
251        if (!isSupportRedelivery()) {
252            throw new IllegalArgumentException("This error handler does not support redelivery");
253        }
254
255        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
256        redelivery.getRedeliveryPolicy().setRetriesExhaustedLogLevel(LoggingLevel.valueOf(level));
257    }
258
259    public String getRetryAttemptedLogLevel() {
260        if (!isSupportRedelivery()) {
261            return null;
262        }
263
264        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
265        return redelivery.getRedeliveryPolicy().getRetryAttemptedLogLevel().name();
266    }
267
268    public void setRetryAttemptedLogLevel(String level) {
269        if (!isSupportRedelivery()) {
270            throw new IllegalArgumentException("This error handler does not support redelivery");
271        }
272
273        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
274        redelivery.getRedeliveryPolicy().setRetryAttemptedLogLevel(LoggingLevel.valueOf(level));
275    }
276
277    public Boolean getLogStackTrace() {
278        if (!isSupportRedelivery()) {
279            return null;
280        }
281
282        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
283        return redelivery.getRedeliveryPolicy().isLogStackTrace();
284    }
285
286    public void setLogStackTrace(Boolean log) {
287        if (!isSupportRedelivery()) {
288            throw new IllegalArgumentException("This error handler does not support redelivery");
289        }
290
291        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
292        redelivery.getRedeliveryPolicy().setLogStackTrace(log);
293    }
294
295    public Boolean getLogRetryStackTrace() {
296        if (!isSupportRedelivery()) {
297            return null;
298        }
299
300        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
301        return redelivery.getRedeliveryPolicy().isLogRetryStackTrace();
302    }
303
304    public void setLogRetryStackTrace(Boolean log) {
305        if (!isSupportRedelivery()) {
306            throw new IllegalArgumentException("This error handler does not support redelivery");
307        }
308
309        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
310        redelivery.getRedeliveryPolicy().setLogRetryStackTrace(log);
311    }
312
313    public Boolean getLogHandled() {
314        if (!isSupportRedelivery()) {
315            return null;
316        }
317
318        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
319        return redelivery.getRedeliveryPolicy().isLogHandled();
320    }
321
322    public void setLogHandled(Boolean log) {
323        if (!isSupportRedelivery()) {
324            throw new IllegalArgumentException("This error handler does not support redelivery");
325        }
326
327        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
328        redelivery.getRedeliveryPolicy().setLogHandled(log);
329    }
330
331    public Boolean getLogNewException() {
332        if (!isSupportRedelivery()) {
333            return null;
334        }
335
336        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
337        return redelivery.getRedeliveryPolicy().isLogNewException();
338    }
339
340    public void setLogNewException(Boolean log) {
341        if (!isSupportRedelivery()) {
342            throw new IllegalArgumentException("This error handler does not support redelivery");
343        }
344
345        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
346        redelivery.getRedeliveryPolicy().setLogNewException(log);
347    }
348
349    public Boolean getLogExhaustedMessageHistory() {
350        if (!isSupportRedelivery()) {
351            throw new IllegalArgumentException("This error handler does not support redelivery");
352        }
353
354        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
355        return redelivery.getRedeliveryPolicy().isLogExhaustedMessageHistory();
356    }
357
358    public void setLogExhaustedMessageHistory(Boolean log) {
359        if (!isSupportRedelivery()) {
360            throw new IllegalArgumentException("This error handler does not support redelivery");
361        }
362
363        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
364        redelivery.getRedeliveryPolicy().setLogExhaustedMessageHistory(log);
365    }
366
367    public Boolean getLogExhaustedMessageBody() {
368        if (!isSupportRedelivery()) {
369            throw new IllegalArgumentException("This error handler does not support redelivery");
370        }
371
372        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
373        return redelivery.getRedeliveryPolicy().isLogExhaustedMessageBody();
374    }
375
376    public void setLogExhaustedMessageBody(Boolean log) {
377        if (!isSupportRedelivery()) {
378            throw new IllegalArgumentException("This error handler does not support redelivery");
379        }
380
381        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
382        redelivery.getRedeliveryPolicy().setLogExhaustedMessageBody(log);
383    }
384
385    public Boolean getLogContinued() {
386        if (!isSupportRedelivery()) {
387            return null;
388        }
389
390        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
391        return redelivery.getRedeliveryPolicy().isLogHandled();
392    }
393
394    public void setLogContinued(Boolean log) {
395        if (!isSupportRedelivery()) {
396            throw new IllegalArgumentException("This error handler does not support redelivery");
397        }
398
399        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
400        redelivery.getRedeliveryPolicy().setLogContinued(log);
401    }
402
403    public Boolean getLogExhausted() {
404        if (!isSupportRedelivery()) {
405            return null;
406        }
407
408        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
409        return redelivery.getRedeliveryPolicy().isLogExhausted();
410    }
411
412    public void setLogExhausted(Boolean log) {
413        if (!isSupportRedelivery()) {
414            throw new IllegalArgumentException("This error handler does not support redelivery");
415        }
416
417        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
418        redelivery.getRedeliveryPolicy().setLogExhausted(log);
419    }
420
421    public Boolean getUseCollisionAvoidance() {
422        if (!isSupportRedelivery()) {
423            return null;
424        }
425
426        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
427        return redelivery.getRedeliveryPolicy().isUseCollisionAvoidance();
428    }
429
430    public void setUseCollisionAvoidance(Boolean avoidance) {
431        if (!isSupportRedelivery()) {
432            throw new IllegalArgumentException("This error handler does not support redelivery");
433        }
434
435        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
436        redelivery.getRedeliveryPolicy().setUseCollisionAvoidance(avoidance);
437    }
438
439    public Boolean getUseExponentialBackOff() {
440        if (!isSupportRedelivery()) {
441            return null;
442        }
443
444        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
445        return redelivery.getRedeliveryPolicy().isUseExponentialBackOff();
446    }
447
448    public void setUseExponentialBackOff(Boolean backoff) {
449        if (!isSupportRedelivery()) {
450            throw new IllegalArgumentException("This error handler does not support redelivery");
451        }
452
453        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
454        redelivery.getRedeliveryPolicy().setUseExponentialBackOff(backoff);
455    }
456
457    public Boolean getAllowRedeliveryWhileStopping() {
458        if (!isSupportRedelivery()) {
459            return null;
460        }
461
462        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
463        return redelivery.getRedeliveryPolicy().isAllowRedeliveryWhileStopping();
464    }
465
466    public void setAllowRedeliveryWhileStopping(Boolean allow) {
467        if (!isSupportRedelivery()) {
468            throw new IllegalArgumentException("This error handler does not support redelivery");
469        }
470
471        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
472        redelivery.getRedeliveryPolicy().setAllowRedeliveryWhileStopping(allow);
473    }
474
475    public Integer getPendingRedeliveryCount() {
476        if (!isSupportRedelivery()) {
477            return null;
478        }
479
480        RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
481        return redelivery.getPendingRedeliveryCount();
482    }
483
484}