org.activiti.engine.ManagementService Java Examples

/**
 * 作业.
 */
public Page findJobs(String tenantId, Page page) {
    ManagementService managementService = processEngine
            .getManagementService();

    long count = managementService.createJobQuery().jobTenantId(tenantId)
            .count();
    List<Job> jobs = managementService.createJobQuery()
            .jobTenantId(tenantId)
            .listPage((int) page.getStart(), page.getPageSize());
    page.setResult(jobs);

    page.setTotalCount(count);

    return page;
}
 

@Bean
CommandLineRunner customMybatisXmlMapper(final ManagementService managementService) {
    return new CommandLineRunner() {
        @Override
        public void run(String... args) throws Exception {
            String processDefinitionDeploymentId = managementService.executeCommand(new Command<String>() {
                @Override
                public String execute(CommandContext commandContext) {
                    return (String) commandContext
                            .getDbSqlSession()
                            .selectOne("selectProcessDefinitionDeploymentIdByKey", "waiter");
                }
            });

            logger.info("Process definition deployment id = {}", processDefinitionDeploymentId);
        }
    };
}
 

@Test
@Deployment(resources = { "org/activiti/engine/test/bpmn/async/AsyncTaskTest.testAsyncTask.bpmn20.xml" })
public void testWaitForJobs() {
  RuntimeService runtimeService = activitiRule.getRuntimeService();
  ManagementService managementService = activitiRule.getManagementService();

  // start process
  runtimeService.startProcessInstanceByKey("asyncTask");

  // now there should be one job in the database:
  assertEquals(1, managementService.createJobQuery().count());

  JobTestHelper.waitForJobExecutorToProcessAllJobs(activitiRule, 5000L, 500L);

  // the job is done
  assertEquals(0, managementService.createJobQuery().count());
}
 

@Test
@Deployment(resources={"org/activiti5/engine/test/bpmn/async/AsyncTaskTest.testAsyncTask.bpmn20.xml"})
public void testWaitForJobs() {
  RuntimeService runtimeService = activitiRule.getRuntimeService();
  ManagementService managementService = activitiRule.getManagementService();
 
  // start process 
  runtimeService.startProcessInstanceByKey("asyncTask");
 
  // now there should be one job in the database:
  assertEquals(1, managementService.createJobQuery().count());
    
  JobTestHelper.waitForJobExecutorToProcessAllJobs(activitiRule, 5000L, 500L);
 
  // the job is done
  assertEquals(0, managementService.createJobQuery().count()); 
}
 

public static void main(String[] args) {
    AnnotationConfigApplicationContext ctx =
            new AnnotationConfigApplicationContext();
    ctx.register(SpringAnnotationConfiguration.class);
    ctx.refresh();

    assertNotNull(ctx.getBean(ProcessEngine.class));
    assertNotNull(ctx.getBean(RuntimeService.class));
    TaskService bean = ctx.getBean(TaskService.class);
    assertNotNull(bean);
    assertNotNull(ctx.getBean(HistoryService.class));
    assertNotNull(ctx.getBean(RepositoryService.class));
    assertNotNull(ctx.getBean(ManagementService.class));
    assertNotNull(ctx.getBean(FormService.class));
    Task task = bean.newTask();
    task.setName("哈哈");
    bean.saveTask(task);
}
 

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();
    InteruptTask task = new InteruptTask(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 ActivitiException("time limit of " + maxMillisToWait + " was exceeded");
    }

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

@Autowired
public RevokeAccessServiceTask(EmailServiceWrapper emailServiceWrapper,
                               DatabaseConnectionService databaseConnectionService,
                               ManagementService managementService,
                               RdsLookupService rdsLookupService) {
    this.emailServiceWrapper = emailServiceWrapper;
    this.databaseConnectionService = databaseConnectionService;
    this.managementService = managementService;
    this.rdsLookupService = rdsLookupService;
}
 

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();
    InteruptTask task = new InteruptTask(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 ActivitiException("time limit of " + maxMillisToWait + " was exceeded");
    }

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

@Autowired
public RevokeAccessServiceTask(EmailServiceWrapper emailServiceWrapper,
                               SsmService ssmService,
                               SnsService snsService,
                               ManagementService managementService,
                               Ec2LookupService ec2LookupService,
                               AccessRequestService accessRequestService){
    this.emailServiceWrapper = emailServiceWrapper;
    this.ssmService = ssmService;
    this.snsService = snsService;
    this.managementService = managementService;
    this.ec2LookupService = ec2LookupService;
    this.accessRequestService = accessRequestService;
}
 

public static boolean areJobsOrExecutableTimersAvailable(ManagementService managementService) {
  boolean emptyJobs = managementService.createJobQuery().list().isEmpty();
  if (emptyJobs) {
    return !managementService.createTimerJobQuery().executable().list().isEmpty();
  } else {
    return true;
  }
}
 

