コード例 #1
0
  // Cancel paused run according to its branches state
  //      If the run has branches, (it can be branch-paused / user-paused / no-workers-in-group) -
  // then it's a 'virtual' pause, and we should cancel the paused branches. Then, the run itself
  // will be canceled as well.
  //      If it doesn't - just cancel it straight away - extract the Run Object, set its context
  // accordingly and put into the queue.
  private void cancelPausedRun(ExecutionState executionStateToCancel) {
    final List<ExecutionState> branches =
        executionStateService.readByExecutionId(executionStateToCancel.getExecutionId());

    // If the parent is paused because one of the branches is paused, OR, it was paused by the user
    // / no-workers-in-group, but has branches that were not finished (and thus, were paused) -
    // The parent itself will return to the queue after all the branches are ended (due to this
    // cancellation), and then it'll be canceled as well.
    if (branches.size()
        > 1) { // more than 1 means that it has paused branches (branches is at least 1 - the
               // parent)
      for (ExecutionState branch : branches) {
        if (!EMPTY_BRANCH.equals(branch.getBranchId())) { // exclude the base execution
          returnCanceledRunToQueue(branch);
          executionStateService.deleteExecutionState(branch.getExecutionId(), branch.getBranchId());
        }
      }
      executionStateToCancel.setStatus(
          ExecutionStatus
              .PENDING_CANCEL); // when the parent will return to queue - should have the correct
                                // status
    } else {
      returnCanceledRunToQueue(executionStateToCancel);
    }
  }
コード例 #2
0
 @Override
 @Transactional(readOnly = true)
 public List<Long> readCanceledExecutionsIds() {
   List<Long> result = executionStateService.readExecutionIdByStatuses(getCancelStatuses());
   if (result == null) {
     result = Arrays.asList();
   }
   return result;
 }
コード例 #3
0
  @Override
  @Transactional
  public ExecutionActionResult requestCancelExecution(Long executionId) {
    if (logger.isDebugEnabled()) {
      logger.debug("Cancelling Execution Id: " + executionId);
    }
    if (executionId == null) {
      throw new IllegalArgumentException(
          "Null is not allowed as input of execution id in cancelExecution()");
    }

    ExecutionState executionStateToCancel =
        executionStateService.readByExecutionIdAndBranchId(executionId, EMPTY_BRANCH);
    // we must have such execution in the table - the record is created on execution triggering
    if (executionStateToCancel == null) {
      String errMsg = "Failed to cancel execution. Execution id: " + executionId + ".";
      logger.error(errMsg);
      return ExecutionActionResult.FAILED_NOT_FOUND;
    }

    ExecutionStatus status = executionStateToCancel.getStatus();

    if (status.equals(ExecutionStatus.CANCELED) || status.equals(ExecutionStatus.PENDING_CANCEL)) {
      return ExecutionActionResult.FAILED_ALREADY_CANCELED_OR_PENDING_CANCELLATION;
    }

    // it's possible to cancel only running or paused executions.
    // If it's running - set to pending-cancel, and the ExecutionServiceImpl will handle it and
    // extract it from the queue.
    // If it's paused - sometimes needs to handle its branches (if such exists).
    if (status.equals(ExecutionStatus.RUNNING)) {
      executionStateToCancel.setStatus(ExecutionStatus.PENDING_CANCEL);
    } else if (status.equals(ExecutionStatus.PAUSED)) {
      cancelPausedRun(executionStateToCancel);
    } else {
      String errMsg =
          "Failed to cancel execution. Execution id: "
              + executionId
              + ". Execution is in status: "
              + executionStateToCancel.getStatus().name();
      logger.error(errMsg);
      return ExecutionActionResult.getExecutionActionResult(status);
    }

    return ExecutionActionResult.SUCCESS;
  }
コード例 #4
0
 @Override
 @Transactional(readOnly = true)
 public boolean isCanceledExecution(Long executionId) {
   return executionStateService.readCancelledExecution(executionId) != null;
 }