public void waitForJobExecutorOnCondition(long maxMillisToWait, Callable<Boolean> condition) { JobExecutor jobExecutor = processEngineConfiguration.getJobExecutor(); jobExecutor.start(); long intervalMillis = 500; if(maxMillisToWait < (jobExecutor.getWaitTimeInMillis()*2)) { maxMillisToWait = (jobExecutor.getWaitTimeInMillis()*2); } try { Timer timer = new Timer(); InterruptTask task = new InterruptTask(Thread.currentThread()); timer.schedule(task, maxMillisToWait); boolean conditionIsViolated = true; try { while (conditionIsViolated && !task.isTimeLimitExceeded()) { Thread.sleep(intervalMillis); conditionIsViolated = !condition.call(); } } catch (InterruptedException e) { } catch (Exception e) { throw new ProcessEngineException("Exception while waiting on condition: "+e.getMessage(), e); } finally { timer.cancel(); } if (conditionIsViolated) { throw new ProcessEngineException("time limit of " + maxMillisToWait + " was exceeded"); } } finally { jobExecutor.shutdown(); } }
public boolean isActive() { return jobExecutor.isActive(); } }
protected void lockJob(JobEntity job) { String lockOwner = jobExecutor.getLockOwner(); job.setLockOwner(lockOwner); int lockTimeInMillis = jobExecutor.getLockTimeInMillis(); GregorianCalendar gregorianCalendar = new GregorianCalendar(); gregorianCalendar.setTime(ClockUtil.getCurrentTime()); gregorianCalendar.add(Calendar.MILLISECOND, lockTimeInMillis); job.setLockExpirationTime(gregorianCalendar.getTime()); }
public BackoffJobAcquisitionStrategy(JobExecutor jobExecutor) { this(jobExecutor.getWaitTimeInMillis(), jobExecutor.getWaitIncreaseFactor(), jobExecutor.getMaxWait(), jobExecutor.getBackoffTimeInMillis(), jobExecutor.getWaitIncreaseFactor(), jobExecutor.getMaxBackoff(), jobExecutor.getBackoffDecreaseThreshold(), jobExecutor.getMaxJobsPerAcquisition()); }
@Override public void jobsRejected(List<String> jobIds, ProcessEngineImpl processEngine, JobExecutor jobExecutor) { AcquireJobsRunnable acquireJobsRunnable = jobExecutor.getAcquireJobsRunnable(); if (acquireJobsRunnable instanceof SequentialJobAcquisitionRunnable) { JobAcquisitionContext context = ((SequentialJobAcquisitionRunnable) acquireJobsRunnable).getAcquisitionContext(); context.submitRejectedBatch(processEngine.getName(), jobIds); } else { jobExecutor.getExecuteJobsRunnable(jobIds, processEngine).run(); } }
public static void waitForJobExecutorToProcessAllJobs(ProcessEngineConfigurationImpl processEngineConfiguration, long maxMillisToWait, long intervalMillis) { JobExecutor jobExecutor = processEngineConfiguration.getJobExecutor(); jobExecutor.start(); try { Timer timer = new Timer(); InteruptTask task = new InteruptTask(Thread.currentThread()); timer.schedule(task, maxMillisToWait); boolean areJobsAvailable = true; try { while (areJobsAvailable && !task.isTimeLimitExceeded()) { Thread.sleep(intervalMillis); areJobsAvailable = areJobsAvailable(processEngineConfiguration); } } catch (InterruptedException e) { } finally { timer.cancel(); } if (areJobsAvailable) { throw new ProcessEngineException("time limit of " + maxMillisToWait + " was exceeded"); } } finally { jobExecutor.shutdown(); } }
private static Details from(JobExecutor jobExecutor) { final DetailsBuilder builder = Details.builder() .name(jobExecutor.getName()) .lockOwner(jobExecutor.getLockOwner()) .lockTimeInMillis(jobExecutor.getLockTimeInMillis()) .maxJobsPerAcquisition(jobExecutor.getMaxJobsPerAcquisition()) .waitTimeInMillis(jobExecutor.getWaitTimeInMillis()); for (ProcessEngineImpl processEngineImpl : jobExecutor.getProcessEngines()) { builder.processEngineName(processEngineImpl.getName()); } return builder.build(); }
jobExecutor.shutdown(); jobExecutor.start(); waitForJobExecutorToProcessAllJobs(10000, 100, jobExecutor, engine1.getManagementService(), false); jobExecutor.start(); waitForJobExecutorToProcessAllJobs(10000, 100, jobExecutor, engine2.getManagementService(), false); Assert.assertFalse(((SequentialJobAcquisitionRunnable) jobExecutor.getAcquireJobsRunnable()).isJobAdded());
protected void hintJobExecutor(JobEntity job) { JobExecutor jobExecutor = Context.getProcessEngineConfiguration().getJobExecutor(); if (!jobExecutor.isActive()) { return; } JobExecutorContext jobExecutorContext = Context.getJobExecutorContext(); TransactionListener transactionListener = null; if(!job.isSuspended() && job.isExclusive() && jobExecutorContext != null && jobExecutorContext.isExecutingExclusiveJob() && areInSameProcessInstance(job, jobExecutorContext.getCurrentJob())) { // lock job & add to the queue of the current processor Date currentTime = ClockUtil.getCurrentTime(); job.setLockExpirationTime(new Date(currentTime.getTime() + jobExecutor.getLockTimeInMillis())); job.setLockOwner(jobExecutor.getLockOwner()); transactionListener = new ExclusiveJobAddedNotification(job.getId(), jobExecutorContext); } else { // notify job executor: transactionListener = new MessageAddedNotification(jobExecutor); } Context.getCommandContext() .getTransactionContext() .addTransactionListener(TransactionState.COMMITTED, transactionListener); }
public void shutdown() { jobExecutor.shutdown(); }
public void start() { jobExecutor.start(); }
public void testJobExecutorConfigurationProperties() { // given JobExecutor jobExecutor = new DefaultJobExecutor(); Map<String, String> propertiesToSet = new HashMap<String, String>(); propertiesToSet.put(MAX_JOBS_PER_ACQUISITION, Integer.toString(Integer.MAX_VALUE)); propertiesToSet.put(MAX_WAIT, Long.toString(Long.MAX_VALUE)); propertiesToSet.put(WAIT_INCREASE_FACTOR, Float.toString(Float.MAX_VALUE)); propertiesToSet.put(BACKOFF_TIME_IN_MILLIS, Integer.toString(Integer.MAX_VALUE)); // when PropertyHelper.applyProperties(jobExecutor, propertiesToSet); // then Assert.assertEquals(Integer.MAX_VALUE, jobExecutor.getMaxJobsPerAcquisition()); Assert.assertEquals(Long.MAX_VALUE, jobExecutor.getMaxWait()); Assert.assertEquals(Float.MAX_VALUE, jobExecutor.getWaitIncreaseFactor(), 0.0001d); Assert.assertEquals(Integer.MAX_VALUE, jobExecutor.getBackoffTimeInMillis()); }
@Before public void initCommand() { JobExecutor jobExecutor = mock(JobExecutor.class); when(jobExecutor.getMaxJobsPerAcquisition()).thenReturn(3); when(jobExecutor.getLockOwner()).thenReturn("test"); when(jobExecutor.getLockTimeInMillis()).thenReturn(5 * 60 * 1000); acquireJobsCmd = new AcquireJobsCmd(jobExecutor); commandContext = mock(CommandContext.class); DbEntityManager dbEntityManager = mock(DbEntityManager.class); when(commandContext.getDbEntityManager()).thenReturn(dbEntityManager); jobManager = mock(JobManager.class); when(commandContext.getJobManager()).thenReturn(jobManager); }
public synchronized void run() { LOG.startingToAcquireJobs(jobExecutor.getName()); Iterator<ProcessEngineImpl> engineIterator = jobExecutor.engineIterator(); if (!jobExecutor.hasRegisteredEngine(currentProcessEngine)) { LOG.stoppedJobAcquisition(jobExecutor.getName());
if(jobExecutor.isActive()) { try { executeJob(nextJobId, commandExecutor); jobExecutor.jobWasAdded();
public int getMaxJobsPerAcquisition() { return jobExecutor.getMaxJobsPerAcquisition(); }
public int getWaitTimeInMillis() { return jobExecutor.getWaitTimeInMillis(); }
Iterator<ProcessEngineImpl> engineIterator = jobExecutor.engineIterator(); while (engineIterator.hasNext()) { ProcessEngineImpl currentProcessEngine = engineIterator.next(); if (!jobExecutor.hasRegisteredEngine(currentProcessEngine)) {
public int getLockTimeInMillis() { return jobExecutor.getLockTimeInMillis(); }