org.flowable.job.service.impl.asyncexecutor.AsyncExecutor Java Examples

public void waitForJobExecutorToProcessAllJobs(long maxMillisToWait, long intervalMillis) {
    AsyncExecutor asyncExecutor = processEngineConfiguration.getAsyncExecutor();
    asyncExecutor.start();

    try {
        Timer timer = new Timer();
        InterruptTask task = new InterruptTask(Thread.currentThread());
        timer.schedule(task, maxMillisToWait);
        boolean areJobsAvailable = true;
        try {
            while (areJobsAvailable && !task.isTimeLimitExceeded()) {
                Thread.sleep(intervalMillis);
                areJobsAvailable = areJobsAvailable();
            }
        } catch (InterruptedException e) {
        } finally {
            timer.cancel();
        }
        if (areJobsAvailable) {
            throw new FlowableException("time limit of " + maxMillisToWait + " was exceeded");
        }

    } finally {
        asyncExecutor.shutdown();
    }
}
 

public static void executeJobExecutorForTime(CmmnEngineConfiguration cmmnEngineConfiguration, long maxMillisToWait, long intervalMillis) {
    AsyncExecutor asyncExecutor = cmmnEngineConfiguration.getAsyncExecutor();
    asyncExecutor.start();

    try {
        Timer timer = new Timer();
        InterruptTask task = new InterruptTask(Thread.currentThread());
        timer.schedule(task, maxMillisToWait);
        try {
            while (!task.isTimeLimitExceeded()) {
                Thread.sleep(intervalMillis);
            }
        } catch (InterruptedException e) {
            // ignore
        } finally {
            timer.cancel();
        }

    } finally {
        asyncExecutor.shutdown();
    }
}
 

public static void executeJobExecutorForTime(ProcessEngineConfiguration processEngineConfiguration, long maxMillisToWait, long intervalMillis) {
    AsyncExecutor asyncExecutor = processEngineConfiguration.getAsyncExecutor();
    asyncExecutor.start();

    try {
        Timer timer = new Timer();
        InterruptTask task = new InterruptTask(Thread.currentThread());
        timer.schedule(task, maxMillisToWait);
        try {
            while (!task.isTimeLimitExceeded()) {
                Thread.sleep(intervalMillis);
            }
        } catch (InterruptedException e) {
            // ignore
        } finally {
            timer.cancel();
        }

    } finally {
        asyncExecutor.shutdown();
    }
}
 

public void waitForJobExecutorToProcessAllJobs(long maxMillisToWait, long intervalMillis) {
    AsyncExecutor asyncExecutor = processEngineConfiguration.getAsyncExecutor();
    asyncExecutor.start();

    try {
        Timer timer = new Timer();
        InterruptTask task = new InterruptTask(Thread.currentThread());
        timer.schedule(task, maxMillisToWait);
        boolean areJobsAvailable = true;
        try {
            while (areJobsAvailable && !task.isTimeLimitExceeded()) {
                Thread.sleep(intervalMillis);
                areJobsAvailable = areJobsAvailable();
            }
        } catch (InterruptedException e) {
        } finally {
            timer.cancel();
        }
        if (areJobsAvailable) {
            throw new FlowableException("time limit of " + maxMillisToWait + " was exceeded");
        }

    } finally {
        asyncExecutor.shutdown();
    }
}
 

