source: branches/HiveStatistics/sources/HeuristicLab.Services.WebApp.Maintenance/3.3/WebApi/CleanupController.cs @ 12761

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web.Http;
using HeuristicLab.Services.Hive;
using HeuristicLab.Services.Hive.DataAccess;
using HeuristicLab.Services.Hive.DataAccess.Interfaces;
using DT = HeuristicLab.Services.WebApp.Maintenance.WebApi.DataTransfer;

namespace HeuristicLab.Services.WebApp.Maintenance.WebApi {
  public class CleanupController : ApiController {

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

    [HttpGet, HttpPost]
    public bool CleanupJob(Guid jobId) {
      using (var pm = PersistenceManager) {
        var jobDao = pm.JobDao;
        var factTaskDao = pm.FactTaskDao;
        return pm.UseTransaction(() => {
          if (jobDao.Exists(jobId)) return false;
          var jobTimeData = factTaskDao.GetByJobId(jobId).GroupBy(x => x.JobId).Select(x => new {
            CalculatingTime = x.Sum(y => y.CalculatingTime),
            WaitingTime = x.Sum(y => y.WaitingTime),
            TransferTime = x.Sum(y => y.TransferTime),
            InitialWaitingTime = x.Sum(y => y.InitialWaitingTime),
            StartTime = x.Min(y => y.StartTime),
            EndTime = x.Max(y => y.EndTime)
          }).SingleOrDefault();
          factTaskDao.DeleteByJobId(jobId);
          factTaskDao.Save(new FactTask {
            TaskId = Guid.NewGuid(),
            JobId = jobId,
            CalculatingTime = jobTimeData.CalculatingTime,
            WaitingTime = jobTimeData.WaitingTime,
            TransferTime = jobTimeData.TransferTime,
            InitialWaitingTime = jobTimeData.InitialWaitingTime,
            StartTime = jobTimeData.StartTime,
            EndTime = jobTimeData.EndTime,
            NumCalculationRuns = 0,
            NumRetries = 0,
            CoresRequired = 0,
            MemoryRequired = 0,
            Priority = 0,
            TaskState = TaskState.Finished
          });
          pm.SubmitChanges();
          return true;
        });
      }
    }

    [HttpGet, HttpPost]
    public void AggregateClient(Guid clientId, int entries) {
      using (var pm = PersistenceManager) {
        var factClientInfoDao = pm.FactClientInfoDao;
        var clientInfos = pm.UseTransaction(() => factClientInfoDao.GetByClientId(clientId).OrderBy(x => x.Time).ToList());
        FactClientInfo lastClientInfo = null, sumClientInfo = new FactClientInfo();
        int counter = 0;
        var aggregatedClientInfos = new List<FactClientInfo>();
        foreach (var clientInfo in clientInfos) {
          if (lastClientInfo != null) {
            if (lastClientInfo.SlaveState != clientInfo.SlaveState ||
                lastClientInfo.IsAllowedToCalculate != clientInfo.IsAllowedToCalculate) {
              // update into 'lastClientInfo'
              if (aggregatedClientInfos.Any()) {
                counter = aggregatedClientInfos.Count();
                pm.UseTransaction(() => {
                  factClientInfoDao.Delete(aggregatedClientInfos);
                  lastClientInfo.NumUsedCores = sumClientInfo.NumUsedCores / counter;
                  lastClientInfo.NumTotalCores = sumClientInfo.NumTotalCores / counter;
                  lastClientInfo.UsedMemory = sumClientInfo.UsedMemory / counter;
                  lastClientInfo.TotalMemory = sumClientInfo.TotalMemory / counter;
                  lastClientInfo.CpuUtilization = sumClientInfo.CpuUtilization / counter;
                  lastClientInfo.IdleTime = sumClientInfo.IdleTime;
                  lastClientInfo.OfflineTime = sumClientInfo.OfflineTime;
                  lastClientInfo.UnavailableTime = sumClientInfo.UnavailableTime;
                  pm.SubmitChanges();
                });
              }
              aggregatedClientInfos.Clear();
              counter = 0;
              sumClientInfo = new FactClientInfo();
            } else {
              // sum up 
              sumClientInfo.NumUsedCores += clientInfo.NumUsedCores;
              sumClientInfo.NumTotalCores += clientInfo.NumTotalCores;
              sumClientInfo.UsedMemory += clientInfo.UsedMemory;
              sumClientInfo.TotalMemory += clientInfo.TotalMemory;
              sumClientInfo.CpuUtilization += clientInfo.CpuUtilization;
              sumClientInfo.IdleTime += clientInfo.IdleTime;
              sumClientInfo.OfflineTime += clientInfo.OfflineTime;
              sumClientInfo.UnavailableTime += clientInfo.UnavailableTime;
              counter++;
              if (counter >= entries) {
                pm.UseTransaction(() => {
                  factClientInfoDao.Delete(aggregatedClientInfos);
                  clientInfo.NumUsedCores = sumClientInfo.NumUsedCores / counter;
                  clientInfo.NumTotalCores = sumClientInfo.NumTotalCores / counter;
                  clientInfo.UsedMemory = sumClientInfo.UsedMemory / counter;
                  clientInfo.TotalMemory = sumClientInfo.TotalMemory / counter;
                  clientInfo.CpuUtilization = sumClientInfo.CpuUtilization / counter;
                  clientInfo.IdleTime = sumClientInfo.IdleTime;
                  clientInfo.OfflineTime = sumClientInfo.OfflineTime;
                  clientInfo.UnavailableTime = sumClientInfo.UnavailableTime;
                  pm.SubmitChanges();
                });
                aggregatedClientInfos.Clear();
                counter = 0;
                sumClientInfo = new FactClientInfo();
              } else {
                aggregatedClientInfos.Add(clientInfo);
              }
            }
          }
          lastClientInfo = clientInfo;
        }
      }
    }

    public IEnumerable<DT.Plugin> GetUnusedPlugins() {
      using (var pm = PersistenceManager) {
        var pluginDao = pm.PluginDao;
        var requiredPluginDao = pm.RequiredPluginDao;
        var taskDao = pm.TaskDao;
        return pm.UseTransaction(() => {
          var taskIds = taskDao.GetAll().Select(x => x.TaskId);
          var usedPluginIds = requiredPluginDao.GetAll()
            .Where(x => taskIds.Contains(x.TaskId))
            .Select(x => x.PluginId)
            .Distinct();
          return pluginDao.GetAll()
            .Where(x => !usedPluginIds.Any(y => y == x.PluginId))
            .Select(x => new DT.Plugin {
              Name = x.Name,
              Version = x.Version,
              DateCreated = x.DateCreated
            })
            .ToList();
        });
      }
    }

    public void DeletePlugin(Guid id) {
      using (var pm = PersistenceManager) {
        var pluginDao = pm.PluginDao;
        pm.UseTransaction(() => {
          pluginDao.Delete(id);
          pm.SubmitChanges();
        });
      }
    }

    public void DeleteUnusedPlugins() {
      using (var pm = PersistenceManager) {
        var pluginDao = pm.PluginDao;
        pm.UseTransaction(() => {
          pluginDao.DeleteUnusedPlugins();
          pm.SubmitChanges();
        });
      }
    }

  }
}