import org.camunda.bpm.engine.impl.util.ClockUtil; //导入依赖的package包/类
@Override
public void executeImpl(ProcessEngine engine) {
  if (workItem.isSuspended())
    return;

  if (workItem instanceof TimerEntity) {
    /*
     * Caused by DurationHelper.getDateAfterRepeat: return next.before(date)
     * ? null : next;
     * 
     * This leads to endless loop if we call a timer job at exactly the time
     * it will schedule next. Cannot be handled by engine, because there is
     * no "counter" in the database for executions - it has to trust the
     * clock on the wall.
     */
    Calendar cal = Calendar.getInstance();
    cal.setTime(ClockUtil.getCurrentTime());
    cal.add(Calendar.MILLISECOND, 1);
    ClockUtil.setCurrentTime(cal.getTime());
  }
  engine.getManagementService().executeJob(workItem.getId());
}
 

import org.camunda.bpm.engine.impl.util.ClockUtil; //导入依赖的package包/类
protected void prepareProcessInstances(String key, int daysInThePast, Integer historyTimeToLive, int instanceCount) {
  ProcessDefinition processDefinition = selectProcessDefinitionByKey(key);
  disableAuthorization();
  repositoryService.updateProcessDefinitionHistoryTimeToLive(processDefinition.getId(), historyTimeToLive);
  enableAuthorization();

  Date oldCurrentTime = ClockUtil.getCurrentTime();
  ClockUtil.setCurrentTime(DateUtils.addDays(new Date(), daysInThePast));

  List<String> processInstanceIds = new ArrayList<String>();
  for (int i = 0; i < instanceCount; i++) {
    ProcessInstance processInstance = startProcessInstanceByKey(key);
    processInstanceIds.add(processInstance.getId());
  }

  disableAuthorization();
  runtimeService.deleteProcessInstances(processInstanceIds, null, true, true);
  enableAuthorization();

  ClockUtil.setCurrentTime(oldCurrentTime);
}
 

import org.camunda.bpm.engine.impl.util.ClockUtil; //导入依赖的package包/类
@Test
@Deployment(resources = { "org/camunda/bpm/engine/test/dmn/businessruletask/DmnBusinessRuleTaskTest.testDecisionRef.bpmn20.xml",
    "org/camunda/bpm/engine/test/api/history/testDmnWithPojo.dmn11.xml", "org/camunda/bpm/engine/test/api/authorization/oneTaskCase.cmmn" })
public void testHistoryCleanupWithoutAuthorization() {
  // given
  prepareInstances(5, 5, 5);

  ClockUtil.setCurrentTime(new Date());

  try {
    // when
    historyService.cleanUpHistoryAsync(true).getId();
    fail("Exception expected: It should not be possible to execute the history cleanup");
  } catch (AuthorizationException e) {
    // then
    String message = e.getMessage();
    assertTextPresent(Groups.CAMUNDA_ADMIN, message);
    assertTextPresent("Required authenticated group", message);
  }
}
 

import org.camunda.bpm.engine.impl.util.ClockUtil; //导入依赖的package包/类
private void prepareCaseInstances(String key, int daysInThePast, Integer historyTimeToLive, int instanceCount) {
  // update time to live
  List<CaseDefinition> caseDefinitions = repositoryService.createCaseDefinitionQuery().caseDefinitionKey(key).list();
  assertEquals(1, caseDefinitions.size());
  repositoryService.updateCaseDefinitionHistoryTimeToLive(caseDefinitions.get(0).getId(), historyTimeToLive);

  Date oldCurrentTime = ClockUtil.getCurrentTime();
  ClockUtil.setCurrentTime(DateUtils.addDays(oldCurrentTime, daysInThePast));

  for (int i = 0; i < instanceCount; i++) {
    CaseInstance caseInstance = caseService.createCaseInstanceByKey(key);
    caseService.terminateCaseExecution(caseInstance.getId());
    caseService.closeCaseInstance(caseInstance.getId());
  }

  ClockUtil.setCurrentTime(oldCurrentTime);
}
 