@Test
public void cmmnShouldUseDedicatedAndProcessEngineShouldUsePrimaryRejectedHandler() {
    contextRunner.withUserConfiguration(CmmnRejectedHandlerConfiguration.class, PrimaryRejectedHandlerConfiguration.class)
        .run((context -> {
            AsyncExecutor processAsyncExecutor = context.getBean(ProcessEngine.class).getProcessEngineConfiguration().getAsyncExecutor();
            AsyncExecutor cmmnAsyncExecutor = context.getBean(CmmnEngine.class).getCmmnEngineConfiguration().getAsyncExecutor();

            assertThat(context)
                .doesNotHaveBean("springRejectedJobsHandler")
                .hasBean("cmmnRejectedJobsHandler")
                .hasBean("primaryRejectedJobsHandler");

            SpringRejectedJobsHandler primaryRejectedJobsHandlerBean = context.getBean("primaryRejectedJobsHandler", SpringRejectedJobsHandler.class);
            SpringRejectedJobsHandler cmmnRejectedJobsHandlerBean = context.getBean("cmmnRejectedJobsHandler", SpringRejectedJobsHandler.class);

            assertThat(((SpringAsyncExecutor) processAsyncExecutor).getRejectedJobsHandler())
                .as("Process Async Rejected Jobs Handler")
                .isSameAs(primaryRejectedJobsHandlerBean)
                .isNotSameAs(((SpringAsyncExecutor) cmmnAsyncExecutor).getRejectedJobsHandler());

            assertThat(((SpringAsyncExecutor) cmmnAsyncExecutor).getRejectedJobsHandler())
                .as("Cmmn Async Rejected Jobs Handler")
                .isSameAs(cmmnRejectedJobsHandlerBean);
        }));
}
 

@Test
public void cmmnAndProcessEngineShouldUseDistinctRejectedHandlers() {
    contextRunner.withUserConfiguration(DedicatedRejectedHandlerConfiguration.class)
        .run((context -> {
            AsyncExecutor processAsyncExecutor = context.getBean(ProcessEngine.class).getProcessEngineConfiguration().getAsyncExecutor();
            AsyncExecutor cmmnAsyncExecutor = context.getBean(CmmnEngine.class).getCmmnEngineConfiguration().getAsyncExecutor();

            assertThat(context)
                .doesNotHaveBean("springRejectedJobsHandler")
                .hasBean("cmmnRejectedJobsHandler")
                .hasBean("processRejectedJobsHandler");

            SpringRejectedJobsHandler processRejectedJobsHandlerBean = context.getBean("processRejectedJobsHandler", SpringRejectedJobsHandler.class);
            SpringRejectedJobsHandler cmmnRejectedJobsHandlerBean = context.getBean("cmmnRejectedJobsHandler", SpringRejectedJobsHandler.class);

            assertThat(((SpringAsyncExecutor) processAsyncExecutor).getRejectedJobsHandler())
                .as("Process Async Rejected Jobs Handler")
                .isSameAs(processRejectedJobsHandlerBean)
                .isNotSameAs(((SpringAsyncExecutor) cmmnAsyncExecutor).getRejectedJobsHandler());

            assertThat(((SpringAsyncExecutor) cmmnAsyncExecutor).getRejectedJobsHandler())
                .as("Cmmn Async Rejected Jobs Handler")
                .isSameAs(cmmnRejectedJobsHandlerBean);
        }));
}
 

@Test
public void cmmnShouldUsePrimaryAndProcessEngineShouldUseDedicatedTaskExecutor() {
    contextRunner.withUserConfiguration(ProcessTaskExecutorConfiguration.class, PrimaryTaskExecutorConfiguration.class)
        .run((context -> {
            AsyncExecutor processAsyncExecutor = context.getBean(ProcessEngine.class).getProcessEngineConfiguration().getAsyncExecutor();
            AsyncExecutor cmmnAsyncExecutor = context.getBean(CmmnEngine.class).getCmmnEngineConfiguration().getAsyncExecutor();

            assertThat(context)
                .doesNotHaveBean("taskExecutor")
                .hasBean("primaryTaskExecutor")
                .hasBean("processTaskExecutor");

            TaskExecutor prmiaryTaskExecutorBean = context.getBean("primaryTaskExecutor", TaskExecutor.class);
            TaskExecutor processTaskExecutorBean = context.getBean("processTaskExecutor", TaskExecutor.class);

            assertThat(((SpringAsyncExecutor) processAsyncExecutor).getTaskExecutor())
                .as("Process Async Task Executor")
                .isSameAs(processTaskExecutorBean)
                .isNotSameAs(((SpringAsyncExecutor) cmmnAsyncExecutor).getTaskExecutor());

            assertThat(((SpringAsyncExecutor) cmmnAsyncExecutor).getTaskExecutor())
                .as("Cmmn Async Task Executor")
                .isSameAs(prmiaryTaskExecutorBean);
        }));
}
 

