How to use

getStatus

method

in

org.springframework.batch.core.job.flow.FlowExecution

/**
 * Aggregate all of the {@link FlowExecutionStatus}es of the
 * {@link FlowExecution}s into one status. The aggregate status will be the
 * status with the highest precedence.
 *
 * @see FlowExecutionAggregator#aggregate(Collection)
 */
@Override
public FlowExecutionStatus aggregate(Collection<FlowExecution> executions) {
  if (executions == null || executions.size() == 0) {
    return FlowExecutionStatus.UNKNOWN;
  }
  return Collections.max(executions).getStatus();
}

@Override
public FlowExecutionStatus handle(FlowExecutor executor) throws Exception {
  return flow.start(executor).getStatus();
}

/**
 * Create an ordering on {@link FlowExecution} instances by comparing their
 * statuses.
 *
 * @see Comparable#compareTo(Object)
 *
 * @param other the {@link FlowExecution} instance to compare with this instance.
 * @return negative, zero or positive as per the contract
 */
@Override
public int compareTo(FlowExecution other) {
  return this.status.compareTo(other.getStatus());
}

/**
 * @see AbstractJob#doExecute(JobExecution)
 */
@Override
protected void doExecute(final JobExecution execution) throws JobExecutionException {
  try {
    JobFlowExecutor executor = new JobFlowExecutor(getJobRepository(),
        new SimpleStepHandler(getJobRepository()), execution);
    executor.updateJobExecutionStatus(flow.start(executor).getStatus());
  }
  catch (FlowExecutionException e) {
    if (e.getCause() instanceof JobExecutionException) {
      throw (JobExecutionException) e.getCause();
    }
    throw new JobExecutionException("Flow execution ended unexpectedly", e);
  }
}

@Test
public void testOneStepWithListenerCallsClose() throws Exception {
  flow.setStateTransitions(Collections.singletonList(StateTransition.createEndStateTransition(new StubState(
      "step1"))));
  flow.afterPropertiesSet();
  final List<FlowExecution> list = new ArrayList<>();
  executor = new JobFlowExecutorSupport() {
    @Override
    public void close(FlowExecution result) {
      list.add(result);
    }
  };
  FlowExecution execution = flow.start(executor);
  assertEquals(1, list.size());
  assertEquals(FlowExecutionStatus.COMPLETED, execution.getStatus());
  assertEquals("step1", execution.getName());
}

@Test
public void testOneStep() throws Exception {
  flow.setStateTransitions(Collections.singletonList(StateTransition.createEndStateTransition(new StubState(
      "step1"))));
  flow.afterPropertiesSet();
  FlowExecution execution = flow.start(executor);
  assertEquals(FlowExecutionStatus.COMPLETED, execution.getStatus());
  assertEquals("step1", execution.getName());
}

/**
 * Delegate to the flow provided for the execution of the step.
 * 
 * @see AbstractStep#doExecute(StepExecution)
 */
@Override
protected void doExecute(StepExecution stepExecution) throws Exception {
  try {
    stepExecution.getExecutionContext().put(STEP_TYPE_KEY, this.getClass().getName());
    StepHandler stepHandler = new SimpleStepHandler(getJobRepository(), stepExecution.getExecutionContext());
    FlowExecutor executor = new JobFlowExecutor(getJobRepository(), stepHandler, stepExecution.getJobExecution());
    executor.updateJobExecutionStatus(flow.start(executor).getStatus());
    stepExecution.upgradeStatus(executor.getJobExecution().getStatus());
    stepExecution.setExitStatus(executor.getJobExecution().getExitStatus());
  }
  catch (FlowExecutionException e) {
    if (e.getCause() instanceof JobExecutionException) {
      throw (JobExecutionException) e.getCause();
    }
    throw new JobExecutionException("Flow execution ended unexpectedly", e);
  }
}

/**
 * @see AbstractJob#doExecute(JobExecution)
 */
@Override
protected void doExecute(final JobExecution execution) throws JobExecutionException {
  try {
    JobFlowExecutor executor = new JsrFlowExecutor(getJobRepository(),
        new JsrStepHandler(getJobRepository(), jobExplorer), execution);
    State startState = ((JsrFlow)flow).getStartState();
    validateFirstStep(startState);
    executor.updateJobExecutionStatus(flow.start(executor).getStatus());
  }
  catch (FlowExecutionException e) {
    if (e.getCause() instanceof JobExecutionException) {
      throw (JobExecutionException) e.getCause();
    }
    throw new JobExecutionException("Flow execution ended unexpectedly", e);
  }
}

@Test
public void testBasicProperties() throws Exception {
  FlowExecution execution = new FlowExecution("foo", new FlowExecutionStatus("BAR"));
  assertEquals("foo",execution.getName());
  assertEquals("BAR",execution.getStatus().getName());
}

@Test
public void testResume() throws Exception {
  flow.setStateTransitions(collect(StateTransition.createStateTransition(new StubState("step1"), "step2"),
      StateTransition.createEndStateTransition(new StubState("step2"))));
  flow.afterPropertiesSet();
  FlowExecution execution = flow.resume("step2", executor);
  assertEquals(FlowExecutionStatus.COMPLETED, execution.getStatus());
  assertEquals("step2", execution.getName());
}

