// Implementation methods
// -------------------------------------------------------------------------
@SuppressWarnings("unchecked")
protected RouteContext addRoutes(CamelContext camelContext, Collection<Route> routes, FromDefinition fromType) throws Exception {
RouteContext routeContext = new DefaultRouteContext(camelContext, this, fromType, routes);
// configure tracing
if (trace != null) {
Boolean isTrace = CamelContextHelper.parseBoolean(camelContext, getTrace());
if (isTrace != null) {
routeContext.setTracing(isTrace);
if (isTrace) {
log.debug("Tracing is enabled on route: {}", getId());
// tracing is added in the DefaultChannel so we can enable it on the fly
}
}
}
// configure stream caching
if (streamCache != null) {
Boolean isStreamCache = CamelContextHelper.parseBoolean(camelContext, getStreamCache());
if (isStreamCache != null) {
routeContext.setStreamCaching(isStreamCache);
if (isStreamCache) {
log.debug("StreamCaching is enabled on route: {}", getId());
// only add a new stream cache if not already a global configured on camel context
if (StreamCaching.getStreamCaching(camelContext) == null) {
addInterceptStrategy(new StreamCaching());
}
}
}
}
// configure handle fault
if (handleFault != null) {
Boolean isHandleFault = CamelContextHelper.parseBoolean(camelContext, getHandleFault());
if (isHandleFault != null) {
routeContext.setHandleFault(isHandleFault);
if (isHandleFault) {
log.debug("HandleFault is enabled on route: {}", getId());
// only add a new handle fault if not already a global configured on camel context
if (HandleFault.getHandleFault(camelContext) == null) {
addInterceptStrategy(new HandleFault());
}
}
}
}
// configure delayer
if (delayer != null) {
Long delayer = CamelContextHelper.parseLong(camelContext, getDelayer());
if (delayer != null) {
routeContext.setDelayer(delayer);
if (delayer > 0) {
log.debug("Delayer is enabled with: {} ms. on route: {}", delayer, getId());
addInterceptStrategy(new Delayer(delayer));
} else {
log.debug("Delayer is disabled on route: {}", getId());
}
}
}
// configure route policy
if (routePolicies != null && !routePolicies.isEmpty()) {
for (RoutePolicy policy : routePolicies) {
log.debug("RoutePolicy is enabled: {} on route: {}", policy, getId());
routeContext.getRoutePolicyList().add(policy);
}
}
if (routePolicyRef != null) {
StringTokenizer policyTokens = new StringTokenizer(routePolicyRef, ",");
while (policyTokens.hasMoreTokens()) {
String ref = policyTokens.nextToken().trim();
RoutePolicy policy = CamelContextHelper.mandatoryLookup(camelContext, ref, RoutePolicy.class);
log.debug("RoutePolicy is enabled: {} on route: {}", policy, getId());
routeContext.getRoutePolicyList().add(policy);
}
}
// configure auto startup
Boolean isAutoStartup = CamelContextHelper.parseBoolean(camelContext, getAutoStartup());
if (isAutoStartup != null) {
log.debug("Using AutoStartup {} on route: {}", isAutoStartup, getId());
routeContext.setAutoStartup(isAutoStartup);
}
// configure shutdown
if (shutdownRoute != null) {
log.debug("Using ShutdownRoute {} on route: {}", getShutdownRoute(), getId());
routeContext.setShutdownRoute(getShutdownRoute());
}
if (shutdownRunningTask != null) {
log.debug("Using ShutdownRunningTask {} on route: {}", getShutdownRunningTask(), getId());
routeContext.setShutdownRunningTask(getShutdownRunningTask());
}
// should inherit the intercept strategies we have defined
routeContext.setInterceptStrategies(this.getInterceptStrategies());
// force endpoint resolution
routeContext.getEndpoint();
if (camelContext != null) {
for (LifecycleStrategy strategy : camelContext.getLifecycleStrategies()) {
strategy.onRouteContextCreate(routeContext);
}
}
// validate route has output processors
if (!ProcessorDefinitionHelper.hasOutputs(outputs, true)) {
RouteDefinition route = routeContext.getRoute();
String at = fromType.toString();
Exception cause = new IllegalArgumentException("Route " + route.getId() + " has no output processors."
+ " You need to add outputs to the route such as to(\"log:foo\").");
throw new FailedToCreateRouteException(route.getId(), route.toString(), at, cause);
}
List<ProcessorDefinition> list = new ArrayList<ProcessorDefinition>(outputs);
for (ProcessorDefinition output : list) {
try {
output.addRoutes(routeContext, routes);
} catch (Exception e) {
RouteDefinition route = routeContext.getRoute();
throw new FailedToCreateRouteException(route.getId(), route.toString(), output.toString(), e);
}
}
routeContext.commit();
return routeContext;
}