@Test
public void cmmnAndProcessEngineShouldUseDistinctTaskExecutors() {
    contextRunner.withUserConfiguration(DedicatedTaskExecutorsConfiguration.class)
        .run((context -> {
            AsyncExecutor processAsyncExecutor = context.getBean(ProcessEngine.class).getProcessEngineConfiguration().getAsyncExecutor();
            AsyncExecutor cmmnAsyncExecutor = context.getBean(CmmnEngine.class).getCmmnEngineConfiguration().getAsyncExecutor();

            assertThat(context)
                .doesNotHaveBean("taskExecutor")
                .hasBean("cmmnTaskExecutor")
                .hasBean("processTaskExecutor");
            TaskExecutor cmmnTaskExecutorBean = context.getBean("cmmnTaskExecutor", TaskExecutor.class);
            TaskExecutor processTaskExecutorBean = context.getBean("processTaskExecutor", TaskExecutor.class);

            assertThat(((SpringAsyncExecutor) processAsyncExecutor).getTaskExecutor())
                .as("Process Async Task Executor")
                .isSameAs(processTaskExecutorBean)
                .isNotSameAs(((SpringAsyncExecutor) cmmnAsyncExecutor).getTaskExecutor());

            assertThat(((SpringAsyncExecutor) cmmnAsyncExecutor).getTaskExecutor())
                .as("Cmmn Async Task Executor")
                .isSameAs(cmmnTaskExecutorBean);
        }));
}
 

@Test
public void asyncHistoryExecutorBeanWithDefault() {
    contextRunner
        .run((context -> {
            assertThat(context).doesNotHaveBean("asyncHistoryExecutor");

            AsyncExecutor processAsyncHistoryExecutor = context.getBean(ProcessEngine.class).getProcessEngineConfiguration().getAsyncHistoryExecutor();
            assertThat(processAsyncHistoryExecutor).isNull();

            assertThat(context.getBean(ProcessEngine.class).getProcessEngineConfiguration().isAsyncHistoryExecutorActivate()).isTrue();

            assertThat(((ProcessEngineConfigurationImpl) context.getBean(ProcessEngine.class).getProcessEngineConfiguration()).isAsyncHistoryEnabled())
                .isFalse();

        }));
}
 

public static void executeJobExecutorForTime(ProcessEngineConfiguration processEngineConfiguration, long maxMillisToWait, long intervalMillis) {
    AsyncExecutor asyncExecutor = processEngineConfiguration.getAsyncExecutor();
    asyncExecutor.start();

    try {
        Timer timer = new Timer();
        InterruptTask task = new InterruptTask(Thread.currentThread());
        timer.schedule(task, maxMillisToWait);
        try {
            while (!task.isTimeLimitExceeded()) {
                Thread.sleep(intervalMillis);
            }
        } catch (InterruptedException e) {
            // ignore
        } finally {
            timer.cancel();
        }

    } finally {
        asyncExecutor.shutdown();
    }
}
 

protected void hintAsyncExecutor(Job job) {

        AsyncExecutor asyncExecutor = Context.getProcessEngineConfiguration().getAsyncExecutor();
        CommandContext commandContext = CommandContextUtil.getCommandContext();

        TransactionContext transactionContext = org.flowable.common.engine.impl.context.Context.getTransactionContext();
        if (transactionContext != null) {
            JobAddedTransactionListener jobAddedTransactionListener = new JobAddedTransactionListener(job, asyncExecutor,
                CommandContextUtil.getJobServiceConfiguration(commandContext).getCommandExecutor());
            transactionContext.addTransactionListener(TransactionState.COMMITTED, jobAddedTransactionListener);

        } else {
            CommandContextCloseListener commandContextCloseListener = new AsyncJobAddedNotification(job, asyncExecutor);
            Context.getCommandContext().addCloseListener(commandContextCloseListener);

        }
    }
 

private int getAsyncExecutorJobCount(ProcessEngine processEngine) {
    AsyncExecutor asyncExecutor = processEngine.getProcessEngineConfiguration().getAsyncExecutor();
    if (asyncExecutor instanceof CountingAsyncExecutor) {
        return ((CountingAsyncExecutor) asyncExecutor).getCounter().get();
    }
    return 0;
}
 

