Examples with AggregationRepository org.apache.camel.spi.AggregationRepository used on opensource projects

Example 1 with AggregationRepository

use of org.apache.camel.spi.AggregationRepository in project camel by apache.

the class AggregateDefinition method createAggregator.

protected AggregateProcessor createAggregator(RouteContext routeContext) throws Exception {
    Processor childProcessor = this.createChildProcessor(routeContext, true);
    // wrap the aggregate route in a unit of work processor
    CamelInternalProcessor internal = new CamelInternalProcessor(childProcessor);
    internal.addAdvice(new CamelInternalProcessor.UnitOfWorkProcessorAdvice(routeContext));
    Expression correlation = getExpression().createExpression(routeContext);
    AggregationStrategy strategy = createAggregationStrategy(routeContext);
    boolean parallel = getParallelProcessing() != null && getParallelProcessing();
    boolean shutdownThreadPool = ProcessorDefinitionHelper.willCreateNewThreadPool(routeContext, this, parallel);
    ExecutorService threadPool = ProcessorDefinitionHelper.getConfiguredExecutorService(routeContext, "Aggregator", this, parallel);
    if (threadPool == null && !parallel) {
        // executor service is mandatory for the Aggregator
        // we do not run in parallel mode, but use a synchronous executor, so we run in current thread
        threadPool = new SynchronousExecutorService();
        shutdownThreadPool = true;
    }
    AggregateProcessor answer = new AggregateProcessor(routeContext.getCamelContext(), internal, correlation, strategy, threadPool, shutdownThreadPool);
    AggregationRepository repository = createAggregationRepository(routeContext);
    if (repository != null) {
        answer.setAggregationRepository(repository);
    }
    if (getAggregateController() == null && getAggregateControllerRef() != null) {
        setAggregateController(routeContext.mandatoryLookup(getAggregateControllerRef(), AggregateController.class));
    }
    // this EIP supports using a shared timeout checker thread pool or fallback to create a new thread pool
    boolean shutdownTimeoutThreadPool = false;
    ScheduledExecutorService timeoutThreadPool = timeoutCheckerExecutorService;
    if (timeoutThreadPool == null && timeoutCheckerExecutorServiceRef != null) {
        // lookup existing thread pool
        timeoutThreadPool = routeContext.getCamelContext().getRegistry().lookupByNameAndType(timeoutCheckerExecutorServiceRef, ScheduledExecutorService.class);
        if (timeoutThreadPool == null) {
            // then create a thread pool assuming the ref is a thread pool profile id
            timeoutThreadPool = routeContext.getCamelContext().getExecutorServiceManager().newScheduledThreadPool(this, AggregateProcessor.AGGREGATE_TIMEOUT_CHECKER, timeoutCheckerExecutorServiceRef);
            if (timeoutThreadPool == null) {
                throw new IllegalArgumentException("ExecutorServiceRef " + timeoutCheckerExecutorServiceRef + " not found in registry or as a thread pool profile.");
            }
            shutdownTimeoutThreadPool = true;
        }
    }
    answer.setTimeoutCheckerExecutorService(timeoutThreadPool);
    answer.setShutdownTimeoutCheckerExecutorService(shutdownTimeoutThreadPool);
    // set other options
    answer.setParallelProcessing(parallel);
    if (getOptimisticLocking() != null) {
        answer.setOptimisticLocking(getOptimisticLocking());
    }
    if (getCompletionPredicate() != null) {
        Predicate predicate = getCompletionPredicate().createPredicate(routeContext);
        answer.setCompletionPredicate(predicate);
    } else if (strategy instanceof Predicate) {
        // if aggregation strategy implements predicate and was not configured then use as fallback
        log.debug("Using AggregationStrategy as completion predicate: {}", strategy);
        answer.setCompletionPredicate((Predicate) strategy);
    }
    if (getCompletionTimeoutExpression() != null) {
        Expression expression = getCompletionTimeoutExpression().createExpression(routeContext);
        answer.setCompletionTimeoutExpression(expression);
    }
    if (getCompletionTimeout() != null) {
        answer.setCompletionTimeout(getCompletionTimeout());
    }
    if (getCompletionInterval() != null) {
        answer.setCompletionInterval(getCompletionInterval());
    }
    if (getCompletionSizeExpression() != null) {
        Expression expression = getCompletionSizeExpression().createExpression(routeContext);
        answer.setCompletionSizeExpression(expression);
    }
    if (getCompletionSize() != null) {
        answer.setCompletionSize(getCompletionSize());
    }
    if (getCompletionFromBatchConsumer() != null) {
        answer.setCompletionFromBatchConsumer(getCompletionFromBatchConsumer());
    }
    if (getEagerCheckCompletion() != null) {
        answer.setEagerCheckCompletion(getEagerCheckCompletion());
    }
    if (getIgnoreInvalidCorrelationKeys() != null) {
        answer.setIgnoreInvalidCorrelationKeys(getIgnoreInvalidCorrelationKeys());
    }
    if (getCloseCorrelationKeyOnCompletion() != null) {
        answer.setCloseCorrelationKeyOnCompletion(getCloseCorrelationKeyOnCompletion());
    }
    if (getDiscardOnCompletionTimeout() != null) {
        answer.setDiscardOnCompletionTimeout(getDiscardOnCompletionTimeout());
    }
    if (getForceCompletionOnStop() != null) {
        answer.setForceCompletionOnStop(getForceCompletionOnStop());
    }
    if (getCompleteAllOnStop() != null) {
        answer.setCompleteAllOnStop(getCompleteAllOnStop());
    }
    if (optimisticLockRetryPolicy == null) {
        if (getOptimisticLockRetryPolicyDefinition() != null) {
            answer.setOptimisticLockRetryPolicy(getOptimisticLockRetryPolicyDefinition().createOptimisticLockRetryPolicy());
        }
    } else {
        answer.setOptimisticLockRetryPolicy(optimisticLockRetryPolicy);
    }
    if (getAggregateController() != null) {
        answer.setAggregateController(getAggregateController());
    }
    return answer;
}