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.model;
018
019 import java.util.ArrayList;
020 import java.util.List;
021 import javax.xml.bind.annotation.XmlAccessType;
022 import javax.xml.bind.annotation.XmlAccessorType;
023 import javax.xml.bind.annotation.XmlElementRef;
024 import javax.xml.bind.annotation.XmlRootElement;
025 import javax.xml.bind.annotation.XmlTransient;
026
027 import org.apache.camel.CamelContext;
028 import org.apache.camel.Endpoint;
029 import org.apache.camel.builder.ErrorHandlerBuilder;
030 import org.apache.camel.util.EndpointHelper;
031
032 /**
033 * Represents a collection of routes
034 *
035 * @version $Revision: 788663 $
036 */
037 @XmlRootElement(name = "routes")
038 @XmlAccessorType(XmlAccessType.FIELD)
039 public class RoutesDefinition extends OptionalIdentifiedType<RoutesDefinition> implements RouteContainer {
040 @XmlElementRef
041 private List<RouteDefinition> routes = new ArrayList<RouteDefinition>();
042 @XmlTransient
043 private List<InterceptDefinition> intercepts = new ArrayList<InterceptDefinition>();
044 @XmlTransient
045 private List<InterceptFromDefinition> interceptFroms = new ArrayList<InterceptFromDefinition>();
046 @XmlTransient
047 private List<InterceptSendToEndpointDefinition> interceptSendTos = new ArrayList<InterceptSendToEndpointDefinition>();
048 @XmlTransient
049 private List<OnExceptionDefinition> onExceptions = new ArrayList<OnExceptionDefinition>();
050 @XmlTransient
051 private List<OnCompletionDefinition> onCompletions = new ArrayList<OnCompletionDefinition>();
052 @XmlTransient
053 private CamelContext camelContext;
054 @XmlTransient
055 private ErrorHandlerBuilder errorHandlerBuilder;
056
057 @Override
058 public String toString() {
059 return "Routes: " + routes;
060 }
061
062 @Override
063 public String getShortName() {
064 return "routes";
065 }
066
067 // Properties
068 //-----------------------------------------------------------------------
069 public List<RouteDefinition> getRoutes() {
070 return routes;
071 }
072
073 public void setRoutes(List<RouteDefinition> routes) {
074 this.routes = routes;
075 }
076
077 public List<InterceptFromDefinition> getInterceptFroms() {
078 return interceptFroms;
079 }
080
081 public void setInterceptFroms(List<InterceptFromDefinition> interceptFroms) {
082 this.interceptFroms = interceptFroms;
083 }
084
085 public List<InterceptSendToEndpointDefinition> getInterceptSendTos() {
086 return interceptSendTos;
087 }
088
089 public void setInterceptSendTos(List<InterceptSendToEndpointDefinition> interceptSendTos) {
090 this.interceptSendTos = interceptSendTos;
091 }
092
093 public List<InterceptDefinition> getIntercepts() {
094 return intercepts;
095 }
096
097 public void setIntercepts(List<InterceptDefinition> intercepts) {
098 this.intercepts = intercepts;
099 }
100
101 public List<OnExceptionDefinition> getOnExceptions() {
102 return onExceptions;
103 }
104
105 public void setOnExceptions(List<OnExceptionDefinition> onExceptions) {
106 this.onExceptions = onExceptions;
107 }
108
109 public List<OnCompletionDefinition> getOnCompletions() {
110 return onCompletions;
111 }
112
113 public void setOnCompletions(List<OnCompletionDefinition> onCompletions) {
114 this.onCompletions = onCompletions;
115 }
116
117 public CamelContext getCamelContext() {
118 return camelContext;
119 }
120
121 public void setCamelContext(CamelContext camelContext) {
122 this.camelContext = camelContext;
123 }
124
125 public ErrorHandlerBuilder getErrorHandlerBuilder() {
126 return errorHandlerBuilder;
127 }
128
129 public void setErrorHandlerBuilder(ErrorHandlerBuilder errorHandlerBuilder) {
130 this.errorHandlerBuilder = errorHandlerBuilder;
131 }
132
133 // Fluent API
134 //-------------------------------------------------------------------------
135
136 /**
137 * Creates a new route
138 *
139 * @return the builder
140 */
141 public RouteDefinition route() {
142 RouteDefinition route = createRoute();
143 return route(route);
144 }
145
146 /**
147 * Creates a new route from the given URI input
148 *
149 * @param uri the from uri
150 * @return the builder
151 */
152 public RouteDefinition from(String uri) {
153 RouteDefinition route = createRoute();
154 route.from(uri);
155 return route(route);
156 }
157
158 /**
159 * Creates a new route from the given endpoint
160 *
161 * @param endpoint the from endpoint
162 * @return the builder
163 */
164 public RouteDefinition from(Endpoint endpoint) {
165 RouteDefinition route = createRoute();
166 route.from(endpoint);
167 return route(route);
168 }
169
170 /**
171 * Creates a new route from the given URI inputs
172 *
173 * @param uris the from uri
174 * @return the builder
175 */
176 public RouteDefinition from(String... uris) {
177 RouteDefinition route = createRoute();
178 route.from(uris);
179 return route(route);
180 }
181
182 /**
183 * Creates a new route from the given endpoints
184 *
185 * @param endpoints the from endpoints
186 * @return the builder
187 */
188 public RouteDefinition from(Endpoint... endpoints) {
189 RouteDefinition route = createRoute();
190 route.from(endpoints);
191 return route(route);
192 }
193
194 /**
195 * Creates a new route using the given route
196 *
197 * @param route the route
198 * @return the builder
199 */
200 public RouteDefinition route(RouteDefinition route) {
201 // lets configure the route
202 route.setCamelContext(getCamelContext());
203
204 // configure intercepts
205 for (InterceptDefinition intercept : getIntercepts()) {
206 // add as first output so intercept is handled before the acutal route and that gives
207 // us the needed head start to init and be able to intercept all the remaining processing steps
208 route.getOutputs().add(0, intercept);
209 }
210
211 // configure intercept from
212 for (InterceptFromDefinition intercept : getInterceptFroms()) {
213
214 // should we only apply interceptor for a given endpoint uri
215 boolean match = true;
216 if (intercept.getUri() != null) {
217 match = false;
218 for (FromDefinition input : route.getInputs()) {
219 if (EndpointHelper.matchEndpoint(input.getUri(), intercept.getUri())) {
220 match = true;
221 break;
222 }
223 }
224 }
225
226 if (match) {
227 // add as first output so intercept is handled before the acutal route and that gives
228 // us the needed head start to init and be able to intercept all the remaining processing steps
229 route.getOutputs().add(0, intercept);
230 }
231 }
232
233 // configure intercept send to endpoint
234 for (InterceptSendToEndpointDefinition sendTo : getInterceptSendTos()) {
235 // add as first output so intercept is handled before the acutal route and that gives
236 // us the needed head start to init and be able to intercept all the remaining processing steps
237 route.getOutputs().add(0, sendTo);
238 }
239
240 // add on completions after the interceptors
241 route.getOutputs().addAll(getOnCompletions());
242
243 // add on exceptions at top since we need to inject this by the error handlers
244 route.getOutputs().addAll(0, getOnExceptions());
245
246 getRoutes().add(route);
247 return route;
248 }
249
250 /**
251 * Creates and adds an interceptor that is triggered on every step in the route
252 * processing.
253 *
254 * @return the interceptor builder to configure
255 */
256 public InterceptDefinition intercept() {
257 InterceptDefinition answer = new InterceptDefinition();
258 getIntercepts().add(0, answer);
259 return answer;
260 }
261
262 /**
263 * Creates and adds an interceptor that is triggered when an exchange
264 * is received as input to any routes (eg from all the <tt>from</tt>)
265 *
266 * @return the interceptor builder to configure
267 */
268 public InterceptFromDefinition interceptFrom() {
269 InterceptFromDefinition answer = new InterceptFromDefinition();
270 getInterceptFroms().add(answer);
271 return answer;
272 }
273
274 /**
275 * Creates and adds an interceptor that is triggered when an exchange is received
276 * as input to the route defined with the given endpoint (eg from the <tt>from</tt>)
277 *
278 * @param uri uri of the endpoint
279 * @return the interceptor builder to configure
280 */
281 public InterceptFromDefinition interceptFrom(final String uri) {
282 InterceptFromDefinition answer = new InterceptFromDefinition(uri);
283 getInterceptFroms().add(answer);
284 return answer;
285 }
286
287 /**
288 * Creates and adds an interceptor that is triggered when an exchange is
289 * send to the given endpoint
290 *
291 * @param uri uri of the endpoint
292 * @return the builder
293 */
294 public InterceptSendToEndpointDefinition interceptSendToEndpoint(final String uri) {
295 InterceptSendToEndpointDefinition answer = new InterceptSendToEndpointDefinition(uri);
296 getInterceptSendTos().add(answer);
297 return answer;
298 }
299
300 /**
301 * Adds an on exception
302 *
303 * @param exception the exception
304 * @return the builder
305 */
306 public OnExceptionDefinition onException(Class exception) {
307 OnExceptionDefinition answer = new OnExceptionDefinition(exception);
308 getOnExceptions().add(answer);
309 return answer;
310 }
311
312 /**
313 * Adds an on completion
314 *
315 * @return the builder
316 */
317 public OnCompletionDefinition onCompletion() {
318 OnCompletionDefinition answer = new OnCompletionDefinition();
319 getOnCompletions().add(answer);
320 return answer;
321 }
322
323 // Implementation methods
324 //-------------------------------------------------------------------------
325 protected RouteDefinition createRoute() {
326 RouteDefinition route = new RouteDefinition();
327 ErrorHandlerBuilder handler = getErrorHandlerBuilder();
328 if (handler != null) {
329 route.setErrorHandlerBuilderIfNull(handler);
330 }
331 return route;
332 }
333 }