@Test
public void asyncHistoryExecutorBeanAvailable() {
    contextRunner.withPropertyValues("flowable.process.async-history.enable=true").run((context -> {
        assertThat(context)
                .hasSingleBean(ProcessEngine.class)
                .hasBean("taskExecutor")
                .hasBean("processAsyncExecutor")
                .hasBean("asyncHistoryExecutor");

        AsyncExecutor processAsyncExecutor = context.getBean(ProcessEngine.class).getProcessEngineConfiguration().getAsyncExecutor();
        assertThat(processAsyncExecutor).isNotNull();
        AsyncExecutor processAsyncHistoryExecutor = context.getBean(ProcessEngine.class).getProcessEngineConfiguration().getAsyncHistoryExecutor();
        assertThat(processAsyncHistoryExecutor).isNotNull();

        assertThat(processAsyncExecutor).isNotSameAs(processAsyncHistoryExecutor);

        TaskExecutor taskExecutorBean = context.getBean("taskExecutor", TaskExecutor.class);

        assertThat(((SpringAsyncExecutor) processAsyncExecutor).getTaskExecutor()).isSameAs(taskExecutorBean);
        assertThat(((SpringAsyncExecutor) processAsyncHistoryExecutor).getTaskExecutor()).isSameAs(taskExecutorBean);

        assertThat(context.getBean(ProcessEngine.class).getProcessEngineConfiguration().isAsyncExecutorActivate()).isTrue();
        assertThat(context.getBean(ProcessEngine.class).getProcessEngineConfiguration().isAsyncHistoryExecutorActivate()).isTrue();

        assertThat(((ProcessEngineConfigurationImpl) context.getBean(ProcessEngine.class).getProcessEngineConfiguration()).isAsyncHistoryEnabled()).isTrue();

    }));
}
 

@Test
public void asyncHistoryExecutorBeanDisabled() {
    contextRunner
        .withPropertyValues("flowable.process.async-history.enable=false")
        .run((context -> {
            assertThat(context)
                    .hasSingleBean(ProcessEngine.class)
                    .hasBean("taskExecutor")
                    .hasBean("processAsyncExecutor")
                    .doesNotHaveBean("asyncHistoryExecutor");

            AsyncExecutor processAsyncExecutor = context.getBean(ProcessEngine.class).getProcessEngineConfiguration().getAsyncExecutor();
            assertThat(processAsyncExecutor).isNotNull();
            AsyncExecutor processAsyncHistoryExecutor = context.getBean(ProcessEngine.class).getProcessEngineConfiguration().getAsyncHistoryExecutor();
            assertThat(processAsyncHistoryExecutor).isNull();

            assertThat(processAsyncExecutor).isNotSameAs(processAsyncHistoryExecutor);

            TaskExecutor taskExecutorBean = context.getBean("taskExecutor", TaskExecutor.class);

            assertThat(((SpringAsyncExecutor) processAsyncExecutor).getTaskExecutor()).isSameAs(taskExecutorBean);

            assertThat(context.getBean(ProcessEngine.class).getProcessEngineConfiguration().isAsyncExecutorActivate()).isTrue();
            assertThat(context.getBean(ProcessEngine.class).getProcessEngineConfiguration().isAsyncHistoryExecutorActivate()).isTrue();

            assertThat(((ProcessEngineConfigurationImpl) context.getBean(ProcessEngine.class).getProcessEngineConfiguration()).isAsyncHistoryEnabled())
                .isFalse();

        }));
}
 

