Changeset 6725 for branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave/3.3/Executor.cs

Timestamp:

09/08/11 16:38:28 (13 years ago)

Author:

ascheibe

Message:

#1233 more renaming for more consistency

File:

• branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave/3.3/Executor.cs (modified) (6 diffs)

branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave/3.3/Executor.cs

@@ -29 +29 @@
 namespace HeuristicLab.Clients.Hive.SlaveCore {
   /// <summary>
-  /// The executor runs in the appdomain and handles the execution of an Hive job.
+  /// The executor runs in the appdomain and handles the execution of an Hive task.
   /// </summary>
   public class Executor : MarshalByRefObject, IDisposable {
-    private bool wasJobAborted = false;
+    private bool wasTaskAborted = false;
     private AutoResetEvent pauseStopSem = new AutoResetEvent(false);
-    private AutoResetEvent startJobSem = new AutoResetEvent(false); // block start method call
-    private AutoResetEvent jobStartedSem = new AutoResetEvent(false); // make pause or stop wait until start is finished
+    private AutoResetEvent startTaskSem = new AutoResetEvent(false); // block start method call
+    private AutoResetEvent taskStartedSem = new AutoResetEvent(false); // make pause or stop wait until start is finished
     private ExecutorQueue executorQueue;
-    private bool jobDataInvalid = false; // if true, the jobdata is not sent when the job is failed
-    private IJob job;
+    private bool taskDataInvalid = false; // if true, the jobdata is not sent when the task is failed
+    private ITask task;
     private DateTime creationTime;
 
-    public Guid JobId { get; set; }
+    public Guid TaskId { get; set; }
     public int CoresNeeded { get; set; }
     public int MemoryNeeded { get; set; }
@@ -63 +63 @@
 
     private ExecutionState ExecutionState {
-      get { return job != null ? job.ExecutionState : HeuristicLab.Core.ExecutionState.Stopped; }
+      get { return task != null ? task.ExecutionState : HeuristicLab.Core.ExecutionState.Stopped; }
     }
 
     public TimeSpan ExecutionTime {
-      get { return job != null ? job.ExecutionTime : new TimeSpan(0, 0, 0); }
+      get { return task != null ? task.ExecutionTime : new TimeSpan(0, 0, 0); }
     }
 
@@ -79 +79 @@
       try {
         creationTime = DateTime.Now;
-        job = PersistenceUtil.Deserialize<IJob>(serializedJob);
+        task = PersistenceUtil.Deserialize<ITask>(serializedJob);
 
         RegisterJobEvents();
 
-        job.Start();
-        if (!startJobSem.WaitOne(Settings.Default.ExecutorSemTimeouts)) {
-          jobDataInvalid = true;
-          throw new TimeoutException("Timeout when starting the job. JobStarted event was not fired.");
+        task.Start();
+        if (!startTaskSem.WaitOne(Settings.Default.ExecutorSemTimeouts)) {
+          taskDataInvalid = true;
+          throw new TimeoutException("Timeout when starting the task. TaskStarted event was not fired.");
         }
       }
       catch (Exception e) {
         this.CurrentException = e;
-        Job_JobFailed(this, new EventArgs<Exception>(e));
+        Task_TaskFailed(this, new EventArgs<Exception>(e));
       }
       finally {
-        jobStartedSem.Set();
+        taskStartedSem.Set();
       }
     }
@@ -100 +100 @@
     public void Pause() {
       IsPausing = true;
-      // wait until job is started. if this does not happen, the Task is null an we give up
-      jobStartedSem.WaitOne(Settings.Default.ExecutorSemTimeouts);
-      if (job == null) {
-        CurrentException = new Exception("Pausing job " + this.JobId + ": Task is null");
+      // wait until task is started. if this does not happen, the Task is null an we give up
+      taskStartedSem.WaitOne(Settings.Default.ExecutorSemTimeouts);
+      if (task == null) {
+        CurrentException = new Exception("Pausing task " + this.TaskId + ": Task is null");
         executorQueue.AddMessage(ExecutorMessageType.ExceptionOccured);
         return;
       }
 
-      if (job.ExecutionState == ExecutionState.Started) {
+      if (task.ExecutionState == ExecutionState.Started) {
         try {
-          job.Pause();
+          task.Pause();
           //we need to block the pause...
           pauseStopSem.WaitOne();
         }
         catch (Exception ex) {
-          CurrentException = new Exception("Error pausing job " + this.JobId + ": " + ex.ToString());
+          CurrentException = new Exception("Error pausing task " + this.TaskId + ": " + ex.ToString());
           executorQueue.AddMessage(ExecutorMessageType.ExceptionOccured);
         }
@@ -123 +123 @@
     public void Stop() {
       IsStopping = true;
-      // wait until job is started. if this does not happen, the Task is null an we give up
-      jobStartedSem.WaitOne(Settings.Default.ExecutorSemTimeouts);
-      if (job == null) {
-        CurrentException = new Exception("Stopping job " + this.JobId + ": Task is null");
+      // wait until task is started. if this does not happen, the Task is null an we give up
+      taskStartedSem.WaitOne(Settings.Default.ExecutorSemTimeouts);
+      if (task == null) {
+        CurrentException = new Exception("Stopping task " + this.TaskId + ": Task is null");
         executorQueue.AddMessage(ExecutorMessageType.ExceptionOccured);
       }
-      wasJobAborted = true;
+      wasTaskAborted = true;
 
       if ((ExecutionState == ExecutionState.Started) || (ExecutionState == ExecutionState.Paused)) {
         try {
-          job.Stop();
+          task.Stop();
           pauseStopSem.WaitOne();
         }
         catch (Exception ex) {
-          CurrentException = new Exception("Error stopping job " + this.JobId + ": " + ex.ToString());
+          CurrentException = new Exception("Error stopping task " + this.TaskId + ": " + ex.ToString());
           executorQueue.AddMessage(ExecutorMessageType.ExceptionOccured);
         }
@@ -144 +144 @@
 
     private void RegisterJobEvents() {
-      job.JobStopped += new EventHandler(Job_JobStopped);
-      job.JobFailed += new EventHandler(Job_JobFailed);
-      job.JobPaused += new EventHandler(Job_JobPaused);
-      job.JobStarted += new EventHandler(Job_JobStarted);
+      task.TaskStopped += new EventHandler(Task_TaskStopped);
+      task.TaskFailed += new EventHandler(Task_TaskFailed);
+      task.TaskPaused += new EventHandler(Task_TaskPaused);
+      task.TaskStarted += new EventHandler(Task_TaskStarted);
     }
 
     private void DeregisterJobEvents() {
-      job.JobStopped -= new EventHandler(Job_JobStopped);
-      job.JobFailed -= new EventHandler(Job_JobFailed);
-      job.JobPaused -= new EventHandler(Job_JobPaused);
-      job.JobStarted -= new EventHandler(Job_JobStarted);
+      task.TaskStopped -= new EventHandler(Task_TaskStopped);
+      task.TaskFailed -= new EventHandler(Task_TaskFailed);
+      task.TaskPaused -= new EventHandler(Task_TaskPaused);
+      task.TaskStarted -= new EventHandler(Task_TaskStarted);
     }
 
     #region Task Events
-    private void Job_JobFailed(object sender, EventArgs e) {
+    private void Task_TaskFailed(object sender, EventArgs e) {
       IsStopping = true;
       EventArgs<Exception> ex = (EventArgs<Exception>)e;
       CurrentException = ex.Value;
-      executorQueue.AddMessage(ExecutorMessageType.JobFailed);
-    }
-
-    private void Job_JobStopped(object sender, EventArgs e) {
+      executorQueue.AddMessage(ExecutorMessageType.TaskFailed);
+    }
+
+    private void Task_TaskStopped(object sender, EventArgs e) {
       IsStopping = true;
-      if (wasJobAborted) {
+      if (wasTaskAborted) {
         pauseStopSem.Set();
       }
-      executorQueue.AddMessage(ExecutorMessageType.JobStopped);
-    }
-
-    private void Job_JobPaused(object sender, EventArgs e) {
+      executorQueue.AddMessage(ExecutorMessageType.TaskStopped);
+    }
+
+    private void Task_TaskPaused(object sender, EventArgs e) {
       IsPausing = true;
       pauseStopSem.Set();
-      executorQueue.AddMessage(ExecutorMessageType.JobPaused);
-    }
-
-    private void Job_JobStarted(object sender, EventArgs e) {
-      startJobSem.Set();
-      executorQueue.AddMessage(ExecutorMessageType.JobStarted);
+      executorQueue.AddMessage(ExecutorMessageType.TaskPaused);
+    }
+
+    private void Task_TaskStarted(object sender, EventArgs e) {
+      startTaskSem.Set();
+      executorQueue.AddMessage(ExecutorMessageType.TaskStarted);
     }
     #endregion
 
-    public TaskData GetJobData() {
-      if (jobDataInvalid) return null;
-
-      if (job.ExecutionState == ExecutionState.Started) {
+    public TaskData GetTaskData() {
+      if (taskDataInvalid) return null;
+
+      if (task.ExecutionState == ExecutionState.Started) {
         throw new InvalidStateException("Task is still running");
       } else {
-        TaskData jobData = new TaskData();
-        if (job == null) {
-          //send empty job and save exception
-          jobData.Data = PersistenceUtil.Serialize(new TaskData());
+        TaskData taskData = new TaskData();
+        if (task == null) {
+          //send empty task and save exception
+          taskData.Data = PersistenceUtil.Serialize(new TaskData());
           if (CurrentException == null) {
-            CurrentException = new Exception("Task with id " + this.JobId + " is null, sending empty job");
+            CurrentException = new Exception("Task with id " + this.TaskId + " is null, sending empty task");
           }
         } else {
-          jobData.Data = PersistenceUtil.Serialize(job);
-        }
-        jobData.TaskId = JobId;
-        return jobData;
+          taskData.Data = PersistenceUtil.Serialize(task);
+        }
+        taskData.TaskId = TaskId;
+        return taskData;
       }
     }
 
     public void Dispose() {
-      if (job != null)
+      if (task != null)
         DeregisterJobEvents();
-      job = null;
+      task = null;
     }
   }