Changeset 4264 for branches/3.3-HiveMigration/sources/HeuristicLab.Hive/HeuristicLab.Hive.Slave.Core/3.3

Timestamp:

08/19/10 13:30:56 (14 years ago)

Author:

cneumuel

Message:

Split up "State" to "JobState" and "SlaveState" (#1159)

Location:

branches/3.3-HiveMigration/sources/HeuristicLab.Hive/HeuristicLab.Hive.Slave.Core/3.3

Files:

• Core.cs (modified) (4 diffs)
• Heartbeat.cs (modified) (4 diffs)

branches/3.3-HiveMigration/sources/HeuristicLab.Hive/HeuristicLab.Hive.Slave.Core/3.3/Core.cs

@@ -22 +22 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Hive.Slave.ExecutionEngine;
+using System.IO;
+using System.Threading;
+using HeuristicLab.Core;
+using HeuristicLab.Hive.Contracts;
+using HeuristicLab.Hive.Contracts.BusinessObjects;
+using HeuristicLab.Hive.Contracts.ResponseObjects;
 using HeuristicLab.Hive.Slave.Common;
-using System.Threading;
-using System.Reflection;
-using System.Diagnostics;
-using System.Security.Permissions;
-using System.Security.Policy;
-using System.Security;
 using HeuristicLab.Hive.Slave.Communication;
-using HeuristicLab.Hive.Contracts.BusinessObjects;
-using HeuristicLab.Hive.Contracts;
-using System.Runtime.Remoting.Messaging;
-using HeuristicLab.PluginInfrastructure;
-using System.ServiceModel;
-using System.ServiceModel.Description;
+using HeuristicLab.Hive.Slave.Communication.ServerService;
 using HeuristicLab.Hive.Slave.Core.ClientConsoleService;
 using HeuristicLab.Hive.Slave.Core.ConfigurationManager;
-using HeuristicLab.Hive.Slave.Communication.ServerService;
-using HeuristicLab.Hive.JobBase;
 using HeuristicLab.Hive.Slave.Core.JobStorage;
+using HeuristicLab.Hive.Slave.ExecutionEngine;
 using HeuristicLab.Tracing;
-using HeuristicLab.Core;
-using System.IO;
-using HeuristicLab.Hive.Contracts.ResponseObjects;
 
 namespace HeuristicLab.Hive.Slave.Core {
@@ -102 +90 @@
 
       //Initialize the heartbeat
-      beat = new Heartbeat { Interval = 10000 };
+      beat = new Heartbeat { Interval = new TimeSpan(0, 0, 10) };
       beat.StartHeartbeat();
 
@@ -171 +159 @@
           Logger.Info("Uptime Limit reached, storing jobs and sending them back");
 
-          //check if there are running jobs
-          if (engines.Count > 0) {
-            //make sure there is no more fetching of jobs while the snapshots get processed
-            CurrentlyFetching = true;
-            //request a snapshot of each running job
-            foreach (KeyValuePair<Guid, Executor> kvp in engines) {
-              kvp.Value.RequestSnapshot();
-            }
-
-          } else {
-            //Disconnect afterwards
-            WcfService.Instance.Disconnect();
-          }
+          ShutdownRunningJobsAndSubmitSnapshots();
           break;
 
@@ -209 +185 @@
           WcfService.Instance.Logout(ConfigManager.Instance.GetClientInfo().Id);
           break;
+      }
+    }
+
+    private void ShutdownRunningJobsAndSubmitSnapshots() {
+      //check if there are running jobs
+      if (engines.Count > 0) {
+        //make sure there is no more fetching of jobs while the snapshots get processed
+        CurrentlyFetching = true;
+        //request a snapshot of each running job
+        foreach (KeyValuePair<Guid, Executor> kvp in engines) {
+          kvp.Value.RequestSnapshot();
+        }
+
       }
     }

branches/3.3-HiveMigration/sources/HeuristicLab.Hive/HeuristicLab.Hive.Slave.Core/3.3/Heartbeat.cs

@@ -33 +33 @@
 using HeuristicLab.Hive.Slave.Communication.ServerService;
 using HeuristicLab.Tracing;
+using System.Threading;
 //using BO = HeuristicLab.Hive.Contracts.BusinessObjects;
 
@@ -43 +44 @@
     private bool offline;
 
-    public double Interval { get; set; }
-    private Timer heartbeatTimer = null;
+    public TimeSpan Interval { get; set; }
+
+    private Thread heartBeatThread;
 
     private static object locker = new object();
 
     public Heartbeat() {
-      Interval = 100;
+      Interval = new TimeSpan(0,0,10);
     }
 