public static void waitForJobExecutorToProcessAllJobs(ProcessEngineConfiguration processEngineConfiguration,
        ManagementService managementService, long maxMillisToWait, long intervalMillis, boolean shutdownExecutorWhenFinished) {

    AsyncExecutor asyncExecutor = processEngineConfiguration.getAsyncExecutor();
    asyncExecutor.start();

    try {
        Timer timer = new Timer();
        InterruptTask task = new InterruptTask(Thread.currentThread());
        timer.schedule(task, maxMillisToWait);
        boolean areJobsAvailable = true;
        try {
            while (areJobsAvailable && !task.isTimeLimitExceeded()) {
                Thread.sleep(intervalMillis);
                try {
                    areJobsAvailable = areJobsAvailable(managementService);
                } catch (Throwable t) {
                    // Ignore, possible that exception occurs due to locking/updating of table on MSSQL when
                    // isolation level doesn't allow READ of the table
                }
            }
        } catch (InterruptedException e) {
            // ignore
        } finally {
            timer.cancel();
        }
        if (areJobsAvailable) {
            throw new FlowableException("time limit of " + maxMillisToWait + " was exceeded");
        }

    } finally {
        if (shutdownExecutorWhenFinished) {
            asyncExecutor.shutdown();
        }
    }
}
 

@Test
public void cmmnAndProcessEngineShouldUseDistinctAsyncExecutorsWithDefaultConfiguration() {
    contextRunner.run((context -> {
        assertThat(context)
                .hasSingleBean(ProcessEngine.class)
                .hasSingleBean(CmmnEngine.class)
                .hasBean("taskExecutor")
                .hasBean("cmmnAsyncExecutor")
                .hasBean("processAsyncExecutor");
        AsyncExecutor processAsyncExecutor = context.getBean(ProcessEngine.class).getProcessEngineConfiguration().getAsyncExecutor();
        AsyncExecutor cmmnAsyncExecutor = context.getBean(CmmnEngine.class).getCmmnEngineConfiguration().getAsyncExecutor();

        assertThat(processAsyncExecutor)
            .as("Process Engine Async Executor vs Cmmn Engine Async Executor")
            .isNotSameAs(cmmnAsyncExecutor);
        assertThat(processAsyncExecutor)
            .as("Process Engine Async Executor")
            .isInstanceOf(SpringAsyncExecutor.class);
        assertThat(cmmnAsyncExecutor)
            .as("Cmmn Engine Async Executor")
            .isInstanceOf(SpringAsyncExecutor.class);

        TaskExecutor taskExecutorBean = context.getBean("taskExecutor", TaskExecutor.class);

        assertThat(((SpringAsyncExecutor) processAsyncExecutor).getTaskExecutor())
            .as("Process Async Task Executor")
            .isSameAs(taskExecutorBean);
        assertThat(((SpringAsyncExecutor) cmmnAsyncExecutor).getTaskExecutor())
            .as("Cmmn Async Task Executor")
            .isSameAs(taskExecutorBean);
    }));
}
 

@Test
public void cmmnAndProcessEngineShouldUseDistinctTaskExecutorsWhenPrimaryIsPresent() {
    contextRunner.withUserConfiguration(DedicatedTaskExecutorsConfiguration.class, PrimaryTaskExecutorConfiguration.class)
        .run((context -> {
            AsyncExecutor processAsyncExecutor = context.getBean(ProcessEngine.class).getProcessEngineConfiguration().getAsyncExecutor();
            AsyncExecutor cmmnAsyncExecutor = context.getBean(CmmnEngine.class).getCmmnEngineConfiguration().getAsyncExecutor();

            assertThat(context)
                .doesNotHaveBean("taskExecutor")
                .hasBean("primaryTaskExecutor")
                .hasBean("cmmnTaskExecutor")
                .hasBean("processTaskExecutor");

            TaskExecutor primaryTaskExecutorBean = context.getBean("primaryTaskExecutor", TaskExecutor.class);
            TaskExecutor cmmnTaskExecutorBean = context.getBean("cmmnTaskExecutor", TaskExecutor.class);
            TaskExecutor processTaskExecutorBean = context.getBean("processTaskExecutor", TaskExecutor.class);

            assertThat(((SpringAsyncExecutor) processAsyncExecutor).getTaskExecutor())
                .as("Process Async Task Executor")
                .isSameAs(processTaskExecutorBean)
                .isNotSameAs(((SpringAsyncExecutor) cmmnAsyncExecutor).getTaskExecutor())
                .as("Process Async Task Executor with primary")
                .isNotSameAs(primaryTaskExecutorBean);

            assertThat(((SpringAsyncExecutor) cmmnAsyncExecutor).getTaskExecutor())
                .as("Cmmn Async Task Executor")
                .isSameAs(cmmnTaskExecutorBean)
                .as("Cmmn Async Task Executor with primary")
                .isNotSameAs(primaryTaskExecutorBean);
        }));
}
 

