|
|
package org.openslx.taskmanager.api;
import java.util.UUID;
import org.apache.log4j.Logger;
import org.openslx.taskmanager.api.TaskStatus.StatusCode;
import com.google.gson.annotations.Expose;
public abstract class AbstractTask implements Runnable
{
private static final long RELEASE_DELAY = 10l * 60l * 1000l;
private static final Logger LOG = Logger.getLogger( AbstractTask.class );
/*
* To be set from task invocation (json data)
*/
/**
* The id of the task instance.
*/
@Expose
private volatile String id = null;
/**
* Parent task. This task won't be started as long as the parent task currently
* waiting for execution or is being executed. Otherwise this task is available for execution.
* Note that MAX_INSTANCES is still being taken into account. Set to null to ignore.
*/
@Expose
private volatile String parentTask = null;
/**
* If the parent task failed to execute, don't run this task and fail immediately.
*/
@Expose
private volatile boolean failOnParentFail = true;
/*
* Variables we're working with - these should never be set from incoming (json) data
*/
/**
* Maximum age of a task, if it's not freed explicitly.
*/
private static final long MAX_TASK_AGE = 24l * 3600l * 1000l;
/**
* timeMillis when this task will be removed. This will be set automatically to something
* reasonable like 24 hours, once the job has finished. This is to prevent clogging the task
* manager with finished jobs over time. Note that you can explicitly remove a job using the
* "release" command.
*/
private volatile long removalDeadline = System.currentTimeMillis() + MAX_TASK_AGE;
/**
* True if init() has been called. Task will not start if this is false.
*/
private volatile boolean initDone = false;
/**
* Status of Task
*/
private volatile TaskStatus status = TaskStatus.ts_waiting;
/**
* Reference to parent task
*/
private volatile AbstractTask parent = null;
/**
* Reference to "owner" so we can tell it to check for more
* work when we're done.
*/
private volatile FinishCallback finishCallback = null;
/**
* Set to true as soon as we try to start this task using the thread pool executor.
*/
private volatile boolean triedToStart = false;
/**
* Default constructor which should not be overridden
*/
public AbstractTask()
{
this.id = UUID.randomUUID().toString();
}
/*
* Overridable methods
*/
/**
* Initialize the task; method used by the {@link Taskmanager}.
* Put your own initialization code in initTask()
*/
public final boolean init( AbstractTask parent, FinishCallback finishCallback )
{
if ( this.initDone ) {
LOG.fatal( "init() called twice on " + this.getClass().getSimpleName() );
System.exit( 1 );
}
if ( this.parentTask != null && this.parentTask.isEmpty() )
this.parentTask = null;
if ( this.parentTask != null && parent == null ) {
if ( this.failOnParentFail ) {
this.status = new TaskStatus( StatusCode.PARENT_FAILED, this.id );
return false;
}
this.parentTask = null;
}
if ( this.parentTask == null && parent != null )
parent = null;
this.finishCallback = finishCallback;
this.parent = parent;
this.status = new TaskStatus( StatusCode.TASK_WAITING, this.id );
this.initDone = true;
boolean ret;
try {
ret = this.initTask();
} catch ( Throwable t ) {
ret = false;
}
if ( !ret ) {
this.status.statusCode = StatusCode.TASK_ERROR;
}
return ret;
}
/**
* Your own initialization code. This is run synchronously within the network
* handling thread, so do NOT put anything here that might take longer than a few milliseconds!
* You should usually only validate the input to the task here, and return false if it is
* invalid.
*
* @return - true if the task should be executed by the scheduler (ie init was successful)
* - false if init was not successful, or you don't need to do any more processing
*/
protected abstract boolean initTask();
/**
* This is where you put your huge work stuff that takes ages.
*/
protected abstract boolean execute();
/**
* This is called when a client requests the status of this task. In case you
* want to return complex structures like Lists, which are not thread safe, you
* might want to keep that list outside the status class you return, and only
* create a copy of it for the status class in this function.
* If you only return more or less atomic data, you don't need to override
* this function
*/
protected void updateStatus()
{
}
/*
* Final methods
*/
/**
* Get id of parent task.
*
* @return id of parent task, null if no parent set
*
*/
public final String getParentTaskId()
{
return this.parentTask;
}
/**
* Set the custom status data object to be returned on status requests.
* For simple tasks it should be sufficient to set this once before executing
* the task starts, and then just update fields in that class while the
* task is running. For cases where you have complicated data structures or
* multiple values that need to stay in sync you could create a new instance
* every time, fill it with values, and then call this method.
*
* @param obj the object containing you specific task data
*/
protected final void setStatusObject( Object obj )
{
status.setStatusObject( obj );
}
/**
* Get current status of task.
*/
public final TaskStatus getStatus()
{
if ( this.initDone && this.parent != null ) {
final StatusCode parentStatus = parent.getStatusCode();
switch ( parentStatus ) {
case DUPLICATE_ID:
case NO_SUCH_INSTANCE:
case NO_SUCH_TASK:
case NO_SUCH_CONSTRUCTOR:
case PARENT_FAILED:
case TASK_ERROR:
if ( this.failOnParentFail ) {
this.status.statusCode = StatusCode.PARENT_FAILED;
LOG.debug( "Parent " + this.parentTask + " of " + this.id + " failed." );
}
this.parentTask = null;
break;
default:
break;
}
}
return this.status;
}
/**
* Get status code if task.
*
* @return
*/
public final StatusCode getStatusCode()
{
return getStatus().getStatusCode();
}
/**
* Get id of task
*/
public final String getId()
{
return this.id;
}
/**
* Getter for failOnParentTask
*/
public final boolean getFailOnParentFail()
{
return this.failOnParentFail;
}
/**
* Release the task: If the task is still pending/running, it will be removed from the task
* manager as soon as it finishes. So you can't query for its result later. If the task has
* already finished (either successful or failed), it will be removed (almost) immediately.
*/
public final void release()
{
this.removalDeadline = Math.min( this.removalDeadline, System.currentTimeMillis() + RELEASE_DELAY );
}
/**
* Can this task be started? This checks all the conditions:
* - Has this task been initialized yet?
* - Is it actually waiting for execution?
* - Does it depend on a parent task?
* -- If so, did the parent finish?
* -- Or did it fail?
* --- If so, should this task only run if it didn't fail?
*
* @return true iff this task can be started
*/
public final boolean canStart()
{
if ( this.triedToStart || !this.initDone || this.id == null || this.getStatus().getStatusCode() != StatusCode.TASK_WAITING ) {
return false;
}
if ( this.parent == null )
return true;
return parent.getStatusCode() != StatusCode.TASK_WAITING && parent.getStatusCode() != StatusCode.TASK_PROCESSING;
}
/**
* Mark this task as being started to prevent a race condition where
* the task would be submitted to the thread pool more than once.
*/
public final void markAsStarting()
{
this.triedToStart = true;
}
/**
* Checks whether this task can be removed from the task manager.
* A task can be removed if it is not executing or waiting for execution, and
* its removal deadline has been reached.
*
* @return true if it can be released
*/
public final boolean canBeReleased()
{
if ( this.status.statusCode == StatusCode.TASK_WAITING || this.status.statusCode == StatusCode.TASK_PROCESSING )
return false;
return this.removalDeadline != 0 && System.currentTimeMillis() > this.removalDeadline;
}
/**
* Check whether the given task is finished, i.e. either failed or succeeded,
* or couldn't be started because its parent failed,
* but is not running or still waiting for execution.
*
* @return true if task finished running or was not able to start
*/
public final boolean isFinished()
{
StatusCode sc = getStatusCode();
return sc != StatusCode.TASK_WAITING && sc != StatusCode.TASK_PROCESSING;
}
/**
* Execute the task, wrapped in some sanity checks.
*/
@Override
public final void run()
{
synchronized ( this ) {
if ( this.status.statusCode != StatusCode.TASK_WAITING )
throw new RuntimeException( "Tried to launch task " + this.getClass().getSimpleName() + " twice!" );
if ( !this.initDone )
throw new RuntimeException( "Tried to launch " + this.getClass().getSimpleName() + " without initializing it!" );
this.status.statusCode = StatusCode.TASK_PROCESSING;
}
boolean ret;
try {
ret = execute();
} catch ( Throwable t ) {
LOG.warn( "Task " + this.getClass().getSimpleName() + " failed with uncaught exception", t );
ret = false;
}
if ( ret ) {
this.status.statusCode = StatusCode.TASK_FINISHED;
} else if ( this.status.statusCode == StatusCode.TASK_CANCELLING ) {
this.status.statusCode = StatusCode.TASK_CANCELLED;
} else {
this.status.statusCode = StatusCode.TASK_ERROR;
}
LOG.debug( "Finished task " + this.getClass().getSimpleName() + ": " + this.status.statusCode.toString() + " (" + this.id + ")" );
if ( this.finishCallback != null )
this.finishCallback.taskFinished();
}
}
|