import org.camunda.bpm.engine.impl.util.ClockUtil; //导入依赖的package包/类
@Deployment(resources = {"org/camunda/bpm/engine/test/api/runtime/ProcessInstanceSuspensionTest.testJobNotExecutedAfterProcessInstanceSuspend.bpmn20.xml"})
public void testJobNotExecutedAfterProcessInstanceSuspendByProcessDefinitionKey() {

  Date now = new Date();
  ClockUtil.setCurrentTime(now);

  // Suspending the process instance should also stop the execution of jobs for that process instance
  ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().singleResult();
  runtimeService.startProcessInstanceById(processDefinition.getId());
  assertEquals(1, managementService.createJobQuery().count());
  runtimeService.suspendProcessInstanceByProcessDefinitionKey(processDefinition.getKey());
  assertEquals(1, managementService.createJobQuery().count());

  // The jobs should not be executed now
  ClockUtil.setCurrentTime(new Date(now.getTime() + (60 * 60 * 1000))); // Timer is set to fire on 5 minutes
  assertEquals(0, managementService.createJobQuery().executable().count());

  // Activation of the process instance should now allow for job execution
  runtimeService.activateProcessInstanceByProcessDefinitionKey(processDefinition.getKey());
  assertEquals(1, managementService.createJobQuery().executable().count());
  managementService.executeJob(managementService.createJobQuery().singleResult().getId());
  assertEquals(0, managementService.createJobQuery().count());
  assertEquals(0, runtimeService.createProcessInstanceQuery().count());
}
 

import org.camunda.bpm.engine.impl.util.ClockUtil; //导入依赖的package包/类
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);
}
 

import org.camunda.bpm.engine.impl.util.ClockUtil; //导入依赖的package包/类
@Test
public void testHistoricProcInstExecutedActivityWithEmptyInterval() {
  // given
  Calendar now = Calendar.getInstance();
  ClockUtil.setCurrentTime(now.getTime());
  BpmnModelInstance model = Bpmn.createExecutableProcess("proc").startEvent().endEvent().done();
  deployment(model);

  Calendar hourBeforeNow = (Calendar) now.clone();
  hourBeforeNow.add(Calendar.HOUR, -1);

  runtimeService.startProcessInstanceByKey("proc");

  //when query historic proc inst which executes an activity an hour before and after the starting time
  HistoricProcessInstance historicProcessInstance = historyService.createHistoricProcessInstanceQuery()
    .executedActivityBefore(hourBeforeNow.getTime())
    .executedActivityAfter(hourBeforeNow.getTime()).singleResult();

  //then query returns no result
  assertNull(historicProcessInstance);
}
 

import org.camunda.bpm.engine.impl.util.ClockUtil; //导入依赖的package包/类
public void execute(DelegateExecution execution) throws Exception {
  
  SimpleDateFormat sdf =  new SimpleDateFormat("dd/MM/yyyy hh:mm:ss SSS");
  // We set the time to check of the updated time is picked up in the history
  Date updatedDate = sdf.parse("01/01/2001 01:23:46 000");
  ClockUtil.setCurrentTime(updatedDate);
  
  
  execution.setVariable("aVariable", "updated value");
  execution.setVariable("bVariable", 123);
  execution.setVariable("cVariable", 12345L);
  execution.setVariable("dVariable", 1234.567);
  execution.setVariable("eVariable", (short)12);
  
  Date theDate =sdf.parse("01/01/2001 01:23:45 678");
  execution.setVariable("fVariable", theDate);
  
  execution.setVariable("gVariable", new SerializableVariable("hello hello"));
  execution.setVariable("hVariable", ";-)".getBytes());
}
 

import org.camunda.bpm.engine.impl.util.ClockUtil; //导入依赖的package包/类
public void testIdlingWithHint(JobCreationInCycle jobCreationInCycle) {
  initAcquisitionAndIdleToMaxTime();

  final Date startTime = new Date();
  ProcessInstance procInstance = jobCreationInCycle.createJobAndContinueCycle();

   // After process start, there should be 1 timer created
  Task task1 = engineRule.getTaskService().createTaskQuery().singleResult();
  assertEquals("Timer Task", task1.getName());
  //and one job
  JobQuery jobQuery = engineRule.getManagementService().createJobQuery().processInstanceId(
          procInstance.getId());
  Job job = jobQuery.singleResult();
  assertNotNull(job);

  // the hint of the added job resets the idle time
  // => 0 jobs are acquired so we had to wait BASE IDLE TIME
  //after this time we can acquire the timer
  triggerReconfigurationAndNextCycle();
  assertJobExecutorWaitEvent(BASE_IDLE_WAIT_TIME);

  //time is increased so timer is found
  ClockUtil.setCurrentTime(new Date(startTime.getTime() + BASE_IDLE_WAIT_TIME));
  //now we are able to acquire the job
  cycleAcquisitionAndAssertAfterJobExecution(jobQuery);
}
 

