source: branches/HiveStatistics/sources/HeuristicLab.Services.Hive/3.3/NewHiveService.cs @ 12584

using System;
using System.Collections.Generic;
using System.Linq;
using HeuristicLab.Services.Access;
using HeuristicLab.Services.Hive.DataAccess.Interfaces;
using HeuristicLab.Services.Hive.DataTransfer;
using HeuristicLab.Services.Hive.ServiceContracts;
using DA = HeuristicLab.Services.Hive.DataAccess;
using DT = HeuristicLab.Services.Hive.DataTransfer;

namespace HeuristicLab.Services.Hive {
  public class NewHiveService : IHiveService {
    private static readonly DA.TaskState[] CompletedStates = { DA.TaskState.Finished, DA.TaskState.Aborted, DA.TaskState.Failed };

    private IPersistenceManager PersistenceManager {
      get { return ServiceLocator.Instance.PersistenceManager; }
    }

    private IUserManager UserManager {
      get { return ServiceLocator.Instance.UserManager; }
    }

    private IRoleVerifier RoleVerifier {
      get { return ServiceLocator.Instance.RoleVerifier; }
    }

    private IAuthorizationManager AuthorizationManager {
      get { return ServiceLocator.Instance.AuthorizationManager; }
    }

    public Guid AddTask(DT.Task task, DT.TaskData taskData, IEnumerable<Guid> resourceIds) {
      RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
      using (var pm = PersistenceManager) {
        var taskDao = pm.TaskDao;
        var stateLogDao = pm.StateLogDao;
        var newTask = task.ToEntity();
        newTask.JobData = taskData.ToEntity();
        newTask.JobData.LastUpdate = DateTime.Now;
        newTask.AssignedResources.AddRange(resourceIds.Select(
          x => new DA.AssignedResource {
            ResourceId = x
          }));
        newTask.State = DA.TaskState.Waiting;
        return pm.UseTransaction(() => {
          taskDao.Save(newTask);
          pm.SubmitChanges();
          stateLogDao.Save(new DA.StateLog {
            State = DA.TaskState.Waiting,
            DateTime = DateTime.Now,
            TaskId = newTask.TaskId,
            UserId = UserManager.CurrentUserId,
            SlaveId = null,
            Exception = null
          });
          pm.SubmitChanges();
          return newTask.TaskId;
        }, false, true);
      }
    }

    public Guid AddChildTask(Guid parentTaskId, DT.Task task, DT.TaskData taskData) {
      RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
      IEnumerable<Guid> resourceIds;
      using (var pm = PersistenceManager) {
        var assignedResourceDao = pm.AssignedResourceDao;
        resourceIds = pm.UseTransaction(() => {
          return assignedResourceDao.GetByTaskId(parentTaskId)
            .Select(x => x.ResourceId)
            .ToList();
        });
      }
      task.ParentTaskId = parentTaskId;
      return AddTask(task, taskData, resourceIds);
    }

    public DT.Task GetTask(Guid taskId) {
      RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
      AuthorizationManager.AuthorizeForTask(taskId, Permission.Read);
      using (var pm = PersistenceManager) {
        var taskDao = pm.TaskDao;
        return pm.UseTransaction(() => {
          var task = taskDao.GetById(taskId);
          return task.ToDto();
        });
      }
    }

    public IEnumerable<Task> GetTasks() {
      // unused
      throw new NotImplementedException();
    }

    public IEnumerable<LightweightTask> GetLightweightTasks(IEnumerable<Guid> taskIds) {
      // unused
      throw new NotImplementedException();
    }

    public IEnumerable<LightweightTask> GetLightweightChildTasks(Guid? parentTaskId, bool recursive, bool includeParent) {
      // unused
      throw new NotImplementedException();
    }

    public IEnumerable<DT.LightweightTask> GetLightweightJobTasks(Guid jobId) {
      RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
      AuthorizationManager.AuthorizeForJob(jobId, Permission.Read);
      using (var pm = PersistenceManager) {
        var taskDao = pm.TaskDao;
        return pm.UseTransaction(() => {
          return taskDao.GetByJobId(jobId)
            .Select(x => new DT.LightweightTask {
              Id = x.TaskId,
              ExecutionTime = TimeSpan.FromMilliseconds(x.ExecutionTimeMs),
              ParentTaskId = x.ParentTaskId,
              StateLog = x.StateLogs.OrderBy(y => y.DateTime)
                                    .Select(z => z.ToDto())
                                    .ToList(),
              State = x.State.ToDto(),
              Command = x.Command.ToDto(),
              LastTaskDataUpdate = x.JobData.LastUpdate
            });
        }, false, true);
      }
    }

