source: branches/2877_HiveImprovements/HeuristicLab.Clients.Hive.Administrator/3.3/Views/ResourcesView.cs @ 16362

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2018 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.Drawing;
using System.Linq;
using System.ServiceModel.Security;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using HeuristicLab.Clients.Access;
using HeuristicLab.Clients.Hive.Views;
using HeuristicLab.Core;
using HeuristicLab.Core.Views;
using HeuristicLab.MainForm;
using TS = System.Threading.Tasks;

namespace HeuristicLab.Clients.Hive.Administrator.Views {
  [View("Resources View")]
  [Content(typeof(IItemList<Resource>), false)]
  public partial class ResourcesView : ItemView, IDisposable {
    public new IItemList<Resource> Content {
      get { return (IItemList<Resource>)base.Content; }
      set { base.Content = value; }
    }

    public const string UNGROUPED_GROUP_NAME = "UNGROUPED";
    private TreeNode ungroupedGroupNode;
    private const int slaveImageIndex = 0;
    private const int slaveGroupImageIndex = 1;
    private readonly Color ownedResourceColor = Color.LightGreen;
    private readonly Color calculatingColor = Color.DarkGreen;
    private readonly Color offlineColor = Color.Red;
    private TS.Task progressTask;
    private bool stopProgressTask;
    private bool currentlyAuthorized;


    public ResourcesView() {
      InitializeComponent();
      treeSlaveGroup.ImageList.Images.Add(HeuristicLab.Common.Resources.VSImageLibrary.MonitorLarge);
      treeSlaveGroup.ImageList.Images.Add(HeuristicLab.Common.Resources.VSImageLibrary.NetworkCenterLarge);

      HiveAdminClient.Instance.Refreshing += new EventHandler(Instance_Refreshing);
      HiveAdminClient.Instance.Refreshed += new EventHandler(Instance_Refreshed);

      Access.AccessClient.Instance.Refreshing += new EventHandler(AccessClient_Refreshing);
      Access.AccessClient.Instance.Refreshed += new EventHandler(AccessClient_Refreshed);
    }

    private void UpdateProgress() {
      while (!stopProgressTask) {
        int diff = (progressBar.Maximum - progressBar.Minimum) / 10;

        if (progressBar.InvokeRequired) {
          progressBar.Invoke(new Action(delegate() { progressBar.Value = (progressBar.Value + diff) % progressBar.Maximum; }));
        } else {
          progressBar.Value = (progressBar.Value + diff) % progressBar.Maximum;
        }

        //ok, this is not very clever...
        Thread.Sleep(500);
      }
      if (progressBar.InvokeRequired) {
        progressBar.Invoke(new Action(delegate() { progressBar.Value = progressBar.Minimum; }));
      } else {
        progressBar.Value = progressBar.Minimum;
      }
    }

    void Instance_Refreshing(object sender, EventArgs e) {
      stopProgressTask = false;
      progressTask = new TS.Task(UpdateProgress);
      progressTask.Start();
      SetEnabledStateOfControls();
    }

    void Instance_Refreshed(object sender, EventArgs e) {
      stopProgressTask = true;
      SetEnabledStateOfControls();
    }

    void AccessClient_Refreshing(object sender, EventArgs e) {
      stopProgressTask = false;
      progressTask = new TS.Task(UpdateProgress);
      progressTask.Start();
      SetEnabledStateOfControls();
      btnPermissionsSave.Enabled = false;
    }

    void AccessClient_Refreshed(object sender, EventArgs e) {
      stopProgressTask = true;
      SetEnabledStateOfControls();
    }

    #region Register Content Events
    protected override void DeregisterContentEvents() {
      Content.ItemsAdded -= new Collections.CollectionItemsChangedEventHandler<Collections.IndexedItem<Resource>>(Content_ItemsAdded);
      Content.ItemsRemoved -= new Collections.CollectionItemsChangedEventHandler<Collections.IndexedItem<Resource>>(Content_ItemsRemoved);
      base.DeregisterContentEvents();
    }
    protected override void RegisterContentEvents() {
      base.RegisterContentEvents();
      Content.ItemsAdded += new Collections.CollectionItemsChangedEventHandler<Collections.IndexedItem<Resource>>(Content_ItemsAdded);
      Content.ItemsRemoved += new Collections.CollectionItemsChangedEventHandler<Collections.IndexedItem<Resource>>(Content_ItemsRemoved);
    }
    #endregion

