Changeset 12435 for trunk/sources/HeuristicLab.Services.WebApp.Status/3.3/WebApi/DataController.cs

Timestamp:

06/12/15 14:59:54 (9 years ago)

Author:

dglaser

Message:

#2394: Improved PluginManager and updated hive status monitor.

File:

• trunk/sources/HeuristicLab.Services.WebApp.Status/3.3/WebApi/DataController.cs (modified) (6 diffs)

trunk/sources/HeuristicLab.Services.WebApp.Status/3.3/WebApi/DataController.cs

@@ -1 @@
-using System;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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.Linq;
@@ -21 +42 @@
         SELECT 
           DISTINCT UserId,
-          ISNULL((SELECT Count FROM UserTasks WHERE TaskState = 'Calculating' AND UserId = ut.UserId), 0) AS CalculatingTasks,
-          ISNULL((SELECT Count FROM UserTasks WHERE TaskState = 'Waiting' AND UserId = ut.UserId), 0) AS WaitingTasks
+          (SELECT Count FROM UserTasks WHERE TaskState = 'Calculating' AND UserId = ut.UserId) AS CalculatingTasks,
+          (SELECT Count FROM UserTasks WHERE TaskState = 'Waiting' AND UserId = ut.UserId) AS WaitingTasks
         FROM UserTasks ut;";
 
@@ -41 +62 @@
         CalculatingTasks = uts.CalculatingTasks,
         WaitingTasks = uts.WaitingTasks
-      });
+      }).OrderBy(x => x.User.Name);
     }
     // end temporary quickfix
@@ -50 +71 @@
                             where slave.SlaveState == SlaveState.Calculating || slave.SlaveState == SlaveState.Idle
                             select slave).ToList();
+        var activeSlaves = onlineSlaves.Where(s => s.IsAllowedToCalculate).ToList();
+        var calculatingSlaves = activeSlaves.Where(s => s.SlaveState == SlaveState.Calculating).ToList();
+
+        int calculatingMemory = calculatingSlaves.Any() ? (int)calculatingSlaves.Sum(s => s.Memory) / 1024 : 0;
+        int freeCalculatingMemory = calculatingSlaves.Any() ? (int)calculatingSlaves.Sum(s => s.FreeMemory) / 1024 : 0;
+
         return new DTO.Status {
           CoreStatus = new DTO.CoreStatus {
             TotalCores = onlineSlaves.Sum(s => s.Cores ?? 0),
-            AvailableCores = onlineSlaves.Where(s => s.IsAllowedToCalculate).Sum(s => s.Cores ?? 0),
-            FreeCores = onlineSlaves.Sum(s => s.FreeCores ?? 0)
+            FreeCores = onlineSlaves.Sum(s => s.FreeCores ?? 0), // temporary for old chart data
+            ActiveCores = activeSlaves.Sum(s => s.Cores ?? 0),
+            CalculatingCores = calculatingSlaves.Sum(s => s.Cores ?? 0)
           },
           CpuUtilizationStatus = new DTO.CpuUtilizationStatus {
@@ -60 +88 @@
                                   ? Math.Round(onlineSlaves.Average(s => s.CpuUtilization), 2)
                                   : 0.0,
-            UsedCpuUtilization = onlineSlaves.Any(x => x.IsAllowedToCalculate)
-                                 ? Math.Round(onlineSlaves.Where(x => x.IsAllowedToCalculate).Average(s => s.CpuUtilization), 2)
-                                 : 0.0
+            ActiveCpuUtilization = activeSlaves.Any()
+                                   ? Math.Round(activeSlaves.Average(s => s.CpuUtilization), 2)
+                                   : 0.0,
+            CalculatingCpuUtilization = calculatingSlaves.Any()
+                                        ? Math.Round(calculatingSlaves.Average(s => s.CpuUtilization), 2)
+                                        : 0.0
           },
           MemoryStatus = new DTO.MemoryStatus {
             TotalMemory = onlineSlaves.Any() ? (int)onlineSlaves.Sum(s => s.Memory) / 1024 : 0,
-            FreeMemory = onlineSlaves.Any() ? (int)onlineSlaves.Sum(s => s.FreeMemory) / 1024 : 0
+            FreeMemory = onlineSlaves.Any() ? (int)onlineSlaves.Sum(s => s.FreeMemory) / 1024 : 0,
+            ActiveMemory = activeSlaves.Any() ? (int)activeSlaves.Sum(s => s.Memory) / 1024 : 0,
+            UsedMemory = calculatingMemory - freeCalculatingMemory
           },
           TasksStatus = GetTaskStatus(db),
-          SlavesCpuStatus = onlineSlaves.Select(x => new DTO.SlaveCpuStatus {
-            CpuUtilization = Math.Round(x.CpuUtilization, 2),
+          SlavesStatus = onlineSlaves.Select(x => new DTO.SlaveStatus {
             Slave = new DTO.Slave {
               Id = x.ResourceId.ToString(),
               Name = x.Name
-            }
-          }),
+            },
+            CpuUtilization = x.CpuUtilization,
+            Cores = x.Cores ?? 0,
+            FreeCores = x.FreeCores ?? 0,
+            Memory = (x.Memory ?? 0) / 1024,
+            FreeMemory = (x.FreeMemory ?? 0) / 1024,
+            IsAllowedToCalculate = x.IsAllowedToCalculate,
+            State = x.SlaveState.ToString()
+          }).OrderBy(x => x.Slave.Name),
           Timestamp = JavascriptUtils.ToTimestamp(DateTime.Now)
         };
