Example usage for org.springframework.batch.core StepExecution addFailureException

List of usage examples for org.springframework.batch.core StepExecution addFailureException

Introduction

In this page you can find the example usage for org.springframework.batch.core StepExecution addFailureException.

Prototype

public void addFailureException(Throwable throwable) 

Source Link

Usage

From source file:org.duracloud.snapshot.service.impl.SyncWriter.java

@Override
public void beforeStep(StepExecution stepExecution) {
    try {/*from   w w w.  java 2  s .c  om*/
        restoreManager.transitionRestoreStatus(restorationId, RestoreStatus.TRANSFERRING_TO_DURACLOUD, "");
        Space space = this.contentStore.getSpace(destinationSpaceId, null, 1, null);
        if (!CollectionUtils.isEmpty(space.getContentIds())) {
            stepExecution.addFailureException(new RuntimeException(
                    "destination space " + destinationSpaceId + " must be empty to receive restored content"));
        }
    } catch (NotFoundException ex) {
        try {
            this.contentStore.createSpace(destinationSpaceId);
        } catch (ContentStoreException e) {
            stepExecution.addFailureException(e);
        }
    } catch (Exception ex) {
        stepExecution.addFailureException(ex);
    }
}

From source file:org.springframework.batch.core.step.AbstractStep.java

/**
 * Template method for step execution logic - calls abstract methods for resource initialization (
 * {@link #open(ExecutionContext)}), execution logic ({@link #doExecute(StepExecution)}) and resource closing (
 * {@link #close(ExecutionContext)})./*from  www. j  av  a2  s . c  o  m*/
 */
@Override
public final void execute(StepExecution stepExecution)
        throws JobInterruptedException, UnexpectedJobExecutionException {

    if (logger.isDebugEnabled()) {
        logger.debug("Executing: id=" + stepExecution.getId());
    }
    stepExecution.setStartTime(new Date());
    stepExecution.setStatus(BatchStatus.STARTED);
    getJobRepository().update(stepExecution);

    // Start with a default value that will be trumped by anything
    ExitStatus exitStatus = ExitStatus.EXECUTING;

    doExecutionRegistration(stepExecution);

    try {
        getCompositeListener().beforeStep(stepExecution);
        open(stepExecution.getExecutionContext());

        try {
            doExecute(stepExecution);
        } catch (RepeatException e) {
            throw e.getCause();
        }
        exitStatus = ExitStatus.COMPLETED.and(stepExecution.getExitStatus());

        // Check if someone is trying to stop us
        if (stepExecution.isTerminateOnly()) {
            throw new JobInterruptedException("JobExecution interrupted.");
        }

        // Need to upgrade here not set, in case the execution was stopped
        stepExecution.upgradeStatus(BatchStatus.COMPLETED);
        if (logger.isDebugEnabled()) {
            logger.debug("Step execution success: id=" + stepExecution.getId());
        }
    } catch (Throwable e) {
        stepExecution.upgradeStatus(determineBatchStatus(e));
        exitStatus = exitStatus.and(getDefaultExitStatusForFailure(e));
        stepExecution.addFailureException(e);
        if (stepExecution.getStatus() == BatchStatus.STOPPED) {
            logger.info(String.format("Encountered interruption executing step %s in job %s : %s", name,
                    stepExecution.getJobExecution().getJobInstance().getJobName(), e.getMessage()));
            if (logger.isDebugEnabled()) {
                logger.debug("Full exception", e);
            }
        } else {
            logger.error(String.format("Encountered an error executing step %s in job %s", name,
                    stepExecution.getJobExecution().getJobInstance().getJobName()), e);
        }
    } finally {

        try {
            // Update the step execution to the latest known value so the
            // listeners can act on it
            exitStatus = exitStatus.and(stepExecution.getExitStatus());
            stepExecution.setExitStatus(exitStatus);
            exitStatus = exitStatus.and(getCompositeListener().afterStep(stepExecution));
        } catch (Exception e) {
            logger.error(String.format("Exception in afterStep callback in step %s in job %s", name,
                    stepExecution.getJobExecution().getJobInstance().getJobName()), e);
        }

        try {
            getJobRepository().updateExecutionContext(stepExecution);
        } catch (Exception e) {
            stepExecution.setStatus(BatchStatus.UNKNOWN);
            exitStatus = exitStatus.and(ExitStatus.UNKNOWN);
            stepExecution.addFailureException(e);
            logger.error(String.format(
                    "Encountered an error saving batch meta data for step %s in job %s. "
                            + "This job is now in an unknown state and should not be restarted.",
                    name, stepExecution.getJobExecution().getJobInstance().getJobName()), e);
        }

        stepExecution.setEndTime(new Date());
        stepExecution.setExitStatus(exitStatus);

        try {
            getJobRepository().update(stepExecution);
        } catch (Exception e) {
            stepExecution.setStatus(BatchStatus.UNKNOWN);
            stepExecution.setExitStatus(exitStatus.and(ExitStatus.UNKNOWN));
            stepExecution.addFailureException(e);
            logger.error(String.format(
                    "Encountered an error saving batch meta data for step %s in job %s. "
                            + "This job is now in an unknown state and should not be restarted.",
                    name, stepExecution.getJobExecution().getJobInstance().getJobName()), e);
        }

        try {
            close(stepExecution.getExecutionContext());
        } catch (Exception e) {
            logger.error(String.format("Exception while closing step execution resources in step %s in job %s",
                    name, stepExecution.getJobExecution().getJobInstance().getJobName()), e);
            stepExecution.addFailureException(e);
        }

        doExecutionRelease();

        if (logger.isDebugEnabled()) {
            logger.debug("Step execution complete: " + stepExecution.getSummary());
        }
    }
}