    protected override void OnContentChanged() {
      base.OnContentChanged();
      if (Content == null) {
        slaveView.Content = null;
        scheduleView.Content = null;
        permissionView.Content = null;
        permissionView.FetchSelectedUsers = null;
        treeSlaveGroup.Nodes.Clear();
      } else {
        permissionView.Content = Access.AccessClient.Instance;
        treeSlaveGroup.Nodes.Clear();

        //rebuild
        var ungroupedSlaves = new SlaveGroup {
          Id = Guid.NewGuid(),
          Name = UNGROUPED_GROUP_NAME,
          Description = "Slaves without a group"
        };
        ungroupedGroupNode = CreateTreeNode(ungroupedSlaves);

        var parentlessResources = from r in Content
                                  where r.ParentResourceId == null
                                  orderby r.Name
                                  select r;
        foreach (Resource r in parentlessResources) {
          if (r.GetType() == typeof(SlaveGroup)) {  // root node
            var root = CreateTreeNode(r);
            treeSlaveGroup.Nodes.Add(root);
            BuildSlaveGroupTree((SlaveGroup)r, root);
          } else if (r.GetType() == typeof(Slave)) {  // ungrouped slaves
            ungroupedGroupNode.Nodes.Add(CreateTreeNode(r));
          }
        }
        if (ungroupedGroupNode.Nodes.Count > 0)
          ungroupedGroupNode.Text += "   [" + ungroupedGroupNode.Nodes.Count.ToString() + "]";
        treeSlaveGroup.Nodes.Add(ungroupedGroupNode);
      }
    }

    private void BuildSlaveGroupTree(SlaveGroup group, TreeNode node) {
      var childGroups = from r in Content.OfType<SlaveGroup>()
                        where r.ParentResourceId == @group.Id
                        orderby r.Name
                        select r;
      foreach (var g in childGroups) {
        var childNode = CreateTreeNode(g);
        node.Nodes.Add(childNode);
        BuildSlaveGroupTree(g, childNode);
      }

      var childSlaves = from r in Content.OfType<Slave>()
                        where r.ParentResourceId == @group.Id
                        orderby r.Name
                        select r;
      var childSlavesCount = 0;
      foreach (var s in childSlaves) {
        node.Nodes.Add(CreateTreeNode(s));
        childSlavesCount++;
      }
      if (childSlavesCount > 0)
        node.Text = group.Name + "   [" + childSlavesCount.ToString() + "]";
    }

    private TreeNode CreateTreeNode(Resource r) {
      var node = new TreeNode();
      node.Text = r.Name;

      if (r is SlaveGroup) {
        node.ImageIndex = slaveGroupImageIndex;
      } else if (r is Slave) {
        var s = r as Slave;
        node.ImageIndex = slaveImageIndex;
        if (s.SlaveState == SlaveState.Calculating) {
          node.ForeColor = calculatingColor;
          node.Text += "   [" + s.CpuUtilization.ToString("N2") + " %]";
        } else if (s.SlaveState == SlaveState.Offline) {
          node.ForeColor = offlineColor;
          if (s.LastHeartbeat.HasValue)
            node.Text += "   [" + s.LastHeartbeat?.ToString("g") + "]";
        }
      }
      node.SelectedImageIndex = node.ImageIndex;

      if (r.OwnerUserId == Access.UserInformation.Instance.User.Id) node.BackColor = ownedResourceColor;

      node.Tag = r;
      return node;
    }

    protected override void SetEnabledStateOfControls() {
      base.SetEnabledStateOfControls();
      if (Content == null) {
        btnAddGroup.Enabled = false;
        btnRemoveGroup.Enabled = false;
        btnSave.Enabled = false;
        btnPermissionsSave.Enabled = false;
        permissionView.Enabled = false;
        scheduleView.SetEnabledStateOfSchedule(false);
        btnPermissionsSave.Enabled = false;
        permissionView.Enabled = false;
      } else {
        btnAddGroup.Enabled = true;
        btnRemoveGroup.Enabled = true;
        btnSave.Enabled = true;
        scheduleView.SetEnabledStateOfSchedule(IsAuthorized(slaveView.Content));
        btnPermissionsSave.Enabled = permissionView.FetchSelectedUsers != null;
        permissionView.Enabled = permissionView.FetchSelectedUsers != null;
      }
    }

