protected void createJmxConnector(String host) throws IOException {
ObjectHelper.notEmpty(serviceUrlPath, "serviceUrlPath");
ObjectHelper.notNull(registryPort, "registryPort");
try {
registry = LocateRegistry.createRegistry(registryPort);
LOG.debug("Created JMXConnector RMI registry on port {}", registryPort);
} catch (RemoteException ex) {
// The registry may had been created, we could get the registry instead
}
// must start with leading slash
String path = serviceUrlPath.startsWith("/") ? serviceUrlPath : "/" + serviceUrlPath;
// Create an RMI connector and start it
final JMXServiceURL url;
if (connectorPort > 0) {
url =
new JMXServiceURL(
"service:jmx:rmi://"
+ host
+ ":"
+ connectorPort
+ "/jndi/rmi://"
+ host
+ ":"
+ registryPort
+ path);
} else {
url = new JMXServiceURL("service:jmx:rmi:///jndi/rmi://" + host + ":" + registryPort + path);
}
cs = JMXConnectorServerFactory.newJMXConnectorServer(url, null, server);
// use async thread for starting the JMX Connector
// (no need to use a thread pool or enlist in JMX as this thread is terminated when the JMX
// connector has been started)
String threadName =
camelContext.getExecutorServiceManager().resolveThreadName("JMXConnector: " + url);
Thread thread =
getCamelContext()
.getExecutorServiceManager()
.newThread(
threadName,
new Runnable() {
public void run() {
try {
LOG.debug("Staring JMX Connector thread to listen at: {}", url);
cs.start();
LOG.info("JMX Connector thread started and listening at: {}", url);
} catch (IOException ioe) {
LOG.warn(
"Could not start JMXConnector thread at: "
+ url
+ ". JMX Connector not in use.",
ioe);
}
}
});
thread.start();
}
public void performAction(Exchange exchange) throws Exception {
final CamelContext context = exchange.getContext();
// Check if action and method are set as headers
String routeId = (String) exchange.getIn().getHeader(ROUTE_ID, getRouteId());
final String action = (String) exchange.getIn().getHeader(ACTION_ID, getAction());
if (routeId == null) {
// We get the from route id in the case the routeId is still null
// please note that the route id we obtain here is the route which
// initiated the flow and not necessary this particular route.
routeId = exchange.getFromRouteId();
}
if (routeId.equals(exchange.getFromRouteId())) {
// Run the controlling in a separate thread in order for the current
// flow to finish
final String finalRouteId = routeId;
context
.getExecutorServiceManager()
.newSingleThreadExecutor(this, "RouteControllerSelf")
.execute(
new Runnable() {
@Override
public void run() {
try {
performAction(finalRouteId, action, context);
} catch (Exception e) {
// Cannot do much with this exception except log it
logger.warn(
"Exception thrown while attempting to "
+ action
+ " route "
+ finalRouteId
+ " asynchronously.",
e);
}
}
});
} else {
performAction(routeId, action, context);
}
}
/**
* Strategy to create the thread pool for the aggregator background task which waits for and
* aggregates completed tasks when running in parallel mode.
*
* @param name the suggested name for the background thread
* @return the thread pool
*/
protected synchronized ExecutorService createAggregateExecutorService(String name) {
// use a cached thread pool so we each on-the-fly task has a dedicated thread to process
// completions as they come in
return camelContext.getExecutorServiceManager().newCachedThreadPool(this, name);
}
@SuppressWarnings("deprecation")
public MethodInfo(
CamelContext camelContext,
Class<?> type,
Method method,
List<ParameterInfo> parameters,
List<ParameterInfo> bodyParameters,
boolean hasCustomAnnotation,
boolean hasHandlerAnnotation) {
this.camelContext = camelContext;
this.type = type;
this.method = method;
this.parameters = parameters;
this.bodyParameters = bodyParameters;
this.hasCustomAnnotation = hasCustomAnnotation;
this.hasHandlerAnnotation = hasHandlerAnnotation;
this.parametersExpression = createParametersExpression();
Map<Class<?>, Annotation> collectedMethodAnnotation = collectMethodAnnotations(type, method);
Pattern oneway = findOneWayAnnotation(method);
if (oneway != null) {
pattern = oneway.value();
}
org.apache.camel.RoutingSlip routingSlipAnnotation =
(org.apache.camel.RoutingSlip)
collectedMethodAnnotation.get(org.apache.camel.RoutingSlip.class);
if (routingSlipAnnotation != null && matchContext(routingSlipAnnotation.context())) {
routingSlip = new RoutingSlip(camelContext);
routingSlip.setDelimiter(routingSlipAnnotation.delimiter());
routingSlip.setIgnoreInvalidEndpoints(routingSlipAnnotation.ignoreInvalidEndpoints());
// add created routingSlip as a service so we have its lifecycle managed
try {
camelContext.addService(routingSlip);
} catch (Exception e) {
throw ObjectHelper.wrapRuntimeCamelException(e);
}
}
org.apache.camel.DynamicRouter dynamicRouterAnnotation =
(org.apache.camel.DynamicRouter)
collectedMethodAnnotation.get(org.apache.camel.DynamicRouter.class);
if (dynamicRouterAnnotation != null && matchContext(dynamicRouterAnnotation.context())) {
dynamicRouter = new DynamicRouter(camelContext);
dynamicRouter.setDelimiter(dynamicRouterAnnotation.delimiter());
dynamicRouter.setIgnoreInvalidEndpoints(dynamicRouterAnnotation.ignoreInvalidEndpoints());
// add created dynamicRouter as a service so we have its lifecycle managed
try {
camelContext.addService(dynamicRouter);
} catch (Exception e) {
throw ObjectHelper.wrapRuntimeCamelException(e);
}
}
org.apache.camel.RecipientList recipientListAnnotation =
(org.apache.camel.RecipientList)
collectedMethodAnnotation.get(org.apache.camel.RecipientList.class);
if (recipientListAnnotation != null && matchContext(recipientListAnnotation.context())) {
recipientList = new RecipientList(camelContext, recipientListAnnotation.delimiter());
recipientList.setStopOnException(recipientListAnnotation.stopOnException());
recipientList.setIgnoreInvalidEndpoints(recipientListAnnotation.ignoreInvalidEndpoints());
recipientList.setParallelProcessing(recipientListAnnotation.parallelProcessing());
recipientList.setParallelAggregate(recipientListAnnotation.parallelAggregate());
recipientList.setStreaming(recipientListAnnotation.streaming());
recipientList.setTimeout(recipientListAnnotation.timeout());
recipientList.setShareUnitOfWork(recipientListAnnotation.shareUnitOfWork());
if (ObjectHelper.isNotEmpty(recipientListAnnotation.executorServiceRef())) {
ExecutorService executor =
camelContext
.getExecutorServiceManager()
.newDefaultThreadPool(this, recipientListAnnotation.executorServiceRef());
recipientList.setExecutorService(executor);
}
if (recipientListAnnotation.parallelProcessing()
&& recipientList.getExecutorService() == null) {
// we are running in parallel so we need a thread pool
ExecutorService executor =
camelContext.getExecutorServiceManager().newDefaultThreadPool(this, "@RecipientList");
recipientList.setExecutorService(executor);
}
if (ObjectHelper.isNotEmpty(recipientListAnnotation.strategyRef())) {
AggregationStrategy strategy =
CamelContextHelper.mandatoryLookup(
camelContext, recipientListAnnotation.strategyRef(), AggregationStrategy.class);
recipientList.setAggregationStrategy(strategy);
}
if (ObjectHelper.isNotEmpty(recipientListAnnotation.onPrepareRef())) {
Processor onPrepare =
CamelContextHelper.mandatoryLookup(
camelContext, recipientListAnnotation.onPrepareRef(), Processor.class);
recipientList.setOnPrepare(onPrepare);
}
// add created recipientList as a service so we have its lifecycle managed
try {
camelContext.addService(recipientList);
} catch (Exception e) {
throw ObjectHelper.wrapRuntimeCamelException(e);
}
}
}