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