    public IEnumerable<DT.LightweightTask> GetLightweightJobTasksWithoutStateLog(Guid jobId) {
      RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
      AuthorizationManager.AuthorizeForJob(jobId, Permission.Read);
      using (var pm = PersistenceManager) {
        var taskDao = pm.TaskDao;
        return pm.UseTransaction(() => {
          return taskDao.GetByJobId(jobId)
            .Select(x => new DT.LightweightTask {
              Id = x.TaskId,
              ExecutionTime = TimeSpan.FromMilliseconds(x.ExecutionTimeMs),
              ParentTaskId = x.ParentTaskId,
              StateLog = new List<DT.StateLog>(),
              State = x.State.ToDto(),
              Command = x.Command.ToDto(),
              LastTaskDataUpdate = x.JobData.LastUpdate
            });
        }, false, true);
      }
    }

    public DT.TaskData GetTaskData(Guid taskId) {
      RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
      AuthorizationManager.AuthorizeForTask(taskId, Permission.Read);
      using (var pm = PersistenceManager) {
        var taskDataDao = pm.TaskDataDao;
        return pm.UseTransaction(() => taskDataDao.GetById(taskId).ToDto());
      }
    }

    public void UpdateTask(DT.Task taskDto) {
      RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
      AuthorizationManager.AuthorizeForTask(taskDto.Id, Permission.Full);
      using (var pm = PersistenceManager) {
        var taskDao = pm.TaskDao;
        pm.UseTransaction(() => {
          var task = taskDao.GetById(taskDto.Id);
          taskDto.CopyToEntity(task);
          pm.SubmitChanges();
        });
      }
    }

    public void UpdateTaskData(DT.Task taskDto, DT.TaskData taskDataDto) {
      RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
      AuthorizationManager.AuthorizeForTask(taskDto.Id, Permission.Full);
      using (var pm = PersistenceManager) {
        var taskDao = pm.TaskDao;
        var taskDataDao = pm.TaskDataDao;
        pm.UseTransaction(() => {
          var task = taskDao.GetById(taskDto.Id);
          var taskData = taskDataDao.GetById(taskDataDto.TaskId);
          taskDto.CopyToEntity(task);
          taskDataDto.CopyToEntity(taskData);
          taskData.LastUpdate = DateTime.Now;
          pm.SubmitChanges();
        });
      }
    }

    public void DeleteTask(Guid taskId) {
      // unused
      throw new NotImplementedException();
    }

    public void DeleteChildTasks(Guid parentTaskId) {
      // unused
      throw new NotImplementedException();
    }

    public DT.Task UpdateTaskState(Guid taskId, DT.TaskState taskState, Guid? slaveId, Guid? userId, string exception) {
      RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
      AuthorizationManager.AuthorizeForTask(taskId, Permission.Full);
      using (var pm = PersistenceManager) {
        var taskDao = pm.TaskDao;
        var stateLogDao = pm.StateLogDao;
        return pm.UseTransaction(() => {
          var task = taskDao.GetById(taskId);
          UpdateTaskState(pm, task, taskState, slaveId, userId, exception);
          pm.SubmitChanges();
          return task.ToDto();
        });
      }
    }

    private void UpdateTaskState(IPersistenceManager pm, DA.Task task, DT.TaskState taskState, Guid? slaveId, Guid? userId, string exception) {
      var stateLogDao = pm.StateLogDao;
      var taskStateEntity = taskState.ToEntity();
      if (task.Command == DA.Command.Pause && task.State == DA.TaskState.Paused
          || task.Command == DA.Command.Abort && task.State == DA.TaskState.Aborted
          || task.Command == DA.Command.Stop && task.State == DA.TaskState.Aborted) {
        task.Command = null;
      } else if (taskStateEntity == DA.TaskState.Paused) {
        taskStateEntity = DA.TaskState.Waiting;
      }
      stateLogDao.Save(new DA.StateLog {
        State = taskStateEntity,
        DateTime = DateTime.Now,
        TaskId = task.TaskId,
        UserId = userId,
        SlaveId = slaveId,
        Exception = exception
      });
      task.State = taskStateEntity;
    }

