WorkflowOperationInstance.java
/*
* Licensed to The Apereo Foundation under one or more contributor license
* agreements. See the NOTICE file distributed with this work for additional
* information regarding copyright ownership.
*
*
* The Apereo Foundation licenses this file to you under the Educational
* Community 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:
*
* http://opensource.org/licenses/ecl2.txt
*
* 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.opencastproject.workflow.api;
import java.util.Collections;
import java.util.Date;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.TreeMap;
import javax.persistence.Access;
import javax.persistence.AccessType;
import javax.persistence.CollectionTable;
import javax.persistence.Column;
import javax.persistence.ElementCollection;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Index;
import javax.persistence.JoinColumn;
import javax.persistence.Lob;
import javax.persistence.ManyToOne;
import javax.persistence.MapKeyColumn;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
/**
* A workflow operation belonging to a workflow instance.
*/
@Entity(name = "WorkflowOperationInstance")
@Access(AccessType.FIELD)
@Table(name = "oc_workflow_operation", indexes = {
@Index(name = "IX_oc_workflow_operation_workflow_id", columnList = ("workflow_id"))})
public class WorkflowOperationInstance implements Configurable {
public enum OperationState {
INSTANTIATED, RUNNING, PAUSED, SUCCEEDED, FAILED, SKIPPED, RETRY
}
@Id
@GeneratedValue
@Column(name = "id")
private Long id;
@Column(name = "template")
protected String template;
@Column(name = "job")
protected Long jobId;
@Column(name = "state")
protected OperationState state;
@Column(name = "description")
@Lob
protected String description;
@ElementCollection
@CollectionTable(
name = "oc_workflow_operation_configuration",
joinColumns = @JoinColumn(name = "workflow_operation_id"),
indexes = {
@Index(name = "IX_oc_workflow_operation_configuration_workflow_operation_id",
columnList = ("workflow_operation_id")),
}
)
@MapKeyColumn(name = "configuration_key", nullable = false)
@Lob
@Column(name = "configuration_value")
protected Map<String, String> configurations;
@Column(name = "fail_on_error")
protected boolean failOnError;
@Column(name = "if_condition")
@Lob
protected String executeCondition;
@Column(name = "exception_handler_workflow")
protected String exceptionHandlingWorkflow;
@Column(name = "abortable")
protected Boolean abortable;
@Column(name = "continuable")
protected Boolean continuable;
@Column(name = "started")
@Temporal(TemporalType.TIMESTAMP)
protected Date dateStarted;
@Column(name = "completed")
@Temporal(TemporalType.TIMESTAMP)
protected Date dateCompleted;
@Column(name = "time_in_queue")
protected Long timeInQueue;
@Column(name = "max_attempts")
protected int maxAttempts;
@Column(name = "failed_attempts")
protected int failedAttempts;
@Column(name = "execution_host")
protected String executionHost;
@Column(name = "retry_strategy", length = 128)
protected RetryStrategy retryStrategy;
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "workflow_id", nullable = false)
private WorkflowInstance instance;
/**
* No-arg constructor needed for JAXB serialization
*/
public WorkflowOperationInstance() {
this.maxAttempts = 1;
this.retryStrategy = RetryStrategy.NONE;
}
/**
* Builds a new workflow operation instance based on another workflow operation.
*
* @param def
* the workflow definition
*/
public WorkflowOperationInstance(WorkflowOperationDefinition def) {
this();
setTemplate(def.getId());
setState(OperationState.INSTANTIATED);
setDescription(def.getDescription());
setMaxAttempts(def.getMaxAttempts());
setFailOnError(def.isFailWorkflowOnException());
setExceptionHandlingWorkflow(def.getExceptionHandlingWorkflow());
setExecutionCondition(def.getExecutionCondition());
setRetryStrategy(def.getRetryStrategy());
Set<String> defConfigs = def.getConfigurationKeys();
this.configurations = new TreeMap<>();
if (defConfigs != null) {
for (String key : defConfigs) {
configurations.put(key, def.getConfiguration(key));
}
}
if ((retryStrategy == RetryStrategy.RETRY || retryStrategy == RetryStrategy.HOLD) && maxAttempts < 2) {
maxAttempts = 2;
}
}
/**
* Constructs a new operation instance with the given id and initial state.
*
* @param id
* the operation id
* @param state
* the state
*/
public WorkflowOperationInstance(String id, OperationState state) {
this();
setTemplate(id);
setState(state);
}
public WorkflowOperationInstance(
String template,
Long jobId,
OperationState state,
String description,
Map<String, String> configurations,
boolean failOnError,
String executeCondition,
String exceptionHandlingWorkflow,
Boolean abortable,
Boolean continuable,
Date dateStarted,
Date dateCompleted,
Long timeInQueue,
int maxAttempts,
int failedAttempts,
String executionHost,
RetryStrategy retryStrategy) {
this.template = template;
this.jobId = jobId;
this.state = state;
this.description = description;
this.configurations = configurations;
this.failOnError = failOnError;
this.executeCondition = executeCondition;
this.exceptionHandlingWorkflow = exceptionHandlingWorkflow;
this.abortable = abortable;
this.continuable = continuable;
this.dateStarted = dateStarted;
this.dateCompleted = dateCompleted;
this.timeInQueue = timeInQueue;
this.maxAttempts = maxAttempts;
this.failedAttempts = failedAttempts;
this.executionHost = executionHost;
this.retryStrategy = retryStrategy;
}
/**
* Sets the template
*
* @param template
* the template
*/
public void setTemplate(String template) {
this.template = template;
}
/**
* Gets the operation type.
*
* @return the operation type
*/
public String getTemplate() {
return template;
}
/**
* Gets the unique identifier for this operation, or null.
*
* @return the identifier, or null if this operation has not yet run
*/
public Long getId() {
return jobId;
}
/**
* Sets the unique identifier for this operation.
*
* @param jobId
* the identifier
*/
public void setId(Long jobId) {
this.jobId = jobId;
}
/**
* Gets the operation description
*
* @return the description
*/
public String getDescription() {
return description;
}
/**
* Set the operation description.
*
* @param description The new description
*/
public void setDescription(String description) {
this.description = description;
}
/**
* The state of this operation.
*/
public OperationState getState() {
return state;
}
/**
* Sets the state of this operation
*
* @param state
* the state to set
*/
public void setState(OperationState state) {
Date now = new Date();
if (OperationState.RUNNING.equals(state)) {
this.dateStarted = now;
} else if (OperationState.FAILED.equals(state) || OperationState.SUCCEEDED.equals(state)) {
this.dateCompleted = now;
}
this.state = state;
}
/**
* Return configuration of this workflow operation as Map.
* Guaranteed to be not null
*
* @return Configuration map
*/
public Map<String, String> getConfigurations() {
return configurations;
}
/**
* {@inheritDoc}
*
* @see org.opencastproject.workflow.api.WorkflowInstance#getConfiguration(java.lang.String)
*/
@Override
public String getConfiguration(String key) {
if (key == null || configurations == null) {
return null;
}
return configurations.get(key);
}
/**
* {@inheritDoc}
*
* @see org.opencastproject.workflow.api.WorkflowInstance#removeConfiguration(java.lang.String)
*/
@Override
public void removeConfiguration(String key) {
if (key == null || configurations == null) {
return;
}
configurations.remove(key);
}
/**
* {@inheritDoc}
*
* @see org.opencastproject.workflow.api.WorkflowInstance#setConfiguration(java.lang.String, java.lang.String)
*/
@Override
public void setConfiguration(String key, String value) {
if (key == null) {
return;
}
if (configurations == null) {
configurations = new TreeMap<>();
}
configurations.put(key, value);
}
/**
* {@inheritDoc}
*
* @see org.opencastproject.workflow.api.WorkflowOperationInstance#getConfigurationKeys()
*/
@Override
public Set<String> getConfigurationKeys() {
if (configurations == null) {
return Collections.emptySet();
}
return configurations.keySet();
}
/** The workflow to run if an exception is thrown while this operation is running. */
public String getExceptionHandlingWorkflow() {
return exceptionHandlingWorkflow;
}
public void setExceptionHandlingWorkflow(String exceptionHandlingWorkflow) {
this.exceptionHandlingWorkflow = exceptionHandlingWorkflow;
}
/**
* If true, this workflow will be put into a failed (or failing, if getExceptionHandlingWorkflow() is not null) state
* when exceptions are thrown during an operation.
*/
public boolean isFailOnError() {
return failOnError;
}
public void setFailOnError(boolean failOnError) {
this.failOnError = failOnError;
}
/**
* The timestamp this operation started. If the job was queued, this can be significantly later than the date created.
*/
public Date getDateStarted() {
return dateStarted;
}
/** The number of milliseconds this operation waited in a service queue */
public Long getTimeInQueue() {
return timeInQueue;
}
public void setTimeInQueue(long timeInQueue) {
this.timeInQueue = timeInQueue;
}
/** The timestamp this operation completed */
public Date getDateCompleted() {
return dateCompleted;
}
/**
* Returns either <code>null</code> or <code>true</code> to have the operation executed. Any other value is
* interpreted as <code>false</code> and will skip the operation.
* <p>
* Usually, this will be a variable name such as <code>${foo}</code>, which will be replaced with its acutal value
* once the workflow is executed.
* <p>
* If both <code>getExecuteCondition()</code> and <code>getSkipCondition</code> return a non-null value, the execute
* condition takes precedence.
*
* @return the execution condition.
*/
public String getExecutionCondition() {
return executeCondition;
}
public void setExecutionCondition(String condition) {
this.executeCondition = condition;
}
/**
* Returns <code>true</code> if this operation can be continued by the user from an optional hold state. A return
* value of <code>null</code> indicates that this operation instance does not have a hold state.
*
* @return <code>true</code> if this operation instance is continuable
*/
public Boolean isContinuable() {
return continuable;
}
/**
* Defines whether this operation instance should be continuable from a hold state or whether it is resumed
* automatically.
*
* @param continuable
* <code>true</code> to allow the user to resume the operation
*/
public void setContinuable(Boolean continuable) {
this.continuable = continuable;
}
/**
* Returns <code>true</code> if this operation can be aborted by the user from an optional hold state. If a resumable
* operation is aborted from its hold state, the workflow is put into
* {@link org.opencastproject.workflow.api.WorkflowInstance.WorkflowState#STOPPED}. A return value of
* <code>null</code> indicates that this operation instance does not have a hold state.
*
* @return <code>true</code> if this operation instance is abortable
*/
public Boolean isAbortable() {
return abortable;
}
/**
* Defines whether this operation instance should be abortable from a hold state.
*
* @param abortable
* <code>true</code> to allow the user to cancel the operation
*/
public void setAbortable(Boolean abortable) {
this.abortable = abortable;
}
/**
* Return the strategy to use in case of operation failure
*
* @return a strategy from {@link org.opencastproject.workflow.api.RetryStrategy}.
*/
public RetryStrategy getRetryStrategy() {
return retryStrategy;
}
private void setRetryStrategy(RetryStrategy retryStrategy) {
this.retryStrategy = retryStrategy;
}
/**
* Returns the number of attempts the workflow service will make to execute this operation.
*
* @return the maximum number of retries before failing
*/
public int getMaxAttempts() {
return maxAttempts;
}
/**
* @param maxAttempts
* the maxAttempts to set
* @throws IllegalArgumentException
* if maxAttempts is less than one.
*/
private void setMaxAttempts(int maxAttempts) {
if (maxAttempts < 1) {
throw new IllegalArgumentException("maxAttempts must be >=1");
}
this.maxAttempts = maxAttempts;
}
/**
* Returns the number of failed executions that have previously been attempted.
*
* @return the number of previous attempts
*/
public int getFailedAttempts() {
return failedAttempts;
}
public void setFailedAttempts(int failedAttempts) {
this.failedAttempts = failedAttempts;
}
/**
* Returns the current execution host
*
* @return the execution host
*/
public String getExecutionHost() {
return executionHost;
}
/**
* Sets the current execution host
*
* @param executionHost
* the execution host
*/
public void setExecutionHost(String executionHost) {
this.executionHost = executionHost;
}
public WorkflowInstance getWorkflowInstance() {
return instance;
}
public void setWorkflowInstance(WorkflowInstance instance) {
this.instance = instance;
}
@Override
public int hashCode() {
return Long.valueOf(id).hashCode();
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o instanceof WorkflowOperationInstance) {
WorkflowOperationInstance other = (WorkflowOperationInstance) o;
return other.getTemplate().equals(this.getTemplate()) && Objects.equals(other.id, this.id);
}
return false;
}
/**
* {@inheritDoc}
*
* @see java.lang.Object#toString()
*/
@Override
public String toString() {
return "operation:'" + template + ", state:'" + this.state + "'";
}
}