public static void waitForJobExecutorToProcessAllJobsAndExecutableTimerJobs(ProcessEngineConfiguration processEngineConfiguration, ManagementService managementService, long maxMillisToWait, long intervalMillis,
        boolean shutdownExecutorWhenFinished) {

    AsyncExecutor asyncExecutor = processEngineConfiguration.getAsyncExecutor();
    asyncExecutor.start();
    processEngineConfiguration.setAsyncExecutorActivate(true);

    try {
        Timer timer = new Timer();
        InterruptTask task = new InterruptTask(Thread.currentThread());
        timer.schedule(task, maxMillisToWait);
        boolean areJobsAvailable = true;
        try {
            while (areJobsAvailable && !task.isTimeLimitExceeded()) {
                Thread.sleep(intervalMillis);
                try {
                    areJobsAvailable = areJobsOrExecutableTimersAvailable(managementService);
                } catch (Throwable t) {
                    // Ignore, possible that exception occurs due to locking/updating of table on MSSQL when
                    // isolation level doesn't allow READ of the table
                }
            }
        } catch (InterruptedException e) {
            // ignore
        } finally {
            timer.cancel();
        }
        if (areJobsAvailable) {
            throw new FlowableException("time limit of " + maxMillisToWait + " was exceeded");
        }

    } finally {
        if (shutdownExecutorWhenFinished) {
            processEngineConfiguration.setAsyncExecutorActivate(false);
            asyncExecutor.shutdown();
        }
    }
}
 

private int getAsyncExecutorJobCount(ProcessEngine processEngine) {
    AsyncExecutor asyncExecutor = processEngine.getProcessEngineConfiguration().getAsyncExecutor();
    if (asyncExecutor instanceof CountingAsyncExecutor) {
        return ((CountingAsyncExecutor) asyncExecutor).getCounter().get();
    }
    return 0;
}
 

@Override
public SpringProcessEngineConfiguration springProcessEngineConfiguration(DataSource dataSource, PlatformTransactionManager platformTransactionManager, ObjectProvider<AsyncExecutor> asyncExecutorProvider)
        throws IOException {
    SpringProcessEngineConfiguration conf = super.springProcessEngineConfiguration(dataSource, platformTransactionManager, asyncExecutorProvider);
    String databaseSchema = conf.getDatabaseSchema();
    conf.setDatabaseCatalog(databaseSchema);
    conf.setDatabaseTablePrefix(databaseSchema + ".");
    conf.setTablePrefixIsSchema(true);
    conf.setActivityFontName("黑体");
    conf.setLabelFontName("黑体");
    conf.setAnnotationFontName("黑体");
    return conf;
}
 

public static void waitForExecutorToProcessAllJobs(final AsyncExecutor asyncExecutor, Callable<Boolean> callable,
        final long maxMillisToWait, final long intervalMillis, final boolean shutdownExecutorWhenFinished) {

    if (asyncExecutor == null) {
        throw new FlowableException("No async executor set. Check the cmmn engine configuration.");
    }
    
    asyncExecutor.start();

    try {
        Timer timer = new Timer();
        InterruptTask interruptTask = new InterruptTask(Thread.currentThread());
        timer.schedule(interruptTask, maxMillisToWait);
        
        boolean areJobsAvailable = true;
        try {
            while (areJobsAvailable && !interruptTask.isTimeLimitExceeded()) {
                Thread.sleep(intervalMillis);
                try {
                    areJobsAvailable = callable.call();
                } catch (Throwable t) { 
                    // ignore
                }
            }
        } catch (InterruptedException e) {
            // ignore
        } finally {
            timer.cancel();
        }
        if (areJobsAvailable) {
            throw new FlowableException("Time limit of " + maxMillisToWait + " was exceeded");
        }

    } finally {
        if (shutdownExecutorWhenFinished) {
            asyncExecutor.shutdown();
        }
    }
}
 

