public void onRoutesAdd(Collection<Route> routes) {
    for (Route route : routes) {

      // if we are starting CamelContext or either of the two options has been
      // enabled, then enlist the route as a known route
      if (getCamelContext().getStatus().isStarting()
          || getManagementStrategy().getManagementAgent().getRegisterAlways()
          || getManagementStrategy().getManagementAgent().getRegisterNewRoutes()) {
        // register as known route id
        knowRouteIds.add(route.getId());
      }

      if (!shouldRegister(route, route)) {
        // avoid registering if not needed, skip to next route
        continue;
      }

      Object mr = getManagementObjectStrategy().getManagedObjectForRoute(camelContext, route);

      // skip already managed routes, for example if the route has been restarted
      if (getManagementStrategy().isManaged(mr, null)) {
        LOG.trace("The route is already managed: {}", route);
        continue;
      }

      // get the wrapped instrumentation processor from this route
      // and set me as the counter
      if (route instanceof EventDrivenConsumerRoute) {
        EventDrivenConsumerRoute edcr = (EventDrivenConsumerRoute) route;
        Processor processor = edcr.getProcessor();
        if (processor instanceof CamelInternalProcessor && mr instanceof ManagedRoute) {
          CamelInternalProcessor internal = (CamelInternalProcessor) processor;
          ManagedRoute routeMBean = (ManagedRoute) mr;

          CamelInternalProcessor.InstrumentationAdvice task =
              internal.getAdvice(CamelInternalProcessor.InstrumentationAdvice.class);
          if (task != null) {
            // we need to wrap the counter with the camel context so we get stats updated on the
            // context as well
            if (camelContextMBean != null) {
              CompositePerformanceCounter wrapper =
                  new CompositePerformanceCounter(routeMBean, camelContextMBean);
              task.setCounter(wrapper);
            } else {
              task.setCounter(routeMBean);
            }
          }
        }
      }

      try {
        manageObject(mr);
      } catch (JMException e) {
        LOG.warn("Could not register Route MBean", e);
      } catch (Exception e) {
        LOG.warn("Could not create Route MBean", e);
      }
    }
  }
Exemplo n.º 2
0
  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);
    }
  }