    private bool IsAuthorized(Resource resource) {
      return resource != null
          && resource != ungroupedGroupNode.Tag
          && resource.Id != Guid.Empty
          && UserInformation.Instance.UserExists
          && (resource.OwnerUserId == UserInformation.Instance.User.Id || HiveRoles.CheckAdminUserPermissions());
    }

    private void treeSlaveGroup_AfterSelect(object sender, TreeViewEventArgs e) {
      if (e.Action != TreeViewAction.Unknown) {
        Resource selectedResource = ((Resource)e.Node.Tag);
        currentlyAuthorized = IsAuthorized(selectedResource);
        if (currentlyAuthorized) {
          permissionView.FetchSelectedUsers = new Func<List<Guid>>(() => {
            return HiveServiceLocator.Instance.CallHiveService<List<ResourcePermission>>(service => {
              return service.GetResourcePermissions(selectedResource.Id);
            }).Select(x => x.GrantedUserId).ToList();
          });
          if (!tabSlaveGroup.TabPages.Contains(tabPermissions)) tabSlaveGroup.TabPages.Add(tabPermissions);
        } else {
          permissionView.FetchSelectedUsers = null;
          btnPermissionsSave.Enabled = false;
          if (selectedResource.Id == Guid.Empty) {
            if (!tabSlaveGroup.TabPages.Contains(tabPermissions)) tabSlaveGroup.TabPages.Add(tabPermissions);
          } else tabSlaveGroup.TabPages.Remove(tabPermissions);
        }

        if (slaveView.Content != null && slaveView.Content is SlaveGroup) {
          slaveView.Content.PropertyChanged -= new System.ComponentModel.PropertyChangedEventHandler(SlaveViewContent_PropertyChanged);
        }

        slaveView.Content = selectedResource;
        HiveAdminClient.Instance.DowntimeForResourceId = selectedResource.Id;

        if (selectedResource is SlaveGroup) {
          slaveView.Content.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(SlaveViewContent_PropertyChanged);
        }

        if (tabSlaveGroup.SelectedIndex == 1) {
          UpdateScheduleAsync();
        } else if (tabSlaveGroup.SelectedIndex == 2) {
          UpdatePermissionsAsync();
        }
      }
    }

    void SlaveViewContent_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e) {
      OnContentChanged();
      if (e.PropertyName == "HbInterval") {
        UpdateChildHbIntervall(slaveView.Content);
      }
    }

    private void UpdateChildHbIntervall(Resource resource) {
      foreach (Resource r in Content.Where(x => x.ParentResourceId == resource.Id)) {
        r.HbInterval = resource.HbInterval;
        if (r is SlaveGroup) {
          UpdateChildHbIntervall(r);
        }
      }
    }

    private void btnAddGroup_Click(object sender, EventArgs e) {
      SlaveGroup newGroup = new SlaveGroup();
      newGroup.Name = "New Group";
      newGroup.OwnerUserId = UserInformation.Instance.User.Id;
      Content.Add(newGroup);
    }

    void Content_ItemsRemoved(object sender, Collections.CollectionItemsChangedEventArgs<Collections.IndexedItem<Resource>> e) {
      OnContentChanged();
    }

    void Content_ItemsAdded(object sender, Collections.CollectionItemsChangedEventArgs<Collections.IndexedItem<Resource>> e) {
      OnContentChanged();
    }