import org.camunda.bpm.engine.impl.util.ClockUtil; //导入依赖的package包/类
public HistoryCleanupConfigurationDto getHistoryCleanupConfiguration() {
  HistoryCleanupConfigurationDto configurationDto = new HistoryCleanupConfigurationDto();
  Date startTime = ((ProcessEngineConfigurationImpl) processEngine.getProcessEngineConfiguration())
      .getHistoryCleanupBatchWindowStartTimeAsDate();
  Date endTime = ((ProcessEngineConfigurationImpl) processEngine.getProcessEngineConfiguration())
      .getHistoryCleanupBatchWindowEndTimeAsDate();
  if (startTime == null || endTime == null) {
    return configurationDto;
  }
  Date now = ClockUtil.getCurrentTime();
  Date startDate = HistoryCleanupHelper.getCurrentOrNextBatchWindowStartTime(now, startTime, endTime);
  Date endDate = HistoryCleanupHelper.getNextBatchWindowEndTime(now, endTime);
  configurationDto.setBatchWindowStartTime(startDate);
  configurationDto.setBatchWindowEndTime(endDate);
  return configurationDto;
}
 

import org.camunda.bpm.engine.impl.util.ClockUtil; //导入依赖的package包/类
@Test
public void testNotEnoughTimeToDeleteEverything() {
  //given
  //we have something to cleanup
  prepareData(40);
  //we call history cleanup within batch window
  Date now = new Date();
  ClockUtil.setCurrentTime(now);
  processEngineConfiguration.setHistoryCleanupBatchWindowStartTime(new SimpleDateFormat("HH:mm").format(now));
  processEngineConfiguration.setHistoryCleanupBatchWindowEndTime(new SimpleDateFormat("HH:mm").format(DateUtils.addHours(now, HISTORY_TIME_TO_LIVE)));
  processEngineConfiguration.initHistoryCleanup();
  String jobId = historyService.cleanUpHistoryAsync().getId();
  //job is executed once within batch window
  managementService.executeJob(jobId);

  //when
  //time passed -> outside batch window
  ClockUtil.setCurrentTime(DateUtils.addHours(now, 6));
  //the job is called for the second time
  managementService.executeJob(jobId);

  //then
  //second execution was not able to delete rest data
  assertResult(20);
}
 

import org.camunda.bpm.engine.impl.util.ClockUtil; //导入依赖的package包/类
@Test
@Deployment(resources = { "org/camunda/bpm/engine/test/dmn/businessruletask/DmnBusinessRuleTaskTest.testDecisionRef.bpmn20.xml",
    "org/camunda/bpm/engine/test/api/history/testDmnWithPojo.dmn11.xml", "org/camunda/bpm/engine/test/api/authorization/oneTaskCase.cmmn" })
public void testHistoryCleanupNothingRemoved() {
  // given
  prepareInstances(null, null, null);

  ClockUtil.setCurrentTime(new Date());
  // when
  String jobId = historyService.cleanUpHistoryAsync(true).getId();

  managementService.executeJob(jobId);

  // then
  assertEquals(PROCESS_INSTANCES_COUNT, historyService.createHistoricProcessInstanceQuery().count());
  assertEquals(DECISION_INSTANCES_COUNT + DECISIONS_IN_PROCESS_INSTANCES, historyService.createHistoricDecisionInstanceQuery().count());
  assertEquals(CASE_INSTANCES_COUNT, historyService.createHistoricCaseInstanceQuery().count());
}
 

import org.camunda.bpm.engine.impl.util.ClockUtil; //导入依赖的package包/类
@Test
public void testReportZeroTTL() {
  Map<String, String> map = new HashMap<String, String>();
  int modOperationsTTL = 0;
  map.put("instance-modification", "P0D");
  processEngineConfiguration.setBatchOperationsForHistoryCleanup(map);
  processEngineConfiguration.initHistoryCleanup();

  Date startDate = ClockUtil.getCurrentTime();
  int daysInThePast = -11;
  ClockUtil.setCurrentTime(DateUtils.addDays(startDate, daysInThePast));

  Batch modificationBatch = createModificationBatch();
  ClockUtil.setCurrentTime(DateUtils.addDays(startDate, -7));

  managementService.deleteBatch(modificationBatch.getId(), false);

  CleanableHistoricBatchReportResult result = historyService.createCleanableHistoricBatchReport().singleResult();
  assertNotNull(result);
  checkResultNumbers(result, 1, 1, modOperationsTTL);
}
 

