import javax.batch.operations.NoSuchJobExecutionException; //导入依赖的package包/类
public TCKJobExecutionWrapper restartJobAndWaitForResult(long oldExecutionId, Properties restartJobParameters) throws NoSuchJobExecutionException, NoSuchJobException, JobRestartException, JobExecutionAlreadyCompleteException, JobExecutionNotMostRecentException, JobSecurityException, JobExecutionTimeoutException {    	

		JobExecution terminatedJobExecution = null;
		long newExecutionId = jobOp.restart(oldExecutionId, restartJobParameters);

		JobExecutionWaiter waiter = waiterFactory.createWaiter(newExecutionId, jobOp, sleepTime);

		try {
			terminatedJobExecution = waiter.awaitTermination();
		} catch (JobExecutionTimeoutException e) {
			logger.severe(TIMEOUT_MSG);
			Reporter.log(TIMEOUT_MSG);
			throw e;
		}									

		return new TCKJobExecutionWrapper(terminatedJobExecution, jobOp);
	}
 

import javax.batch.operations.NoSuchJobExecutionException; //导入依赖的package包/类
public JobExecution stopJobAndWaitForResult(JobExecution jobExecution) throws NoSuchJobExecutionException, JobExecutionNotRunningException, JobSecurityException, JobExecutionTimeoutException {
	
	JobExecution terminatedJobExecution = null;
	jobOp.stop(jobExecution.getExecutionId());

	JobExecutionWaiter waiter = waiterFactory.createWaiter(jobExecution.getExecutionId(), jobOp, sleepTime);

	try {
		terminatedJobExecution = waiter.awaitTermination();
	} catch (JobExecutionTimeoutException e) {
		logger.severe(TIMEOUT_MSG);
		Reporter.log(TIMEOUT_MSG);
		throw e;
	}									

	return new TCKJobExecutionWrapper(terminatedJobExecution, jobOp);
}
 

import javax.batch.operations.NoSuchJobExecutionException; //导入依赖的package包/类
public TCKJobExecutionWrapper startJobAndWaitForResult(String jobName, Properties jobParameters) throws JobStartException, NoSuchJobExecutionException, JobSecurityException, JobExecutionTimeoutException{
	JobExecution terminatedJobExecution = null;
	long executionId = jobOp.start(jobName, jobParameters);

	JobExecutionWaiter waiter = waiterFactory.createWaiter(executionId, jobOp, sleepTime);

	try {
		terminatedJobExecution = waiter.awaitTermination();
	} catch (JobExecutionTimeoutException e) {
		logger.severe(TIMEOUT_MSG);
		Reporter.log(TIMEOUT_MSG);
		throw e;
	}									

	return new TCKJobExecutionWrapper(terminatedJobExecution, jobOp);
}
 

import javax.batch.operations.NoSuchJobExecutionException; //导入依赖的package包/类
@Override
public Properties getParameters(long executionId)
		throws NoSuchJobExecutionException, JobSecurityException{

	Properties props = null;
	JobInstance requestedJobInstance = batchKernel.getJobInstance(executionId);

	if (isAuthorized(requestedJobInstance.getInstanceId())) {
		props = persistenceService.getParameters(executionId);
	} else {
		logger.warning("getParameters: The current user is not authorized to perform this operation");
		throw new JobSecurityException("The current user is not authorized to perform this operation");
	}

	return props;
}
 

import javax.batch.operations.NoSuchJobExecutionException; //导入依赖的package包/类
@Override
public List<StepExecution> getStepExecutions(long executionId)
		throws NoSuchJobExecutionException, JobSecurityException {

	logger.entering(sourceClass, "getStepExecutions", executionId);

	List<StepExecution> stepExecutions = new ArrayList<StepExecution>();

	IJobExecution jobEx = batchKernel.getJobExecution(executionId);
	if (jobEx == null){
		logger.fine("Job Execution: " + executionId + " not found");
		throw new NoSuchJobExecutionException("Job Execution: " + executionId + " not found");
	}
	if (isAuthorized(persistenceService.getJobInstanceIdByExecutionId(executionId))) {
		stepExecutions = persistenceService.getStepExecutionsForJobExecution(executionId);
	} else {
		logger.warning("getStepExecutions: The current user is not authorized to perform this operation");
		throw new JobSecurityException("The current user is not authorized to perform this operation");
	}

	logger.exiting(sourceClass, "getStepExecutions", stepExecutions);
	return stepExecutions;

}
 

