Changeset 5955 for branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive/3.4/ServiceClients/HiveExperiment.cs

Timestamp:

04/05/11 15:37:04 (13 years ago)

Author:

cneumuel

Message:

#1233

• seperated ExperimentMangerClient (OKB-Style, contains business logic) and HiveExperiment (mainly only contains information)
• fixed redundant cloning methods in dtos
• added simple statistics in HiveExperiment which the user can see before downloading an experiment
• added db-delete cascade for slaves and statelogs - now slaves can be safely deleted

File:

• branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive/3.4/ServiceClients/HiveExperiment.cs (modified) (2 diffs)

branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive/3.4/ServiceClients/HiveExperiment.cs

@@ -20 +20 @@
 #endregion
 
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using HeuristicLab.Clients.Hive.Jobs;
 using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
 
 namespace HeuristicLab.Clients.Hive {
 
-  public partial class HiveExperiment : IDeepCloneable, IContent {
-
-    public HiveExperiment() { }
+  public partial class HiveExperiment : IDeepCloneable, IContent, IProgressReporter {
+    private JobResultPoller jobResultPoller;
+
+    private bool useLocalPlugins;
+    public bool UseLocalPlugins {
+      get { return useLocalPlugins; }
+      set { useLocalPlugins = value; }
+    }
+
+    private ExecutionState executionState;
+    public ExecutionState ExecutionState {
+      get { return executionState; }
+      internal set {
+        if (executionState != value) {
+          executionState = value;
+          OnExecutionStateChanged();
+        }
+      }
+    }
+
+    private TimeSpan executionTime;
+    public TimeSpan ExecutionTime {
+      get { return executionTime; }
+      internal set {
+        if (executionTime != value) {
+          executionTime = value;
+          OnExecutionTimeChanged();
+        }
+      }
+    }
+
+    private HiveJob hiveJob;
+    public HiveJob HiveJob {
+      get { return hiveJob; }
+      set {
+        DeregisterHiveJobEvents();
+        if (hiveJob != value) {
+          hiveJob = value;
+          RegisterHiveJobEvents();
+          OnHiveJobChanged();
+        }
+      }
+    }
+
+    private bool isProgressing;
+    public bool IsProgressing {
+      get { return isProgressing; }
+      set {
+        if (isProgressing != value) {
+          isProgressing = value;
+          OnIsProgressingChanged();
+        }
+      }
+    }
+
+    /** include jobs when refreshing **/
+    private bool includeJobs;
+    public bool IncludeJobs {
+      get { return includeJobs; }
+      set { includeJobs = value; }
+    }
+
+    private bool refreshAutomatically;
+    public bool RefreshAutomatically {
+      get { return refreshAutomatically; }
+      set {
+        if (refreshAutomatically != value) {
+          refreshAutomatically = value;
+          OnRefreshAutomaticallyChanged();
+          if (RefreshAutomatically) {
+            StartResultPolling();
+          } else {
+            StopResultPolling();
+          }
+        }
+      }
+    }
+
+    private IProgress progress;
+    public IProgress Progress {
+      get { return progress; }
+      set { this.progress = value; }
+    }
+
+    #region Constructors and Cloning
+    public HiveExperiment() {
+      this.ResourceNames = "HEAL";
+      this.includeJobs = true;
+      this.refreshAutomatically = true;
+    }
 
     protected HiveExperiment(HiveExperiment original, Cloner cloner) {
@@ -38 +132 @@
       this.Description = original.Description;
       this.Id = original.Id;
-    }
-    public IDeepCloneable Clone(Cloner cloner) {
+
+      this.UseLocalPlugins = original.UseLocalPlugins;
+      this.ExecutionTime = original.ExecutionTime;
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
       return new HiveExperiment(this, cloner);
     }
+    #endregion
 
     public override string ToString() {
-      return base.ToString() + "Name: " + Name + ", Description: " + Description;
-    }
-
-    public object Clone() {
-      return Clone(new Cloner());
+      return Name;
+    }
+
+    #region Events
+    public event EventHandler ExecutionTimeChanged;
+    private void OnExecutionTimeChanged() {
+      EventHandler handler = ExecutionTimeChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+
+    public event EventHandler ExecutionStateChanged;
+    private void OnExecutionStateChanged() {
+      EventHandler handler = ExecutionStateChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+
+    public event EventHandler HiveJobChanged;
+    private void OnHiveJobChanged() {
+      if (jobResultPoller != null && jobResultPoller.IsPolling) {
+        jobResultPoller.Stop();
+        DeregisterResultPollingEvents();
+      }
+      if (HiveJob != null && HiveJob.Job.Id != Guid.Empty) {
+        if (this.RefreshAutomatically)
+          StartResultPolling();
+      }
+      EventHandler handler = HiveJobChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+
+    public event EventHandler IsProgressingChanged;
+    private void OnIsProgressingChanged() {
+      EventHandler handler = IsProgressingChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+
+    public event EventHandler RefreshAutomaticallyChanged;
+    private void OnRefreshAutomaticallyChanged() {
+      EventHandler handler = RefreshAutomaticallyChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    #endregion
+
+    private void RegisterHiveJobEvents() {
+      if (HiveJob != null) {
+        HiveJob.JobStateChanged += new EventHandler(HiveJob_JobStateChanged);
+      }
+    }
+
+    private void DeregisterHiveJobEvents() {
+      if (HiveJob != null) {
+        HiveJob.JobStateChanged -= new EventHandler(HiveJob_JobStateChanged);
+      }
+    }
+
+    private void HiveJob_JobStateChanged(object sender, EventArgs e) {
+      if (this.HiveJob != null) {
+        this.RootJobId = HiveJob.Job.Id;
+      }
+    }
+
+    public Experiment GetExperiment() {
+      if (this.HiveJob != null) {
+        return HiveJob.OptimizerJob.OptimizerAsExperiment;
+      }
+      return null;
+    }
+
+    public void SetExperiment(Experiment experiment) {
+      this.HiveJob = new HiveJob(experiment);
+    }
+
+    protected override void OnPropertyChanged(PropertyChangedEventArgs e) {
+      base.OnPropertyChanged(e);
+      if (e.PropertyName == "Name") {
+        OnToStringChanged();
+      }
+    }
+
+    #region JobResultPoller Events
+
+    public void StartResultPolling() {
+      if (jobResultPoller == null) {
+        jobResultPoller = new JobResultPoller(HiveJob, /*ApplicationConstants.ResultPollingInterval*/new TimeSpan(0, 0, 5)); //TODO: find a better place for ApplicationConstants
+        RegisterResultPollingEvents();
+      }
+
+      if (!jobResultPoller.IsPolling) {
+        jobResultPoller.Start();
+      }
+    }
+
+    public void StopResultPolling() {
+      if (jobResultPoller.IsPolling) {
+        jobResultPoller.Stop();
+      }
+    }
+
+    private void RegisterResultPollingEvents() {
+      jobResultPoller.ExceptionOccured += new EventHandler<EventArgs<Exception>>(jobResultPoller_ExceptionOccured);
+      jobResultPoller.JobResultsReceived += new EventHandler<EventArgs<IEnumerable<LightweightJob>>>(jobResultPoller_JobResultReceived);
+      jobResultPoller.IsPollingChanged += new EventHandler(jobResultPoller_IsPollingChanged);
+    }
+    private void DeregisterResultPollingEvents() {
+      jobResultPoller.ExceptionOccured -= new EventHandler<EventArgs<Exception>>(jobResultPoller_ExceptionOccured);
+      jobResultPoller.JobResultsReceived -= new EventHandler<EventArgs<IEnumerable<LightweightJob>>>(jobResultPoller_JobResultReceived);
+      jobResultPoller.IsPollingChanged -= new EventHandler(jobResultPoller_IsPollingChanged);
+    }
+    private void jobResultPoller_IsPollingChanged(object sender, EventArgs e) {
+      this.refreshAutomatically = jobResultPoller.IsPolling;
+      OnRefreshAutomaticallyChanged();
+    }
+    private void jobResultPoller_JobResultReceived(object sender, EventArgs<IEnumerable<LightweightJob>> e) {
+      foreach (LightweightJob lightweightJob in e.Value) {
+        HiveJob hj = hiveJob.GetHiveJobByJobId(lightweightJob.Id);
+        if (hj != null) {
+          DateTime lastJobDataUpdate = hj.Job.LastJobDataUpdate;
+          hj.UpdateFromLightweightJob(lightweightJob);
+
+          // lastJobDataUpdate equals DateTime.MinValue right after it was uploaded. When the first results are polled, this value is updated
+          if (lastJobDataUpdate != DateTime.MinValue && lastJobDataUpdate < hj.Job.LastJobDataUpdate) {
+            OptimizerJob optimizerJob = ExperimentManagerClient.LoadOptimizerJob(hj.Job.Id);
+            if (optimizerJob == null) {
+              // something bad happened to this job. bad job, BAAAD job!
+            } else {
+              // if the job is paused, download but don't integrate into parent optimizer (to avoid Prepare)
+              if (hj.Job.State == JobState.Paused) {
+                hj.OptimizerJob = optimizerJob;
+              } else {
+                if (lightweightJob.ParentJobId.HasValue) {
+                  HiveJob parentHiveJob = HiveJob.GetHiveJobByJobId(lightweightJob.ParentJobId.Value);
+                  parentHiveJob.UpdateChildOptimizer(optimizerJob, hj.Job.Id);
+                }
+              }
+            }
+          }
+        }
+      }
+      GC.Collect(); // force GC, because .NET is too lazy here (deserialization takes a lot of memory)
+      if (AllJobsFinished()) {
+        this.ExecutionState = Core.ExecutionState.Stopped;
+        StopResultPolling();
+        //OnStopped();
+      }
+      UpdateTotalExecutionTime();
+      UpdateStats();
+    }
+
+    private void UpdateStats() {
+      var jobs = HiveJob.GetAllHiveJobs();
+      this.JobCount = jobs.Count();
+      this.CalculatingCount = jobs.Count(j => j.Job.State == JobState.Calculating);
+      this.FinishedCount = jobs.Count(j => j.Job.State == JobState.Finished);
+    }
+
+    private bool AllJobsFinished() {
+      return HiveJob.GetAllHiveJobs().All(j => j.Job.State == JobState.Finished
+                                            || j.Job.State == JobState.Aborted
+                                            || j.Job.State == JobState.Failed);
+    }
+
+    private void jobResultPoller_ExceptionOccured(object sender, EventArgs<Exception> e) {
+      //OnExceptionOccured(e.Value);
+    }
+
+    public void UpdateTotalExecutionTime() {
+      this.ExecutionTime = TimeSpan.FromMilliseconds(HiveJob.GetAllHiveJobs().Sum(x => x.Job.ExecutionTime.HasValue ? x.Job.ExecutionTime.Value.TotalMilliseconds : 0));
+    }
+    #endregion
+
+    protected override void RaisePropertyChanged(string propertyName) {
+      if (!(propertyName == "ExecutionTime")
+        && !(propertyName == "JobCount")
+        && !(propertyName == "CalculatingCount")
+        && !(propertyName == "FinishedCount")) {
+        base.RaisePropertyChanged(propertyName);
+      }
     }
   }