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