import javax.batch.operations.NoSuchJobExecutionException; //导入依赖的package包/类
@Override
public SplitExecutionStatus execute() throws JobRestartException, JobStartException, JobExecutionAlreadyCompleteException, JobExecutionNotMostRecentException, NoSuchJobExecutionException {
	String sourceMethod = "execute";
	if (logger.isLoggable(Level.FINER)) {
		logger.entering(sourceClass, sourceMethod, "Root JobExecution Id = " + rootJobExecutionId);
	}

	// Build all sub jobs from partitioned step
	buildSubJobBatchWorkUnits();

	// kick off the threads
	executeWorkUnits();

	// Deal with the results.
	SplitExecutionStatus status = waitForCompletionAndAggregateStatus();

	if (logger.isLoggable(Level.FINER)) {
		logger.exiting(sourceClass, sourceMethod, status);
	}

	return status;
}
 

import javax.batch.operations.NoSuchJobExecutionException; //导入依赖的package包/类
public void startBatches() throws JobSecurityException, JobStartException, NoSuchJobExecutionException {
      JobOperator jobOperator = BatchRuntime.getJobOperator();

      logger.log(Level.INFO, "starting simple");
      Long executionId = jobOperator.start("simple", new Properties());
      JobExecution jobExecution = jobOperator.getJobExecution(executionId);

      logger.log(Level.INFO, "Started simple job with id {0}", jobExecution.getExecutionId());
      logger.log(Level.INFO, "Status simple {0}", jobExecution.getBatchStatus());

//      logger.log(Level.INFO, "starting chunk");
//      Long chunkExecutionId = jobOperator.start("chunk", new Properties());
//      JobExecution chunkJobExecution = jobOperator.getJobExecution(chunkExecutionId);
//
//      logger.log(Level.INFO, "Status chunk {0}", chunkJobExecution.getBatchStatus());
//      logger.log(Level.INFO, "Started chunk job with id {0}", chunkJobExecution.getExecutionId());
   }
 

import javax.batch.operations.NoSuchJobExecutionException; //导入依赖的package包/类
@Override
public Properties getParameters(final long executionId) throws NoSuchJobExecutionException {
    Connection conn = null;
    PreparedStatement statement = null;
    ResultSet rs = null;

    try {
        conn = getConnection();
        statement = conn.prepareStatement(dictionary.getFindJobExecutionJobProperties());
        statement.setLong(1, executionId);
        rs = statement.executeQuery();

        if (rs.next()) {
            final byte[] buf = rs.getBytes(dictionary.jobExecutionColumns(5));
            return PropertyHelper.stringToProperties(buf != null ? new String(buf) : null);
        }
        throw new NoSuchJobExecutionException("Did not find table entry for executionID =" + executionId);
    } catch (final SQLException e) {
        throw new PersistenceException(e);
    } finally {
        cleanupConnection(conn, rs, statement);
    }
}
 

import javax.batch.operations.NoSuchJobExecutionException; //导入依赖的package包/类
public long getJobInstanceIdByExecutionId(final long executionId) throws NoSuchJobExecutionException {
    Connection conn = null;
    PreparedStatement statement = null;
    ResultSet rs = null;

    try {
        conn = getConnection();
        statement = conn.prepareStatement(dictionary.getFindJobInstanceFromJobExecution());
        statement.setObject(1, executionId);
        rs = statement.executeQuery();
        if (!rs.next()) {
            throw new NoSuchJobExecutionException("Did not find job instance associated with executionID =" + executionId);
        }
        return rs.getLong(dictionary.jobExecutionColumns(8));
    } catch (final SQLException e) {
        throw new PersistenceException(e);
    } finally {
        cleanupConnection(conn, rs, statement);
    }
}
 

import javax.batch.operations.NoSuchJobExecutionException; //导入依赖的package包/类
@Override
public BatchFlowInSplitWorkUnit buildOnRestartFlowInSplitWorkUnit(final FlowInSplitBuilderConfig config, final JobContextImpl jc)
    throws JobRestartException, JobExecutionAlreadyCompleteException, JobExecutionNotMostRecentException {

    final JSLJob jobModel = config.getJobModel();
    final long execId = getMostRecentSubJobExecutionId(jobModel);
    final RuntimeFlowInSplitExecution jobExecution;
    try {
        jobExecution = JobExecutionHelper.restartFlowInSplit(servicesManager, execId, jobModel);
    } catch (final NoSuchJobExecutionException e) {
        throw new IllegalStateException("Caught NoSuchJobExecutionException but this is an internal JobExecution so this shouldn't have happened: execId =" + execId, e);
    }

    final BatchFlowInSplitWorkUnit batchWork = new BatchFlowInSplitWorkUnit(jobExecution, config, servicesManager);
    jobExecution.inheritJobContext(jc);
    registerCurrentInstanceAndExecution(jobExecution, batchWork.getController());
    return batchWork;
}
 

