Changeset 6479 for branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive/3.4/RefreshableHiveExperiment.cs

Timestamp:

06/27/11 15:20:23 (13 years ago)

Author:

cneumuel

Message:

#1233

• finished experiment sharing
• added role for executing privileged jobs
• refreshing experiments in experimentManager does not delete already downloaded jobs
• moved some properties from HiveExperiment into RefreshableHiveExperiment

File:

• branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive/3.4/RefreshableHiveExperiment.cs (modified) (21 diffs)

branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive/3.4/RefreshableHiveExperiment.cs

@@ -25 +25 @@
 using System.Drawing;
 using System.Linq;
+using HeuristicLab.Collections;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 
 namespace HeuristicLab.Clients.Hive {
-  public class RefreshableHiveExperiment : IHiveItem, IDeepCloneable, IContent, IProgressReporter {
+  public class RefreshableHiveExperiment : IHiveItem, IDeepCloneable, IContent, IProgressReporter, IComparable<RefreshableHiveExperiment> {
     private JobResultPoller jobResultPoller;
     private ConcurrentJobDownloader<ItemJob> jobDownloader;
@@ -44 +45 @@
           if (hiveExperiment != null) DergisterHiveExperimentEvents();
           hiveExperiment = value;
-          if (hiveExperiment != null) RegisterHiveExperimentEvents();
+          if (hiveExperiment != null) {
+            RegisterHiveExperimentEvents();
+            hiveExperiment_PropertyChanged(hiveExperiment, new PropertyChangedEventArgs("Id"));
+          }
           OnHiveExperimentChanged();
+          OnToStringChanged(this, EventArgs.Empty);
+        }
+      }
+    }
+
+    private ItemCollection<HiveJob> hiveJobs;
+    public ItemCollection<HiveJob> HiveJobs {
+      get { return hiveJobs; }
+      set {
+        if (hiveJobs != value) {
+          if (hiveJobs != null) DeregisterHiveJobsEvents();
+          hiveJobs = value;
+          if (hiveJobs != null) RegisterHiveJobsEvents();
+          OnHiveJobsChanged();
+        }
+      }
+    }
+
+    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();
         }
       }
@@ -60 +100 @@
           }
           if (RefreshAutomatically) {
-            if (hiveExperiment.HiveJobs != null && hiveExperiment.HiveJobs.Count > 0 && (jobResultPoller == null || !jobResultPoller.IsPolling)) {
+            if (this.HiveJobs != null && this.HiveJobs.Count > 0 && (jobResultPoller == null || !jobResultPoller.IsPolling)) {
               StartResultPolling();
             }
@@ -70 +110 @@
     }
 
-    // if true, all control buttons should be enabled. otherwise disabled (used for HiveEngine)
+    // indicates if download button is enabled
+    private bool isDownloadable = true;
+    public bool IsDownloadable {
+      get { return isDownloadable; }
+      set {
+        if (value != isDownloadable) {
+          isDownloadable = value;
+          OnIsDownloadableChanged();
+        }
+      }
+    }
+
+    // if true, all control buttons should be enabled. otherwise disabled
     private bool isControllable = true;
     public bool IsControllable {
       get { return isControllable; }
-      set {
+      private set {
         if (value != isControllable) {
           isControllable = value;
           OnIsControllableChanged();
-        }
-      }
+          if (this.hiveJobs != null) {
+            foreach (var hiveJob in this.hiveJobs) {
+              hiveJob.IsControllable = value;
+            }
+          }
+        }
+      }
+    }
+
+    // indicates if a user is allowed to share this experiment
+    private bool isSharable = true;
+    public bool IsSharable {
+      get { return isSharable; }
+      private set {
+        if (value != isSharable) {
+          isSharable = value;
+          OnIsSharableChanged();
+        }
+      }
+    }
+
+    // may execute jobs with privileged permissions on slaves
+    private bool isAllowedPrivileged = true;
+    public bool IsAllowedPrivileged {
+      get { return isAllowedPrivileged; }
+      set {
+        if (value != isAllowedPrivileged) {
+          isAllowedPrivileged = value;
+          OnIsAllowedPrivilegedChanged();
+        }
+      }
+    }
+
+    private bool isProgressing;
+    public bool IsProgressing {
+      get { return isProgressing; }
+      set {
+        if (isProgressing != value) {
+          isProgressing = value;
+          OnIsProgressingChanged();
+        }
+      }
+    }
+
+    private IProgress progress;
+    public IProgress Progress {
+      get { return progress; }
+      set { this.progress = value; }
     }
 