    private void btnRemoveGroup_Click(object sender, EventArgs e) {
      if (treeSlaveGroup.SelectedNode != null && treeSlaveGroup.SelectedNode.Tag != null) {
        Resource res = (Resource)treeSlaveGroup.SelectedNode.Tag;

        DialogResult diagRes = MessageBox.Show("Do you really want to delete " + res.Name + "?", "HeuristicLab Hive Administrator", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
        if (diagRes == DialogResult.Yes) {
          if (res is Slave) {
            Content.Remove(res);
            HiveAdminClient.Delete(res);
          } else if (res is SlaveGroup) {
            //only delete empty groups
            if (Content.Where(s => s.ParentResourceId == res.Id).Count() < 1) {
              Content.Remove(res);
              HiveAdminClient.Delete(res);
            } else {
              MessageBox.Show("Only empty groups can be deleted.", "HeuristicLab Hive Administrator", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
          }
        }
      }
    }

    private void btnSave_Click(object sender, EventArgs e) {
      foreach (Resource res in Content) {
        if (res is SlaveGroup && res.Id == Guid.Empty) {
          SlaveGroup slaveGroup = (SlaveGroup)res;
          slaveGroup.Store();
        } else if (res.Id != Guid.Empty && res.Modified) {
          res.Store();
        }
      }
    }

    private void treeSlaveGroup_ItemDrag(object sender, ItemDragEventArgs e) {
      var nodes = GetCheckedNodes(treeSlaveGroup.Nodes).ToList();
      var draggedNode = (TreeNode)e.Item;
      if (!draggedNode.Checked) nodes.Add(draggedNode);
      nodes.Remove(ungroupedGroupNode);
      var resources = nodes.Select(x => x.Tag).OfType<Resource>().ToList();

      if ((resources.Count > 0) && resources.TrueForAll((r) => IsAuthorized(r))) {
        DataObject data = new DataObject();
        data.SetData(HeuristicLab.Common.Constants.DragDropDataFormat, resources);
        var action = DoDragDrop(data, DragDropEffects.Copy | DragDropEffects.Link | DragDropEffects.Move);
        if (action.HasFlag(DragDropEffects.Move)) {
          foreach (var node in nodes) node.Remove();
          ungroupedGroupNode.Text = ((Resource)ungroupedGroupNode.Tag).Name;
          if (ungroupedGroupNode.Nodes.Count > 0)
            ungroupedGroupNode.Text += "   [" + ungroupedGroupNode.Nodes.Count.ToString() + "]";

        }
      }
    }

    private IEnumerable<TreeNode> GetCheckedNodes(TreeNodeCollection nodes) {
      if (nodes != null) {
        foreach (var node in nodes.OfType<TreeNode>()) {
          if (node.Checked) yield return node;
          foreach (var child in GetCheckedNodes(node.Nodes))
            yield return child;
        }
      }
    }

    private void treeSlaveGroup_DragEnterOver(object sender, DragEventArgs e) {
      e.Effect = DragDropEffects.None;
      var resources = e.Data.GetData(HeuristicLab.Common.Constants.DragDropDataFormat) as IEnumerable<Resource>;
      var node = treeSlaveGroup.GetNodeAt(treeSlaveGroup.PointToClient(new Point(e.X, e.Y)));
      var group = node?.Tag as SlaveGroup;

      if ((resources != null) && (node != null) && (group != null) && IsAuthorized(group) && !resources.Contains(group)) {
        while ((node != null) && ((group == null) || !resources.Contains(group))) {  // prevent cycles in groups
          node = node.Parent;
          group = node?.Tag as SlaveGroup;
        }
        if ((node == null) && e.AllowedEffect.HasFlag(DragDropEffects.Move)) e.Effect = DragDropEffects.Move;
      }
    }

    private void treeSlaveGroup_DragDrop(object sender, DragEventArgs e) {
      if (e.Effect != DragDropEffects.None) {
        var node = treeSlaveGroup.GetNodeAt(treeSlaveGroup.PointToClient(new Point(e.X, e.Y)));
        var group = (SlaveGroup)node.Tag;  // drop is only allowed on slave groups, validity of drop target is check in treeSlaveGroup_DragEnterOver
        var resources = e.Data.GetData(HeuristicLab.Common.Constants.DragDropDataFormat) as IEnumerable<Resource>;

        foreach (var r in resources) r.ParentResourceId = group.Id;
        node.Nodes.Clear();
        BuildSlaveGroupTree(group, node);
      }
    }

    void ResetView() {
      if (this.InvokeRequired) {
        Invoke(new Action(ResetView));
      } else {
        treeSlaveGroup.Nodes.Clear();

        if (slaveView.Content != null && slaveView.Content is SlaveGroup) {
          slaveView.Content.PropertyChanged -= new System.ComponentModel.PropertyChangedEventHandler(SlaveViewContent_PropertyChanged);
        }
        slaveView.Content = null;
        if (scheduleView.Content != null) {
          scheduleView.Content.Clear();
        }
        HiveAdminClient.Instance.ResetDowntime();
      }
    }

    private void UpdateResources() {
      ResetView();

      try {
        if (!Access.UserInformation.Instance.UserExists) {
          //do a refresh just in case that the user has changed his usr and pwd in between
          Access.UserInformation.Instance.Refresh();
        }
        HiveAdminClient.Instance.Refresh();
        Content = HiveAdminClient.Instance.Resources;
      }
      catch (MessageSecurityException) {
        ShowMessageSecurityException();
      }
      catch (AnonymousUserException) {
        ShowHiveInformationDialog();
      }
    }

    private void ShowMessageSecurityException() {
      if (this.InvokeRequired) {
        Invoke(new Action(ShowMessageSecurityException));
      } else {
        MessageBox.Show("A Message Security error has occured. This normally means that your user name or password is wrong.", "HeuristicLab Hive Administrator", MessageBoxButtons.OK, MessageBoxIcon.Error);
      }
    }

    private void ShowHiveInformationDialog() {
      if (this.InvokeRequired) {
        Invoke(new Action(ShowHiveInformationDialog));
      } else {
        using (HiveInformationDialog dialog = new HiveInformationDialog()) {
          dialog.ShowDialog(this);
        }
      }
    }

    private void UpdateResourcesAsync() {
      TS.Task.Factory.StartNew(UpdateResources).ContinueWith((t) => {
        DisplayError(t.Exception);
      }, TaskContinuationOptions.OnlyOnFaulted);
    }

    private void UpdateSchedule() {
      HiveAdminClient.Instance.RefreshCalendar();
      scheduleView.Invoke(new Action(() => {
        scheduleView.Content = HiveAdminClient.Instance.Downtimes;
        SetEnabledStateOfControls();
      }));
    }

    private void UpdateScheduleAsync() {
      TS.Task.Factory.StartNew(UpdateSchedule).ContinueWith((t) => {
        DisplayError(t.Exception);
      }, TaskContinuationOptions.OnlyOnFaulted);
    }

    private void UpdatePermissions() {
      if (permissionView.Content != null && permissionView.FetchSelectedUsers != null)
        permissionView.Invoke(new Action(() => permissionView.ManualRefresh()));
    }

    private void UpdatePermissionsAsync() {
      TS.Task.Factory.StartNew(UpdatePermissions).ContinueWith((t) => {
        DisplayError(t.Exception);
      }, TaskContinuationOptions.OnlyOnFaulted);
    }


    private void DisplayError(Exception ex) {
      MessageBox.Show(string.Format("An error occured while updating: {0} {1}", Environment.NewLine, ex.Message), "HeuristicLab Hive Administrator", MessageBoxButtons.OK, MessageBoxIcon.Error);
    }

    private void tabSlaveGroup_SelectedIndexChanged(object sender, EventArgs e) {
      if (tabSlaveGroup.SelectedIndex == 1) {
        UpdateScheduleAsync();
      } else if (tabSlaveGroup.SelectedIndex == 2) {
        UpdatePermissionsAsync();
      }
    }

    private void btnRefresh_Click(object sender, EventArgs e) {
      UpdateResourcesAsync();
    }

    private void ResourcesView_Load(object sender, EventArgs e) {
      UpdateResourcesAsync();
    }

    private void btnPermissionsSave_Click(object sender, EventArgs e) {
      SetEnabledStateOfControls();
      HiveServiceLocator.Instance.CallHiveService(service => {
        service.GrantResourcePermissions(((Resource)treeSlaveGroup.SelectedNode.Tag).Id, permissionView.GetAddedUsers().Select(x => x.Id).ToList());
        service.RevokeResourcePermissions(((Resource)treeSlaveGroup.SelectedNode.Tag).Id, permissionView.GetDeletedUsers().Select(x => x.Id).ToList());
      });
      SetEnabledStateOfControls();
    }
  }
}