Free cookie consent management tool by TermsFeed Policy Generator

source: branches/HeuristicLab.TimeSeries/HeuristicLab.Clients.Hive.JobManager/3.3/Views/RefreshableHiveJobView.cs @ 7842

Last change on this file since 7842 was 7842, checked in by gkronber, 12 years ago

merged r7609:7840 from trunk into time series branch

File size: 20.4 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
4 *
5 * This file is part of HeuristicLab.
6 *
7 * HeuristicLab is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * HeuristicLab is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
19 */
20#endregion
21
22using System;
23using System.ComponentModel;
24using System.Linq;
25using System.Threading;
26using System.Windows.Forms;
27using HeuristicLab.Collections;
28using HeuristicLab.Common;
29using HeuristicLab.Core;
30using HeuristicLab.MainForm;
31using HeuristicLab.MainForm.WindowsForms;
32using HeuristicLab.Optimization;
33using HeuristicLab.PluginInfrastructure;
34
35namespace HeuristicLab.Clients.Hive.JobManager.Views {
36  /// <summary>
37  /// The base class for visual representations of items.
38  /// </summary>
39  [View("Hive Job View")]
40  [Content(typeof(RefreshableJob), true)]
41  public partial class RefreshableHiveJobView : HeuristicLab.Core.Views.ItemView {
42    private ProgressView progressView;
43
44    public new RefreshableJob Content {
45      get { return (RefreshableJob)base.Content; }
46      set { base.Content = value; }
47    }
48
49    /// <summary>
50    /// Initializes a new instance of <see cref="ItemBaseView"/>.
51    /// </summary>
52    public RefreshableHiveJobView() {
53      InitializeComponent();
54    }
55
56    protected override void RegisterContentEvents() {
57      base.RegisterContentEvents();
58      Content.RefreshAutomaticallyChanged += new EventHandler(Content_RefreshAutomaticallyChanged);
59      Content.JobChanged += new EventHandler(Content_HiveExperimentChanged);
60      Content.IsControllableChanged += new EventHandler(Content_IsControllableChanged);
61      Content.JobStatisticsChanged += new EventHandler(Content_JobStatisticsChanged);
62      Content.ExceptionOccured += new EventHandler<EventArgs<Exception>>(Content_ExceptionOccured);
63      Content.StateLogListChanged += new EventHandler(Content_StateLogListChanged);
64      Content.IsProgressingChanged += new EventHandler(Content_IsProgressingChanged);
65      Content.HiveTasksChanged += new EventHandler(Content_HiveTasksChanged);
66      Content.ExecutionStateChanged += new EventHandler(Content_ExecutionStateChanged);
67      Content.ExecutionTimeChanged += new EventHandler(Content_ExecutionTimeChanged);
68      Content.IsAllowedPrivilegedChanged += new EventHandler(Content_IsAllowedPrivilegedChanged);
69      Content.Loaded += new EventHandler(Content_Loaded);
70      Content.TaskReceived += new EventHandler(Content_TaskReceived);
71    }
72
73    protected override void DeregisterContentEvents() {
74      Content.RefreshAutomaticallyChanged -= new EventHandler(Content_RefreshAutomaticallyChanged);
75      Content.JobChanged -= new EventHandler(Content_HiveExperimentChanged);
76      Content.IsControllableChanged -= new EventHandler(Content_IsControllableChanged);
77      Content.JobStatisticsChanged -= new EventHandler(Content_JobStatisticsChanged);
78      Content.ExceptionOccured -= new EventHandler<EventArgs<Exception>>(Content_ExceptionOccured);
79      Content.StateLogListChanged -= new EventHandler(Content_StateLogListChanged);
80      Content.IsProgressingChanged -= new EventHandler(Content_IsProgressingChanged);
81      Content.HiveTasksChanged -= new EventHandler(Content_HiveTasksChanged);
82      Content.ExecutionStateChanged -= new EventHandler(Content_ExecutionStateChanged);
83      Content.ExecutionTimeChanged -= new EventHandler(Content_ExecutionTimeChanged);
84      Content.Loaded -= new EventHandler(Content_Loaded);
85      Content.TaskReceived -= new EventHandler(Content_TaskReceived);
86      base.DeregisterContentEvents();
87    }
88
89    private void RegisterHiveExperimentEvents() {
90      Content.Job.PropertyChanged += new PropertyChangedEventHandler(HiveExperiment_PropertyChanged);
91    }
92
93    private void DeregisterHiveExperimentEvents() {
94      Content.Job.PropertyChanged -= new PropertyChangedEventHandler(HiveExperiment_PropertyChanged);
95    }
96
97    private void RegisterHiveJobEvents() {
98      Content.HiveTasks.ItemsAdded += new CollectionItemsChangedEventHandler<HiveTask>(HiveTasks_ItemsAdded);
99      Content.HiveTasks.ItemsRemoved += new CollectionItemsChangedEventHandler<HiveTask>(HiveTasks_ItemsRemoved);
100      Content.HiveTasks.CollectionReset += new CollectionItemsChangedEventHandler<HiveTask>(HiveTasks_CollectionReset);
101    }
102    private void DeregisterHiveJobEvents() {
103      Content.HiveTasks.ItemsAdded -= new CollectionItemsChangedEventHandler<HiveTask>(HiveTasks_ItemsAdded);
104      Content.HiveTasks.ItemsRemoved -= new CollectionItemsChangedEventHandler<HiveTask>(HiveTasks_ItemsRemoved);
105      Content.HiveTasks.CollectionReset -= new CollectionItemsChangedEventHandler<HiveTask>(HiveTasks_CollectionReset);
106    }
107
108    protected override void OnContentChanged() {
109      base.OnContentChanged();
110      if (Content == null) {
111        nameTextBox.Text = string.Empty;
112        executionTimeTextBox.Text = string.Empty;
113        resourceNamesTextBox.Text = string.Empty;
114        isPrivilegedCheckBox.Checked = false;
115        logView.Content = null;
116        refreshAutomaticallyCheckBox.Checked = false;
117        runCollectionViewHost.Content = null;
118      } else {
119        nameTextBox.Text = Content.Job.Name;
120        executionTimeTextBox.Text = Content.ExecutionTime.ToString();
121        resourceNamesTextBox.Text = Content.Job.ResourceNames;
122        isPrivilegedCheckBox.Checked = Content.Job.IsPrivileged;
123        refreshAutomaticallyCheckBox.Checked = Content.RefreshAutomatically;
124        logView.Content = Content.Log;
125        runCollectionViewHost.Content = GetAllRunsFromJob(Content);
126      }
127      hiveExperimentPermissionListView.Content = null; // has to be filled by refresh button
128      Content_JobStatisticsChanged(this, EventArgs.Empty);
129      Content_HiveExperimentChanged(this, EventArgs.Empty);
130      Content_HiveTasksChanged(this, EventArgs.Empty);
131      Content_IsProgressingChanged(this, EventArgs.Empty);
132      Content_StateLogListChanged(this, EventArgs.Empty);
133      HiveExperiment_PropertyChanged(this, new PropertyChangedEventArgs("Id"));
134      SetEnabledStateOfControls();
135    }
136
137    protected override void SetEnabledStateOfControls() {
138      base.SetEnabledStateOfControls();
139      executionTimeTextBox.Enabled = Content != null;
140      jobsTextBox.ReadOnly = true;
141      calculatingTextBox.ReadOnly = true;
142      finishedTextBox.ReadOnly = true;
143
144      if (Content != null) {
145        bool alreadyUploaded = Content.Id != Guid.Empty;
146        bool jobsLoaded = Content.HiveTasks != null && Content.HiveTasks.All(x => x.Task.Id != Guid.Empty);
147
148        this.nameTextBox.ReadOnly = !Content.IsControllable || Content.ExecutionState != ExecutionState.Prepared || alreadyUploaded;
149        this.resourceNamesTextBox.ReadOnly = !Content.IsControllable || Content.ExecutionState != ExecutionState.Prepared || alreadyUploaded;
150        this.jobsTreeView.ReadOnly = !Content.IsControllable || Content.ExecutionState != ExecutionState.Prepared || alreadyUploaded;
151
152        this.isPrivilegedCheckBox.Enabled = Content.IsAllowedPrivileged && Content.IsControllable && !(Content.ExecutionState != ExecutionState.Prepared || alreadyUploaded); // TODO: check if user has the rights to do this       
153        this.refreshAutomaticallyCheckBox.Enabled = Content.IsControllable && alreadyUploaded && jobsLoaded && Content.ExecutionState == ExecutionState.Started;
154        this.refreshButton.Enabled = Content.IsDownloadable && alreadyUploaded;
155        this.Locked = !Content.IsControllable || Content.ExecutionState == ExecutionState.Started;
156      }
157      SetEnabledStateOfExecutableButtons();
158      tabControl_SelectedIndexChanged(this, EventArgs.Empty); // ensure sharing tabpage is disabled
159    }
160
161    protected override void OnClosed(FormClosedEventArgs e) {
162      if (Content != null) {
163        if (Content.RefreshAutomatically)
164          Content.StopResultPolling();
165      }
166      base.OnClosed(e);
167    }
168
169    #region Content Events
170    void Content_TaskReceived(object sender, EventArgs e) {
171      runCollectionViewHost.Content = GetAllRunsFromJob(Content);
172    }
173
174    private void HiveTasks_ItemsAdded(object sender, CollectionItemsChangedEventArgs<HiveTask> e) {
175      if (InvokeRequired)
176        Invoke(new CollectionItemsChangedEventHandler<HiveTask>(HiveTasks_ItemsAdded), sender, e);
177      else {
178        SetEnabledStateOfControls();
179      }
180    }
181
182    private void HiveTasks_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<HiveTask> e) {
183      if (InvokeRequired)
184        Invoke(new CollectionItemsChangedEventHandler<HiveTask>(HiveTasks_ItemsRemoved), sender, e);
185      else {
186        SetEnabledStateOfControls();
187      }
188    }
189
190    private void HiveTasks_CollectionReset(object sender, CollectionItemsChangedEventArgs<HiveTask> e) {
191      if (InvokeRequired)
192        Invoke(new CollectionItemsChangedEventHandler<HiveTask>(HiveTasks_CollectionReset), sender, e);
193      else {
194        SetEnabledStateOfControls();
195      }
196    }
197
198    private void Content_ExecutionStateChanged(object sender, EventArgs e) {
199      if (InvokeRequired)
200        Invoke(new EventHandler(Content_ExecutionStateChanged), sender, e);
201      else
202        SetEnabledStateOfControls();
203    }
204    private void Content_Prepared(object sender, EventArgs e) {
205      if (InvokeRequired)
206        Invoke(new EventHandler(Content_Prepared), sender, e);
207      else {
208        nameTextBox.Enabled = true;
209        Locked = false;
210        SetEnabledStateOfControls();
211      }
212    }
213    private void Content_Started(object sender, EventArgs e) {
214      if (InvokeRequired)
215        Invoke(new EventHandler(Content_Started), sender, e);
216      else {
217        nameTextBox.Enabled = false;
218        SetEnabledStateOfControls();
219      }
220    }
221    private void Content_Paused(object sender, EventArgs e) {
222      if (InvokeRequired)
223        Invoke(new EventHandler(Content_Paused), sender, e);
224      else {
225        nameTextBox.Enabled = true;
226        SetEnabledStateOfControls();
227      }
228    }
229    private void Content_Stopped(object sender, EventArgs e) {
230      if (InvokeRequired)
231        Invoke(new EventHandler(Content_Stopped), sender, e);
232      else {
233        nameTextBox.Enabled = true;
234        Locked = false;
235        SetEnabledStateOfControls();
236      }
237    }
238    private void Content_ExecutionTimeChanged(object sender, EventArgs e) {
239      if (InvokeRequired)
240        Invoke(new EventHandler(Content_ExecutionTimeChanged), sender, e);
241      else
242        executionTimeTextBox.Text = Content.ExecutionTime.ToString();
243    }
244    private void Content_RefreshAutomaticallyChanged(object sender, EventArgs e) {
245      if (InvokeRequired)
246        Invoke(new EventHandler(Content_RefreshAutomaticallyChanged), sender, e);
247      else {
248        refreshAutomaticallyCheckBox.Checked = Content.RefreshAutomatically;
249        SetEnabledStateOfControls();
250      }
251    }
252    private void Content_HiveTasksChanged(object sender, EventArgs e) {
253      if (InvokeRequired)
254        Invoke(new EventHandler(Content_HiveTasksChanged), sender, e);
255      else {
256        if (Content != null && Content.HiveTasks != null) {
257          jobsTreeView.Content = Content.HiveTasks;
258          RegisterHiveJobEvents();
259        } else {
260          jobsTreeView.Content = null;
261        }
262        SetEnabledStateOfControls();
263      }
264    }
265
266    void Content_Loaded(object sender, EventArgs e) {
267      runCollectionViewHost.Content = GetAllRunsFromJob(Content);
268    }
269
270    private void Content_HiveExperimentChanged(object sender, EventArgs e) {
271      if (Content != null && Content.Job != null) {
272        RegisterHiveExperimentEvents();
273        Content_IsProgressingChanged(sender, e);
274      }
275    }
276    private void Content_IsControllableChanged(object sender, EventArgs e) {
277      SetEnabledStateOfControls();
278    }
279    private void Content_JobStatisticsChanged(object sender, EventArgs e) {
280      if (InvokeRequired)
281        Invoke(new EventHandler(Content_JobStatisticsChanged), sender, e);
282      else {
283        if (Content != null) {
284          jobsTextBox.Text = (Content.Job.JobCount - Content.Job.CalculatingCount - Content.Job.FinishedCount).ToString();
285          calculatingTextBox.Text = Content.Job.CalculatingCount.ToString();
286          finishedTextBox.Text = Content.Job.FinishedCount.ToString();
287        } else {
288          jobsTextBox.Text = "0";
289          calculatingTextBox.Text = "0";
290          finishedTextBox.Text = "0";
291        }
292      }
293    }
294    private void Content_ExceptionOccured(object sender, EventArgs<Exception> e) {
295      if (InvokeRequired)
296        Invoke(new EventHandler<EventArgs<Exception>>(Content_ExceptionOccured), sender, e);
297      else {
298        //don't show the error dialog when downloading tasks, the HiveClient will throw an exception and the dialog will be shown then
299        if (sender.GetType() != typeof(ConcurrentTaskDownloader<ItemTask>) && sender.GetType() != typeof(TaskDownloader)) {
300          ErrorHandling.ShowErrorDialog(this, e.Value);
301        }
302      }
303    }
304    private void Content_StateLogListChanged(object sender, EventArgs e) {
305      if (InvokeRequired)
306        Invoke(new EventHandler(Content_StateLogListChanged), sender, e);
307      else {
308        UpdateStateLogList();
309      }
310    }
311    private void Content_IsAllowedPrivilegedChanged(object sender, EventArgs e) {
312      if (InvokeRequired)
313        Invoke(new EventHandler(Content_IsAllowedPrivilegedChanged), sender, e);
314      else {
315        SetEnabledStateOfControls();
316      }
317    }
318
319
320    private void UpdateStateLogList() {
321      if (Content != null && this.Content.Job != null) {
322        stateLogViewHost.Content = this.Content.StateLogList;
323      } else {
324        stateLogViewHost.Content = null;
325      }
326    }
327
328    private void HiveExperiment_PropertyChanged(object sender, PropertyChangedEventArgs e) {
329      if (this.Content != null && e.PropertyName == "Id") this.hiveExperimentPermissionListView.HiveExperimentId = this.Content.Job.Id;
330    }
331    #endregion
332
333    #region Control events
334    private void startButton_Click(object sender, EventArgs e) {
335      if (nameTextBox.Text.Trim() == string.Empty) {
336        MessageBox.Show("Please enter a name for the job before uploading it!", "HeuristicLab Hive Job Manager", MessageBoxButtons.OK, MessageBoxIcon.Information);
337      } else {
338        HiveClient.StartJob((Exception ex) => ErrorHandling.ShowErrorDialog(this, "Start failed.", ex), Content, new CancellationToken());
339      }
340    }
341    private void pauseButton_Click(object sender, EventArgs e) {
342      HiveClient.PauseJob(Content);
343    }
344    private void stopButton_Click(object sender, EventArgs e) {
345      HiveClient.StopJob(Content);
346    }
347    private void resetButton_Click(object sender, EventArgs e) { }
348
349    private void nameTextBox_Validated(object sender, EventArgs e) {
350      if (Content.Job.Name != nameTextBox.Text)
351        Content.Job.Name = nameTextBox.Text;
352    }
353
354    private void resourceNamesTextBox_Validated(object sender, EventArgs e) {
355      if (Content.Job.ResourceNames != resourceNamesTextBox.Text)
356        Content.Job.ResourceNames = resourceNamesTextBox.Text;
357    }
358
359    private void refreshAutomaticallyCheckBox_Validated(object sender, EventArgs e) {
360      if (Content != null) Content.RefreshAutomatically = refreshAutomaticallyCheckBox.Checked;
361    }
362
363    private void isPrivilegedCheckBox_Validated(object sender, EventArgs e) {
364      if (Content != null) Content.Job.IsPrivileged = isPrivilegedCheckBox.Checked;
365    }
366
367    private void refreshButton_Click(object sender, EventArgs e) {
368      var invoker = new Action<RefreshableJob>(HiveClient.LoadJob);
369      invoker.BeginInvoke(Content, (ar) => {
370        try {
371          invoker.EndInvoke(ar);
372        }
373        catch (Exception ex) {
374          ThreadPool.QueueUserWorkItem(delegate(object exception) { ErrorHandling.ShowErrorDialog(this, (Exception)exception); }, ex);
375        }
376      }, null);
377    }
378
379    private void refreshPermissionsButton_Click(object sender, EventArgs e) {
380      if (this.Content.Job.Id == Guid.Empty) {
381        MessageBox.Show("You have to upload the Job first before you can share it.", "HeuristicLab Hive Job Manager", MessageBoxButtons.OK, MessageBoxIcon.Information);
382      } else {
383        hiveExperimentPermissionListView.Content = HiveClient.GetJobPermissions(this.Content.Job.Id);
384      }
385    }
386
387
388    #endregion
389
390    #region Helpers
391    private void SetEnabledStateOfExecutableButtons() {
392      if (Content == null) {
393        startButton.Enabled = pauseButton.Enabled = stopButton.Enabled = resetButton.Enabled = false;
394      } else {
395        startButton.Enabled = Content.IsControllable && Content.HiveTasks != null && Content.HiveTasks.Count > 0 && Content.ExecutionState == ExecutionState.Prepared;
396        pauseButton.Enabled = Content.IsControllable && Content.ExecutionState == ExecutionState.Started;
397        stopButton.Enabled = Content.IsControllable && Content.ExecutionState == ExecutionState.Started;
398        resetButton.Enabled = false;
399      }
400    }
401    #endregion
402
403    #region Progress reporting
404    private void Content_IsProgressingChanged(object sender, EventArgs e) {
405      if (this.InvokeRequired) {
406        Invoke(new EventHandler(Content_IsProgressingChanged), sender, e);
407      } else {
408        if (Content != null && Content.IsProgressing) {
409          SetProgressView();
410        } else {
411          FinishProgressView();
412        }
413      }
414    }
415
416    private void SetProgressView() {
417      if (progressView == null) {
418        progressView = new ProgressView(this, Content.Progress);
419      }
420      progressView.Progress = Content.Progress;
421    }
422
423    private void FinishProgressView() {
424      if (progressView != null) {
425        progressView.Finish();
426        progressView = null;
427        SetEnabledStateOfControls();
428      }
429    }
430    #endregion
431
432    #region Drag & Drop
433    private void jobsTreeView_DragOver(object sender, DragEventArgs e) {
434      jobsTreeView_DragEnter(sender, e);
435    }
436
437    private void jobsTreeView_DragEnter(object sender, DragEventArgs e) {
438      e.Effect = DragDropEffects.None;
439      var obj = e.Data.GetData(Constants.DragDropDataFormat);
440      if (obj is IOptimizer) {
441        if (Content.Id != Guid.Empty) e.Effect = DragDropEffects.None;
442        else if ((e.KeyState & 32) == 32) e.Effect = DragDropEffects.Link;  // ALT key
443        else if (e.AllowedEffect.HasFlag(DragDropEffects.Copy)) e.Effect = DragDropEffects.Copy;
444      }
445    }
446
447    private void jobsTreeView_DragDrop(object sender, DragEventArgs e) {
448      if (e.Effect != DragDropEffects.None) {
449        var obj = e.Data.GetData(Constants.DragDropDataFormat);
450
451        var optimizer = obj as IOptimizer;
452        if (optimizer != null) {
453          IOptimizer newOptimizer = null;
454          if (e.Effect.HasFlag(DragDropEffects.Copy)) {
455            newOptimizer = (IOptimizer)optimizer.Clone();
456          } else {
457            newOptimizer = optimizer;
458          }
459          if (newOptimizer.ExecutionState != ExecutionState.Prepared) {
460            newOptimizer.Prepare();
461          }
462
463          Content.HiveTasks.Add(new OptimizerHiveTask(newOptimizer));
464        }
465      }
466    }
467    #endregion
468
469    private void tabControl_SelectedIndexChanged(object sender, EventArgs e) {
470      if (tabControl.SelectedTab == permissionTabPage) {
471        if (!Content.IsSharable) {
472          MessageBox.Show("Unable to load tab. You have insufficient access privileges.");
473          tabControl.SelectedTab = tasksTabPage;
474        }
475      }
476    }
477
478    private RunCollection GetAllRunsFromJob(RefreshableJob job) {
479      if (job != null) {
480        RunCollection runs = new RunCollection();
481
482        foreach (HiveTask subTask in job.HiveTasks) {
483          if (subTask is OptimizerHiveTask) {
484            OptimizerHiveTask ohTask = subTask as OptimizerHiveTask;
485            runs.AddRange(ohTask.ItemTask.Item.Runs);
486          }
487        }
488        return runs;
489      } else {
490        return null;
491      }
492    }
493  }
494}
Note: See TracBrowser for help on using the repository browser.