import javax.batch.operations.NoSuchJobExecutionException; //导入依赖的package包/类
@Override
public void abandon(final long executionId) throws NoSuchJobExecutionException, JobExecutionIsRunningException, JobSecurityException {
    final InternalJobExecution jobEx = persistenceManagerService.jobOperatorGetJobExecution(executionId);

    // if it is not in STARTED or STARTING state, mark it as ABANDONED
    BatchStatus status = jobEx.getBatchStatus();
    if (status == BatchStatus.STARTING ||  status == BatchStatus.STARTED) {
        throw new JobExecutionIsRunningException("Job Execution: " + executionId + " is still running");
    }

    // update table to reflect ABANDONED state
    persistenceManagerService.updateBatchStatusOnly(jobEx.getExecutionId(), BatchStatus.ABANDONED, new Timestamp(System.currentTimeMillis()));

    // Don't forget to update JOBSTATUS table
    statusManagerService.updateJobBatchStatus(jobEx.getInstanceId(), BatchStatus.ABANDONED);
}
 

import javax.batch.operations.NoSuchJobExecutionException; //导入依赖的package包/类
@Override
public List<Long> getRunningExecutions(final String jobName) throws NoSuchJobException, JobSecurityException {
    final List<Long> jobExecutions = new ArrayList<Long>();

    // get the jobexecution ids associated with this job name
    final Set<Long> executionIds = persistenceManagerService.jobOperatorGetRunningExecutions(jobName);

    if (executionIds.isEmpty()) {
        throw new NoSuchJobException("Job Name " + jobName + " not found");
    }

    // for every job instance id
    for (final long id : executionIds) {
        try {
            if (kernelService.isExecutionRunning(id)) {
                final InternalJobExecution jobEx = kernelService.getJobExecution(id);
                jobExecutions.add(jobEx.getExecutionId());
            }
        } catch (final NoSuchJobExecutionException e) {
            throw new IllegalStateException("Just found execution with id = " + id + " in table, but now seeing it as gone", e);
        }
    }
    return jobExecutions;
}
 

import javax.batch.operations.NoSuchJobExecutionException; //导入依赖的package包/类
private void batchMetrics(String batchId, HttpServletRequest req, HttpServletResponse resp) {
    Long executionId = extractExecutionId(batchId, resp);
    if (executionId == null) {
        return;
    }

    try {
        JobExecution jobExecution = jobOperator.getJobExecution(executionId);
        BatchStatus batchStatus = jobExecution.getBatchStatus();

        List<StepExecution> stepExecutions = jobOperator.getStepExecutions(executionId);
        reportSuccess(executionId, resp, batchStatus.name());
        reportMetricsCsv(resp, stepExecutions);
    } catch (NoSuchJobExecutionException noSuchJob) {
        reportFailure(executionId, resp, "NoSuchJob");
    } catch (Exception generalException) {
        StringBuilder msg = new StringBuilder("Failure in BatchExecution");
        appendExceptionMsg(msg, generalException);
        reportFailure(executionId, resp, msg.toString());
    }
}
 

import javax.batch.operations.NoSuchJobExecutionException; //导入依赖的package包/类
private void batchStop(String batchId, HttpServletRequest req, HttpServletResponse resp) {
    Long executionId = extractExecutionId(batchId, resp);
    if (executionId == null) {
        return;
    }

    try {
        jobOperator.stop(executionId);
        reportSuccess(executionId, resp, BatchStatus.STOPPING.toString());
    } catch (NoSuchJobExecutionException noSuchJob) {
        reportFailure(executionId, resp, "NoSuchJob");
    } catch (JobExecutionNotRunningException notRunningException) {
        reportFailure(executionId, resp, "JobExecutionNotRunning");
    } catch (Exception generalException) {
        StringBuilder msg = new StringBuilder("Failure in BatchExecution");
        appendExceptionMsg(msg, generalException);
        reportFailure(executionId, resp, msg.toString());
    }
}
 

import javax.batch.operations.NoSuchJobExecutionException; //导入依赖的package包/类
private void batchRestart(String batchId, HttpServletRequest req, HttpServletResponse resp) {
    Long executionId = extractExecutionId(batchId, resp);
    if (executionId == null) {
        return;
    }

    Properties jobProperties = extractJobProperties(req, resp);

    try {
        jobOperator.restart(executionId, jobProperties);
    } catch (NoSuchJobExecutionException noSuchJob) {
        reportFailure(executionId, resp, "NoSuchJob");
    } catch (JobExecutionAlreadyCompleteException alreadyCompleted) {
        reportFailure(executionId, resp, "NoSuchJob");
    } catch (Exception generalException) {
        StringBuilder msg = new StringBuilder("Failure in BatchExecution");
        appendExceptionMsg(msg, generalException);
        reportFailure(executionId, resp, msg.toString());
    }
}
 

