public void acquiredJobs(String processEngine, AcquiredJobs acquiredJobs) { logDebug( "022", "Acquired {} jobs for process engine '{}': {}", acquiredJobs.size(), processEngine, acquiredJobs.getJobIdBatches()); }
public void acquiredJobs(String processEngine, AcquiredJobs acquiredJobs) { logDebug( "022", "Acquired {} jobs for process engine '{}': {}", acquiredJobs.size(), processEngine, acquiredJobs.getJobIdBatches()); }
@Deployment public void testCompetingJobAcquisitions() throws Exception { runtimeService.startProcessInstanceByKey("CompetingJobAcquisitionProcess"); LOG.debug("test thread starts thread one"); JobAcquisitionThread threadOne = new JobAcquisitionThread(); threadOne.startAndWaitUntilControlIsReturned(); LOG.debug("test thread continues to start thread two"); JobAcquisitionThread threadTwo = new JobAcquisitionThread(); threadTwo.startAndWaitUntilControlIsReturned(); LOG.debug("test thread notifies thread 1"); threadOne.proceedAndWaitTillDone(); assertNull(threadOne.exception); // the job was acquired assertEquals(1, threadOne.jobs.size()); LOG.debug("test thread notifies thread 2"); threadTwo.proceedAndWaitTillDone(); // the acquisition did NOT fail assertNull(threadTwo.exception); // but the job was not acquired assertEquals(0, threadTwo.jobs.size()); }
@Test public void testJobExecutorOnlyAcquiresActiveJobs() { testRule.deploy(SIMPLE_ASYNC_PROCESS); // given suspended job definition: managementService.suspendJobDefinitionByProcessDefinitionKey("simpleAsyncProcess"); // if I start a new instance runtimeService.startProcessInstanceByKey("simpleAsyncProcess"); // then the new job executor will not acquire the job: AcquiredJobs acquiredJobs = acquireJobs(); assertEquals(0, acquiredJobs.size()); // ------------------------- // given a active job definition: managementService.activateJobDefinitionByProcessDefinitionKey("simpleAsyncProcess", true); // then the new job executor will not acquire the job: acquiredJobs = acquireJobs(); assertEquals(1, acquiredJobs.size()); }
@Deployment(resources = "org/camunda/bpm/engine/test/jobexecutor/simpleAsyncProcess.bpmn20.xml") public void testProcessingOfJobsWithMatchingDeployment() { runtimeService.startProcessInstanceByKey("simpleAsyncProcess"); Set<String> registeredDeployments = managementService.getRegisteredDeployments(); Assert.assertEquals(1, registeredDeployments.size()); Assert.assertTrue(registeredDeployments.contains(deploymentId)); Job executableJob = managementService.createJobQuery().singleResult(); String otherDeploymentId = deployAndInstantiateWithNewEngineConfiguration( "org/camunda/bpm/engine/test/jobexecutor/simpleAsyncProcessVersion2.bpmn20.xml"); // assert that two jobs have been created, one for each deployment List<Job> jobs = managementService.createJobQuery().list(); Assert.assertEquals(2, jobs.size()); Set<String> jobDeploymentIds = new HashSet<String>(); jobDeploymentIds.add(jobs.get(0).getDeploymentId()); jobDeploymentIds.add(jobs.get(1).getDeploymentId()); Assert.assertTrue(jobDeploymentIds.contains(deploymentId)); Assert.assertTrue(jobDeploymentIds.contains(otherDeploymentId)); // select executable jobs for executor of first engine AcquiredJobs acquiredJobs = getExecutableJobs(processEngineConfiguration.getJobExecutor()); Assert.assertEquals(1, acquiredJobs.size()); Assert.assertTrue(acquiredJobs.contains(executableJob.getId())); repositoryService.deleteDeployment(otherDeploymentId, true); }
@Deployment(resources = "org/camunda/bpm/engine/test/jobexecutor/simpleAsyncProcess.bpmn20.xml") public void testExplicitDeploymentUnregistration() { runtimeService.startProcessInstanceByKey("simpleAsyncProcess"); processEngine.getManagementService().unregisterDeploymentForJobExecutor(deploymentId); AcquiredJobs acquiredJobs = getExecutableJobs(processEngineConfiguration.getJobExecutor()); Assert.assertEquals(0, acquiredJobs.size()); }
protected AcquiredJobs acquireJobs( JobAcquisitionContext context, JobAcquisitionStrategy acquisitionStrategy, ProcessEngineImpl currentProcessEngine) { CommandExecutor commandExecutor = currentProcessEngine.getProcessEngineConfiguration() .getCommandExecutorTxRequired(); int numJobsToAcquire = acquisitionStrategy.getNumJobsToAcquire(currentProcessEngine.getName()); AcquiredJobs acquiredJobs = null; if (numJobsToAcquire > 0) { jobExecutor.logAcquisitionAttempt(currentProcessEngine); acquiredJobs = commandExecutor.execute(jobExecutor.getAcquireJobsCmd(numJobsToAcquire)); } else { acquiredJobs = new AcquiredJobs(numJobsToAcquire); } context.submitAcquiredJobs(currentProcessEngine.getName(), acquiredJobs); jobExecutor.logAcquiredJobs(currentProcessEngine, acquiredJobs.size()); jobExecutor.logAcquisitionFailureJobs(currentProcessEngine, acquiredJobs.getNumberOfJobsFailedToLock()); LOG.acquiredJobs(currentProcessEngine.getName(), acquiredJobs); return acquiredJobs; }
protected AcquiredJobs acquireJobs( JobAcquisitionContext context, JobAcquisitionStrategy acquisitionStrategy, ProcessEngineImpl currentProcessEngine) { CommandExecutor commandExecutor = currentProcessEngine.getProcessEngineConfiguration() .getCommandExecutorTxRequired(); int numJobsToAcquire = acquisitionStrategy.getNumJobsToAcquire(currentProcessEngine.getName()); AcquiredJobs acquiredJobs = null; if (numJobsToAcquire > 0) { jobExecutor.logAcquisitionAttempt(currentProcessEngine); acquiredJobs = commandExecutor.execute(jobExecutor.getAcquireJobsCmd(numJobsToAcquire)); } else { acquiredJobs = new AcquiredJobs(numJobsToAcquire); } context.submitAcquiredJobs(currentProcessEngine.getName(), acquiredJobs); jobExecutor.logAcquiredJobs(currentProcessEngine, acquiredJobs.size()); jobExecutor.logAcquisitionFailureJobs(currentProcessEngine, acquiredJobs.getNumberOfJobsFailedToLock()); LOG.acquiredJobs(currentProcessEngine.getName(), acquiredJobs); return acquiredJobs; }
@Deployment(resources={"org/camunda/bpm/engine/test/standalone/jobexecutor/oneJobProcess.bpmn20.xml"}) public void testJobsNotVisisbleToAcquisitionIfDefinitionSuspended() { ProcessDefinition pd = repositoryService.createProcessDefinitionQuery().singleResult(); runtimeService.startProcessInstanceByKey(pd.getKey()); // now there is one job: Job job = managementService.createJobQuery() .singleResult(); assertNotNull(job); makeSureJobDue(job); // the acquirejobs command sees the job: AcquiredJobs acquiredJobs = executeAcquireJobsCommand(); assertEquals(1, acquiredJobs.size()); // suspend the process instance: repositoryService.suspendProcessDefinitionById(pd.getId()); // now, the acquirejobs command does not see the job: acquiredJobs = executeAcquireJobsCommand(); assertEquals(0, acquiredJobs.size()); }
@Deployment(resources={"org/camunda/bpm/engine/test/standalone/jobexecutor/oneJobProcess.bpmn20.xml"}) public void testJobsNotVisisbleToAcquisitionIfInstanceSuspended() { ProcessDefinition pd = repositoryService.createProcessDefinitionQuery().singleResult(); ProcessInstance pi = runtimeService.startProcessInstanceByKey(pd.getKey()); // now there is one job: Job job = managementService.createJobQuery() .singleResult(); assertNotNull(job); makeSureJobDue(job); // the acquirejobs command sees the job: AcquiredJobs acquiredJobs = executeAcquireJobsCommand(); assertEquals(1, acquiredJobs.size()); // suspend the process instance: runtimeService.suspendProcessInstanceById(pi.getId()); // now, the acquirejobs command does not see the job: acquiredJobs = executeAcquireJobsCommand(); assertEquals(0, acquiredJobs.size()); }
public void testJobsWithoutDeploymentIdAreAlwaysProcessed() { CommandExecutor commandExecutor = processEngineConfiguration.getCommandExecutorTxRequired(); String messageId = commandExecutor.execute(new Command<String>() { public String execute(CommandContext commandContext) { MessageEntity message = new MessageEntity(); commandContext.getJobManager().send(message); return message.getId(); } }); AcquiredJobs acquiredJobs = getExecutableJobs(processEngineConfiguration.getJobExecutor()); Assert.assertEquals(1, acquiredJobs.size()); Assert.assertTrue(acquiredJobs.contains(messageId)); commandExecutor.execute(new DeleteJobsCmd(messageId, true)); }
public void acquiredJobs(String processEngine, AcquiredJobs acquiredJobs) { logDebug( "022", "Acquired {} jobs for process engine '{}': {}", acquiredJobs.size(), processEngine, acquiredJobs.getJobIdBatches()); }
@Deployment(resources = "org/camunda/bpm/engine/test/jobexecutor/simpleAsyncProcess.bpmn20.xml") public void testExplicitDeploymentRegistration() { runtimeService.startProcessInstanceByKey("simpleAsyncProcess"); String otherDeploymentId = deployAndInstantiateWithNewEngineConfiguration( "org/camunda/bpm/engine/test/jobexecutor/simpleAsyncProcessVersion2.bpmn20.xml"); processEngine.getManagementService().registerDeploymentForJobExecutor(otherDeploymentId); List<Job> jobs = managementService.createJobQuery().list(); AcquiredJobs acquiredJobs = getExecutableJobs(processEngineConfiguration.getJobExecutor()); Assert.assertEquals(2, acquiredJobs.size()); for (Job job : jobs) { Assert.assertTrue(acquiredJobs.contains(job.getId())); } repositoryService.deleteDeployment(otherDeploymentId, true); }
@OperateOnDeployment("pa1") @Test public void testDeploymentAwareJobAcquisition() { JobExecutor jobExecutor1 = engine1Configuration.getJobExecutor(); ProcessInstance instance1 = engine1.getRuntimeService().startProcessInstanceByKey("archive1Process"); ProcessInstance instance2 = processEngine.getRuntimeService().startProcessInstanceByKey("archive2Process"); Job job1 = managementService.createJobQuery().processInstanceId(instance1.getId()).singleResult(); Job job2 = managementService.createJobQuery().processInstanceId(instance2.getId()).singleResult(); // the deployment aware configuration should only return the jobs of the registered deployments CommandExecutor commandExecutor = engine1Configuration.getCommandExecutorTxRequired(); AcquiredJobs acquiredJobs = commandExecutor.execute(new AcquireJobsCmd(jobExecutor1)); Assert.assertEquals(1, acquiredJobs.size()); Assert.assertTrue(acquiredJobs.contains(job1.getId())); Assert.assertFalse(acquiredJobs.contains(job2.getId())); }
@Test public void testCompletingSuspendJobDuringAcquisition() { testRule.deploy(SIMPLE_ASYNC_PROCESS); runtimeService.startProcessInstanceByKey("simpleAsyncProcess"); // given a waiting acquisition and a waiting suspension JobAcquisitionThread acquisitionThread = new JobAcquisitionThread(); acquisitionThread.startAndWaitUntilControlIsReturned(); JobSuspensionThread jobSuspensionThread = new JobSuspensionThread("simpleAsyncProcess"); jobSuspensionThread.startAndWaitUntilControlIsReturned(); // first complete suspension: jobSuspensionThread.proceedAndWaitTillDone(); acquisitionThread.proceedAndWaitTillDone(); // then the acquisition will not fail with optimistic locking assertNull(jobSuspensionThread.exception); assertNull(acquisitionThread.exception); // but the job will also not be acquired assertEquals(0, acquisitionThread.acquiredJobs.size()); //-------------------------------------------- // given a waiting acquisition and a waiting suspension acquisitionThread = new JobAcquisitionThread(); acquisitionThread.startAndWaitUntilControlIsReturned(); jobSuspensionThread = new JobSuspensionThread("simpleAsyncProcess"); jobSuspensionThread.startAndWaitUntilControlIsReturned(); // first complete acquisition: acquisitionThread.proceedAndWaitTillDone(); jobSuspensionThread.proceedAndWaitTillDone(); // then there are no optimistic locking exceptions assertNull(jobSuspensionThread.exception); assertNull(acquisitionThread.exception); }
@OperateOnDeployment("pa1") @Test public void testDeploymentUnawareJobAcquisition() { JobExecutor defaultJobExecutor = processEngineConfiguration.getJobExecutor(); ProcessInstance instance1 = engine1.getRuntimeService().startProcessInstanceByKey("archive1Process"); ProcessInstance instance2 = processEngine.getRuntimeService().startProcessInstanceByKey("archive2Process"); Job job1 = managementService.createJobQuery().processInstanceId(instance1.getId()).singleResult(); Job job2 = managementService.createJobQuery().processInstanceId(instance2.getId()).singleResult(); // the deployment unaware configuration should return both jobs CommandExecutor commandExecutor = processEngineConfiguration.getCommandExecutorTxRequired(); processEngineConfiguration.setJobExecutorDeploymentAware(false); try { AcquiredJobs acquiredJobs = commandExecutor.execute(new AcquireJobsCmd(defaultJobExecutor)); Assert.assertEquals(2, acquiredJobs.size()); Assert.assertTrue(acquiredJobs.contains(job1.getId())); Assert.assertTrue(acquiredJobs.contains(job2.getId())); } finally { processEngineConfiguration.setJobExecutorDeploymentAware(true); } } }
@Test public void testJobExecutorOnlyAcquiresActiveJobs() { testRule.deploy(SIMPLE_ASYNC_PROCESS); // given suspended job definition: managementService.suspendJobDefinitionByProcessDefinitionKey("simpleAsyncProcess"); // if I start a new instance runtimeService.startProcessInstanceByKey("simpleAsyncProcess"); // then the new job executor will not acquire the job: AcquiredJobs acquiredJobs = acquireJobs(); assertEquals(0, acquiredJobs.size()); // ------------------------- // given a active job definition: managementService.activateJobDefinitionByProcessDefinitionKey("simpleAsyncProcess", true); // then the new job executor will not acquire the job: acquiredJobs = acquireJobs(); assertEquals(1, acquiredJobs.size()); }
@Deployment(resources = "org/camunda/bpm/engine/test/jobexecutor/simpleAsyncProcess.bpmn20.xml") public void testExplicitDeploymentUnregistration() { runtimeService.startProcessInstanceByKey("simpleAsyncProcess"); processEngine.getManagementService().unregisterDeploymentForJobExecutor(deploymentId); AcquiredJobs acquiredJobs = getExecutableJobs(processEngineConfiguration.getJobExecutor()); Assert.assertEquals(0, acquiredJobs.size()); }
public void testJobsWithoutDeploymentIdAreAlwaysProcessed() { CommandExecutor commandExecutor = processEngineConfiguration.getCommandExecutorTxRequired(); String messageId = commandExecutor.execute(new Command<String>() { public String execute(CommandContext commandContext) { MessageEntity message = new MessageEntity(); commandContext.getJobManager().send(message); return message.getId(); } }); AcquiredJobs acquiredJobs = getExecutableJobs(processEngineConfiguration.getJobExecutor()); Assert.assertEquals(1, acquiredJobs.size()); Assert.assertTrue(acquiredJobs.contains(messageId)); commandExecutor.execute(new DeleteJobsCmd(messageId, true)); }
@Deployment(resources = "org/camunda/bpm/engine/test/jobexecutor/simpleAsyncProcess.bpmn20.xml") public void testExplicitDeploymentRegistration() { runtimeService.startProcessInstanceByKey("simpleAsyncProcess"); String otherDeploymentId = deployAndInstantiateWithNewEngineConfiguration( "org/camunda/bpm/engine/test/jobexecutor/simpleAsyncProcessVersion2.bpmn20.xml"); processEngine.getManagementService().registerDeploymentForJobExecutor(otherDeploymentId); List<Job> jobs = managementService.createJobQuery().list(); AcquiredJobs acquiredJobs = getExecutableJobs(processEngineConfiguration.getJobExecutor()); Assert.assertEquals(2, acquiredJobs.size()); for (Job job : jobs) { Assert.assertTrue(acquiredJobs.contains(job.getId())); } repositoryService.deleteDeployment(otherDeploymentId, true); }