public static boolean areJobsOrExecutableTimersAvailable(ManagementService managementService) {
  boolean emptyJobs = managementService.createJobQuery().list().isEmpty();
  if (emptyJobs) {
    return !managementService.createTimerJobQuery().executable().list().isEmpty();
  } else {
    return true;
  }
}
 

@Override
public void execute(DelegateExecution execution) throws Exception {
    ManagementService managementService = execution.getEngineServices().getManagementService();
    Job job = managementService.createJobQuery().processInstanceId(execution.getProcessInstanceId()).singleResult();
    if (job.getRetries() > 0) {
        throw new RuntimeException("本次作业执行失败，再次执行可以成功！");
    }
}
 

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();
    InteruptTask task = new InteruptTask(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 ActivitiException("time limit of " + maxMillisToWait + " was exceeded");
    }

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

@Override
public void execute(DelegateExecution execution) throws Exception {
    ManagementService managementService = execution.getEngineServices().getManagementService();
    Job job = managementService.createJobQuery().processInstanceId(execution.getProcessInstanceId()).singleResult();
    if (job.getRetries() > 0) {
        throw new RuntimeException("本次作业执行失败，再次执行可以成功！");
    }
}
 

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();
    InteruptTask task = new InteruptTask(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 ActivitiException("time limit of " + maxMillisToWait + " was exceeded");
    }

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

@Override
public void execute(DelegateExecution execution) throws Exception {
    ManagementService managementService = execution.getEngineServices().getManagementService();
    Job job = managementService.createJobQuery().processInstanceId(execution.getProcessInstanceId()).singleResult();
    if (job.getRetries() > 0) {
        throw new RuntimeException("本次作业执行失败，再次执行可以成功！");
    }
}
 

@Override
public void execute(DelegateExecution execution) throws Exception {
    ManagementService managementService = execution.getEngineServices().getManagementService();
    Job job = managementService.createJobQuery().processInstanceId(execution.getProcessInstanceId()).singleResult();
    if (job.getRetries() > 0) {
        throw new RuntimeException("本次作业执行失败，再次执行可以成功！");
    }
}
 

public ManagementService getManagementService() {
    if (processEngine == null) {
        return null;
    }

    return processEngine.getManagementService();
}
 

@Test
public void executeCustomMybatisXmlQuery() throws Exception {
    AnnotationConfigApplicationContext applicationContext = this.context(Application.class);
    ManagementService managementService = applicationContext.getBean(ManagementService.class);
    String processDefinitionDeploymentId = managementService.executeCommand(new Command<String>() {
        @Override
        public String execute(CommandContext commandContext) {
            return (String) commandContext.getDbSqlSession().selectOne("selectProcessDefinitionDeploymentIdByKey", "waiter");
        }
    });
    Assert.assertNotNull("the processDefinitionDeploymentId should not be null!", processDefinitionDeploymentId);
}
 

@Test
public void executeCustomMybatisMapperQuery() throws Exception {
    AnnotationConfigApplicationContext applicationContext = this.context(Application.class);
    ManagementService managementService = applicationContext.getBean(ManagementService.class);
    String processDefinitionId = managementService.executeCustomSql(new AbstractCustomSqlExecution<CustomMybatisMapper, String>(CustomMybatisMapper.class) {
        @Override
        public String execute(CustomMybatisMapper customMybatisMapper) {
            return customMybatisMapper.loadProcessDefinitionIdByKey("waiter");
        }
    });
    Assert.assertNotNull("the processDefinitionId should not be null!", processDefinitionId);
}
 

public static void waitForJobExecutorToProcessAllJobsAndExecutableTimerJobs(ProcessEngineConfiguration processEngineConfiguration, ManagementService managementService, long maxMillisToWait, long intervalMillis) {
  waitForJobExecutorToProcessAllJobsAndExecutableTimerJobs(processEngineConfiguration, managementService, maxMillisToWait, intervalMillis, true);
}
 

public void setManagementService(ManagementService managementService) {
	this.managementService = managementService;
}
 

/**
 * @return ManagementService
 */
public ManagementService getManagementService()
{
    return managementService;
}
 

public CustomTaskQuery(ManagementService managementService) {
    super(managementService);
}
 

public AttachmentQuery(ManagementService managementService) {
    super(managementService);
}
 

@Override
public ManagementService getManagementService() {
    return managementService;
}
 

public ProcessEngineConfigurationImpl setManagementService(ManagementService managementService) {
    this.managementService = managementService;
    return this;
}
 

@Override
public ManagementService getManagementService() {
    return managementService;
}
 

public AbstractQuery(ManagementService managementService) {
    this(((ManagementServiceImpl) managementService).getCommandExecutor());
}
 

@Bean
public ManagementService activitiManagementService(ProcessEngine activitiProcessEngine) throws Exception
{
    return activitiProcessEngine.getManagementService();
}