    public void StopTask(Guid taskId) {
      RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
      AuthorizationManager.AuthorizeForTask(taskId, Permission.Full);
      using (var pm = PersistenceManager) {
        var taskDao = pm.TaskDao;
        pm.UseTransaction(() => {
          var task = taskDao.GetById(taskId);
          if (task.State == DA.TaskState.Calculating || task.State == DA.TaskState.Transferring) {
            task.Command = DA.Command.Stop;
          } else if (task.State != DA.TaskState.Aborted
                     && task.State != DA.TaskState.Finished
                     && task.State != DA.TaskState.Failed) {
            UpdateTaskState(pm, task, DT.TaskState.Aborted, null, null, string.Empty);
          }
          pm.SubmitChanges();
        });
      }
    }

    public void PauseTask(Guid taskId) {
      RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
      AuthorizationManager.AuthorizeForTask(taskId, Permission.Full);
      using (var pm = PersistenceManager) {
        var taskDao = pm.TaskDao;
        pm.UseTransaction(() => {
          var task = taskDao.GetById(taskId);
          if (task.State == DA.TaskState.Calculating || task.State == DA.TaskState.Transferring) {
            task.Command = DA.Command.Pause;
          } else {
            UpdateTaskState(pm, task, DT.TaskState.Paused, null, null, string.Empty);
          }
          pm.SubmitChanges();
        });
      }
    }

    public void RestartTask(Guid taskId) {
      RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
      AuthorizationManager.AuthorizeForTask(taskId, Permission.Full);
      using (var pm = PersistenceManager) {
        var taskDao = pm.TaskDao;
        pm.UseTransaction(() => {
          var task = taskDao.GetById(taskId);
          task.Command = null;
          UpdateTaskState(pm, task, DT.TaskState.Waiting, null, UserManager.CurrentUserId, string.Empty);
          pm.SubmitChanges();
        });
      }
    }


    public Job GetJob(Guid id) {
      RoleVerifier.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
      AuthorizationManager.AuthorizeForJob(id, Permission.Read);
      using (var pm = PersistenceManager) {
        var jobDao = pm.JobDao;
        var jobPermissionDao = pm.JobPermissionDao;
        var taskDao = pm.TaskDao;
        return pm.UseTransaction(() => {
          var job = jobDao.GetById(id).ToDto();
          if (job != null) {
            var statistics = taskDao.GetByJobId(job.Id)
              .GroupBy(x => x.JobId)
              .Select(x => new {
                TotalCount = x.Count(),
                CalculatingCount = x.Count(y => y.State == DA.TaskState.Calculating),
                FinishedCount = x.Count(y => CompletedStates.Contains(y.State))
              }).FirstOrDefault();
            if (statistics != null) {
              job.JobCount = statistics.TotalCount;
              job.CalculatingCount = statistics.CalculatingCount;
              job.FinishedCount = statistics.FinishedCount;
            }
            // TODO
            //job.Permission = DT.Convert.ToDto(dao.GetPermissionForJob(job.Id, userManager.CurrentUserId));
            job.OwnerUsername = UserManager.GetUserById(job.OwnerUserId).UserName;
          }
          return job;
        });
      }
    }

    public IEnumerable<Job> GetJobs() {
      throw new NotImplementedException();
    }

    public IEnumerable<Job> GetAllJobs() {
      // unused
      throw new NotImplementedException();
    }

    public Guid AddJob(Job jobDto) {
      throw new NotImplementedException();
    }

    public void UpdateJob(Job jobDto) {
      throw new NotImplementedException();
    }

    public void DeleteJob(Guid JobId) {
      throw new NotImplementedException();
    }

    public void GrantPermission(Guid jobId, Guid grantedUserId, Permission permission) {
      throw new NotImplementedException();
    }

    public void RevokePermission(Guid hiveExperimentId, Guid grantedUserId) {
      throw new NotImplementedException();
    }

    public IEnumerable<JobPermission> GetJobPermissions(Guid jobId) {
      throw new NotImplementedException();
    }

