Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* Copyright 2006-2020 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.batch.core;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.CopyOnWriteArrayList;
import org.springframework.batch.item.ExecutionContext;
import org.springframework.lang.Nullable;
/**
* Batch domain object representing the execution of a job.
*
* @author Lucas Ward
* @author Michael Minella
* @author Mahmoud Ben Hassine
* @author Dimitrios Liapis
*
*/
@SuppressWarnings("serial")
public class JobExecution extends Entity {
private final JobParameters jobParameters;
private JobInstance jobInstance;
private volatile Collection stepExecutions = Collections.synchronizedSet(new LinkedHashSet<>());
private volatile BatchStatus status = BatchStatus.STARTING;
private volatile Date startTime = null;
private volatile Date createTime = new Date(System.currentTimeMillis());
private volatile Date endTime = null;
private volatile Date lastUpdated = null;
private volatile ExitStatus exitStatus = ExitStatus.UNKNOWN;
private volatile ExecutionContext executionContext = new ExecutionContext();
private transient volatile List failureExceptions = new CopyOnWriteArrayList<>();
private final String jobConfigurationName;
public JobExecution(JobExecution original) {
this.jobParameters = original.getJobParameters();
this.jobInstance = original.getJobInstance();
this.stepExecutions = original.getStepExecutions();
this.status = original.getStatus();
this.startTime = original.getStartTime();
this.createTime = original.getCreateTime();
this.endTime = original.getEndTime();
this.lastUpdated = original.getLastUpdated();
this.exitStatus = original.getExitStatus();
this.executionContext = original.getExecutionContext();
this.failureExceptions = original.getFailureExceptions();
this.jobConfigurationName = original.getJobConfigurationName();
this.setId(original.getId());
this.setVersion(original.getVersion());
}
/**
* Because a JobExecution isn't valid unless the job is set, this
* constructor is the only valid one from a modeling point of view.
*
* @param job the job of which this execution is a part
* @param id {@link Long} that represents the id for the JobExecution.
* @param jobParameters {@link JobParameters} instance for this JobExecution.
* @param jobConfigurationName {@link String} instance that represents the
* job configuration name (used with JSR-352).
*/
public JobExecution(JobInstance job, Long id, @Nullable JobParameters jobParameters, String jobConfigurationName) {
super(id);
this.jobInstance = job;
this.jobParameters = jobParameters == null ? new JobParameters() : jobParameters;
this.jobConfigurationName = jobConfigurationName;
}
public JobExecution(JobInstance job, JobParameters jobParameters, String jobConfigurationName) {
this(job, null, jobParameters, jobConfigurationName);
}
public JobExecution(Long id, JobParameters jobParameters, String jobConfigurationName) {
this(null, id, jobParameters, jobConfigurationName);
}
/**
* Constructor for transient (unsaved) instances.
*
* @param job the enclosing {@link JobInstance}
* @param jobParameters {@link JobParameters} instance for this JobExecution.
*/
public JobExecution(JobInstance job, JobParameters jobParameters) {
this(job, null, jobParameters, null);
}
public JobExecution(Long id, JobParameters jobParameters) {
this(null, id, jobParameters, null);
}
public JobExecution(Long id) {
this(null, id, null, null);
}
public JobParameters getJobParameters() {
return this.jobParameters;
}
public Date getEndTime() {
return endTime;
}
public void setJobInstance(JobInstance jobInstance) {
this.jobInstance = jobInstance;
}
public void setEndTime(Date endTime) {
this.endTime = endTime;
}
public Date getStartTime() {
return startTime;
}
public void setStartTime(Date startTime) {
this.startTime = startTime;
}
public BatchStatus getStatus() {
return status;
}
/**
* Set the value of the status field.
*
* @param status the status to set
*/
public void setStatus(BatchStatus status) {
this.status = status;
}
/**
* Upgrade the status field if the provided value is greater than the
* existing one. Clients using this method to set the status can be sure
* that they don't overwrite a failed status with an successful one.
*
* @param status the new status value
*/
public void upgradeStatus(BatchStatus status) {
this.status = this.status.upgradeTo(status);
}
/**
* Convenience getter for for the id of the enclosing job. Useful for DAO
* implementations.
*
* @return the id of the enclosing job
*/
public Long getJobId() {
if (jobInstance != null) {
return jobInstance.getId();
}
return null;
}
/**
* @param exitStatus {@link ExitStatus} instance to be used for job execution.
*/
public void setExitStatus(ExitStatus exitStatus) {
this.exitStatus = exitStatus;
}
/**
* @return the exitCode
*/
public ExitStatus getExitStatus() {
return exitStatus;
}
/**
* @return the Job that is executing.
*/
public JobInstance getJobInstance() {
return jobInstance;
}
/**
* Accessor for the step executions.
*
* @return the step executions that were registered
*/
public Collection getStepExecutions() {
return Collections.unmodifiableList(new ArrayList<>(stepExecutions));
}
/**
* Register a step execution with the current job execution.
* @param stepName the name of the step the new execution is associated with
* @return {@link StepExecution} an empty {@code StepExecution} associated with this
* {@code JobExecution}.
*/
public StepExecution createStepExecution(String stepName) {
StepExecution stepExecution = new StepExecution(stepName, this);
this.stepExecutions.add(stepExecution);
return stepExecution;
}
/**
* Test if this {@link JobExecution} indicates that it is running. It should
* be noted that this does not necessarily mean that it has been persisted
* as such yet.
*
* @return true if the end time is null and the start time is not null
*/
public boolean isRunning() {
return startTime != null && endTime == null;
}
/**
* Test if this {@link JobExecution} indicates that it has been signalled to
* stop.
* @return true if the status is {@link BatchStatus#STOPPING}
*/
public boolean isStopping() {
return status == BatchStatus.STOPPING;
}
/**
* Signal the {@link JobExecution} to stop. Iterates through the associated
* {@link StepExecution}s, calling {@link StepExecution#setTerminateOnly()}.
*
* @deprecated Use {@link org.springframework.batch.core.launch.JobOperator#stop(long)}
* or {@link org.springframework.batch.core.launch.support.CommandLineJobRunner}
* with the "-stop" option instead.
*/
@Deprecated
public void stop() {
for (StepExecution stepExecution : stepExecutions) {
stepExecution.setTerminateOnly();
}
status = BatchStatus.STOPPING;
}
/**
* Sets the {@link ExecutionContext} for this execution
*
* @param executionContext the context
*/
public void setExecutionContext(ExecutionContext executionContext) {
this.executionContext = executionContext;
}
/**
* Returns the {@link ExecutionContext} for this execution. The content is
* expected to be persisted after each step completion (successful or not).
*
* @return the context
*/
public ExecutionContext getExecutionContext() {
return executionContext;
}
/**
* @return the time when this execution was created.
*/
public Date getCreateTime() {
return createTime;
}
/**
* @param createTime creation time of this execution.
*/
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
public String getJobConfigurationName() {
return this.jobConfigurationName;
}
/**
* Package private method for re-constituting the step executions from
* existing instances.
* @param stepExecution execution to be added
*/
void addStepExecution(StepExecution stepExecution) {
stepExecutions.add(stepExecution);
}
/**
* Get the date representing the last time this JobExecution was updated in
* the JobRepository.
*
* @return Date representing the last time this JobExecution was updated.
*/
public Date getLastUpdated() {
return lastUpdated;
}
/**
* Set the last time this JobExecution was updated.
*
* @param lastUpdated {@link Date} instance to mark job execution's lastUpdated attribute.
*/
public void setLastUpdated(Date lastUpdated) {
this.lastUpdated = lastUpdated;
}
public List getFailureExceptions() {
return failureExceptions;
}
/**
* Add the provided throwable to the failure exception list.
*
* @param t {@link Throwable} instance to be added failure exception list.
*/
public synchronized void addFailureException(Throwable t) {
this.failureExceptions.add(t);
}
/**
* Return all failure causing exceptions for this JobExecution, including
* step executions.
*
* @return List<Throwable> containing all exceptions causing failure for
* this JobExecution.
*/
public synchronized List getAllFailureExceptions() {
Set allExceptions = new HashSet<>(failureExceptions);
for (StepExecution stepExecution : stepExecutions) {
allExceptions.addAll(stepExecution.getFailureExceptions());
}
return new ArrayList<>(allExceptions);
}
/**
* Deserialize and ensure transient fields are re-instantiated when read
* back.
*
* @param stream instance of {@link ObjectInputStream}.
*
* @throws IOException thrown if error occurs during read.
* @throws ClassNotFoundException thrown if class is not found.
*/
private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException {
stream.defaultReadObject();
failureExceptions = new ArrayList<>();
}
/*
* (non-Javadoc)
*
* @see org.springframework.batch.core.domain.Entity#toString()
*/
@Override
public String toString() {
return super.toString()
+ String.format(", startTime=%s, endTime=%s, lastUpdated=%s, status=%s, exitStatus=%s, job=[%s], jobParameters=[%s]",
startTime, endTime, lastUpdated, status, exitStatus, jobInstance, jobParameters);
}
/**
* Add some step executions. For internal use only.
* @param stepExecutions step executions to add to the current list
*/
public void addStepExecutions(List stepExecutions) {
if (stepExecutions!=null) {
this.stepExecutions.removeAll(stepExecutions);
this.stepExecutions.addAll(stepExecutions);
}
}
}
