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.Endpoint; 028 import org.apache.camel.ErrorHandlerFactory; 029 030 /** 031 * Represents a collection of routes 032 * 033 * @version 034 */ 035 @XmlRootElement(name = "routes") 036 @XmlAccessorType(XmlAccessType.FIELD) 037 public class RoutesDefinition extends OptionalIdentifiedDefinition<RoutesDefinition> implements RouteContainer { 038 @XmlElementRef 039 private List<RouteDefinition> routes = new ArrayList<RouteDefinition>(); 040 @XmlTransient 041 private List<InterceptDefinition> intercepts = new ArrayList<InterceptDefinition>(); 042 @XmlTransient 043 private List<InterceptFromDefinition> interceptFroms = new ArrayList<InterceptFromDefinition>(); 044 @XmlTransient 045 private List<InterceptSendToEndpointDefinition> interceptSendTos = new ArrayList<InterceptSendToEndpointDefinition>(); 046 @XmlTransient 047 private List<OnExceptionDefinition> onExceptions = new ArrayList<OnExceptionDefinition>(); 048 @XmlTransient 049 private List<OnCompletionDefinition> onCompletions = new ArrayList<OnCompletionDefinition>(); 050 @XmlTransient 051 private ModelCamelContext camelContext; 052 @XmlTransient 053 private ErrorHandlerFactory errorHandlerBuilder; 054 055 public RoutesDefinition() { 056 } 057 058 @Override 059 public String toString() { 060 return "Routes: " + routes; 061 } 062 063 @Override 064 public String getShortName() { 065 return "routes"; 066 } 067 068 // Properties 069 //----------------------------------------------------------------------- 070 public List<RouteDefinition> getRoutes() { 071 return routes; 072 } 073 074 public void setRoutes(List<RouteDefinition> routes) { 075 this.routes = routes; 076 } 077 078 public List<InterceptFromDefinition> getInterceptFroms() { 079 return interceptFroms; 080 } 081 082 public void setInterceptFroms(List<InterceptFromDefinition> interceptFroms) { 083 this.interceptFroms = interceptFroms; 084 } 085 086 public List<InterceptSendToEndpointDefinition> getInterceptSendTos() { 087 return interceptSendTos; 088 } 089 090 public void setInterceptSendTos(List<InterceptSendToEndpointDefinition> interceptSendTos) { 091 this.interceptSendTos = interceptSendTos; 092 } 093 094 public List<InterceptDefinition> getIntercepts() { 095 return intercepts; 096 } 097 098 public void setIntercepts(List<InterceptDefinition> intercepts) { 099 this.intercepts = intercepts; 100 } 101 102 public List<OnExceptionDefinition> getOnExceptions() { 103 return onExceptions; 104 } 105 106 public void setOnExceptions(List<OnExceptionDefinition> onExceptions) { 107 this.onExceptions = onExceptions; 108 } 109 110 public List<OnCompletionDefinition> getOnCompletions() { 111 return onCompletions; 112 } 113 114 public void setOnCompletions(List<OnCompletionDefinition> onCompletions) { 115 this.onCompletions = onCompletions; 116 } 117 118 public ModelCamelContext getCamelContext() { 119 return camelContext; 120 } 121 122 public void setCamelContext(ModelCamelContext camelContext) { 123 this.camelContext = camelContext; 124 } 125 126 public ErrorHandlerFactory getErrorHandlerBuilder() { 127 return errorHandlerBuilder; 128 } 129 130 public void setErrorHandlerBuilder(ErrorHandlerFactory errorHandlerBuilder) { 131 this.errorHandlerBuilder = errorHandlerBuilder; 132 } 133 134 // Fluent API 135 //------------------------------------------------------------------------- 136 137 /** 138 * Creates a new route 139 * 140 * @return the builder 141 */ 142 public RouteDefinition route() { 143 RouteDefinition route = createRoute(); 144 return route(route); 145 } 146 147 /** 148 * Creates a new route from the given URI input 149 * 150 * @param uri the from uri 151 * @return the builder 152 */ 153 public RouteDefinition from(String uri) { 154 RouteDefinition route = createRoute(); 155 route.from(uri); 156 return route(route); 157 } 158 159 /** 160 * Creates a new route from the given endpoint 161 * 162 * @param endpoint the from endpoint 163 * @return the builder 164 */ 165 public RouteDefinition from(Endpoint endpoint) { 166 RouteDefinition route = createRoute(); 167 route.from(endpoint); 168 return route(route); 169 } 170 171 /** 172 * Creates a new route from the given URI inputs 173 * 174 * @param uris the from uri 175 * @return the builder 176 */ 177 public RouteDefinition from(String... uris) { 178 RouteDefinition route = createRoute(); 179 route.from(uris); 180 return route(route); 181 } 182 183 /** 184 * Creates a new route from the given endpoints 185 * 186 * @param endpoints the from endpoints 187 * @return the builder 188 */ 189 public RouteDefinition from(Endpoint... endpoints) { 190 RouteDefinition route = createRoute(); 191 route.from(endpoints); 192 return route(route); 193 } 194 195 /** 196 * Creates a new route using the given route 197 * 198 * @param route the route 199 * @return the builder 200 */ 201 public RouteDefinition route(RouteDefinition route) { 202 // must prepare the route before we can add it to the routes list 203 RouteDefinitionHelper.prepareRoute(getCamelContext(), route, getOnExceptions(), getIntercepts(), getInterceptFroms(), 204 getInterceptSendTos(), getOnCompletions()); 205 getRoutes().add(route); 206 // mark this route as prepared 207 route.markPrepared(); 208 return route; 209 } 210 211 /** 212 * Creates and adds an interceptor that is triggered on every step in the route 213 * processing. 214 * 215 * @return the interceptor builder to configure 216 */ 217 public InterceptDefinition intercept() { 218 InterceptDefinition answer = new InterceptDefinition(); 219 getIntercepts().add(0, answer); 220 return answer; 221 } 222 223 /** 224 * Creates and adds an interceptor that is triggered when an exchange 225 * is received as input to any routes (eg from all the <tt>from</tt>) 226 * 227 * @return the interceptor builder to configure 228 */ 229 public InterceptFromDefinition interceptFrom() { 230 InterceptFromDefinition answer = new InterceptFromDefinition(); 231 getInterceptFroms().add(answer); 232 return answer; 233 } 234 235 /** 236 * Creates and adds an interceptor that is triggered when an exchange is received 237 * as input to the route defined with the given endpoint (eg from the <tt>from</tt>) 238 * 239 * @param uri uri of the endpoint 240 * @return the interceptor builder to configure 241 */ 242 public InterceptFromDefinition interceptFrom(final String uri) { 243 InterceptFromDefinition answer = new InterceptFromDefinition(uri); 244 getInterceptFroms().add(answer); 245 return answer; 246 } 247 248 /** 249 * Creates and adds an interceptor that is triggered when an exchange is 250 * send to the given endpoint 251 * 252 * @param uri uri of the endpoint 253 * @return the builder 254 */ 255 public InterceptSendToEndpointDefinition interceptSendToEndpoint(final String uri) { 256 InterceptSendToEndpointDefinition answer = new InterceptSendToEndpointDefinition(uri); 257 getInterceptSendTos().add(answer); 258 return answer; 259 } 260 261 /** 262 * Adds an on exception 263 * 264 * @param exception the exception 265 * @return the builder 266 */ 267 public OnExceptionDefinition onException(Class<? extends Throwable> exception) { 268 OnExceptionDefinition answer = new OnExceptionDefinition(exception); 269 answer.setRouteScoped(false); 270 getOnExceptions().add(answer); 271 return answer; 272 } 273 274 /** 275 * Adds an on completion 276 * 277 * @return the builder 278 */ 279 public OnCompletionDefinition onCompletion() { 280 OnCompletionDefinition answer = new OnCompletionDefinition(); 281 getOnCompletions().add(answer); 282 return answer; 283 } 284 285 // Implementation methods 286 //------------------------------------------------------------------------- 287 protected RouteDefinition createRoute() { 288 RouteDefinition route = new RouteDefinition(); 289 ErrorHandlerFactory handler = getErrorHandlerBuilder(); 290 if (handler != null) { 291 route.setErrorHandlerBuilderIfNull(handler); 292 } 293 return route; 294 } 295 }