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.Collection;
021 import java.util.List;
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 import javax.xml.bind.annotation.XmlType;
029
030 import org.apache.camel.CamelContext;
031 import org.apache.camel.CamelContextAware;
032 import org.apache.camel.Endpoint;
033 import org.apache.camel.NoSuchEndpointException;
034 import org.apache.camel.Route;
035 import org.apache.camel.ServiceStatus;
036 import org.apache.camel.builder.ErrorHandlerBuilder;
037 import org.apache.camel.impl.DefaultRouteContext;
038 import org.apache.camel.processor.interceptor.StreamCaching;
039 import org.apache.camel.spi.RouteContext;
040 import org.apache.camel.util.CamelContextHelper;
041
042 /**
043 * Represents an XML <route/> element
044 *
045 * @version $Revision: 787246 $
046 */
047 @XmlRootElement(name = "route")
048 @XmlType(propOrder = {"inputs", "outputs" })
049 @XmlAccessorType(XmlAccessType.PROPERTY)
050 public class RouteDefinition extends ProcessorDefinition<ProcessorDefinition> implements CamelContextAware {
051 private List<FromDefinition> inputs = new ArrayList<FromDefinition>();
052 private List<ProcessorDefinition> outputs = new ArrayList<ProcessorDefinition>();
053 private CamelContext camelContext;
054 private String group;
055 private Boolean streamCache;
056
057 public RouteDefinition() {
058 }
059
060 public RouteDefinition(String uri) {
061 from(uri);
062 }
063
064 public RouteDefinition(Endpoint endpoint) {
065 from(endpoint);
066 }
067
068 @Override
069 public String toString() {
070 return "Route[" + inputs + " -> " + outputs + "]";
071 }
072
073 @Override
074 public String getShortName() {
075 return "route";
076 }
077
078 /**
079 * Returns the status of the route if it has been registered with a {@link CamelContext}
080 */
081 public ServiceStatus getStatus() {
082 if (camelContext != null) {
083 ServiceStatus answer = camelContext.getRouteStatus(this);
084 if (answer == null) {
085 answer = ServiceStatus.Stopped;
086 }
087 return answer;
088 }
089 return null;
090 }
091
092 public boolean isStartable() {
093 ServiceStatus status = getStatus();
094 if (status == null) {
095 return true;
096 } else {
097 return status.isStartable();
098 }
099 }
100
101 public boolean isStoppable() {
102 ServiceStatus status = getStatus();
103 if (status == null) {
104 return false;
105 } else {
106 return status.isStoppable();
107 }
108 }
109
110 public List<RouteContext> addRoutes(CamelContext context, Collection<Route> routes) throws Exception {
111 List<RouteContext> answer = new ArrayList<RouteContext>();
112 setCamelContext(context);
113
114 ErrorHandlerBuilder handler = context.getErrorHandlerBuilder();
115 if (handler != null) {
116 setErrorHandlerBuilderIfNull(handler);
117 }
118
119 for (FromDefinition fromType : inputs) {
120 RouteContext routeContext = addRoutes(routes, fromType);
121 answer.add(routeContext);
122 }
123 return answer;
124 }
125
126
127 public Endpoint resolveEndpoint(String uri) throws NoSuchEndpointException {
128 CamelContext context = getCamelContext();
129 if (context == null) {
130 throw new IllegalArgumentException("CamelContext has not been injected!");
131 }
132 return CamelContextHelper.getMandatoryEndpoint(context, uri);
133 }
134
135 // Fluent API
136 // -----------------------------------------------------------------------
137
138 /**
139 * Creates an input to the route
140 *
141 * @param uri the from uri
142 * @return the builder
143 */
144 public RouteDefinition from(String uri) {
145 getInputs().add(new FromDefinition(uri));
146 return this;
147 }
148
149 /**
150 * Creates an input to the route
151 *
152 * @param endpoint the from endpoint
153 * @return the builder
154 */
155 public RouteDefinition from(Endpoint endpoint) {
156 getInputs().add(new FromDefinition(endpoint));
157 return this;
158 }
159
160 /**
161 * Creates inputs to the route
162 *
163 * @param uris the from uris
164 * @return the builder
165 */
166 public RouteDefinition from(String... uris) {
167 for (String uri : uris) {
168 getInputs().add(new FromDefinition(uri));
169 }
170 return this;
171 }
172
173 /**
174 * Creates inputs to the route
175 *
176 * @param endpoints the from endpoints
177 * @return the builder
178 */
179 public RouteDefinition from(Endpoint... endpoints) {
180 for (Endpoint endpoint : endpoints) {
181 getInputs().add(new FromDefinition(endpoint));
182 }
183 return this;
184 }
185
186 /**
187 * Set the group name for this route
188 *
189 * @param name the group name
190 * @return the builder
191 */
192 public RouteDefinition group(String name) {
193 setGroup(name);
194 return this;
195 }
196
197 /**
198 * Disable stream caching for this Route.
199 */
200 public RouteDefinition noStreamCaching() {
201 setStreamCache(Boolean.FALSE);
202 StreamCaching.noStreamCaching(getInterceptStrategies());
203 return this;
204 }
205
206 /**
207 * Enable stream caching for this Route.
208 */
209 public RouteDefinition streamCaching() {
210 setStreamCache(Boolean.TRUE);
211 StreamCaching cache = StreamCaching.getStreamCaching(getCamelContext());
212 if (cache == null) {
213 cache = new StreamCaching();
214 }
215
216 getInterceptStrategies().add(cache);
217 return this;
218 }
219
220 // Properties
221 // -----------------------------------------------------------------------
222
223 public List<FromDefinition> getInputs() {
224 return inputs;
225 }
226
227 @XmlElementRef
228 public void setInputs(List<FromDefinition> inputs) {
229 this.inputs = inputs;
230 }
231
232 public List<ProcessorDefinition> getOutputs() {
233 return outputs;
234 }
235
236 @XmlElementRef
237 public void setOutputs(List<ProcessorDefinition> outputs) {
238 this.outputs = outputs;
239
240 if (outputs != null) {
241 for (ProcessorDefinition output : outputs) {
242 configureChild(output);
243 }
244 }
245 }
246
247 public CamelContext getCamelContext() {
248 return camelContext;
249 }
250
251 @XmlTransient
252 public void setCamelContext(CamelContext camelContext) {
253 this.camelContext = camelContext;
254 }
255
256 /**
257 * The group that this route belongs to; could be the name of the RouteBuilder class
258 * or be explicitly configured in the XML.
259 *
260 * May be null.
261 */
262 public String getGroup() {
263 return group;
264 }
265
266 @XmlAttribute
267 public void setGroup(String group) {
268 this.group = group;
269 }
270
271 public Boolean isStreamCache() {
272 return streamCache;
273 }
274
275 @XmlAttribute
276 public void setStreamCache(Boolean streamCache) {
277 this.streamCache = streamCache;
278 }
279
280 // Implementation methods
281 // -------------------------------------------------------------------------
282 protected RouteContext addRoutes(Collection<Route> routes, FromDefinition fromType) throws Exception {
283 RouteContext routeContext = new DefaultRouteContext(this, fromType, routes);
284 // should inherit the intercept strategies we have defined
285 routeContext.setInterceptStrategies(this.getInterceptStrategies());
286 // force endpoint resolution
287 routeContext.getEndpoint();
288 if (camelContext != null) {
289 camelContext.getLifecycleStrategy().onRouteContextCreate(routeContext);
290 }
291
292 List<ProcessorDefinition> list = new ArrayList<ProcessorDefinition>(outputs);
293 for (ProcessorDefinition output : list) {
294 output.addRoutes(routeContext, routes);
295 }
296
297 routeContext.commit();
298 return routeContext;
299 }
300
301 }