@Test
public void testUnconnectedSteps() throws Exception {
  flow.setStateTransitions(collect(StateTransition.createEndStateTransition(new StubState("step1")),
      StateTransition.createEndStateTransition(new StubState("step2"))));
  flow.afterPropertiesSet();
  FlowExecution execution = flow.start(executor);
  assertEquals(FlowExecutionStatus.COMPLETED, execution.getStatus());
  assertEquals("step1", execution.getName());
}

@Test
public void testStepLoop() throws Exception {
  flow.setStateTransitions(collect(StateTransition.createStateTransition(new StateSupport("step"),
      ExitStatus.FAILED.getExitCode(), "step"), StateTransition.createEndStateTransition(new StateSupport("step"))));
  flow.afterPropertiesSet();
  FlowExecution execution = flow.start(executor);
  assertEquals(FlowExecutionStatus.COMPLETED, execution.getStatus());
  assertEquals("step", execution.getName());
}

@Test
public void testTwoSteps() throws Exception {
  flow.setStateTransitions(collect(StateTransition.createStateTransition(new StubState("step1"), "step2"),
      StateTransition.createEndStateTransition(new StubState("step2"))));
  flow.afterPropertiesSet();
  FlowExecution execution = flow.start(executor);
  assertEquals(FlowExecutionStatus.COMPLETED, execution.getStatus());
  assertEquals("step2", execution.getName());
}

@Test
public void testFailedStep() throws Exception {
  flow.setStateTransitions(collect(StateTransition.createStateTransition(new StubState("step1") {
    @Override
    public FlowExecutionStatus handle(FlowExecutor executor) {
      return FlowExecutionStatus.FAILED;
    }
  }, "step2"), StateTransition.createEndStateTransition(new StubState("step2"))));
  flow.afterPropertiesSet();
  FlowExecution execution = flow.start(executor);
  assertEquals(FlowExecutionStatus.COMPLETED, execution.getStatus());
  assertEquals("step2", execution.getName());
}

@Test
public void testExplicitStartStep() throws Exception {
  flow.setStateTransitions(collect(StateTransition.createStateTransition(new StubState("step"),
      ExitStatus.FAILED.getExitCode(), "step"), StateTransition.createEndStateTransition(new StubState("step"))));
  flow.afterPropertiesSet();
  FlowExecution execution = flow.start(executor);
  assertEquals(FlowExecutionStatus.COMPLETED, execution.getStatus());
  assertEquals("step", execution.getName());
}

@Test
public void testBranching() throws Exception {
  flow.setStateTransitions(collect(StateTransition.createStateTransition(new StubState("step1"), "step2"),
      StateTransition.createStateTransition(new StubState("step1"), ExitStatus.COMPLETED.getExitCode(), "step3"),
      StateTransition.createEndStateTransition(new StubState("step2")), StateTransition
      .createEndStateTransition(new StubState("step3"))));
  flow.setStateTransitionComparator(new DefaultStateTransitionComparator());
  flow.afterPropertiesSet();
  FlowExecution execution = flow.start(executor);
  assertEquals(FlowExecutionStatus.COMPLETED, execution.getStatus());
  assertEquals("step3", execution.getName());
}

@Test
public void testNextBasedOnBatchStatus() throws Exception {
  StepExecution stepExecution = new StepExecution("step1", new JobExecution(5L));
  stepExecution.setExitStatus(new ExitStatus("unmapped exit code"));
  stepExecution.setStatus(BatchStatus.FAILED);
  executor = new FlowExecutor(stepExecution);
  State startState = new StateSupport("step1", new FlowExecutionStatus("unmapped exit code"));
  State endState = new StateSupport("failed", FlowExecutionStatus.FAILED);
  StateTransition failureTransition = StateTransition.createStateTransition(startState, "FAILED", "failed");
  StateTransition endTransition = StateTransition.createEndStateTransition(endState);
  flow.setStateTransitions(collect(failureTransition, endTransition));
  flow.afterPropertiesSet();
  FlowExecution execution = flow.start(executor);
  assertEquals(FlowExecutionStatus.FAILED, execution.getStatus());
  assertEquals("failed", execution.getName());
}

@Override
public FlowExecutionStatus handle(FlowExecutor executor) throws Exception {
  return flow.start(executor).getStatus();
}

/**
 * Create an ordering on {@link FlowExecution} instances by comparing their
 * statuses.
 * 
 * @see Comparable#compareTo(Object)
 * 
 * @param other
 * @return negative, zero or positive as per the contract
 */
public int compareTo(FlowExecution other) {
  return this.status.compareTo(other.getStatus());
}

/**
 * Create an ordering on {@link FlowExecution} instances by comparing their
 * statuses.
 *
 * @see Comparable#compareTo(Object)
 *
 * @param other the {@link FlowExecution} instance to compare with this instance.
 * @return negative, zero or positive as per the contract
 */
@Override
public int compareTo(FlowExecution other) {
  return this.status.compareTo(other.getStatus());
}