import org.camunda.bpm.engine.impl.util.ClockUtil; //导入依赖的package包/类
@Deployment(resources = "org/camunda/bpm/engine/test/api/externaltask/twoExternalTaskProcess.bpmn20.xml")
public void testHandleBpmnErrorLockExpiredTask() {
  //given
  runtimeService.startProcessInstanceByKey("twoExternalTaskProcess");
  // when
  List<LockedExternalTask> externalTasks = externalTaskService.fetchAndLock(1, WORKER_ID)
    .topic(TOPIC_NAME, LOCK_TIME)
    .execute();

  // and the lock expires without the task being reclaimed
  ClockUtil.setCurrentTime(new DateTime(ClockUtil.getCurrentTime()).plus(LOCK_TIME * 2).toDate());

  externalTaskService.handleBpmnError(externalTasks.get(0).getId(), WORKER_ID, "ERROR-OCCURED");

  externalTasks = externalTaskService.fetchAndLock(1, WORKER_ID)
    .topic(TOPIC_NAME, LOCK_TIME)
    .execute();

  assertEquals(0, externalTasks.size());
  assertEquals(0, externalTaskService.createExternalTaskQuery().count());
  Task afterBpmnError = taskService.createTaskQuery().singleResult();
  assertNotNull(afterBpmnError);
  assertEquals(afterBpmnError.getTaskDefinitionKey(), "afterBpmnError");
}
 

import org.camunda.bpm.engine.impl.util.ClockUtil; //导入依赖的package包/类
public void testDeleteGroupLinkEvents() {

    // initially there are no task events
    assertTrue(taskService.getTaskEvents(task.getId()).isEmpty());

    taskService.addCandidateGroup(task.getId(), ACCOUNTING);

    ClockUtil.setCurrentTime(new Date(ClockUtil.getCurrentTime().getTime() + 5000));

    taskService.deleteCandidateGroup(task.getId(), ACCOUNTING);

    // now there is a task event created
    List<Event> events = taskService.getTaskEvents(task.getId());
    assertEquals(2, events.size());
    Event event = events.get(0);
    assertEquals(ACCOUNTING, event.getMessageParts().get(0));
    assertEquals(CANDIDATE, event.getMessageParts().get(1));
    assertEquals(task.getId(), event.getTaskId());
    assertEquals(ACTION_DELETE_GROUP_LINK, event.getAction());
    assertEquals(ACCOUNTING + CommentEntity.MESSAGE_PARTS_MARKER + CANDIDATE, event.getMessage());
    assertEquals(null, event.getProcessInstanceId());
    assertNotNull(event.getTime().getTime() <= ClockUtil.getCurrentTime().getTime());

    assertNoCommentsForTask();
  }
 

import org.camunda.bpm.engine.impl.util.ClockUtil; //导入依赖的package包/类
public HistoryEvent createCaseInstanceCloseEvt(DelegateCaseExecution caseExecution) {
  final CaseExecutionEntity caseExecutionEntity = (CaseExecutionEntity) caseExecution;

  // create event instance
  HistoricCaseInstanceEventEntity evt = loadCaseInstanceEventEntity(caseExecutionEntity);

  // initialize event
  initCaseInstanceEvent(evt, caseExecutionEntity, HistoryEventTypes.CASE_INSTANCE_CLOSE);

  // set end time
  evt.setEndTime(ClockUtil.getCurrentTime());

  if (evt.getStartTime() != null) {
    evt.setDurationInMillis(evt.getEndTime().getTime() - evt.getStartTime().getTime());
  }

  return evt;
}
 

