public async Task <ActionResult <CTaskStatus> > PostCTaskStatus(CTaskStatus cTaskStatus)
{
_context.CTaskStatus.Add(cTaskStatus);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetCTaskStatus", new { id = cTaskStatus.Id }, cTaskStatus));
}
}// -----------------------------------------
// # USER EXTEND
// Or you can just use a quick_run
public virtual void start()
{
status = CTaskStatus.start;
onStatus(CTaskStatus.start,this);
PROGRESS = 0; // Make sure you call this after pushing the "start" event
quick_run?.Invoke(this);
}// -----------------------------------------
public async Task <IActionResult> PutCTaskStatus(int id, CTaskStatus cTaskStatus)
{
if (id != cTaskStatus.Id)
{
return(BadRequest());
}
_context.Entry(cTaskStatus).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CTaskStatusExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
}// -----------------------------------------
// Call this from the extended class or a quickrun to indicate task completion
public void complete()
{
PROGRESS = 100;
status = CTaskStatus.complete;
onStatus(CTaskStatus.complete,this);
onComplete?.Invoke();
}// -----------------------------------------
}// -----------------------------------------
//-- Internal task status handler
private void _onTaskStatus(CTaskStatus s,CTask t)
{
// Pass this through
onTaskStatus(s,t);
switch (s)
{
case CTaskStatus.complete:
LOG.log("[CJOB] : Task Completed: {0} ",t);
taskData = t.dataSend;
TASKS_COMPLETE++;
TASKS_COMPLETION_PERCENT = (int)Math.Ceiling((100.0f / TASKS_TOTAL) * TASKS_COMPLETE);
TASK_LAST = t;
onJobStatus(CJobStatus.taskEnd,this);
killTask(t);
feedQueue();
break;
case CTaskStatus.fail:
// Fail the whole job
// FUTURE, make non-important tasks where the job won't fail?
LOG.log("[CJOB] : Error : Task Failed: {0}",t);
killTask(t);
fail(t.ERROR[0],t.ERROR[1]);
break;
case CTaskStatus.start:
TASK_LAST = t;
onJobStatus(CJobStatus.taskStart,this);
break;
}
}// -----------------------------------------
public void Do()
{
WorkerThreadID = Thread.CurrentThread.ManagedThreadId;
this.RealStartTime = DateTime.Now;
Status = CTaskStatus.Running;
CTaskStatus _tmpStatus = Status;
try
{
_result = Action();
_tmpStatus = CTaskStatus.RanToCompletion;
}
catch (Exception ex)
{
_tmpStatus = CTaskStatus.Faulted;
this.IsFaulted = true;
this.Exception = ex;
}
finally
{
IsCompleted = true;
EndTime = DateTime.Now;
Status = _tmpStatus;
}
}
public void Do()
{
this.WorkerThreadID = Thread.CurrentThread.ManagedThreadId;
this.RealStartTime = DateTime.Now;
this.Status = CTaskStatus.Running;
CTaskStatus ranToCompletion = this.Status;
try
{
this._result = this.Action();
ranToCompletion = CTaskStatus.RanToCompletion;
}
catch (System.Exception exception)
{
ranToCompletion = CTaskStatus.Faulted;
this.IsFaulted = true;
this.Exception = exception;
}
finally
{
this.IsCompleted = true;
this.EndTime = DateTime.Now;
this.Status = ranToCompletion;
}
}
public bool IsCanDo(int timeout)
{
if (IsCompleted || IsCanceled)
{
return(false);
}
else if (timeout > 0)
{
if (timeout > ExeuteMilliseconds)
{
return(true);
}
else
{
this.Status = CTaskStatus.Timeout;
this.IsCanceled = true;
this.EndTime = DateTime.Now;
return(false);
}
}
else
{
return(true);
}
}
}// -----------------------------------------
// # USER EXTEND
// Or you can just use a quick_run
public virtual void start()
{
status = CTaskStatus.start;
onStatus(CTaskStatus.start,this);
PROGRESS = 0;
quick_run?.Invoke(this);
}// -----------------------------------------
/// <summary>
/// Create a Task for use in a CJob manager
/// </summary>
/// <param name="Qrun">If you want to create a quick task without extending it</param>
/// <param name="Name">Optional task name, used for logging</param>
/// <param name="extraData">Optional extra data</param>
public CTask(Action <CTask> Qrun = null,string Name = null,bool unknown = false)
{
uid = ++UID;
name = Name ?? string.Format("task_{0}",uid);
desc = "";
quick_run = Qrun;
status = CTaskStatus.waiting;
PROGRESS_UNKNOWN = unknown;
}// -----------------------------------------
/// <summary>
/// Create a Task for use in a CJob manager
/// </summary>
/// <param name="Qrun">If you want to create a quick task without extending it</param>
/// <param name="Name">Optional task name, used for logging</param>
public CTask(Action <CTask> Qrun = null,string Name = null)
{
uid = ++UID;
name = Name ?? string.Format("task_{0}",uid);
desc = "";
quick_run = Qrun;
status = CTaskStatus.waiting;
if (name.StartsWith("-")) // NO PROGRESS
{
FLAG_PROGRESS_DISABLE = true;
name = name.Substring(1);
}
}// -----------------------------------------
}// -----------------------------------------
//-- Internal task status handler
private void _onTaskStatus(CTaskStatus s,CTask t)
{
// Pass this through
onTaskStatus(s,t);
switch (s)
{
case CTaskStatus.complete:
LOG.log("[CJOB]: Task Completed: {0} ",t);
taskData = t.dataSend;
TASKS_COMPLETE++;
TASK_LAST = t;
onJobStatus(CJobStatus.taskEnd,this);
killTask(t);
feedQueue();
break;
// TODO: I could report the progress on a timer
// This is not ideal if there are many tasks running at once (CPU wise)
// NOTE: Will not get called from FLAG_NO_PROGRESS tasks
case CTaskStatus.progress:
slots_progress[t.SLOT] = t.PROGRESS;
// LOG.log("Task:{0}, slot:{2} progress:{1}",t.name,t.PROGRESS,t.SLOT);
calculateProgress();
onJobStatus(CJobStatus.progress,this);
break;
case CTaskStatus.fail:
// Fail the whole job
LOG.log("[CJOB]: Error : Task Failed: {0}",t);
killTask(t);
fail(t.ERROR[0],t.ERROR[1]);
break;
case CTaskStatus.start:
TASK_LAST = t;
onJobStatus(CJobStatus.taskStart,this);
break;
}
}// -----------------------------------------
internal StatusChangeEventArgs(CTaskStatus status)
{
this._status = status;
}
