public void onRouteContextCreate(RouteContext routeContext) {
if (!initialized) {
return;
}
// Create a map (ProcessorType -> PerformanceCounter)
// to be passed to InstrumentationInterceptStrategy.
Map<ProcessorDefinition<?>, PerformanceCounter> registeredCounters =
new HashMap<ProcessorDefinition<?>, PerformanceCounter>();
// Each processor in a route will have its own performance counter.
// These performance counter will be embedded to InstrumentationProcessor
// and wrap the appropriate processor by InstrumentationInterceptStrategy.
RouteDefinition route = routeContext.getRoute();
// register performance counters for all processors and its children
for (ProcessorDefinition<?> processor : route.getOutputs()) {
registerPerformanceCounters(routeContext, processor, registeredCounters);
}
// set this managed intercept strategy that executes the JMX instrumentation for performance
// metrics
// so our registered counters can be used for fine grained performance instrumentation
routeContext.setManagedInterceptStrategy(
new InstrumentationInterceptStrategy(registeredCounters, wrappedProcessors));
}
private void dumpCamelContext(String msg) {
LOGGER.debug("\n\n*************** START: " + msg + " *****************");
List<RouteDefinition> routeDefinitions = camelContext.getRouteDefinitions();
if (routeDefinitions != null) {
LOGGER.debug("Number of routes = " + routeDefinitions.size());
for (RouteDefinition routeDef : routeDefinitions) {
String routeId = routeDef.getId();
LOGGER.debug("route ID = " + routeId);
List<FromDefinition> routeInputs = routeDef.getInputs();
if (routeInputs.isEmpty()) {
LOGGER.debug("routeInputs are EMPTY");
} else {
for (FromDefinition fromDef : routeInputs) {
LOGGER.debug("route input's URI = " + fromDef.getUri());
}
}
ServiceStatus routeStatus = camelContext.getRouteStatus(routeId);
if (routeStatus != null) {
LOGGER.debug("Route ID " + routeId + " is started = " + routeStatus.isStarted());
} else {
LOGGER.debug("routeStatus is NULL for routeId = " + routeId);
}
}
}
LOGGER.debug("*************** END: " + msg + " *****************\n\n");
}
/**
* Appends a namespace on the end of all URIs found in the specified route.
*
* @param route the specified route
* @param namespace the specified namespace
*/
public static final void addNamespaceParameter(RouteDefinition route, String namespace) {
for (FromDefinition fromDef : route.getInputs()) {
addNamespaceParameterFrom(fromDef, namespace);
}
for (ProcessorDefinition<?> procDef : route.getOutputs()) {
addNamespaceParameterTo(procDef, namespace);
}
}
/**
* Add the route in the database if it's not already, or update its state.
*
* @param routes being added to the app
*/
@Override
public void onRoutesAdd(Collection<Route> routes) {
for (Route routeCamel : routes) {
// adding a performance counter on the route
if (routeCamel instanceof EventDrivenConsumerRoute) {
EventDrivenConsumerRoute edcr = (EventDrivenConsumerRoute) routeCamel;
Processor processor = edcr.getProcessor();
if (processor instanceof InstrumentationProcessor) {
InstrumentationProcessor ip = (InstrumentationProcessor) processor;
ConsolePerformanceCounter counter =
new ConsolePerformanceCounter(routeCamel.getId(), repository);
ip.setCounter(counter);
log.debug("Adding a counter" + counter.toString() + " to " + routeCamel.getId());
}
}
// saving route in database
log.debug("Route added " + routeCamel.getId());
com.ninja_squad.console.Route route = repository.findRoute(routeCamel.getId());
if (route == null) {
route =
new com.ninja_squad.console.Route(routeCamel.getId())
.state(State.Started)
.uri(routeCamel.getEndpoint().getEndpointUri());
ObjectMapper mapper = new ObjectMapper();
AnnotationIntrospector introspector =
new JaxbAnnotationIntrospector(TypeFactory.defaultInstance());
// make serializer use JAXB annotations (only)
mapper.setAnnotationIntrospector(introspector);
String definition = null;
RouteDefinition routeDefinition = routeCamel.getRouteContext().getRoute();
try {
definition = mapper.writeValueAsString(routeDefinition);
} catch (IOException e) {
log.error("Error while marshalling route definition", e);
}
route.setDefinition(definition);
for (ProcessorDefinition<?> stepDefinition : routeDefinition.getOutputs()) {
if (stepDefinition.getId() == null) {
stepDefinition.setId(stepDefinition.getClass().getSimpleName());
}
route.getSteps().put(stepDefinition.getId(), stepDefinition.getLabel());
}
repository.save(route);
}
// saving state in database
RouteState routeState = repository.lastRouteState(routeCamel.getId());
if (routeState == null || routeState.getState().equals(State.Stopped)) {
routeState = new RouteState();
routeState.setRouteId(routeCamel.getId());
routeState.setState(State.Started);
routeState.setTimestamp(DateTime.now().getMillis());
repository.save(routeState);
}
}
}
private boolean isMyRoute(String routeId) {
boolean status = false;
if (this.routeCollection != null) {
for (RouteDefinition routeDef : this.routeCollection) {
if (routeDef.getId().equals(routeId)) {
return true;
}
}
}
return status;
}
/**
* Removes the wrapped processors for the given routes, as they are no longer in use.
*
* <p>This is needed to avoid accumulating memory, if a lot of routes is being added and removed.
*
* @param routes the routes
*/
private void removeWrappedProcessorsForRoutes(Collection<Route> routes) {
// loop the routes, and remove the route associated wrapped processors, as they are no longer in
// use
for (Route route : routes) {
String id = route.getId();
Iterator<KeyValueHolder<ProcessorDefinition<?>, InstrumentationProcessor>> it =
wrappedProcessors.values().iterator();
while (it.hasNext()) {
KeyValueHolder<ProcessorDefinition<?>, InstrumentationProcessor> holder = it.next();
RouteDefinition def = ProcessorDefinitionHelper.getRoute(holder.getKey());
if (def != null && id.equals(def.getId())) {
it.remove();
}
}
}
}
public void testAdviceWithErrorHandler() throws Exception {
RouteDefinition route = context.getRouteDefinitions().get(0);
try {
route.adviceWith(
context,
new AdviceWithRouteBuilder() {
@Override
public void configure() throws Exception {
errorHandler(deadLetterChannel("mock:dead"));
}
});
fail("Should have thrown exception");
} catch (IllegalArgumentException e) {
assertEquals(
"You can not advice with error handlers. Remove the error handlers from the route builder.",
e.getMessage());
}
}
public void testAdviceWithOnCompletion() throws Exception {
RouteDefinition route = context.getRouteDefinitions().get(0);
route.adviceWith(
context,
new AdviceWithRouteBuilder() {
@Override
public void configure() throws Exception {
onCompletion().to("mock:done");
}
});
getMockEndpoint("mock:result").expectedBodiesReceived("Hello World");
getMockEndpoint("mock:done").expectedBodiesReceived("Hello World");
template.sendBody("direct:start", "World");
assertMockEndpointsSatisfied();
}
public void testAdviceWithOnException() throws Exception {
RouteDefinition route = context.getRouteDefinitions().get(0);
route.adviceWith(
context,
new AdviceWithRouteBuilder() {
@Override
public void configure() throws Exception {
onException(IllegalArgumentException.class).handled(true).to("mock:error");
}
});
getMockEndpoint("mock:result").expectedBodiesReceived("Hello World");
getMockEndpoint("mock:error").expectedBodiesReceived("Kaboom");
template.sendBody("direct:start", "World");
template.sendBody("direct:start", "Kaboom");
assertMockEndpointsSatisfied();
}
private ToDefinition getDroolsNode(RouteDefinition routeDef) {
ToDefinition toDrools = null;
for (ProcessorDefinition<?> child : routeDef.getOutputs()) {
toDrools = getDroolsNode(child);
if (toDrools != null) {
break;
}
}
return toDrools;
}
public RouteService(
DefaultCamelContext camelContext,
RouteDefinition routeDefinition,
List<RouteContext> routeContexts,
List<Route> routes) {
this.camelContext = camelContext;
this.routeDefinition = routeDefinition;
this.routeContexts = routeContexts;
this.routes = routes;
this.id = routeDefinition.idOrCreate(camelContext.getNodeIdFactory());
}
public void testAdviceWithInterceptFrom() throws Exception {
RouteDefinition route = context.getRouteDefinitions().get(0);
route.adviceWith(
context,
new AdviceWithRouteBuilder() {
@Override
public void configure() throws Exception {
interceptFrom().to("mock:from");
}
});
getMockEndpoint("mock:result").expectedBodiesReceived("Hello World");
getMockEndpoint("mock:from").expectedBodiesReceived("World");
getMockEndpoint("mock:from")
.expectedHeaderReceived(Exchange.INTERCEPTED_ENDPOINT, "direct://start");
template.sendBody("direct:start", "World");
assertMockEndpointsSatisfied();
}
public void testIssue() throws Exception {
final Predicate fail =
PredicateBuilder.or(
header(Exchange.REDELIVERY_COUNTER).isNull(),
header(Exchange.REDELIVERY_COUNTER).isLessThan(5));
RouteDefinition route = context.getRouteDefinitions().get(0);
route.adviceWith(
context,
new RouteBuilder() {
@Override
public void configure() throws Exception {
interceptSendToEndpoint("seda:*")
.skipSendToOriginalEndpoint()
.process(
new Processor() {
public void process(Exchange exchange) throws Exception {
invoked.incrementAndGet();
if (fail.matches(exchange)) {
throw new ConnectException("Forced");
}
}
})
.to("mock:ok");
}
});
getMockEndpoint("mock:global").expectedMessageCount(0);
getMockEndpoint("mock:ok").expectedMessageCount(1);
getMockEndpoint("mock:exhausted").expectedMessageCount(0);
template.sendBody("direct:start", "Hello World");
assertMockEndpointsSatisfied();
// 5 retry + 1 ok
assertEquals(6, invoked.get());
}
public void updateRouteFromXml(String xml) throws Exception {
// convert to model from xml
RouteDefinition def = ModelHelper.createModelFromXml(xml, RouteDefinition.class);
if (def == null) {
return;
}
// if the xml does not contain the route-id then we fix this by adding the actual route id
// this may be needed if the route-id was auto-generated, as the intend is to update this route
// and not add a new route, adding a new route, use the MBean operation on ManagedCamelContext
// instead.
if (ObjectHelper.isEmpty(def.getId())) {
def.setId(getRouteId());
} else if (!def.getId().equals(getRouteId())) {
throw new IllegalArgumentException(
"Cannot update route from XML as routeIds does not match. routeId: "
+ getRouteId()
+ ", routeId from XML: "
+ def.getId());
}
// add will remove existing route first
context.addRouteDefinition(def);
}
private void startRoute(RouteDefinition routeDef) {
String routeId = routeDef.getId();
try {
if (isMyRoute(routeId)) {
ServiceStatus routeStatus = camelContext.getRouteStatus(routeId);
// Only start the route if it is not already started
if (routeStatus == null || !routeStatus.isStarted()) {
LOGGER.trace("Starting route with ID = " + routeId);
camelContext.startRoute(routeDef); // DEPRECATED
// this method does not reliably start a route that was created, then
// app shutdown, and restarted
// camelContext.startRoute(routeId);
}
}
} catch (Exception e) {
LOGGER.warn("Unable to start Camel route with route ID = " + routeId, e);
}
}
/** Gather the route scoped error handler from the given route */
private void doGetRouteScopedErrorHandler(Set<Service> services, Route route) {
// only include error handlers if they are route scoped
boolean includeErrorHandler =
!routeDefinition.isContextScopedErrorHandler(route.getRouteContext().getCamelContext());
List<Service> extra = new ArrayList<Service>();
if (includeErrorHandler) {
for (Service service : services) {
if (service instanceof Channel) {
Processor eh = ((Channel) service).getErrorHandler();
if (eh != null && eh instanceof Service) {
extra.add((Service) eh);
}
}
}
}
if (!extra.isEmpty()) {
services.addAll(extra);
}
}
private void removeRoutes() {
LOGGER.trace("ENTERING: stopRoutes");
List<RouteDefinition> routeDefinitions = camelContext.getRouteDefinitions();
for (RouteDefinition routeDef : routeDefinitions) {
try {
// Only remove routes that this Content Directory Monitor created
// (since same camelContext shared across all ContentDirectoryMonitors
// this is necessary)
if (isMyRoute(routeDef.getId())) {
LOGGER.trace("Stopping route with ID = " + routeDef.getId());
camelContext.stopRoute(routeDef); // DEPRECATED
// camelContext.stopRoute(routeDef.getId());
boolean status = camelContext.removeRoute(routeDef.getId());
LOGGER.trace("Status of removing route " + routeDef.getId() + " is " + status);
camelContext.removeRouteDefinition(routeDef);
}
} catch (Exception e) {
LOGGER.warn("Unable to stop Camel route with route ID = " + routeDef.getId(), e);
}
}
LOGGER.trace("EXITING: stopRoutes");
}
public void commit() {
// now lets turn all of the event driven consumer processors into a single route
if (!eventDrivenProcessors.isEmpty()) {
Processor target = Pipeline.newInstance(getCamelContext(), eventDrivenProcessors);
String routeId = route.idOrCreate(getCamelContext().getNodeIdFactory());
// and wrap it in a unit of work so the UoW is on the top, so the entire route will be in the
// same UoW
CamelInternalProcessor internal = new CamelInternalProcessor(target);
internal.addAdvice(new CamelInternalProcessor.UnitOfWorkProcessorAdvice(routeId));
// and then in route context so we can keep track which route this is at runtime
internal.addAdvice(new CamelInternalProcessor.RouteContextAdvice(this));
// and then optionally add route policy processor if a custom policy is set
List<RoutePolicy> routePolicyList = getRoutePolicyList();
if (routePolicyList != null && !routePolicyList.isEmpty()) {
for (RoutePolicy policy : routePolicyList) {
// add policy as service if we have not already done that (eg possible if two routes have
// the same service)
// this ensures Camel can control the lifecycle of the policy
if (!camelContext.hasService(policy)) {
try {
camelContext.addService(policy);
} catch (Exception e) {
throw ObjectHelper.wrapRuntimeCamelException(e);
}
}
}
internal.addAdvice(new CamelInternalProcessor.RoutePolicyAdvice(routePolicyList));
}
// wrap in route inflight processor to track number of inflight exchanges for the route
internal.addAdvice(
new CamelInternalProcessor.RouteInflightRepositoryAdvice(
camelContext.getInflightRepository(), routeId));
// wrap in JMX instrumentation processor that is used for performance stats
internal.addAdvice(new CamelInternalProcessor.InstrumentationAdvice("route"));
// wrap in route lifecycle
internal.addAdvice(new CamelInternalProcessor.RouteLifecycleAdvice());
// and create the route that wraps the UoW
Route edcr = new EventDrivenConsumerRoute(this, getEndpoint(), internal);
edcr.getProperties().put(Route.ID_PROPERTY, routeId);
edcr.getProperties().put(Route.PARENT_PROPERTY, Integer.toHexString(route.hashCode()));
edcr.getProperties().put(Route.DESCRIPTION_PROPERTY, route.getDescriptionText());
if (route.getGroup() != null) {
edcr.getProperties().put(Route.GROUP_PROPERTY, route.getGroup());
}
String rest = "false";
if (route.isRest() != null && route.isRest()) {
rest = "true";
}
edcr.getProperties().put(Route.REST_PROPERTY, rest);
// after the route is created then set the route on the policy processor so we get hold of it
CamelInternalProcessor.RoutePolicyAdvice task =
internal.getAdvice(CamelInternalProcessor.RoutePolicyAdvice.class);
if (task != null) {
task.setRoute(edcr);
}
CamelInternalProcessor.RouteLifecycleAdvice task2 =
internal.getAdvice(CamelInternalProcessor.RouteLifecycleAdvice.class);
if (task2 != null) {
task2.setRoute(edcr);
}
// invoke init on route policy
if (routePolicyList != null && !routePolicyList.isEmpty()) {
for (RoutePolicy policy : routePolicyList) {
policy.onInit(edcr);
}
}
routes.add(edcr);
}
}
public Endpoint resolveEndpoint(String uri) {
return route.resolveEndpoint(getCamelContext(), uri);
}
public ProcessorDefinition<?> apply(RouteDefinition rd) {
return rd.onException(Exception.class)
.handled(true)
.transform(Builder.exceptionMessage())
.end();
}
public void process(ComponentDefinitionRegistry componentDefinitionRegistry) {
CamelContextFactoryBean ccfb =
(CamelContextFactoryBean)
blueprintContainer.getComponentInstance(
".camelBlueprint.factory." + camelContextName);
CamelContext camelContext = ccfb.getContext();
Set<String> components = new HashSet<String>();
Set<String> languages = new HashSet<String>();
Set<String> dataformats = new HashSet<String>();
Set<String> dependsOn = new HashSet<String>();
for (RouteDefinition rd : camelContext.getRouteDefinitions()) {
findInputComponents(rd.getInputs(), components, languages, dataformats);
findOutputComponents(rd.getOutputs(), components, languages, dataformats);
}
try {
for (String component : components) {
ComponentMetadata cm =
componentDefinitionRegistry.getComponentDefinition(
".camelBlueprint.componentResolver." + component);
if (cm == null) {
MutableReferenceMetadata svc = createMetadata(MutableReferenceMetadata.class);
svc.setId(".camelBlueprint.componentResolver." + component);
svc.setFilter("(component=" + component + ")");
svc.setAvailability(
componentDefinitionRegistry.containsComponentDefinition(component)
? AVAILABILITY_OPTIONAL
: AVAILABILITY_MANDATORY);
try {
// Try to set the runtime interface (only with aries blueprint > 0.1
svc.getClass()
.getMethod("setRuntimeInterface", Class.class)
.invoke(svc, ComponentResolver.class);
} catch (Throwable t) {
// Check if the bundle can see the class
try {
PassThroughMetadata ptm =
(PassThroughMetadata)
componentDefinitionRegistry.getComponentDefinition("blueprintBundle");
Bundle b = (Bundle) ptm.getObject();
if (b.loadClass(ComponentResolver.class.getName()) != ComponentResolver.class) {
throw new UnsupportedOperationException();
}
svc.setInterface(ComponentResolver.class.getName());
} catch (Throwable t2) {
throw new UnsupportedOperationException();
}
}
componentDefinitionRegistry.registerComponentDefinition(svc);
dependsOn.add(svc.getId());
}
}
for (String language : languages) {
ComponentMetadata cm =
componentDefinitionRegistry.getComponentDefinition(
".camelBlueprint.languageResolver." + language);
if (cm == null) {
MutableReferenceMetadata svc = createMetadata(MutableReferenceMetadata.class);
svc.setId(".camelBlueprint.languageResolver." + language);
svc.setFilter("(language=" + language + ")");
svc.setAvailability(
componentDefinitionRegistry.containsComponentDefinition(language)
? AVAILABILITY_OPTIONAL
: AVAILABILITY_MANDATORY);
try {
// Try to set the runtime interface (only with aries blueprint > 0.1
svc.getClass()
.getMethod("setRuntimeInterface", Class.class)
.invoke(svc, LanguageResolver.class);
} catch (Throwable t) {
// Check if the bundle can see the class
try {
PassThroughMetadata ptm =
(PassThroughMetadata)
componentDefinitionRegistry.getComponentDefinition("blueprintBundle");
Bundle b = (Bundle) ptm.getObject();
if (b.loadClass(LanguageResolver.class.getName()) != LanguageResolver.class) {
throw new UnsupportedOperationException();
}
svc.setInterface(LanguageResolver.class.getName());
} catch (Throwable t2) {
throw new UnsupportedOperationException();
}
}
componentDefinitionRegistry.registerComponentDefinition(svc);
dependsOn.add(svc.getId());
}
}
for (String dataformat : dataformats) {
ComponentMetadata cm =
componentDefinitionRegistry.getComponentDefinition(
".camelBlueprint.dataformatResolver." + dataformat);
if (cm == null) {
MutableReferenceMetadata svc = createMetadata(MutableReferenceMetadata.class);
svc.setId(".camelBlueprint.dataformatResolver." + dataformat);
svc.setFilter("(dataformat=" + dataformat + ")");
svc.setAvailability(
componentDefinitionRegistry.containsComponentDefinition(dataformat)
? AVAILABILITY_OPTIONAL
: AVAILABILITY_MANDATORY);
try {
// Try to set the runtime interface (only with aries blueprint > 0.1
svc.getClass()
.getMethod("setRuntimeInterface", Class.class)
.invoke(svc, DataFormatResolver.class);
} catch (Throwable t) {
// Check if the bundle can see the class
try {
PassThroughMetadata ptm =
(PassThroughMetadata)
componentDefinitionRegistry.getComponentDefinition("blueprintBundle");
Bundle b = (Bundle) ptm.getObject();
if (b.loadClass(DataFormatResolver.class.getName()) != DataFormatResolver.class) {
throw new UnsupportedOperationException();
}
svc.setInterface(DataFormatResolver.class.getName());
} catch (Throwable t2) {
throw new UnsupportedOperationException();
}
}
componentDefinitionRegistry.registerComponentDefinition(svc);
dependsOn.add(svc.getId());
}
}
} catch (UnsupportedOperationException e) {
LOG.warn(
"Unable to add dependencies on to camel components OSGi services. "
+ "The Apache Aries blueprint implementation used it too old and the blueprint bundle can not see the org.apache.camel.spi package.");
components.clear();
languages.clear();
dataformats.clear();
}
}