private void ProcessTaskExecutionResult(MrsSystemTask systemTask)
{
this.executionTime += systemTask.ExecutionTime;
if (systemTask.Failure == null)
{
this.ProcessSucceededTask(systemTask.IgnoreTaskSuccessfulExecutionTime);
return;
}
using (SettingsContextBase.ActivateContext(this as ISettingsContextProvider))
{
bool flag;
this.ProcessFailedTask(systemTask.Failure, out flag);
if (!flag)
{
lock (this.jobLock)
{
MrsTracer.Service.Error("Job({0}) failed.", new object[]
{
base.GetType().Name
});
this.state = JobState.Failed;
this.jobDoneEvent.Set();
}
this.StartDeferredDelayIfApplicable();
}
}
}
protected override void CompleteTask(SystemTaskBase task)
{
MrsSystemTask mrsSystemTask = task as MrsSystemTask;
IJob job = mrsSystemTask.Job;
job.ProcessTaskExecutionResult(mrsSystemTask);
switch (job.State)
{
case JobState.Runnable:
lock (this.instanceLock)
{
lock (JobScheduler.staticLock)
{
this.runningJobs.Remove(job);
JobScheduler.RunnableJobs.Add(job);
}
}
return;
case JobState.Failed:
lock (this.instanceLock)
{
job.RevertToPreviousUnthrottledState();
this.runningJobs.Remove(job);
}
this.OnJobStateChanged(job, job.State);
return;
default:
return;
}
}
protected override SystemTaskBase GetTask(ResourceReservationContext context)
{
MrsSystemTask mrsSystemTask = null;
SystemTaskBase result;
lock (this.instanceLock)
{
lock (JobScheduler.staticLock)
{
if (JobScheduler.RunnableJobs.Count > 0)
{
List <IJob> list = new List <IJob>();
List <IJob> list2 = new List <IJob>();
foreach (IJob job in JobScheduler.RunnableJobs)
{
mrsSystemTask = job.GetTask(this, context);
if (mrsSystemTask != null)
{
break;
}
switch (job.State)
{
case JobState.Waiting:
list2.Add(job);
break;
case JobState.Finished:
list.Add(job);
break;
}
}
if (mrsSystemTask != null)
{
JobScheduler.RunnableJobs.Remove(mrsSystemTask.Job);
this.runningJobs.Add(mrsSystemTask.Job);
}
foreach (IJob job2 in list)
{
JobScheduler.RunnableJobs.Remove(job2);
job2.RevertToPreviousUnthrottledState();
this.OnJobStateChanged(job2, job2.State);
}
foreach (IJob item in list2)
{
JobScheduler.RunnableJobs.Remove(item);
this.waitingJobs.Add(item);
}
}
result = mrsSystemTask;
}
}
return(result);
}
private MrsSystemTask GetTask(SystemWorkloadBase systemWorkload, ResourceReservationContext context)
{
MrsTracer.ActivityID = this.traceActivityID;
base.CheckDisposed();
MrsSystemTask result;
using (SettingsContextBase.ActivateContext(this as ISettingsContextProvider))
{
lock (this.jobLock)
{
if (this.IsFinished)
{
MrsTracer.Service.Debug("Job({0}) is finished.", new object[]
{
base.GetType().Name
});
this.state = JobState.Finished;
this.jobDoneEvent.Set();
result = null;
}
else
{
WorkItem workItem = null;
bool flag2 = true;
foreach (WorkItem workItem2 in this.workItemQueue.GetCandidateWorkItems())
{
if (workItem2.ScheduledRunTime <= ExDateTime.UtcNow || CommonUtils.ServiceIsStopping)
{
flag2 = false;
if (this.GetWorkloadType(workItem2.WorkloadType) == systemWorkload.WorkloadType)
{
workItem = workItem2;
break;
}
}
}
if (workItem == null)
{
if (flag2)
{
this.state = JobState.Waiting;
}
result = null;
}
else
{
this.RevertToPreviousUnthrottledState();
IEnumerable <ResourceKey> enumerable = this.ResourceDependencies;
if (enumerable == null)
{
enumerable = Array <ResourceKey> .Empty;
}
ResourceKey resource = null;
ResourceReservation reservation = this.GetReservation(workItem, systemWorkload, context, enumerable, out resource);
if (reservation != null)
{
if (reservation.DelayFactor > 0.0)
{
this.MoveToThrottledState(resource, true);
}
this.TraceWorkItem(workItem);
this.workItemQueue.Remove(workItem);
result = new MrsSystemTask(this, workItem.Callback, systemWorkload, reservation, workItem is JobCheck);
}
else
{
this.MoveToThrottledState(resource, false);
result = null;
}
}
}
}
}
return(result);
}
void IJob.ProcessTaskExecutionResult(MrsSystemTask systemTask)
{
this.ProcessTaskExecutionResult(systemTask);
}
