org.camunda.bpm.engine.impl.jobexecutor.AcquiredJobs.size java code examples

Common ways to obtain AcquiredJobs

private void myMethod () {
 AcquiredJobs a =new AcquiredJobs(numberOfJobsAttemptedToAcquire)
Smart code suggestions by Codota
}

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);
}

Popular methods of AcquiredJobs

Popular in Java

Creating JSON documents from java classes using gson
getSystemService (Context)
notifyDataSetChanged (ArrayAdapter)
getApplicationContext (Context)
BorderLayout (java.awt)
A border layout lays out a container, arranging and resizing its components to fit in five regions:
Menu (java.awt)
Collections (java.util)
This class consists exclusively of static methods that operate on or return collections. It contains
Vector (java.util)
The Vector class implements a growable array of objects. Like an array, it contains components that
JarFile (java.util.jar)
JarFile is used to read jar entries and their associated data from jar files.
Options (org.apache.commons.cli)
Main entry-point into the library. Options represents a collection of Option objects, which describ

How to use sizemethodin org.camunda.bpm.engine.impl.jobexecutor.AcquiredJobs

Best Java code snippets using org.camunda.bpm.engine.impl.jobexecutor.AcquiredJobs.size (Showing top 20 results out of 315)

How to use
size
method
in
org.camunda.bpm.engine.impl.jobexecutor.AcquiredJobs