@@ -82 +121 @@
 
     public IEnumerable<DTO.Status> GetStatusHistory(DateTime start, DateTime end) {
+      TimeSpan ts = end - start;
+      int increment = 1;
+      double totalMinutes = ts.TotalMinutes;
+      while (totalMinutes > 5761) {
+        totalMinutes -= 5761;
+        increment += 5;
+      }
       using (var db = new HiveDataContext()) {
-        var statistics = db.Statistics.Where(s => s.Timestamp >= start && s.Timestamp <= end)
-                                      .OrderBy(x => x.Timestamp)
-                                      .ToList();
+        var statistics = db.Statistics.Where(s => s.Timestamp >= start && s.Timestamp <= end);
+        var status = new DTO.Status {
+          CoreStatus = new DTO.CoreStatus(),
+          CpuUtilizationStatus = new DTO.CpuUtilizationStatus(),
+          MemoryStatus = new DTO.MemoryStatus()
+        };
+        int freeCores = 0;
+        int freeMemory = 0;
+        int i = 1;
         foreach (var statistic in statistics) {
-          yield return new DTO.Status {
-            CoreStatus = new DTO.CoreStatus {
-              TotalCores = statistic.SlaveStatistics.Sum(x => x.Cores),
-              AvailableCores = 0,
-              FreeCores = statistic.SlaveStatistics.Sum(x => x.FreeCores)
-            },
-            CpuUtilizationStatus = new DTO.CpuUtilizationStatus {
-              TotalCpuUtilization = 0.0,
-              UsedCpuUtilization = statistic.SlaveStatistics.Any() ? statistic.SlaveStatistics.Average(x => x.CpuUtilization) : 0.0
-            },
-            MemoryStatus = new DTO.MemoryStatus {
-              TotalMemory = statistic.SlaveStatistics.Sum(x => x.Memory) / 1024,
-              FreeMemory = statistic.SlaveStatistics.Sum(x => x.FreeMemory) / 1024
-            },
-            Timestamp = JavascriptUtils.ToTimestamp(statistic.Timestamp)
-          };
+          status.CoreStatus.TotalCores += statistic.SlaveStatistics.Sum(x => x.Cores);
+          freeCores += statistic.SlaveStatistics.Sum(x => x.FreeCores);
+          status.CpuUtilizationStatus.TotalCpuUtilization += statistic.SlaveStatistics.Any()
+                                                             ? statistic.SlaveStatistics.Average(x => x.CpuUtilization)
+                                                             : 0.0;
+          status.MemoryStatus.TotalMemory += statistic.SlaveStatistics.Sum(x => x.Memory) / 1024;
+          freeMemory += statistic.SlaveStatistics.Sum(x => x.FreeMemory) / 1024;
+          if (i >= increment) {
+            status.Timestamp = JavascriptUtils.ToTimestamp(statistic.Timestamp);
+            status.CoreStatus.TotalCores /= i;
+            freeCores /= i;
+            status.CpuUtilizationStatus.TotalCpuUtilization /= i;
+            status.MemoryStatus.TotalMemory /= i;
+            freeMemory /= i;
+            status.CoreStatus.ActiveCores = status.CoreStatus.TotalCores;
+            status.MemoryStatus.ActiveMemory = status.MemoryStatus.TotalMemory;
+            status.CpuUtilizationStatus.ActiveCpuUtilization = status.CpuUtilizationStatus.TotalCpuUtilization;
+            status.CpuUtilizationStatus.CalculatingCpuUtilization = status.CpuUtilizationStatus.CalculatingCpuUtilization;
+            status.CoreStatus.CalculatingCores = status.CoreStatus.TotalCores - freeCores;
+            status.MemoryStatus.UsedMemory = status.MemoryStatus.TotalMemory - freeMemory;
+            yield return status;
+            status = new DTO.Status {
+              CoreStatus = new DTO.CoreStatus(),
+              CpuUtilizationStatus = new DTO.CpuUtilizationStatus(),
+              MemoryStatus = new DTO.MemoryStatus()
+            };
+            freeCores = 0;
+            freeMemory = 0;
+            i = 1;
+          } else {
+            i++;
+          }
         }
       }