@@ -85 +183 @@
     public ILog Log {
       get { return log; }
+    }
+
+    public StateLogListList StateLogList {
+      get { return new StateLogListList(this.GetAllHiveJobs().Select(x => x.StateLog)); }
     }
 
@@ -94 +196 @@
       this.jobDownloader = new ConcurrentJobDownloader<ItemJob>(2, 2);
       this.jobDownloader.ExceptionOccured += new EventHandler<EventArgs<Exception>>(jobDownloader_ExceptionOccured);
+      this.HiveJobs = new ItemCollection<HiveJob>();
     }
     public RefreshableHiveExperiment(HiveExperiment hiveExperiment) {
@@ -101 +204 @@
       this.jobDownloader = new ConcurrentJobDownloader<ItemJob>(2, 2);
       this.jobDownloader.ExceptionOccured += new EventHandler<EventArgs<Exception>>(jobDownloader_ExceptionOccured);
+      this.HiveJobs = new ItemCollection<HiveJob>();
     }
     protected RefreshableHiveExperiment(RefreshableHiveExperiment original, Cloner cloner) {
@@ -110 +214 @@
       this.jobDownloader = new ConcurrentJobDownloader<ItemJob>(2, 2);
       this.jobDownloader.ExceptionOccured += new EventHandler<EventArgs<Exception>>(jobDownloader_ExceptionOccured);
+      this.HiveJobs = cloner.Clone(original.HiveJobs);
+      this.ExecutionTime = original.ExecutionTime;
+      this.ExecutionState = original.ExecutionState;
     }
     public IDeepCloneable Clone(Cloner cloner) {
@@ -118 +225 @@
     }
     #endregion
-
-    private void hiveExperiment_HiveJobsChanged(object sender, EventArgs e) {
-      if (jobResultPoller != null && jobResultPoller.IsPolling) {
-        jobResultPoller.Stop();
-        DeregisterResultPollingEvents();
-      }
-      if (hiveExperiment.HiveJobs != null && hiveExperiment.HiveJobs.Count > 0 && hiveExperiment.GetAllHiveJobs().All(x => x.Job.Id != Guid.Empty)) {
-        if (this.RefreshAutomatically)
-          StartResultPolling();
-      }
-    }
-
+    
     #region JobResultPoller Events
 
@@ -212 +308 @@
       GC.Collect(); // force GC, because .NET is too lazy here (deserialization takes a lot of memory)
       if (AllJobsFinished()) {
-        hiveExperiment.ExecutionState = Core.ExecutionState.Stopped;
+        this.ExecutionState = Core.ExecutionState.Stopped;
         StopResultPolling();
       }
