source: branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave/3.4/ConfigManager.cs @ 5591

#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 System.Diagnostics;
using System.Management;
using HeuristicLab.Clients.Hive.Slave.Properties;
using HeuristicLab.Services.Hive.Common.DataTransfer;


namespace HeuristicLab.Clients.Hive.Slave {
  /// <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 HeuristicLab.Services.Hive.Common.DataTransfer.Slave slave;

    /// <summary>
    /// Constructor for the singleton, must recover Guid, Calendar, ...
    /// </summary>
    private ConfigManager() {
      slave = new HeuristicLab.Services.Hive.Common.DataTransfer.Slave();
      slave.Id = GetUniqueMachineId();
      slave.Name = Environment.MachineName;
      slave.Cores = Environment.ProcessorCount;
      slave.Memory = GetPhysicalMemory();
      slave.CpuArchitecture = Environment.Is64BitOperatingSystem ? CpuArchitecture.x64 : CpuArchitecture.x86;
      slave.OperatingSystem = Environment.OSVersion.VersionString;
      slave.CpuSpeed = GetCpuSpeed();
      slave.FreeMemory = GetFreeMemory();
    }

    /// <summary>
    /// Get all the Information about the client
    /// </summary>
    /// <returns>the ClientInfo object</returns>
    public HeuristicLab.Services.Hive.Common.DataTransfer.Slave GetClientInfo() {
      //TODO: how to display connectedsince in gui?
      //hardwareInfo.Login = WcfService.Instance.ConnectedSince;
      return slave;
    }

    /// <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 = slave.Id;

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

      st.TotalCores = slave.Cores.HasValue ? slave.Cores.Value : 0;
      st.FreeCores = slave.Cores.HasValue ? slave.Cores.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> GetExecutionTimeOfAllJobs() {
      Dictionary<Guid, TimeSpan> prog = new Dictionary<Guid, TimeSpan>();
      Dictionary<Guid, Executor> engines = Core.ExecutionEngines;
      lock (engines) {
        foreach (KeyValuePair<Guid, Executor> kvp in engines) {
          Executor e = kvp.Value;
          prog[e.JobId] = e.ExecutionTime;
        }
      }
      return prog;
    }

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

    public static Guid GetUniqueMachineId() {
      // todo: instead of creating a new id, generate an ID from hardware IDs which is always the same for one machine
      if (Settings.Default.Guid == Guid.Empty) {
        Guid id = Guid.NewGuid();
        Settings.Default.Guid = id;
        Settings.Default.Save();
        return id;
      } else
        return Settings.Default.Guid;
    }

    /// <summary>
    /// MegaBytes
    /// </summary>
    private static int? GetPhysicalMemory() {
      long? res = GetWMIValue("Win32_ComputerSystem", "TotalPhysicalMemory");
      if (res != null)
        return (int)(res / 1024 / 1024);
      else
        return null;
    }

    /// <summary>
    /// Mhz
    /// </summary>
    private static int? GetCpuSpeed() {
      return (int)GetWMIValue("Win32_Processor", "MaxClockSpeed");
    }

    private static long? GetWMIValue(string clazz, string property) {
      ManagementClass mgtClass = new ManagementClass(clazz);
      ManagementObjectCollection mgtCol = mgtClass.GetInstances();

      foreach (ManagementObject mgtObj in mgtCol) {
        foreach (var prop in mgtObj.Properties) {
          if (prop.Value != null && prop.Name == property) {
            try {
              return long.Parse(prop.Value.ToString());
            }
            catch {
              return null;
            }
          }
        }
      }
      return null;
    }

    public static int GetFreeMemory() {
      PerformanceCounter counter = new PerformanceCounter("Memory", "Available Bytes", true);
      int mb = (int)(counter.NextValue() / 1024 / 1024);
      return mb;
    }
  }
}