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     */
017    package org.apache.camel.management.mbean;
018    
019    import org.apache.camel.ErrorHandlerFactory;
020    import org.apache.camel.LoggingLevel;
021    import org.apache.camel.Processor;
022    import org.apache.camel.api.management.ManagedResource;
023    import org.apache.camel.api.management.mbean.ManagedErrorHandlerMBean;
024    import org.apache.camel.processor.ErrorHandlerSupport;
025    import org.apache.camel.processor.RedeliveryErrorHandler;
026    import org.apache.camel.spi.ManagementStrategy;
027    import org.apache.camel.spi.RouteContext;
028    
029    /**
030     * @version 
031     */
032    @ManagedResource(description = "Managed ErrorHandler")
033    public 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 boolean isSupportRedelivery() {
065            return errorHandler instanceof RedeliveryErrorHandler;
066        }
067    
068        public boolean isDeadLetterChannel() {
069            if (!isSupportRedelivery()) {
070                return false;
071            }
072    
073            RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
074            return redelivery.getDeadLetter() != null;
075        }
076    
077        public boolean isDeadLetterUseOriginalMessage() {
078            if (!isSupportRedelivery()) {
079                return false;
080            }
081    
082            RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
083            return redelivery.isUseOriginalMessagePolicy();
084        }
085    
086        public boolean isSupportTransactions() {
087            if (errorHandler instanceof ErrorHandlerSupport) {
088                ErrorHandlerSupport ehs = (ErrorHandlerSupport) errorHandler;
089                return ehs.supportTransacted();
090            } else {
091                return false;
092            }
093        }
094    
095        public String getDeadLetterChannelEndpointUri() {
096            if (!isSupportRedelivery()) {
097                return null;
098            }
099    
100            RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
101            return redelivery.getDeadLetterUri();
102        }
103    
104        public Integer getMaximumRedeliveries() {
105            if (!isSupportRedelivery()) {
106                return null;
107            }
108    
109            RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
110            return redelivery.getRedeliveryPolicy().getMaximumRedeliveries();
111        }
112    
113        public void setMaximumRedeliveries(Integer maximum) {
114            if (!isSupportRedelivery()) {
115                throw new IllegalArgumentException("This error handler does not support redelivery");
116            }
117    
118            RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
119            redelivery.getRedeliveryPolicy().setMaximumRedeliveries(maximum);
120        }
121    
122        public Long getMaximumRedeliveryDelay() {
123            if (!isSupportRedelivery()) {
124                return null;
125            }
126    
127            RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
128            return redelivery.getRedeliveryPolicy().getMaximumRedeliveryDelay();
129        }
130    
131        public void setMaximumRedeliveryDelay(Long delay) {
132            if (!isSupportRedelivery()) {
133                throw new IllegalArgumentException("This error handler does not support redelivery");
134            }
135    
136            RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
137            redelivery.getRedeliveryPolicy().setMaximumRedeliveryDelay(delay);
138        }
139    
140        public Long getRedeliveryDelay() {
141            if (!isSupportRedelivery()) {
142                return null;
143            }
144    
145            RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
146            return redelivery.getRedeliveryPolicy().getRedeliveryDelay();
147        }
148    
149        public void setRedeliveryDelay(Long delay) {
150            if (!isSupportRedelivery()) {
151                throw new IllegalArgumentException("This error handler does not support redelivery");
152            }
153    
154            RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
155            redelivery.getRedeliveryPolicy().setRedeliveryDelay(delay);
156        }
157    
158        public Double getBackOffMultiplier() {
159            if (!isSupportRedelivery()) {
160                return null;
161            }
162    
163            RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
164            return redelivery.getRedeliveryPolicy().getBackOffMultiplier();
165        }
166    
167        public void setBackOffMultiplier(Double multiplier) {
168            if (!isSupportRedelivery()) {
169                throw new IllegalArgumentException("This error handler does not support redelivery");
170            }
171    
172            RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
173            redelivery.getRedeliveryPolicy().setBackOffMultiplier(multiplier);
174        }
175    
176        public Double getCollisionAvoidanceFactor() {
177            if (!isSupportRedelivery()) {
178                return null;
179            }
180    
181            RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
182            return redelivery.getRedeliveryPolicy().getCollisionAvoidanceFactor();
183        }
184    
185        public void setCollisionAvoidanceFactor(Double factor) {
186            if (!isSupportRedelivery()) {
187                throw new IllegalArgumentException("This error handler does not support redelivery");
188            }
189    
190            RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
191            redelivery.getRedeliveryPolicy().setCollisionAvoidanceFactor(factor);
192        }
193    
194        public Double getCollisionAvoidancePercent() {
195            if (!isSupportRedelivery()) {
196                return null;
197            }
198    
199            RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
200            return (double) redelivery.getRedeliveryPolicy().getCollisionAvoidancePercent();  
201        }
202    
203        public void setCollisionAvoidancePercent(Double percent) {
204            if (!isSupportRedelivery()) {
205                throw new IllegalArgumentException("This error handler does not support redelivery");
206            }
207    
208            RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
209            redelivery.getRedeliveryPolicy().setCollisionAvoidancePercent(percent);
210        }
211    
212        public String getDelayPattern() {
213            if (!isSupportRedelivery()) {
214                return null;
215            }
216    
217            RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
218            return redelivery.getRedeliveryPolicy().getDelayPattern();
219        }
220    
221        public void setDelayPattern(String pattern) {
222            if (!isSupportRedelivery()) {
223                throw new IllegalArgumentException("This error handler does not support redelivery");
224            }
225    
226            RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
227            redelivery.getRedeliveryPolicy().setDelayPattern(pattern);
228        }
229    
230        public String getRetriesExhaustedLogLevel() {
231            if (!isSupportRedelivery()) {
232                return null;
233            }
234    
235            RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
236            return redelivery.getRedeliveryPolicy().getRetriesExhaustedLogLevel().name();
237        }
238    
239        public void setRetriesExhaustedLogLevel(String level) {
240            if (!isSupportRedelivery()) {
241                throw new IllegalArgumentException("This error handler does not support redelivery");
242            }
243    
244            RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
245            redelivery.getRedeliveryPolicy().setRetriesExhaustedLogLevel(LoggingLevel.valueOf(level));
246        }
247    
248        public String getRetryAttemptedLogLevel() {
249            if (!isSupportRedelivery()) {
250                return null;
251            }
252    
253            RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
254            return redelivery.getRedeliveryPolicy().getRetryAttemptedLogLevel().name();
255        }
256    
257        public void setRetryAttemptedLogLevel(String level) {
258            if (!isSupportRedelivery()) {
259                throw new IllegalArgumentException("This error handler does not support redelivery");
260            }
261    
262            RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
263            redelivery.getRedeliveryPolicy().setRetryAttemptedLogLevel(LoggingLevel.valueOf(level));
264        }
265    
266        public Boolean getLogStackTrace() {
267            if (!isSupportRedelivery()) {
268                return null;
269            }
270    
271            RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
272            return redelivery.getRedeliveryPolicy().isLogStackTrace();
273        }
274    
275        public void setLogStackTrace(Boolean log) {
276            if (!isSupportRedelivery()) {
277                throw new IllegalArgumentException("This error handler does not support redelivery");
278            }
279    
280            RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
281            redelivery.getRedeliveryPolicy().setLogStackTrace(log);
282        }
283    
284        public Boolean getLogRetryStackTrace() {
285            if (!isSupportRedelivery()) {
286                return null;
287            }
288    
289            RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
290            return redelivery.getRedeliveryPolicy().isLogRetryStackTrace();
291        }
292    
293        public void setLogRetryStackTrace(Boolean log) {
294            if (!isSupportRedelivery()) {
295                throw new IllegalArgumentException("This error handler does not support redelivery");
296            }
297    
298            RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
299            redelivery.getRedeliveryPolicy().setLogRetryStackTrace(log);
300        }
301    
302        public Boolean getLogHandled() {
303            if (!isSupportRedelivery()) {
304                return null;
305            }
306    
307            RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
308            return redelivery.getRedeliveryPolicy().isLogHandled();
309        }
310    
311        public void setLogHandled(Boolean log) {
312            if (!isSupportRedelivery()) {
313                throw new IllegalArgumentException("This error handler does not support redelivery");
314            }
315    
316            RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
317            redelivery.getRedeliveryPolicy().setLogHandled(log);
318        }
319    
320        public Boolean getLogContinued() {
321            if (!isSupportRedelivery()) {
322                return null;
323            }
324    
325            RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
326            return redelivery.getRedeliveryPolicy().isLogHandled();
327        }
328    
329        public void setLogContinued(Boolean log) {
330            if (!isSupportRedelivery()) {
331                throw new IllegalArgumentException("This error handler does not support redelivery");
332            }
333    
334            RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
335            redelivery.getRedeliveryPolicy().setLogContinued(log);
336        }
337    
338        public Boolean getLogExhausted() {
339            if (!isSupportRedelivery()) {
340                return null;
341            }
342    
343            RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
344            return redelivery.getRedeliveryPolicy().isLogExhausted();
345        }
346    
347        public void setLogExhausted(Boolean log) {
348            if (!isSupportRedelivery()) {
349                throw new IllegalArgumentException("This error handler does not support redelivery");
350            }
351    
352            RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
353            redelivery.getRedeliveryPolicy().setLogExhausted(log);
354        }
355    
356        public Boolean getUseCollisionAvoidance() {
357            if (!isSupportRedelivery()) {
358                return null;
359            }
360    
361            RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
362            return redelivery.getRedeliveryPolicy().isUseCollisionAvoidance();
363        }
364    
365        public void setUseCollisionAvoidance(Boolean avoidance) {
366            if (!isSupportRedelivery()) {
367                throw new IllegalArgumentException("This error handler does not support redelivery");
368            }
369    
370            RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
371            redelivery.getRedeliveryPolicy().setUseCollisionAvoidance(avoidance);
372        }
373    
374        public Boolean getUseExponentialBackOff() {
375            if (!isSupportRedelivery()) {
376                return null;
377            }
378    
379            RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
380            return redelivery.getRedeliveryPolicy().isUseExponentialBackOff();
381        }
382    
383        public void setUseExponentialBackOff(Boolean backoff) {
384            if (!isSupportRedelivery()) {
385                throw new IllegalArgumentException("This error handler does not support redelivery");
386            }
387    
388            RedeliveryErrorHandler redelivery = (RedeliveryErrorHandler) errorHandler;
389            redelivery.getRedeliveryPolicy().setUseExponentialBackOff(backoff);
390        }
391    
392    }