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