import org.camunda.bpm.engine.impl.util.ClockUtil; //导入依赖的package包/类
public void testSuspendStandaloneJobById() {
  // given
  createGrantAuthorization(PROCESS_DEFINITION, TIMER_START_PROCESS_KEY, userId, UPDATE);

  Date startTime = new Date();
  ClockUtil.setCurrentTime(startTime);
  long oneWeekFromStartTime = startTime.getTime() + (7 * 24 * 60 * 60 * 1000);

  disableAuthorization();
  // creates a new "standalone" job
  managementService.suspendJobDefinitionByProcessDefinitionKey(TIMER_START_PROCESS_KEY, false, new Date(oneWeekFromStartTime));
  enableAuthorization();

  String jobId = managementService.createJobQuery().singleResult().getId();

  // when
  managementService.suspendJobById(jobId);

  // then
  Job job = selectJobById(jobId);
  assertNotNull(job);
  assertTrue(job.isSuspended());

  deleteJob(jobId);
}
 

import org.camunda.bpm.engine.impl.util.ClockUtil; //导入依赖的package包/类
protected void initUserOperationLogEvent(UserOperationLogEntryEventEntity evt, UserOperationLogContext context,
    UserOperationLogContextEntry contextEntry, PropertyChange propertyChange) {
  // init properties
  evt.setDeploymentId(contextEntry.getDeploymentId());
  evt.setEntityType(contextEntry.getEntityType());
  evt.setOperationType(contextEntry.getOperationType());
  evt.setOperationId(context.getOperationId());
  evt.setUserId(context.getUserId());
  evt.setProcessDefinitionId(contextEntry.getProcessDefinitionId());
  evt.setProcessDefinitionKey(contextEntry.getProcessDefinitionKey());
  evt.setProcessInstanceId(contextEntry.getProcessInstanceId());
  evt.setExecutionId(contextEntry.getExecutionId());
  evt.setCaseDefinitionId(contextEntry.getCaseDefinitionId());
  evt.setCaseInstanceId(contextEntry.getCaseInstanceId());
  evt.setCaseExecutionId(contextEntry.getCaseExecutionId());
  evt.setTaskId(contextEntry.getTaskId());
  evt.setJobId(contextEntry.getJobId());
  evt.setJobDefinitionId(contextEntry.getJobDefinitionId());
  evt.setBatchId(contextEntry.getBatchId());
  evt.setTimestamp(ClockUtil.getCurrentTime());

  // init property value
  evt.setProperty(propertyChange.getPropertyName());
  evt.setOrgValue(propertyChange.getOrgValueString());
  evt.setNewValue(propertyChange.getNewValueString());
}
 

import org.camunda.bpm.engine.impl.util.ClockUtil; //导入依赖的package包/类
public void testDeleteUserLinkEvents() {

    // initially there are no task events
    assertTrue(taskService.getTaskEvents(task.getId()).isEmpty());

    taskService.addCandidateUser(task.getId(), JONNY);

    ClockUtil.setCurrentTime(new Date(ClockUtil.getCurrentTime().getTime() + 5000));

    taskService.deleteCandidateUser(task.getId(), JONNY);

    // now there is a task event created
    List<Event> events = taskService.getTaskEvents(task.getId());
    assertEquals(2, events.size());
    Event event = events.get(0);
    assertEquals(JONNY, event.getMessageParts().get(0));
    assertEquals(CANDIDATE, event.getMessageParts().get(1));
    assertEquals(task.getId(), event.getTaskId());
    assertEquals(ACTION_DELETE_USER_LINK, event.getAction());
    assertEquals(JONNY + CommentEntity.MESSAGE_PARTS_MARKER + CANDIDATE, event.getMessage());
    assertEquals(null, event.getProcessInstanceId());
    assertNotNull(event.getTime().getTime() <= ClockUtil.getCurrentTime().getTime());

    assertNoCommentsForTask();
  }
 

import org.camunda.bpm.engine.impl.util.ClockUtil; //导入依赖的package包/类
public HistoryEvent createTaskInstanceCompleteEvt(DelegateTask task, String deleteReason) {

    // create event instance
    HistoricTaskInstanceEventEntity evt = loadTaskInstanceEvent(task);

    // initialize event
    initTaskInstanceEvent(evt, (TaskEntity) task, HistoryEventTypes.TASK_INSTANCE_COMPLETE);

    // set end time
    evt.setEndTime(ClockUtil.getCurrentTime());
    if(evt.getStartTime() != null) {
      evt.setDurationInMillis(evt.getEndTime().getTime()-evt.getStartTime().getTime());
    }

    // set delete reason
    evt.setDeleteReason(deleteReason);

    return evt;
  }