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

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2010 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.Linq;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Services.Hive.Common;
using HeuristicLab.Hive;
using HeuristicLab.Services.Hive.Common.DataTransfer;
using System.Collections.Generic;
using HeuristicLab.Clients.Hive.Slave;
using HeuristicLab.PluginInfrastructure;

                                             
namespace HeuristicLab.Clients.Hive.Salve {
  public class Executor : MarshalByRefObject, IDisposable {
    public Guid JobId { get; set; }
    public IJob Job { get; set; }
    public MessageContainer.MessageType CurrentMessage { get; set; }
    public Core core { get; set; }    
        
    private Exception currentException;
    public String CurrentException {
      get {
        if (currentException != null) {
          return currentException.ToString();
        } else {
          return string.Empty;
        }
      }
    }
    
    public 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 DateTime CreationTime { get; set; }

    /// <param name="serializedJob"></param>
    /// <param name="collectChildJobs">if true, all child-jobs are downloaded and the job will be resumed.</param>
    public void Start(byte[] serializedJob) {
      try {
        CreationTime = DateTime.Now;
        Job = PersistenceUtil.Deserialize<IJob>(serializedJob);

        RegisterJobEvents();

        if (Job.CollectChildJobs) {          
          IEnumerable<JobData> childjobs = WcfService.Instance.GetChildJobs(JobId);
          Job.Resume(childjobs.Select(j => PersistenceUtil.Deserialize<IJob>(j.Data)));
        } else {
          Job.Prepare();
          Job.Start();
        }
      }
      catch (Exception e) {
        this.currentException = e;        
      }
    }

    public void StartOnlyJob() {
      try {
        Job.Start();
      }
      catch (Exception e) {
        this.currentException = e;        
      }
    }

    public void Abort() {
      CurrentMessage = MessageContainer.MessageType.AbortJob;
      if ((ExecutionState == ExecutionState.Started) || (ExecutionState == ExecutionState.Paused)) {
        Job.Stop();
      } else {
        Job_JobStopped(this, EventArgs.Empty);
      }
    }

    private void RegisterJobEvents() {
      //TODO: warum gibt es jobStopped und jobfailed nicht mehr? 
      Job.JobStopped += new EventHandler(Job_JobStopped);
      Job.JobFailed += new EventHandler(Job_JobFailed);
      Job.NewChildJob += new EventHandler<EventArgs<IJob>>(Job_NewChildJob);
      Job.WaitForChildJobs += new EventHandler(Job_WaitForChildJobs);
      Job.DeleteChildJobs += new EventHandler(Job_DeleteChildJobs);
    }

    private void DeregisterJobEvents() {
      Job.JobStopped -= new EventHandler(Job_JobStopped);
      Job.JobFailed -= new EventHandler(Job_JobFailed);
      Job.NewChildJob -= new EventHandler<EventArgs<IJob>>(Job_NewChildJob);
      Job.WaitForChildJobs -= new EventHandler(Job_WaitForChildJobs);
      Job.DeleteChildJobs -= new EventHandler(Job_DeleteChildJobs);
    }

    private List<Guid> FindPluginsNeeded(IJob obj) {
      List<Guid> guids = new List<Guid>();
      foreach(IPluginDescription desc in PluginUtil.GetDeclaringPlugins(obj)) {        
      }
      throw new NotImplementedException("FindPluginsNeeded for Job_NewChildJob");

      return guids;
    }

    private void Job_NewChildJob(object sender, EventArgs<IJob> e) {
      JobData childJobData = new JobData();
      childJobData.Data = PersistenceUtil.Serialize(e.Value);

      Job childJob = new Job();
      childJob.JobState = JobState.Offline;
      childJob.CoresNeeded = 1;
      childJob.MemoryNeeded = 0;
      childJob.PluginsNeededIds = FindPluginsNeeded(e.Value);

      //TODO: is return value needed?
      WcfService.Instance.AddChildJob(this.JobId, childJob, childJobData);
    }

    private void Job_WaitForChildJobs(object sender, EventArgs e) {
      // Pause the job and send it back to the hive. The server will awake it when all child-jobs are finished
      this.Job.CollectChildJobs = true;
      
      JobData jdata = new JobData();
      jdata.Data = PersistenceUtil.Serialize(Job);
      jdata.JobId = this.JobId;
      
      core.PauseJob(jdata);
    }

    private void Job_DeleteChildJobs(object sender, EventArgs e) {
      WcfService.Instance.DeleteChildJobs(JobId);
    }

    private void Job_JobFailed(object sender, EventArgs e) {
      //TODO: get exception to client
      HeuristicLab.Common.EventArgs<Exception> ex = (HeuristicLab.Common.EventArgs<Exception>)e;
      currentException = ex.Value;
      core.SendFinishedJob(JobId);
    }

    private void Job_JobStopped(object sender, EventArgs e) {
     if (CurrentMessage == MessageContainer.MessageType.AbortJob) {
       core.KillAppDomain(JobId);
      } else {
        core.SendFinishedJob(JobId);
      }
    }

    public JobData GetFinishedJob() {
      if (Job == null) {
        throw new InvalidStateException("Job is null"); 
      }              

      if (Job.ExecutionState == HeuristicLab.Core.ExecutionState.Started) {
        try { Job.Stop(); }
        catch { }
      }

      if (Job.ExecutionState == HeuristicLab.Core.ExecutionState.Started) {
        throw new InvalidStateException("Job is still running"); 
      } else {
        JobData jdata = new JobData();
        jdata.Data = PersistenceUtil.Serialize(Job);
        jdata.JobId = JobId;
        return jdata;
      }
    }   
   
    public Executor() {
      // CurrentMessage = MessageContainer.MessageType.NoMessage; [chn] check usage of 'CurrentMessage'
    }

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