@@ -221 +317 @@
 
     public HiveJob GetHiveJobById(Guid jobId) {
-      foreach (HiveJob job in hiveExperiment.HiveJobs) {
+      foreach (HiveJob job in this.HiveJobs) {
         var hj = job.GetHiveJobByJobId(jobId);
         if (hj != null)
@@ -229 +325 @@
     }
     private void UpdateStatistics() {
-      var jobs = hiveExperiment.GetAllHiveJobs();
+      var jobs = this.GetAllHiveJobs();
       hiveExperiment.JobCount = jobs.Count();
       hiveExperiment.CalculatingCount = jobs.Count(j => j.Job.State == JobState.Calculating);
@@ -237 +333 @@
 
     public bool AllJobsFinished() {
-      return hiveExperiment.GetAllHiveJobs().All(j => (j.Job.State == JobState.Finished
+      return this.GetAllHiveJobs().All(j => (j.Job.State == JobState.Finished
                                                    || j.Job.State == JobState.Aborted
                                                    || j.Job.State == JobState.Failed)
@@ -250 +346 @@
     }
     public void UpdateTotalExecutionTime() {
-      hiveExperiment.ExecutionTime = TimeSpan.FromMilliseconds(hiveExperiment.GetAllHiveJobs().Sum(x => x.Job.ExecutionTime.TotalMilliseconds));
+      this.ExecutionTime = TimeSpan.FromMilliseconds(this.GetAllHiveJobs().Sum(x => x.Job.ExecutionTime.TotalMilliseconds));
     }
     #endregion
@@ -256 +352 @@
     #region HiveExperiment Events
     private void RegisterHiveExperimentEvents() {
-      hiveExperiment.HiveJobsChanged += new EventHandler(hiveExperiment_HiveJobsChanged);
-      hiveExperiment.ToStringChanged += new EventHandler(hiveExperiment_ToStringChanged);
+      hiveExperiment.ToStringChanged += new EventHandler(OnToStringChanged);
       hiveExperiment.PropertyChanged += new PropertyChangedEventHandler(hiveExperiment_PropertyChanged);
       hiveExperiment.ItemImageChanged += new EventHandler(hiveExperiment_ItemImageChanged);
       hiveExperiment.ModifiedChanged += new EventHandler(hiveExperiment_ModifiedChanged);
-      hiveExperiment.IsProgressingChanged += new EventHandler(hiveExperiment_IsProgressingChanged);
-      hiveExperiment.Loaded += new EventHandler(hiveExperiment_Loaded);
     }
 
     private void DergisterHiveExperimentEvents() {
-      hiveExperiment.HiveJobsChanged -= new EventHandler(hiveExperiment_HiveJobsChanged);
-      hiveExperiment.ToStringChanged -= new EventHandler(hiveExperiment_ToStringChanged);
+      hiveExperiment.ToStringChanged -= new EventHandler(OnToStringChanged);
       hiveExperiment.PropertyChanged -= new PropertyChangedEventHandler(hiveExperiment_PropertyChanged);
       hiveExperiment.ItemImageChanged -= new EventHandler(hiveExperiment_ItemImageChanged);
       hiveExperiment.ModifiedChanged -= new EventHandler(hiveExperiment_ModifiedChanged);
-      hiveExperiment.IsProgressingChanged -= new EventHandler(hiveExperiment_IsProgressingChanged);
-      hiveExperiment.Loaded -= new EventHandler(hiveExperiment_Loaded);
-    }
-
-    private void hiveExperiment_Loaded(object sender, EventArgs e) {
-      this.UpdateTotalExecutionTime();
-
-      if (hiveExperiment.ExecutionState != ExecutionState.Stopped) {
-        this.RefreshAutomatically = true;
-      }
     }
     #endregion
@@ -311 +393 @@
     public event PropertyChangedEventHandler PropertyChanged;
     private void hiveExperiment_PropertyChanged(object sender, PropertyChangedEventArgs e) {
+      this.IsSharable = hiveExperiment.Permission == Permission.Full;
+      this.IsControllable = hiveExperiment.Permission == Permission.Full;
+
       var handler = PropertyChanged;
       if (handler != null) handler(sender, e);
@@ -316 +401 @@
 
     public event EventHandler ToStringChanged;
-    private void hiveExperiment_ToStringChanged(object sender, EventArgs e) {
+    private void OnToStringChanged(object sender, EventArgs e) {
       var handler = ToStringChanged;
       if (handler != null) handler(this, e);
@@ -322 +407 @@
 
     public event EventHandler IsProgressingChanged;
-    private void hiveExperiment_IsProgressingChanged(object sender, EventArgs e) {
+    protected virtual void OnIsProgressingChanged() {
       var handler = IsProgressingChanged;
-      if (handler != null) handler(sender, e);
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+
+    public event EventHandler IsDownloadableChanged;
+    private void OnIsDownloadableChanged() {
+      var handler = IsDownloadableChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
     }
 
@@ -330 +421 @@
     private void OnIsControllableChanged() {
       var handler = IsControllableChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+
+    public event EventHandler IsSharableChanged;
+    private void OnIsSharableChanged() {
+      var handler = IsSharableChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+
+    public event EventHandler IsAllowedPrivilegedChanged;
+    private void OnIsAllowedPrivilegedChanged() {
+      var handler = IsAllowedPrivilegedChanged;
       if (handler != null) handler(this, EventArgs.Empty);
     }
@@ -351 +454 @@
       if (handler != null) handler(this, EventArgs.Empty);
     }
+
+    public event EventHandler ExecutionTimeChanged;
+    protected virtual void OnExecutionTimeChanged() {
+      var handler = ExecutionTimeChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+
+    public event EventHandler ExecutionStateChanged;
+    protected virtual void OnExecutionStateChanged() {
+      var handler = ExecutionStateChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
     #endregion
+
+    #region HiveJobs Events
+    private void RegisterHiveJobsEvents() {
+      this.hiveJobs.ItemsAdded += new CollectionItemsChangedEventHandler<HiveJob>(hiveJobs_ItemsAdded);
+      this.hiveJobs.ItemsRemoved += new CollectionItemsChangedEventHandler<HiveJob>(hiveJobs_ItemsRemoved);
+      this.hiveJobs.CollectionReset += new CollectionItemsChangedEventHandler<HiveJob>(hiveJobs_CollectionReset);
+    }
+
+    private void DeregisterHiveJobsEvents() {
+      this.hiveJobs.ItemsAdded -= new CollectionItemsChangedEventHandler<HiveJob>(hiveJobs_ItemsAdded);
+      this.hiveJobs.ItemsRemoved -= new CollectionItemsChangedEventHandler<HiveJob>(hiveJobs_ItemsRemoved);
+      this.hiveJobs.CollectionReset -= new CollectionItemsChangedEventHandler<HiveJob>(hiveJobs_CollectionReset);
+    }
+
+    private void hiveJobs_CollectionReset(object sender, CollectionItemsChangedEventArgs<HiveJob> e) {
+      foreach (var item in e.Items) {
+        item.StateLogChanged -= new EventHandler(item_StateLogChanged);
+      }
+      OnHiveJobsReset(e);
+    }
+
+    private void hiveJobs_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<HiveJob> e) {
+      foreach (var item in e.Items) {
+        item.StateLogChanged -= new EventHandler(item_StateLogChanged);
+      }
+      OnHiveJobsRemoved(e);
+    }
+
+    private void hiveJobs_ItemsAdded(object sender, CollectionItemsChangedEventArgs<HiveJob> e) {
+      foreach (var item in e.Items) {
+        item.StateLogChanged += new EventHandler(item_StateLogChanged);
+        item.IsControllable = this.IsControllable;
+      }
+      OnHiveJobsAdded(e);
+    }
+
+    private void item_StateLogChanged(object sender, EventArgs e) {
+      OnStateLogListChanged();
+    }
+    #endregion
+
+    public event EventHandler HiveJobsChanged;
+    protected virtual void OnHiveJobsChanged() {
+      if (jobResultPoller != null && jobResultPoller.IsPolling) {
+        jobResultPoller.Stop();
+        DeregisterResultPollingEvents();
+      }
+      if (this.HiveJobs != null && this.HiveJobs.Count > 0 && this.GetAllHiveJobs().All(x => x.Job.Id != Guid.Empty)) {
+        if (this.RefreshAutomatically)
+          StartResultPolling();
+      }
+
+      var handler = HiveJobsChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+
+    public event EventHandler Loaded;
+    public virtual void OnLoaded() {
+      this.UpdateTotalExecutionTime();
+
+      if (this.ExecutionState != ExecutionState.Stopped) {
+        this.RefreshAutomatically = true;
+      }
+
+      var handler = Loaded;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+
+    public event EventHandler<CollectionItemsChangedEventArgs<HiveJob>> HiveJobsAdded;
+    private void OnHiveJobsAdded(CollectionItemsChangedEventArgs<HiveJob> e) {
+      var handler = HiveJobsAdded;
+      if (handler != null) handler(this, e);
+    }
+
+    public event EventHandler<CollectionItemsChangedEventArgs<HiveJob>> HiveJobsRemoved;
+    private void OnHiveJobsRemoved(CollectionItemsChangedEventArgs<HiveJob> e) {
+      var handler = HiveJobsRemoved;
+      if (handler != null) handler(this, e);
+    }
+
+    public event EventHandler<CollectionItemsChangedEventArgs<HiveJob>> HiveJobsReset;
+    private void OnHiveJobsReset(CollectionItemsChangedEventArgs<HiveJob> e) {
+      var handler = HiveJobsReset;
+      if (handler != null) handler(this, e);
+    }
 
     public Guid Id {
@@ -375 +575 @@
       get { return hiveExperiment.ItemVersion; }
     }
-    
-    #region IProgressReporter Members
-    public IProgress Progress {
-      get { return HiveExperiment.Progress; }
-    }
-
-    public bool IsProgressing {
-      get { return HiveExperiment.IsProgressing; }
-    }
-    #endregion
 
     public override string ToString() {
       return string.Format("{0} {1}", HiveExperiment.DateCreated.ToString("MM.dd.yyyy HH:mm"), HiveExperiment.ToString());
     }
+
+    public bool IsFinished() {
+      return HiveJobs != null
+        && HiveJobs.All(x => x.Job.DateFinished.HasValue && x.Job.DateCreated.HasValue);
+    }
+
+    public IEnumerable<HiveJob> GetAllHiveJobs() {
+      if (hiveJobs == null) return Enumerable.Empty<HiveJob>();
+
+      var jobs = new List<HiveJob>();
+      foreach (HiveJob job in HiveJobs) {
+        jobs.AddRange(job.GetAllHiveJobs());
+      }
+      return jobs;
+    }
+
+    public int CompareTo(RefreshableHiveExperiment other) {
+      return this.ToString().CompareTo(other.ToString());
+    }
   }
 }