source: branches/HeuristicLab.Hive-3.3/sources/HeuristicLab.Hive/HeuristicLab.Hive.Slave.Core/3.3/ConfigurationManager/ConfigManager.cs @ 5181

#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.Collections.Generic;
using HeuristicLab.Hive.Contracts.BusinessObjects;
using HeuristicLab.Hive.Slave.Communication;
using HeuristicLab.Hive.Slave.Core.Properties;
using HeuristicLab.Hive.Slave.Core.SlaveConsoleService;
using HeuristicLab.Hive.Slave.ExecutionEngine;

namespace HeuristicLab.Hive.Slave.Core.ConfigurationManager {
  /// <summary>
  /// accesses the Server and sends his data (uuid, uptimes, hardware config) 
  /// </summary>
  public class ConfigManager {
    private static ConfigManager instance = null;
    public static ConfigManager Instance {
      get {
        if (instance == null) {
          instance = new ConfigManager();
        }
        return instance;
      }
    }

    public Core Core { get; set; }
    private SlaveDto hardwareInfo;

    /// <summary>
    /// Constructor for the singleton, must recover Guid, Calendar, ...
    /// </summary>
    private ConfigManager() {
      hardwareInfo = new SlaveDto();

      if (Settings.Default.Guid == Guid.Empty) {
        hardwareInfo.Id = Guid.NewGuid();
        Settings.Default.Guid = hardwareInfo.Id;
        Settings.Default.Save();
      } else
        hardwareInfo.Id = Settings.Default.Guid;

      hardwareInfo.NrOfCores = Environment.ProcessorCount;
      hardwareInfo.Memory = 1024;
      hardwareInfo.Name = Environment.MachineName;
    }

    /// <summary>
    /// Get all the Information about the client
    /// </summary>
    /// <returns>the ClientInfo object</returns>
    public SlaveDto GetClientInfo() {
      hardwareInfo.Login = WcfService.Instance.ConnectedSince;
      return hardwareInfo;
    }

    /// <summary>
    /// collects and returns information that get displayed by the Client Console
    /// </summary>
    /// <returns></returns>
    public StatusCommons GetStatusForClientConsole() {
      //Todo: Locking
      StatusCommons st = new StatusCommons();
      st.ClientGuid = hardwareInfo.Id;

      st.Status = WcfService.Instance.ConnState;
      st.ConnectedSince = WcfService.Instance.ConnectedSince;

      st.TotalCores = hardwareInfo.NrOfCores.HasValue ? hardwareInfo.NrOfCores.Value : 0;
      st.FreeCores = hardwareInfo.NrOfCores.HasValue ? hardwareInfo.NrOfCores.Value - GetUsedCores() : 0;

      st.JobsAborted = SlaveStatusInfo.JobsAborted;
      st.JobsDone = SlaveStatusInfo.JobsProcessed;
      st.JobsFetched = SlaveStatusInfo.JobsFetched;

      Dictionary<Guid, Executor> engines = Core.ExecutionEngines;
      st.Jobs = new List<JobStatus>();

      lock (engines) {
        foreach (KeyValuePair<Guid, Executor> kvp in engines) {
          Executor e = kvp.Value;
          st.Jobs.Add(new JobStatus { JobId = e.JobId, ExecutionTime = e.ExecutionTime, Since = e.CreationTime });
        }
      }
      return st;
    }

    public Dictionary<Guid, TimeSpan> GetExecutionTimeOfRunningJobs() {
      Dictionary<Guid, TimeSpan> prog = new Dictionary<Guid, TimeSpan>();
      Dictionary<Guid, Executor> engines = Core.ExecutionEngines;
      lock (engines) {
        foreach (KeyValuePair<Guid, Executor> kvp in engines) {
          if (kvp.Value.ExecutionState == HeuristicLab.Core.ExecutionState.Started) { // only report from started jobs. this ensures that hung jobs will get an abort after some timeout. also if a job is already prepared (after it stopped), the executionTime would be 00:00:00
            Executor e = kvp.Value;
            prog[e.JobId] = e.ExecutionTime;
          }
        }
      }
      return prog;
    }

    public int GetUsedCores() {
      Dictionary<Guid, Executor> engines = Core.ExecutionEngines;
      Dictionary<Guid, JobDto> jobs = Core.Jobs;
      int usedCores = 0;
      lock (engines) {
        foreach (KeyValuePair<Guid, JobDto> kvp in jobs)
          usedCores += kvp.Value.CoresNeeded;
      }
      return usedCores;
    }

  }
}