protected Processor createErrorHandler(
      RouteContext routeContext, Exchange exchange, Processor processor) {
    Processor answer;

    boolean tryBlock = exchange.getProperty(Exchange.TRY_ROUTE_BLOCK, false, boolean.class);

    // do not wrap in error handler if we are inside a try block
    if (!tryBlock && routeContext != null) {
      // wrap the producer in error handler so we have fine grained error handling on
      // the output side instead of the input side
      // this is needed to support redelivery on that output alone and not doing redelivery
      // for the entire multicast block again which will start from scratch again

      // create key for cache
      final PreparedErrorHandler key = new PreparedErrorHandler(routeContext, processor);

      // lookup cached first to reuse and preserve memory
      answer = errorHandlers.get(key);
      if (answer != null) {
        LOG.trace("Using existing error handler for: {}", processor);
        return answer;
      }

      LOG.trace("Creating error handler for: {}", processor);
      ErrorHandlerFactory builder = routeContext.getRoute().getErrorHandlerBuilder();
      // create error handler (create error handler directly to keep it light weight,
      // instead of using ProcessorDefinition.wrapInErrorHandler)
      try {
        processor = builder.createErrorHandler(routeContext, processor);

        // and wrap in unit of work processor so the copy exchange also can run under UoW
        answer = createUnitOfWorkProcessor(routeContext, processor, exchange);

        boolean child =
            exchange.getProperty(Exchange.PARENT_UNIT_OF_WORK, UnitOfWork.class) != null;

        // must start the error handler
        ServiceHelper.startServices(answer);

        // here we don't cache the child unit of work
        if (!child) {
          // add to cache
          errorHandlers.putIfAbsent(key, answer);
        }

      } catch (Exception e) {
        throw ObjectHelper.wrapRuntimeCamelException(e);
      }
    } else {
      // and wrap in unit of work processor so the copy exchange also can run under UoW
      answer = createUnitOfWorkProcessor(routeContext, processor, exchange);
    }

    return answer;
  }
  @Override
  protected void doStart() throws Exception {
    ServiceHelper.startServices(output, outputAsync, deadLetter);
    // use a shared scheduler
    if (executorService == null || executorService.isShutdown()) {
      // camel context will shutdown the executor when it shutdown so no need to shut it down when
      // stopping
      if (executorServiceRef != null) {
        executorService =
            camelContext
                .getExecutorServiceStrategy()
                .lookupScheduled(this, "ErrorHandlerRedeliveryTask", executorServiceRef);
        if (executorService == null) {
          throw new IllegalArgumentException(
              "ExecutorServiceRef " + executorServiceRef + " not found in registry.");
        }
      } else {
        executorService =
            camelContext
                .getExecutorServiceStrategy()
                .newScheduledThreadPool(this, "ErrorHandlerRedeliveryTask");
      }
    }

    // determine if redeliver is enabled or not
    redeliveryEnabled = determineIfRedeliveryIsEnabled();
    if (log.isDebugEnabled()) {
      log.debug("Redelivery enabled: {} on error handler: {}", redeliveryEnabled, this);
    }
  }
  @Override
  @Before
  protected void setUp() throws Exception {
    super.setUp();

    context2 = new DefaultCamelContext();
    template2 = context2.createProducerTemplate();

    ServiceHelper.startServices(template2, context2);

    // add routes after CamelContext has been started
    RouteBuilder routeBuilder = createRouteBuilderForSecondContext();
    if (routeBuilder != null) {
      context2.addRoutes(routeBuilder);
    }
  }
Exemple #4
0
 protected void doStart() throws Exception {
   if (consumerCache == null) {
     // create consumer cache if we use dynamic expressions for computing the endpoints to poll
     if (cacheSize < 0) {
       consumerCache = new EmptyConsumerCache(this, camelContext);
       LOG.debug("PollEnrich {} is not using ConsumerCache", this);
     } else if (cacheSize == 0) {
       consumerCache = new ConsumerCache(this, camelContext);
       LOG.debug("PollEnrich {} using ConsumerCache with default cache size", this);
     } else {
       consumerCache = new ConsumerCache(this, camelContext, cacheSize);
       LOG.debug("PollEnrich {} using ConsumerCache with cacheSize={}", this, cacheSize);
     }
   }
   ServiceHelper.startServices(consumerCache, aggregationStrategy);
 }
 @Override
 protected void doStart() throws Exception {
   // inject CamelContext before starting
   if (jsonMarshal instanceof CamelContextAware) {
     ((CamelContextAware) jsonMarshal).setCamelContext(camelContext);
   }
   if (jsonUnmarshal instanceof CamelContextAware) {
     ((CamelContextAware) jsonUnmarshal).setCamelContext(camelContext);
   }
   if (xmlMarshal instanceof CamelContextAware) {
     ((CamelContextAware) xmlMarshal).setCamelContext(camelContext);
   }
   if (xmlUnmarshal instanceof CamelContextAware) {
     ((CamelContextAware) xmlUnmarshal).setCamelContext(camelContext);
   }
   ServiceHelper.startServices(jsonMarshal, jsonUnmarshal, xmlMarshal, xmlUnmarshal);
 }
  protected void setUp(String endpointUri) throws Exception {
    template = camelContext.createProducerTemplate();
    startServices(template, camelContext);

    endpoint = camelContext.getEndpoint(endpointUri, JpaEndpoint.class);

    transactionStrategy = endpoint.createTransactionStrategy();
    jpaTemplate = endpoint.getTemplate();

    transactionStrategy.execute(
        new JpaCallback() {
          public Object doInJpa(EntityManager entityManager) throws PersistenceException {
            entityManager.createQuery("delete from " + Customer.class.getName()).executeUpdate();
            return null;
          }
        });

    assertEntitiesInDatabase(0, Customer.class.getName());
    assertEntitiesInDatabase(0, Address.class.getName());
  }
 protected void doStart() throws Exception {
   if (isParallelProcessing() && executorService == null) {
     throw new IllegalArgumentException(
         "ParallelProcessing is enabled but ExecutorService has not been set");
   }
   if (timeout > 0 && !isParallelProcessing()) {
     throw new IllegalArgumentException(
         "Timeout is used but ParallelProcessing has not been enabled");
   }
   if (isParallelProcessing() && aggregateExecutorService == null) {
     // use unbounded thread pool so we ensure the aggregate on-the-fly task always will have
     // assigned a thread
     // and run the tasks when the task is submitted. If not then the aggregate task may not be
     // able to run
     // and signal completion during processing, which would lead to what would appear as a
     // dead-lock or a slow processing
     String name = getClass().getSimpleName() + "-AggregateTask";
     aggregateExecutorService = createAggregateExecutorService(name);
   }
   ServiceHelper.startServices(aggregationStrategy, processors);
 }
 protected void doStart() throws Exception {
   ServiceHelper.startServices(aggregationStrategy, consumer);
 }
Exemple #9
0
 protected void doStart() throws Exception {
   log.debug("Starting consumer: {}", this);
   ServiceHelper.startServices(processor);
 }
 @Override
 protected void doStart() throws Exception {
   ServiceHelper.startServices(target, interceptor);
 }