source: branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.4/HiveService.cs @ 5404

using System;
using System.Collections.Generic;
using System.Linq;
using System.ServiceModel;
using HeuristicLab.Services.Hive.Common;
using HeuristicLab.Services.Hive.Common.DataTransfer;
using HeuristicLab.Services.Hive.Common.ServiceContracts;

namespace HeuristicLab.Services.Hive {

  /// <summary>
  /// Implementation of the Hive service (interface <see cref="IHiveService"/>).
  /// </summary>
  [ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall)]
  public class HiveService : IHiveService {
    private DataAccess.IHiveDao dao {
      get { return ServiceLocator.Instance.HiveDao; }
    }
    private HeuristicLab.Services.Hive.DataAccess.TransactionManager trans {
      get { return ServiceLocator.Instance.TransactionManager; }
    }
    private IAuthorizationManager auth {
      get { return ServiceLocator.Instance.AuthorizationManager; }
    }
    private ILifecycleManager lifecycleManager {
      get { return ServiceLocator.Instance.LifecycleManager; }
    }

    #region Job Methods
    //[PrincipalPermission(SecurityAction.Demand, Role = HiveRoles.Administrator)]
    //[PrincipalPermission(SecurityAction.Demand, Role = HiveRoles.Client)]
    public Guid AddJob(Job job, JobData jobData, IEnumerable<Guid> slaveGroupIds) {
      using (trans.OpenTransaction()) {
        job.UserId = auth.UserId;
        job.DateCreated = DateTime.Now;
        job.JobState = JobState.Waiting;
        job.Id = dao.AddJob(job);
        jobData.JobId = job.Id;
        jobData.LastUpdate = DateTime.Now;
        if (slaveGroupIds != null) {
          foreach (Guid slaveGroupId in slaveGroupIds) {
            dao.AssignJobToResource(job.Id, slaveGroupId);
          }
        } else {
          // todo: use default group
        }
        dao.AddJobData(jobData);
        return jobData.JobId;
      }
    }

    public Guid AddChildJob(Guid parentJobId, Job job, JobData jobData) {
      using (trans.OpenTransaction()) {
        job.ParentJobId = parentJobId;
        return AddJob(job, jobData, dao.GetAssignedResources(parentJobId).Select(x => x.Id));
      }
    }

    public Job GetJob(Guid jobId) {
      return dao.GetJob(jobId);
    }

    public IEnumerable<Job> GetJobs() {
      return dao.GetJobs(x => true);
    }

    public IEnumerable<LightweightJob> GetLightweightJobs(IEnumerable<Guid> jobIds) {
      return dao.GetJobs(x => jobIds.Contains(x.JobId)).Select(x => new LightweightJob(x)).ToArray();
    }

    public IEnumerable<LightweightJob> GetLightweightChildJobs(Guid? parentJobId, bool recursive, bool includeParent) {
      return GetChildJobs(parentJobId, recursive, includeParent).Select(x => new LightweightJob(x)).ToArray();
    }

    public JobData GetJobData(Guid jobId) {
      return dao.GetJobData(jobId);
    }

    public void UpdateJob(Job job, JobData jobData) {
      using (trans.OpenTransaction()) {
        jobData.LastUpdate = DateTime.Now;
        dao.UpdateJob(job);
        dao.UpdateJobData(jobData);
      }
    }

    public void DeleteJob(Guid jobId) {
      using (trans.OpenTransaction()) {
        dao.DeleteJob(jobId);
      }
    }

    public void DeleteChildJobs(Guid parentJobId) {
      using (trans.OpenTransaction()) {
        var jobs = GetChildJobs(parentJobId, true, false);
        foreach (var job in jobs) {
          dao.DeleteJob(job.Id);
          dao.DeleteJobData(job.Id);
        };
      }
    }
    
    public PluginData GetConfigurationFile() {
      using (trans.OpenTransaction()) {
        //TODO: move filename to app.config
        PluginData configFile = dao.GetPluginDatas(x => x.FileName == "HeuristicLab 3.3.exe.config").SingleOrDefault();
        if (configFile == null) {
          //TODO: error handling
          return null;
        } else {
          return configFile;
        }
      }
    }

    #endregion

    #region Job Control Methods
    public void StopJob(Guid jobId) {
      using (trans.OpenTransaction()) {
        throw new NotImplementedException();
      }
    }
    public void PauseJob(Guid jobId) {
      using (trans.OpenTransaction()) {
        throw new NotImplementedException();
      }
    }
    #endregion

    #region HiveExperiment Methods

    public HiveExperiment GetHiveExperiment(Guid id) {
      return dao.GetHiveExperiments(x => x.UserId == auth.UserId && x.HiveExperimentId == id).FirstOrDefault();
    }

    public IEnumerable<HiveExperiment> GetHiveExperiments() {
      return dao.GetHiveExperiments(x => x.UserId == auth.UserId);
    }

    public Guid AddHiveExperiment(HiveExperiment hiveExperimentDto) {
      using (trans.OpenTransaction()) {
        hiveExperimentDto.UserId = auth.UserId;
        hiveExperimentDto.DateCreated = DateTime.Now;
        return dao.AddHiveExperiment(hiveExperimentDto);
      }
    }

    public void UpdateHiveExperiment(HiveExperiment hiveExperimentDto) {
      using (trans.OpenTransaction()) {
        dao.UpdateHiveExperiment(hiveExperimentDto);
      }
    }

    public void DeleteHiveExperiment(Guid hiveExperimentId) {
      using (trans.OpenTransaction()) {
        HiveExperiment he = dao.GetHiveExperiment(hiveExperimentId);
        dao.DeleteHiveExperiment(hiveExperimentId); // child jobs will be deleted by db-trigger
      }
    }
    #endregion

    #region Login Methods
    public void Hello(Guid slaveId, string name, int cores, int memory) {
      using (trans.OpenTransaction()) {
        var slave = dao.GetSlave(slaveId);

        if (slave == null) {
          slave = new Slave { Id = slaveId, Name = name, Cores = cores, Memory = memory };
          slave.IsAllowedToCalculate = true; //a little bit to optimistic?
          slave.SlaveState = SlaveState.Idle;
          dao.AddSlave(slave);
        } else {
          //TODO: error handling? 
        }
      }
    }

    public void GoodBye(Guid slaveId) {
      using (trans.OpenTransaction()) {
        var slave = dao.GetSlave(slaveId);
        if (slave != null) {
          slave.SlaveState = SlaveState.Offline;
          dao.UpdateSlave(slave);
        }
      }
    }
    #endregion

    #region Heartbeat Methods
    public List<MessageContainer> Heartbeat(Heartbeat heartbeat) {
      using (trans.OpenTransaction()) {
        return lifecycleManager.ProcessHeartbeat(heartbeat);
      }
    }
    #endregion

    #region Plugin Methods
    public Guid AddPlugin(Plugin plugin, List<PluginData> pluginDatas) {
      using (trans.OpenTransaction()) {
        plugin.UserId = auth.UserId;
        plugin.DateCreated = DateTime.Now;
        Guid pluginId = dao.AddPlugin(plugin);
        foreach (PluginData pluginData in pluginDatas) {
          pluginData.PluginId = pluginId;
          dao.AddPluginData(pluginData);
        }
        return pluginId;
      }
    }
    public IEnumerable<Plugin> GetPlugins() {
      return dao.GetPlugins(x => true);
    }

    public IEnumerable<PluginData> GetPluginDatas(List<Guid> pluginIds) {
      List<PluginData> pluginDatas = new List<PluginData>();

      using (trans.OpenTransaction()) {
        foreach (Guid guid in pluginIds) {
          List<PluginData> pluginData = dao.GetPluginDatas(x => x.PluginId == guid).ToList();
          if (pluginData != null) {
            pluginDatas.AddRange(pluginData);
          } else {
            //ignore ? 
          }
        }
        return pluginDatas;
      }
    }

    #endregion

    #region Slave Methods
    public Guid AddSlave(Slave slave) {
      using (trans.OpenTransaction()) {
        return dao.AddSlave(slave);
      }
    }

    public Guid AddSlaveGroup(SlaveGroup slaveGroup) {
      using (trans.OpenTransaction()) {
        return dao.AddSlaveGroup(slaveGroup);
      }
    }

    public Slave GetSlave(Guid slaveId) {
      return dao.GetSlave(slaveId);
    }

    public SlaveGroup GetSlaveGroup(Guid slaveGroupId) {
      return dao.GetSlaveGroup(slaveGroupId);
    }

    public IEnumerable<Slave> GetSlaves() {
      return dao.GetSlaves(x => true);
    }

    public IEnumerable<SlaveGroup> GetSlaveGroups() {
      return dao.GetSlaveGroups(x => true);
    }

    public void UpdateSlave(Slave slave) {
      using (trans.OpenTransaction()) {
        dao.UpdateSlave(slave);
      }
    }

    public void UpdateSlaveGroup(SlaveGroup slaveGroup) {
      using (trans.OpenTransaction()) {
        dao.UpdateSlaveGroup(slaveGroup);
      }
    }

    public void DeleteSlave(Guid slaveId) {
      using (trans.OpenTransaction()) {
        dao.DeleteSlave(slaveId);
      }
    }

    public void DeleteSlaveGroup(Guid slaveGroupId) {
      using (trans.OpenTransaction()) {
        dao.DeleteSlaveGroup(slaveGroupId);
      }
    }

    public void AddResourceToGroup(Guid slaveGroupId, Guid resourceId) {
      using (trans.OpenTransaction()) {
        var resource = dao.GetResource(resourceId);
        resource.ParentResourceId = slaveGroupId;
        dao.UpdateResource(resource);
      }
    }

    public void RemoveResourceFromGroup(Guid slaveGroupId, Guid resourceId) {
      using (trans.OpenTransaction()) {
        var resource = dao.GetResource(resourceId);
        resource.ParentResourceId = null;
        dao.UpdateResource(resource);
      }
    }

    #endregion

    #region Helper Methods
    private IEnumerable<Job> GetChildJobs(Guid? parentJobId, bool recursive, bool includeParent) {
      var jobs = new List<Job>(dao.GetJobs(x => parentJobId == null ? !x.ParentJobId.HasValue : x.ParentJobId.Value == parentJobId));

      if (includeParent) {
        jobs.Add(GetJob(parentJobId.Value));
      }

      if (recursive) {
        var childs = new List<Job>();
        foreach (var job in jobs) {
          childs.AddRange(GetChildJobs(job.Id, recursive, false));
        }
        jobs.AddRange(childs);
      }
      return jobs;
    }

    #endregion

  }
}