From source file:org.springframework.cloud.task.batch.partition.DeployerStepExecutionHandler.java

@Override
public void run(String... args) throws Exception {

    validateRequest();/* www  .j ava 2  s . c  o m*/

    Long jobExecutionId = Long
            .parseLong(environment.getProperty(DeployerPartitionHandler.SPRING_CLOUD_TASK_JOB_EXECUTION_ID));
    Long stepExecutionId = Long
            .parseLong(environment.getProperty(DeployerPartitionHandler.SPRING_CLOUD_TASK_STEP_EXECUTION_ID));
    StepExecution stepExecution = jobExplorer.getStepExecution(jobExecutionId, stepExecutionId);

    if (stepExecution == null) {
        throw new NoSuchStepException(String.format(
                "No StepExecution could be located for step execution id %s within job execution %s",
                stepExecutionId, jobExecutionId));
    }

    String stepName = environment.getProperty(DeployerPartitionHandler.SPRING_CLOUD_TASK_STEP_NAME);
    Step step = stepLocator.getStep(stepName);

    try {
        logger.debug(String.format("Executing step %s with step execution id %s and job execution id %s",
                stepExecution.getStepName(), stepExecutionId, jobExecutionId));

        step.execute(stepExecution);
    } catch (JobInterruptedException e) {
        stepExecution.setStatus(BatchStatus.STOPPED);
        jobRepository.update(stepExecution);
    } catch (Throwable e) {
        stepExecution.addFailureException(e);
        stepExecution.setStatus(BatchStatus.FAILED);
        jobRepository.update(stepExecution);
    }
}

From source file:org.springframework.yarn.batch.container.DefaultBatchYarnContainer.java

@Override
protected void runInternal() {

    Long jobExecutionId = safeParse(getEnvironment(YarnSystemConstants.AMSERVICE_BATCH_JOBEXECUTIONID));
    Long stepExecutionId = safeParse(getEnvironment(YarnSystemConstants.AMSERVICE_BATCH_STEPEXECUTIONID));
    String stepName = getEnvironment(YarnSystemConstants.AMSERVICE_BATCH_STEPNAME);

    if (log.isDebugEnabled()) {
        log.debug("Requesting StepExecution: " + jobExecutionId + " / " + stepExecutionId);
    }/*from   ww  w  .  j a v a  2 s .c  o m*/

    StepExecution stepExecution = getJobExplorer().getStepExecution(jobExecutionId, stepExecutionId);
    if (stepExecution == null) {
        throw new NoSuchStepException("No StepExecution could be located for this request: ");
    }

    if (log.isDebugEnabled()) {
        log.debug("Got StepExecution: " + stepExecution);
        log.debug("Locating Step: " + stepName);
    }

    Step step = getStepLocator().getStep(stepName);
    if (log.isDebugEnabled()) {
        log.debug("Located step: " + step);
    }

    if (step == null) {
        throw new NoSuchStepException(String.format("No Step with name [%s] could be located.", stepName));
    }

    try {
        if (log.isDebugEnabled()) {
            log.debug("Executing step: " + step + " / " + stepExecution);
        }
        step.execute(stepExecution);
    } catch (JobInterruptedException e) {
        log.error("error executing step 1", e);
        stepExecution.setStatus(BatchStatus.STOPPED);
    } catch (Throwable e) {
        log.error("error executing step 2", e);
        stepExecution.addFailureException(e);
        stepExecution.setStatus(BatchStatus.FAILED);
    }

    if (log.isDebugEnabled()) {
        log.debug("Finished remote step run, status is " + stepExecution.getStatus());
    }

    MindAppmasterServiceClient client = (MindAppmasterServiceClient) getIntegrationServiceClient();
    PartitionedStepExecutionStatusReq req = new PartitionedStepExecutionStatusReq();
    req.stepExecution = JobRepositoryRpcFactory.convertStepExecutionType(stepExecution);
    BaseResponseObject doMindRequest = client.doMindRequest(req);
    log.info("got response for status update: " + doMindRequest);
}