import javax.batch.operations.NoSuchJobExecutionException; //导入依赖的package包/类
@Override
public long restart(String jobName, Integer executionId)
        throws BatchException {
    Properties restartParameters = getJobParameters(jobName);
    try {
        return jsrJobOperator.restart(executionId, restartParameters);
    } catch (NoSuchJobExecutionException e) {
        throw new BatchException(ApplicationErrors.BAD_REQUEST, e,
                e.getMessage());
    }

}
 

import javax.batch.operations.NoSuchJobExecutionException; //导入依赖的package包/类
@Override
public void abandon(long executionId)
		throws NoSuchJobExecutionException, JobExecutionIsRunningException, JobSecurityException {

	if (isAuthorized(persistenceService.getJobInstanceIdByExecutionId(executionId))) {
		IJobExecution jobEx = persistenceService.jobOperatorGetJobExecution(executionId);

		// if it is not in STARTED or STARTING state, mark it as ABANDONED
		List<BatchStatus> runningStatusesList = Arrays.asList(new BatchStatus[] {BatchStatus.STARTED, BatchStatus.STARTING});
		Set<BatchStatus> runningStatusesSet = Collections.unmodifiableSet(new HashSet<BatchStatus>(runningStatusesList));

		if (!runningStatusesSet.contains(jobEx.getBatchStatus())) {
			// update table to reflect ABANDONED state
			long time = System.currentTimeMillis();
			Timestamp timestamp = new Timestamp(time);
			persistenceService.updateBatchStatusOnly(jobEx.getExecutionId(), BatchStatus.ABANDONED, timestamp);
			logger.fine("Job Execution: " + executionId + " was abandoned");

			// Don't forget to update JOBSTATUS table
			_jobStatusManagerService.updateJobBatchStatus(jobEx.getInstanceId(), BatchStatus.ABANDONED);
		}
		else {
			logger.warning("Job Execution: " + executionId + " is still running");
			throw new JobExecutionIsRunningException("Job Execution: " + executionId + " is still running");
		}
	} else {
		throw new JobSecurityException("The current user is not authorized to perform this operation");
	}

}
 

import javax.batch.operations.NoSuchJobExecutionException; //导入依赖的package包/类
@Override
public IJobExecution getJobExecution(long executionId)
		throws NoSuchJobExecutionException, JobSecurityException {
	if (isAuthorized(persistenceService.getJobInstanceIdByExecutionId(executionId))) {
		return batchKernel.getJobExecution(executionId);
	} else {
		throw new JobSecurityException("The current user is not authorized to perform this operation");
	}
}
 

import javax.batch.operations.NoSuchJobExecutionException; //导入依赖的package包/类
@Override
public JobInstance getJobInstance(long executionId)
		throws NoSuchJobExecutionException, JobSecurityException {
	if (isAuthorized(persistenceService.getJobInstanceIdByExecutionId(executionId))) {
		return this.batchKernel.getJobInstance(executionId);
	} else {
		throw new JobSecurityException("The current user is not authorized to perform this operation");
	}
}
 

import javax.batch.operations.NoSuchJobExecutionException; //导入依赖的package包/类
@Override
public List<Long> getRunningExecutions(String jobName)
		throws NoSuchJobException, JobSecurityException {

	logger.entering(sourceClass, "getRunningExecutions", jobName);
	List<Long> jobExecutions = new ArrayList<Long>();

	// get the jobexecution ids associated with this job name
	Set<Long> executionIds = persistenceService.jobOperatorGetRunningExecutions(jobName);

	if (executionIds.size() > 0){
		// for every job instance id
		for (long id : executionIds){
			try {
				logger.finer("Examining executionId: " + id);
				if(isAuthorized(persistenceService.getJobInstanceIdByExecutionId(id))) {
					if (batchKernel.isExecutionRunning(id)) {
						IJobExecution jobEx = batchKernel.getJobExecution(id);
						jobExecutions.add(jobEx.getExecutionId());
					} else {
						logger.finer("Found executionId: " + id + " with a BatchStatus indicating running, but kernel doesn't currently have an entry for this execution in the kernel's in-memory map.");
					}
				} else {
					logger.finer("Don't have authorization for executionId: " + id);
				}
			} catch (NoSuchJobExecutionException e) {
				String errorMsg = "Just found execution with id = " + id + " in table, but now seeing it as gone";
				logger.severe(errorMsg);
				throw new IllegalStateException(errorMsg, e);
			}
		}
		// send the list of objs back to caller
		logger.exiting(sourceClass, "getRunningExecutions", jobExecutions);
		return jobExecutions;
	}
	else { 
		logger.fine("getRunningExecutions: Job Name " + jobName + " not found");
		throw new NoSuchJobException( "Job Name " + jobName + " not found");
	}
}