    public bool IsAllowedPrivileged() {
      throw new NotImplementedException();
    }

    public void Hello(Slave slave) {
      throw new NotImplementedException();
    }

    public void GoodBye(Guid slaveId) {
      throw new NotImplementedException();
    }

    public List<MessageContainer> Heartbeat(Heartbeat heartbeat) {
      throw new NotImplementedException();
    }

    public Plugin GetPlugin(Guid pluginId) {
      throw new NotImplementedException();
    }

    public Plugin GetPluginByHash(byte[] hash) {
      // unused
      throw new NotImplementedException();
    }

    public Guid AddPlugin(Plugin plugin, List<PluginData> pluginData) {
      throw new NotImplementedException();
    }

    public IEnumerable<Plugin> GetPlugins() {
      throw new NotImplementedException();
    }

    public IEnumerable<PluginData> GetPluginDatas(List<Guid> pluginIds) {
      throw new NotImplementedException();
    }

    public void DeletePlugin(Guid pluginId) {
      // unused
      throw new NotImplementedException();
    }

    public void GrantResourcePermissions(Guid resourceId, Guid[] grantedUserIds) {
      throw new NotImplementedException();
    }

    public void RevokeResourcePermissions(Guid resourceId, Guid[] grantedUserIds) {
      throw new NotImplementedException();
    }

    public IEnumerable<ResourcePermission> GetResourcePermissions(Guid resourceId) {
      throw new NotImplementedException();
    }

    public IEnumerable<Resource> GetChildResources(Guid resourceId) {
      // unused
      throw new NotImplementedException();
    }

    public Guid AddSlave(Slave slave) {
      throw new NotImplementedException();
    }

    public Guid AddSlaveGroup(SlaveGroup slaveGroup) {
      throw new NotImplementedException();
    }

    public Slave GetSlave(Guid slaveId) {
      throw new NotImplementedException();
    }

    public SlaveGroup GetSlaveGroup(Guid slaveGroupId) {
      // unused
      throw new NotImplementedException();
    }

    public IEnumerable<Slave> GetSlaves() {
      throw new NotImplementedException();
    }

    public IEnumerable<SlaveGroup> GetSlaveGroups() {
      throw new NotImplementedException();
    }

    public void UpdateSlave(Slave slave) {
      throw new NotImplementedException();
    }

    public void UpdateSlaveGroup(SlaveGroup slaveGroup) {
      throw new NotImplementedException();
    }

    public void DeleteSlave(Guid slaveId) {
      throw new NotImplementedException();
    }

    public void DeleteSlaveGroup(Guid slaveGroupId) {
      throw new NotImplementedException();
    }

    public void AddResourceToGroup(Guid slaveGroupId, Guid resourceId) {
      throw new NotImplementedException();
    }

    public void RemoveResourceFromGroup(Guid slaveGroupId, Guid resourceId) {
      throw new NotImplementedException();
    }

    public Guid GetResourceId(string resourceName) {
      throw new NotImplementedException();
    }

    public IEnumerable<Task> GetTasksByResourceId(Guid resourceId) {
      // unused
      throw new NotImplementedException();
    }

    public void TriggerEventManager(bool force) {
      // private method...
      throw new NotImplementedException();
    }

    public int GetNewHeartbeatInterval(Guid slaveId) {
      throw new NotImplementedException();
    }

    public Guid AddDowntime(Downtime downtime) {
      throw new NotImplementedException();
    }

    public void DeleteDowntime(Guid downtimeId) {
      throw new NotImplementedException();
    }

    public void UpdateDowntime(Downtime downtime) {
      throw new NotImplementedException();
    }

    public IEnumerable<Downtime> GetDowntimesForResource(Guid resourceId) {
      throw new NotImplementedException();
    }

    public string GetUsernameByUserId(Guid userId) {
      throw new NotImplementedException();
    }

    public Guid GetUserIdByUsername(string username) {
      throw new NotImplementedException();
    }

    public IEnumerable<UserPriority> GetUserPriorities() {
      throw new NotImplementedException();
    }

    public IEnumerable<Statistics> GetStatistics() {
      // unused
      throw new NotImplementedException();
    }

    public IEnumerable<Statistics> GetStatisticsForTimePeriod(DateTime @from, DateTime to) {
      // unused
      throw new NotImplementedException();
    }
  }
}