source: branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave/3.4/Executor.cs @ 6371

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System;
using System.Threading;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Hive;

namespace HeuristicLab.Clients.Hive.SlaveCore {
  /// <summary>
  /// The executor runs in the appdomain and handles the execution of an Hive job.
  /// </summary>
  public class Executor : MarshalByRefObject, IDisposable {
    public Guid JobId { get; set; }
    private IJob Job { get; set; }
    public int CoresNeeded { get; set; }
    public int MemoryNeeded { get; set; }
    private bool wasJobAborted = false;
    private Semaphore pauseStopSem = new Semaphore(0, 1);
    private Semaphore startJobSem = new Semaphore(0, 1);
    //make pause or stop wait until start is finished
    private Semaphore jobStartedSem = new Semaphore(0, 1);
    private ExecutorQueue executorQueue;
    public ExecutorQueue ExecutorCommandQueue {
      get {
        return executorQueue;
      }
    }
    public bool IsStopping { get; set; }
    public bool IsPausing { get; set; }
    private DateTime CreationTime { get; set; }
    private Exception currentException;
    public String CurrentException {
      get {
        if (currentException != null) {
          return currentException.ToString();
        } else {
          return string.Empty;
        }
      }
    }

    private ExecutionState ExecutionState {
      get {
        return Job != null ? Job.ExecutionState : HeuristicLab.Core.ExecutionState.Stopped;
      }
    }

    public TimeSpan ExecutionTime {
      get {
        return Job != null ? Job.ExecutionTime : new TimeSpan(0, 0, 0);
      }
    }

    public Executor() {
      IsStopping = false;
      IsPausing = false;
      executorQueue = new ExecutorQueue();
    }

    public void Start(byte[] serializedJob) {
      try {
        CreationTime = DateTime.Now;
        Job = PersistenceUtil.Deserialize<IJob>(serializedJob);

        RegisterJobEvents();

        Job.Start();
        if (!jobStartedSem.WaitOne(TimeSpan.FromSeconds(15))) {
          throw new TimeoutException("Timeout when starting the job. JobStarted event was not fired.");
        }
        jobStartedSem.Release();
      }
      catch (Exception e) {
        this.currentException = e;
        Job_JobFailed(this, new EventArgs<Exception>(e));
      }
    }

    public void Pause() {
      IsPausing = true;
      // wait until job is started. if this does not happen, the Job is null an we give up
      jobStartedSem.WaitOne(TimeSpan.FromSeconds(15));
      if (Job == null) {
        currentException = new Exception("Pausing job " + this.JobId + ": Job is null");
        return;
      }

      if (Job.ExecutionState == ExecutionState.Started) {
        try {
          Job.Pause();
          //we need to block the pause...
          pauseStopSem.WaitOne();
        }
        catch (Exception ex) {
          currentException = new Exception("Error pausing job " + this.JobId + ": " + ex.ToString());
        }
      }
    }

    public void Stop() {
      IsStopping = true;
      // wait until job is started. if this does not happen, the Job is null an we give up
      jobStartedSem.WaitOne(TimeSpan.FromSeconds(15));
      if (Job == null) {
        currentException = new Exception("Stopping job " + this.JobId + ": Job is null");
      }
      wasJobAborted = true;

      if ((ExecutionState == ExecutionState.Started) || (ExecutionState == ExecutionState.Paused)) {
        try {
          Job.Stop();
          pauseStopSem.WaitOne();
        }
        catch (Exception ex) {
          currentException = new Exception("Error stopping job " + this.JobId + ": " + ex.ToString());
        }
      }
    }

    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);
    }

    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);
    }

    #region Job Events
    private void Job_JobFailed(object sender, EventArgs e) {
      EventArgs<Exception> ex = (EventArgs<Exception>)e;
      currentException = ex.Value;

      executorQueue.AddMessage(ExecutorMessageType.JobFailed);
    }

    private void Job_JobStopped(object sender, EventArgs e) {
      if (wasJobAborted)
        pauseStopSem.Release();

      executorQueue.AddMessage(ExecutorMessageType.JobStopped);
    }

    private void Job_JobPaused(object sender, EventArgs e) {
      pauseStopSem.Release();
      executorQueue.AddMessage(ExecutorMessageType.JobPaused);
    }

    private void Job_JobStarted(object sender, EventArgs e) {
      jobStartedSem.Release();
      executorQueue.AddMessage(ExecutorMessageType.JobStarted);
    }
    #endregion

    public JobData GetJobData() {
      if (Job.ExecutionState == ExecutionState.Started) {
        throw new InvalidStateException("Job is still running");
      } else {
        JobData jobData = new JobData();
        if (Job == null) {
          //send empty job and save exception
          jobData.Data = PersistenceUtil.Serialize(new JobData());
          if (currentException == null) {
            currentException = new Exception("Job with id " + this.JobId + " is null, sending empty job");
          }
        } else {
          jobData.Data = PersistenceUtil.Serialize(Job);
        }
        jobData.JobId = JobId;
        return jobData;
      }
    }

    public void Dispose() {
      if (Job != null)
        DeregisterJobEvents();
      Job = null;
    }
  }
}