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.builder;
018    
019    import org.apache.camel.Expression;
020    import org.apache.camel.Processor;
021    import org.apache.camel.processor.DeadLetterChannel;
022    import org.apache.camel.processor.Logger;
023    import org.apache.camel.processor.LoggingLevel;
024    import org.apache.camel.processor.RecipientList;
025    import org.apache.camel.processor.RedeliveryPolicy;
026    import org.apache.commons.logging.Log;
027    import org.apache.commons.logging.LogFactory;
028    
029    /**
030     * A builder of a <a
031     * href="http://activemq.apache.org/camel/dead-letter-channel.html">Dead Letter
032     * Channel</a>
033     * 
034     * @version $Revision: 564295 $
035     */
036    public class DeadLetterChannelBuilder extends ErrorHandlerBuilderSupport {
037        private RedeliveryPolicy redeliveryPolicy = new RedeliveryPolicy();
038        private ProcessorFactory deadLetterFactory;
039        private Processor defaultDeadLetterEndpoint;
040        private Expression defaultDeadLetterEndpointExpression;
041        private String defaultDeadLetterEndpointUri = "log:org.apache.camel.DeadLetterChannel:error";
042        private Logger logger = DeadLetterChannel.createDefaultLogger();
043    
044        public DeadLetterChannelBuilder() {
045        }
046    
047        public DeadLetterChannelBuilder(Processor processor) {
048            this(new ConstantProcessorBuilder(processor));
049        }
050    
051        public DeadLetterChannelBuilder(ProcessorFactory deadLetterFactory) {
052            this.deadLetterFactory = deadLetterFactory;
053        }
054    
055        public ErrorHandlerBuilder copy() {
056            DeadLetterChannelBuilder answer = new DeadLetterChannelBuilder(deadLetterFactory);
057            answer.setRedeliveryPolicy(getRedeliveryPolicy().copy());
058            return answer;
059        }
060    
061        public Processor createErrorHandler(Processor processor) throws Exception {
062            Processor deadLetter = getDeadLetterFactory().createProcessor();
063            DeadLetterChannel answer = new DeadLetterChannel(processor, deadLetter, getRedeliveryPolicy(), getLogger());
064            configure(answer);
065            return answer;
066        }
067    
068        // Builder methods
069        // -------------------------------------------------------------------------
070        public DeadLetterChannelBuilder backOffMultiplier(double backOffMultiplier) {
071            getRedeliveryPolicy().backOffMultiplier(backOffMultiplier);
072            return this;
073        }
074    
075        public DeadLetterChannelBuilder collisionAvoidancePercent(short collisionAvoidancePercent) {
076            getRedeliveryPolicy().collisionAvoidancePercent(collisionAvoidancePercent);
077            return this;
078        }
079    
080        public DeadLetterChannelBuilder initialRedeliveryDelay(long initialRedeliveryDelay) {
081            getRedeliveryPolicy().initialRedeliveryDelay(initialRedeliveryDelay);
082            return this;
083        }
084    
085        public DeadLetterChannelBuilder maximumRedeliveries(int maximumRedeliveries) {
086            getRedeliveryPolicy().maximumRedeliveries(maximumRedeliveries);
087            return this;
088        }
089    
090        public DeadLetterChannelBuilder useCollisionAvoidance() {
091            getRedeliveryPolicy().useCollisionAvoidance();
092            return this;
093        }
094    
095        public DeadLetterChannelBuilder useExponentialBackOff() {
096            getRedeliveryPolicy().useExponentialBackOff();
097            return this;
098        }
099    
100        /**
101         * Sets the logger used for caught exceptions
102         */
103        public DeadLetterChannelBuilder logger(Logger logger) {
104            setLogger(logger);
105            return this;
106        }
107    
108        /**
109         * Sets the logging level of exceptions caught
110         */
111        public DeadLetterChannelBuilder loggingLevel(LoggingLevel level) {
112            getLogger().setLevel(level);
113            return this;
114        }
115    
116        /**
117         * Sets the log used for caught exceptions
118         */
119        public DeadLetterChannelBuilder log(Log log) {
120            getLogger().setLog(log);
121            return this;
122        }
123    
124        /**
125         * Sets the log used for caught exceptions
126         */
127        public DeadLetterChannelBuilder log(String log) {
128            return log(LogFactory.getLog(log));
129        }
130    
131        /**
132         * Sets the log used for caught exceptions
133         */
134        public DeadLetterChannelBuilder log(Class log) {
135            return log(LogFactory.getLog(log));
136        }
137    
138        // Properties
139        // -------------------------------------------------------------------------
140        public RedeliveryPolicy getRedeliveryPolicy() {
141            return redeliveryPolicy;
142        }
143    
144        /**
145         * Sets the redelivery policy
146         */
147        public void setRedeliveryPolicy(RedeliveryPolicy redeliveryPolicy) {
148            this.redeliveryPolicy = redeliveryPolicy;
149        }
150    
151        public ProcessorFactory getDeadLetterFactory() {
152            if (deadLetterFactory == null) {
153                deadLetterFactory = new ProcessorFactory() {
154                    public Processor createProcessor() {
155                        return getDefaultDeadLetterEndpoint();
156                    }
157                };
158            }
159            return deadLetterFactory;
160        }
161    
162        /**
163         * Sets the default dead letter queue factory
164         */
165        public void setDeadLetterFactory(ProcessorFactory deadLetterFactory) {
166            this.deadLetterFactory = deadLetterFactory;
167        }
168    
169        public Processor getDefaultDeadLetterEndpoint() {
170            if (defaultDeadLetterEndpoint == null) {
171                defaultDeadLetterEndpoint = new RecipientList(getDefaultDeadLetterEndpointExpression());
172            }
173            return defaultDeadLetterEndpoint;
174        }
175    
176        /**
177         * Sets the default dead letter endpoint used
178         */
179        public void setDefaultDeadLetterEndpoint(Processor defaultDeadLetterEndpoint) {
180            this.defaultDeadLetterEndpoint = defaultDeadLetterEndpoint;
181        }
182    
183        public Expression getDefaultDeadLetterEndpointExpression() {
184            if (defaultDeadLetterEndpointExpression == null) {
185                defaultDeadLetterEndpointExpression = ExpressionBuilder
186                    .constantExpression(getDefaultDeadLetterEndpointUri());
187            }
188            return defaultDeadLetterEndpointExpression;
189        }
190    
191        /**
192         * Sets the expression used to decide the dead letter channel endpoint for
193         * an exchange if no factory is provided via
194         * {@link #setDeadLetterFactory(ProcessorFactory)}
195         */
196        public void setDefaultDeadLetterEndpointExpression(Expression defaultDeadLetterEndpointExpression) {
197            this.defaultDeadLetterEndpointExpression = defaultDeadLetterEndpointExpression;
198        }
199    
200        public String getDefaultDeadLetterEndpointUri() {
201            return defaultDeadLetterEndpointUri;
202        }
203    
204        /**
205         * Sets the default dead letter endpoint URI used if no factory is provided
206         * via {@link #setDeadLetterFactory(ProcessorFactory)} and no expression is
207         * provided via {@link #setDefaultDeadLetterEndpointExpression(Expression)}
208         * 
209         * @param defaultDeadLetterEndpointUri the default URI if no deadletter
210         *                factory or expression is provided
211         */
212        public void setDefaultDeadLetterEndpointUri(String defaultDeadLetterEndpointUri) {
213            this.defaultDeadLetterEndpointUri = defaultDeadLetterEndpointUri;
214        }
215    
216        public Logger getLogger() {
217            return logger;
218        }
219    
220        public void setLogger(Logger logger) {
221            this.logger = logger;
222        }
223    }