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
022 import javax.xml.bind.annotation.XmlAccessType;
023 import javax.xml.bind.annotation.XmlAccessorType;
024 import javax.xml.bind.annotation.XmlAttribute;
025 import javax.xml.bind.annotation.XmlElementRef;
026 import javax.xml.bind.annotation.XmlRootElement;
027 import javax.xml.bind.annotation.XmlTransient;
028
029 import org.apache.camel.CamelContext;
030 import org.apache.camel.Endpoint;
031 import org.apache.camel.Predicate;
032 import org.apache.camel.builder.ErrorHandlerBuilder;
033 import org.apache.camel.processor.DelegateProcessor;
034
035 /**
036 * Represents a collection of routes
037 *
038 * @version $Revision: 673837 $
039 */
040 @XmlRootElement(name = "routes")
041 @XmlAccessorType(XmlAccessType.FIELD)
042 public class RoutesType extends OptionalIdentifiedType<RoutesType> implements RouteContainer {
043 // TODO: not sure how else to use an optional attribute in JAXB2
044 @XmlAttribute
045 private Boolean inheritErrorHandlerFlag;
046 @XmlElementRef
047 private List<RouteType> routes = new ArrayList<RouteType>();
048 @XmlElementRef
049 private List<ServiceActivationType> activations = new ArrayList<ServiceActivationType>();
050 @XmlTransient
051 private List<InterceptorType> interceptors = new ArrayList<InterceptorType>();
052 @XmlTransient
053 private List<InterceptType> intercepts = new ArrayList<InterceptType>();
054 @XmlTransient
055 private List<ExceptionType> exceptions = new ArrayList<ExceptionType>();
056 @XmlTransient
057 private CamelContext camelContext;
058 @XmlTransient
059 private ErrorHandlerBuilder errorHandlerBuilder;
060
061 @Override
062 public String toString() {
063 return "Routes: " + routes;
064 }
065
066 // Properties
067 //-----------------------------------------------------------------------
068 public List<RouteType> getRoutes() {
069 return routes;
070 }
071
072 public void setRoutes(List<RouteType> routes) {
073 this.routes = routes;
074 }
075
076 public List<InterceptorType> getInterceptors() {
077 return interceptors;
078 }
079
080 public void setInterceptors(List<InterceptorType> interceptors) {
081 this.interceptors = interceptors;
082 }
083
084 public List<InterceptType> getIntercepts() {
085 return intercepts;
086 }
087
088 public void setIntercepts(List<InterceptType> intercepts) {
089 this.intercepts = intercepts;
090 }
091
092 public List<ExceptionType> getExceptions() {
093 return exceptions;
094 }
095
096 public void setExceptions(List<ExceptionType> exceptions) {
097 this.exceptions = exceptions;
098 }
099
100 public CamelContext getCamelContext() {
101 return camelContext;
102 }
103
104 public void setCamelContext(CamelContext camelContext) {
105 this.camelContext = camelContext;
106 }
107
108 public boolean isInheritErrorHandler() {
109 return ProcessorType.isInheritErrorHandler(getInheritErrorHandlerFlag());
110 }
111
112 public Boolean getInheritErrorHandlerFlag() {
113 return inheritErrorHandlerFlag;
114 }
115
116 public void setInheritErrorHandlerFlag(Boolean inheritErrorHandlerFlag) {
117 this.inheritErrorHandlerFlag = inheritErrorHandlerFlag;
118 }
119
120 public ErrorHandlerBuilder getErrorHandlerBuilder() {
121 return errorHandlerBuilder;
122 }
123
124 public void setErrorHandlerBuilder(ErrorHandlerBuilder errorHandlerBuilder) {
125 this.errorHandlerBuilder = errorHandlerBuilder;
126 }
127
128 // Fluent API
129 //-------------------------------------------------------------------------
130
131 /**
132 * Creates a new route
133 */
134 public RouteType route() {
135 RouteType route = createRoute();
136 return route(route);
137 }
138
139 /**
140 * Creates a new route from the given URI input
141 */
142 public RouteType from(String uri) {
143 RouteType route = createRoute();
144 route.from(uri);
145 return route(route);
146 }
147
148 /**
149 * Creates a new route from the given endpoint
150 */
151 public RouteType from(Endpoint endpoint) {
152 RouteType route = createRoute();
153 route.from(endpoint);
154 return route(route);
155 }
156
157 public RouteType route(RouteType route) {
158 // lets configure the route
159 route.setCamelContext(getCamelContext());
160 route.setInheritErrorHandlerFlag(getInheritErrorHandlerFlag());
161 List<InterceptorType> list = getInterceptors();
162 for (InterceptorType interceptorType : list) {
163 route.addInterceptor(interceptorType);
164 }
165 List<InterceptType> intercepts = getIntercepts();
166 for (InterceptType intercept : intercepts) {
167 // need to create a proxy for this one and use the
168 // proceed of the proxy which will be local to this route
169 InterceptType proxy = intercept.createProxy();
170 route.addOutput(proxy);
171 route.pushBlock(proxy.getProceed());
172 }
173 route.getOutputs().addAll(getExceptions());
174 getRoutes().add(route);
175 return route;
176 }
177
178 public RoutesType intercept(DelegateProcessor interceptor) {
179 getInterceptors().add(new InterceptorRef(interceptor));
180 return this;
181 }
182
183 public InterceptType intercept() {
184 InterceptType answer = new InterceptType();
185 getIntercepts().add(answer);
186 return answer;
187 }
188
189 public ChoiceType intercept(Predicate predicate) {
190 InterceptType answer = new InterceptType();
191 getIntercepts().add(answer);
192 return answer.when(predicate);
193 }
194
195 public ExceptionType exception(Class exceptionType) {
196 ExceptionType answer = new ExceptionType(exceptionType);
197 getExceptions().add(answer);
198 return answer;
199 }
200
201 // Implementation methods
202 //-------------------------------------------------------------------------
203 protected RouteType createRoute() {
204 RouteType route = new RouteType();
205 ErrorHandlerBuilder handler = getErrorHandlerBuilder();
206 if (isInheritErrorHandler() && handler != null) {
207 route.setErrorHandlerBuilderIfNull(handler);
208 }
209 return route;
210 }
211 }