@Override
public void jobRejected(AsyncExecutor asyncExecutor, JobInfo job) {
    try {
        // execute rejected work in caller thread (potentially blocking job
        // acquisition)
        new ExecuteAsyncRunnable(job, asyncExecutor.getJobServiceConfiguration(), 
                asyncExecutor.getJobServiceConfiguration().getJobEntityManager(), null).run();
    } catch (Exception e) {
        LOGGER.error("Failed to execute rejected job {}", job.getId(), e);
    }
}
 

protected void copyProcessEngineProperties(ProcessEngineConfigurationImpl processEngineConfiguration) {
    initProcessInstanceService(processEngineConfiguration);
    initProcessInstanceStateChangedCallbacks(processEngineConfiguration);
    initCaseInstanceService(processEngineConfiguration);
    
    cmmnEngineConfiguration.setEnableTaskRelationshipCounts(processEngineConfiguration.getPerformanceSettings().isEnableTaskRelationshipCounts());
    cmmnEngineConfiguration.setTaskQueryLimit(processEngineConfiguration.getTaskQueryLimit());
    cmmnEngineConfiguration.setHistoricTaskQueryLimit(processEngineConfiguration.getHistoricTaskQueryLimit());
    // use the same query limit for executions/processes and cases
    cmmnEngineConfiguration.setCaseQueryLimit(processEngineConfiguration.getExecutionQueryLimit());
    cmmnEngineConfiguration.setHistoricCaseQueryLimit(processEngineConfiguration.getHistoricProcessInstancesQueryLimit());
    
    if (processEngineConfiguration.isAsyncHistoryEnabled()) {
        AsyncExecutor asyncHistoryExecutor = processEngineConfiguration.getAsyncHistoryExecutor();
        
        // Inject the async history executor from the process engine. 
        // The job handlers will be added in the CmmnEngineConfiguration itself
        cmmnEngineConfiguration.setAsyncHistoryEnabled(true);
        cmmnEngineConfiguration.setAsyncHistoryExecutor(asyncHistoryExecutor);
        cmmnEngineConfiguration.setAsyncHistoryJsonGroupingEnabled(processEngineConfiguration.isAsyncHistoryJsonGroupingEnabled());
        cmmnEngineConfiguration.setAsyncHistoryJsonGroupingThreshold(processEngineConfiguration.getAsyncHistoryJsonGroupingThreshold());
        cmmnEngineConfiguration.setAsyncHistoryJsonGzipCompressionEnabled(processEngineConfiguration.isAsyncHistoryJsonGzipCompressionEnabled());
        
        // See the beforeInit
        ((CmmnEngineConfiguration) cmmnEngineConfiguration).setHistoryJobExecutionScope(JobServiceConfiguration.JOB_EXECUTION_SCOPE_ALL);
    }
}
 

public TenantAwareResetExpiredJobsRunnable(final AsyncExecutor asyncExecutor, TenantInfoHolder tenantInfoHolder, String tenantId) {
    super("flowable-tenant-" + tenantId + "-" + asyncExecutor.getJobServiceConfiguration().getEngineName() + "-reset-expired-jobs", asyncExecutor,
            asyncExecutor.getJobServiceConfiguration().getJobEntityManager(),
            asyncExecutor.getJobServiceConfiguration().getExternalWorkerJobEntityManager()
    );
    this.tenantInfoHolder = tenantInfoHolder;
    this.tenantId = tenantId;
}
 

@Override
public void setJobServiceConfiguration(JobServiceConfiguration jobServiceConfiguration) {
    this.jobServiceConfiguration = jobServiceConfiguration;
    for (AsyncExecutor asyncExecutor : tenantExecutors.values()) {
        asyncExecutor.setJobServiceConfiguration(jobServiceConfiguration);
    }
}
 