-    public Heartbeat(double interval) {
+    public Heartbeat(TimeSpan interval) {
       Interval = interval;
     }
@@ -58 +60 @@
     private WcfService wcfService;
 
+    private bool abortThreadPending;
+
     /// <summary>
     /// Starts the Heartbeat signal.
     /// </summary>
     public void StartHeartbeat() {
-      heartbeatTimer = new System.Timers.Timer();
-      heartbeatTimer.Interval = this.Interval;
-      heartbeatTimer.AutoReset = true;
-      heartbeatTimer.Elapsed += new ElapsedEventHandler(heartbeatTimer_Elapsed);
       wcfService = WcfService.Instance;
       wcfService.ProcessHeartBeatCompleted += new EventHandler<ProcessHeartBeatCompletedEventArgs>(wcfService_ProcessHeartBeatCompleted);
-      heartbeatTimer.Start();
+      abortThreadPending = false;
+      heartBeatThread = GetHeartBeatThread();
+      heartBeatThread.Start();
     }
 
-    /// <summary>
-    /// This Method is called every time the timer ticks
-    /// </summary>
-    /// <param name="sender"></param>
-    /// <param name="e"></param>
-    void heartbeatTimer_Elapsed(object sender, ElapsedEventArgs e) {
-      lock (locker) {
-        // check if cwfService is disconnected for any reason (should happen at first heartbeat)
-        // [chn] TODO: Client should always send heartbeats. when calendar disallows he should tell the server he does not want to compute anything
-        if (wcfService.ConnState == NetworkEnum.WcfConnState.Disconnected &&
-          (!UptimeManager.Instance.CalendarAvailable || UptimeManager.Instance.IsOnline())) {
-          wcfService.Connect();
-        }
-        if (wcfService.ConnState == NetworkEnum.WcfConnState.Connected) {
-          wcfService.LoginSync(ConfigManager.Instance.GetClientInfo());
-        }
-
-        ClientDto info = ConfigManager.Instance.GetClientInfo();
-
-        PerformanceCounter counter = new PerformanceCounter("Memory", "Available Bytes", true);
-        int mb = (int)(counter.NextValue() / 1024 / 1024);
-
-        HeartBeatData heartBeatData = new HeartBeatData {
-          SlaveId = info.Id,
-          FreeCores = info.NrOfCores - ConfigManager.Instance.GetUsedCores(),
-          FreeMemory = mb,
-          JobProgress = ConfigManager.Instance.GetProgressOfAllJobs()
-        };
-
-        DateTime lastFullHour = DateTime.Parse(DateTime.Now.Hour.ToString() + ":00");
-        TimeSpan span = DateTime.Now - lastFullHour;
-        if (span.TotalSeconds < (Interval / 1000)) {
-          if (UptimeManager.Instance.IsOnline() && UptimeManager.Instance.CalendarAvailable) {
-            //That's quiet simple: Just reconnect and you're good for new jobs
-            if (wcfService.ConnState != NetworkEnum.WcfConnState.Loggedin) {
-              Logger.Info("Client goes online according to timetable");
+    private Thread GetHeartBeatThread() {
+      return new Thread(() => {
+        while (!abortThreadPending) {
+          lock (locker) {
+            // check if cwfService is disconnected for any reason (should happen at first heartbeat)
+            // [chn] TODO: Client should always send heartbeats. when calendar disallows he should tell the server he does not want to compute anything
+            if (wcfService.ConnState == NetworkEnum.WcfConnState.Disconnected) {
               wcfService.Connect();
             }
-          } else {
-            //We have quit a lot of work to do here: snapshot all jobs, submit them back, then disconnect and then pray to god that nothing goes wrong
-            MessageQueue.GetInstance().AddMessage(MessageContainer.MessageType.UptimeLimitDisconnect);
-          }
-        }
-        if (wcfService.ConnState == NetworkEnum.WcfConnState.Failed) {
-          wcfService.Connect();
-        } else if (wcfService.ConnState == NetworkEnum.WcfConnState.Loggedin) {
-          Logger.Debug("Sending Heartbeat: " + heartBeatData);
-          wcfService.ProcessHeartBeatAsync(heartBeatData);
-        }
-      }
+
+            if (wcfService.ConnState == NetworkEnum.WcfConnState.Loggedin) {
+
+              // client is allowed to calculate stuff
+              ClientDto info = ConfigManager.Instance.GetClientInfo();
+              
+              HeartBeatData heartBeatData = new HeartBeatData {
+                SlaveId = info.Id,
+                FreeCores = info.NrOfCores - ConfigManager.Instance.GetUsedCores(),
+                FreeMemory = GetFreeMemory(),
+                JobProgress = ConfigManager.Instance.GetProgressOfAllJobs(),
+                IsAllowedToCalculate = UptimeManager.Instance.IsOnline() && UptimeManager.Instance.CalendarAvailable
+              };
+
+              if (!heartBeatData.IsAllowedToCalculate) {
+                // stop all running jobs and send snapshots to server
+                MessageQueue.GetInstance().AddMessage(MessageContainer.MessageType.UptimeLimitDisconnect);
+              }
+
+              Logger.Debug("Sending Heartbeat: " + heartBeatData);
+              wcfService.ProcessHeartBeatAsync(heartBeatData);
+            }
+
+          } // lock
+          Thread.Sleep(Interval);
+        } // while
+        abortThreadPending = false;
+      });
+    }
+
+    private int GetFreeMemory() {
+      PerformanceCounter counter = new PerformanceCounter("Memory", "Available Bytes", true);
+      int mb = (int)(counter.NextValue() / 1024 / 1024);
+      return mb;
     }
 
@@ -129 +124 @@
 
     public void StopHeartBeat() {
-      heartbeatTimer.Dispose();
+      abortThreadPending = true;
     }
   }