protected static void internalWaitForJobs(ProcessEngineConfiguration processEngineConfiguration, ManagementService managementService,
    Predicate<ManagementService> jobsAvailablePredicate, long maxMillisToWait, long intervalMillis, boolean shutdownExecutorWhenFinished) {
    AsyncExecutor asyncExecutor = processEngineConfiguration.getAsyncExecutor();
    asyncExecutor.start();
    processEngineConfiguration.setAsyncExecutorActivate(true);

    try {
        Timer timer = new Timer();
        InterruptTask task = new InterruptTask(Thread.currentThread());
        timer.schedule(task, maxMillisToWait);
        boolean areJobsAvailable = true;
        try {
            while (areJobsAvailable && !task.isTimeLimitExceeded()) {
                Thread.sleep(intervalMillis);
                try {
                    areJobsAvailable = jobsAvailablePredicate.test(managementService);
                } catch (Throwable t) {
                    // Ignore, possible that exception occurs due to locking/updating of table on MSSQL when
                    // isolation level doesn't allow READ of the table
                }
            }
        } catch (InterruptedException e) {
            // ignore
        } finally {
            timer.cancel();
        }
        if (areJobsAvailable) {
            throw new FlowableException("time limit of " + maxMillisToWait + " was exceeded");
        }

    } finally {
        if (shutdownExecutorWhenFinished) {
            processEngineConfiguration.setAsyncExecutorActivate(false);
            asyncExecutor.shutdown();
        }
    }
}
 

protected int getTimerJobsCount() {
    int timerJobsCount = processEngineConfiguration.getCommandExecutor().execute(new Command<Integer>() {

        @Override
        public Integer execute(CommandContext commandContext) {
            List<String> enabledCategories = CommandContextUtil.getJobServiceConfiguration().getEnabledJobCategories();
            AsyncExecutor asyncExecutor = CommandContextUtil.getProcessEngineConfiguration(commandContext).getAsyncExecutor();
            List<TimerJobEntity> timerJobs = CommandContextUtil.getJobServiceConfiguration().getTimerJobEntityManager()
                    .findJobsToExecute(enabledCategories, new Page(0, asyncExecutor.getMaxAsyncJobsDuePerAcquisition()));
            return timerJobs.size();
        }
    });
    
    return timerJobsCount;
}
 

private int getAsyncExecutorJobCount(ProcessEngine processEngine) {
    AsyncExecutor asyncExecutor = processEngine.getProcessEngineConfiguration().getAsyncExecutor();
    if (asyncExecutor instanceof CountingAsyncExecutor) {
        return ((CountingAsyncExecutor) asyncExecutor).getCounter().get();
    }
    return 0;
}
 

@Test
public void testJobCommandsWithTimer() {
    // clock gets automatically reset in LogTestCase.runTest
    processEngineConfiguration.getClock().setCurrentTime(new Date(SOME_TIME));

    AsyncExecutor asyncExecutor = processEngineConfiguration.getAsyncExecutor();
    CommandExecutor commandExecutor = processEngineConfiguration.getCommandExecutor();

    String jobId = commandExecutor.execute(new Command<String>() {

        @Override
        public String execute(CommandContext commandContext) {
            TimerJobEntity timer = createTweetTimer("i'm coding a test", new Date(SOME_TIME + (10 * SECOND)));
            CommandContextUtil.getTimerJobService(commandContext).scheduleTimerJob(timer);
            return timer.getId();
        }
    });

    AcquiredTimerJobEntities acquiredJobs = commandExecutor.execute(new AcquireTimerJobsCmd(asyncExecutor));
    assertThat(acquiredJobs.size()).isZero();

    processEngineConfiguration.getClock().setCurrentTime(new Date(SOME_TIME + (20 * SECOND)));

    acquiredJobs = commandExecutor.execute(new AcquireTimerJobsCmd(asyncExecutor));
    assertThat(acquiredJobs.size()).isEqualTo(1);

    TimerJobEntity job = acquiredJobs.getJobs().iterator().next();

    assertThat(job.getId()).isEqualTo(jobId);

    assertThat(tweetHandler.getMessages()).isEmpty();

    Job executableJob = managementService.moveTimerToExecutableJob(jobId);
    commandExecutor.execute(new ExecuteAsyncJobCmd(executableJob.getId()));

    assertThat(tweetHandler.getMessages().get(0)).isEqualTo("i'm coding a test");
    assertThat(tweetHandler.getMessages()).hasSize(1);
}
 

public AcquireTimerJobsCmd(AsyncExecutor asyncExecutor) {
    this.asyncExecutor = asyncExecutor;
}