mirror of
https://github.com/xcp-ng/xenadmin.git
synced 2024-12-30 15:50:10 +01:00
626fa9198d
# HG changeset patch # User Konstantina Chremmou <Konstantina.Chremmou@citrix.com> # Date 1383906034 0 # Fri Nov 08 10:20:34 2013 +0000 # Node ID 157e4adf37647301d87428e5cd0532c5ce1d380d # Parent 1ded37405ccff8e00c2442a780e1027fa1cb87a1 Signed-off-by: Konstantina Chremmou <konstantina.chremmou@citrix.com>
826 lines
31 KiB
C#
826 lines
31 KiB
C#
/* Copyright (c) Citrix Systems Inc.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms,
|
|
* with or without modification, are permitted provided
|
|
* that the following conditions are met:
|
|
*
|
|
* * Redistributions of source code must retain the above
|
|
* copyright notice, this list of conditions and the
|
|
* following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above
|
|
* copyright notice, this list of conditions and the
|
|
* following disclaimer in the documentation and/or other
|
|
* materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
|
|
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
|
|
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
|
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Diagnostics;
|
|
using System.Drawing;
|
|
using System.Linq;
|
|
using System.Windows.Forms;
|
|
|
|
using XenAdmin.Controls;
|
|
using XenAdmin.Core;
|
|
using XenAdmin.Network;
|
|
using XenAdmin.Properties;
|
|
using XenAPI;
|
|
using XenCenterLib;
|
|
|
|
|
|
namespace XenAdmin.Wizards.HAWizard_Pages
|
|
{
|
|
public partial class AssignPriorities : XenTabPage
|
|
{
|
|
private static readonly log4net.ILog log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
|
|
private IXenConnection connection;
|
|
|
|
private bool showStartOrderAndDelay;
|
|
|
|
private readonly CollectionChangeEventHandler VM_CollectionChangedWithInvoke;
|
|
private readonly QueuedBackgroundWorker m_worker;
|
|
|
|
/// <summary>
|
|
/// May not be set to null.
|
|
/// </summary>
|
|
public new IXenConnection Connection
|
|
{
|
|
set
|
|
{
|
|
if (value == null)
|
|
throw new ArgumentNullException();
|
|
|
|
if (connection != null)
|
|
DeregisterEvents();
|
|
|
|
this.connection = value;
|
|
|
|
RegisterEvents();
|
|
|
|
showStartOrderAndDelay = !Helpers.HaIgnoreStartupOptions(connection);
|
|
if (!showStartOrderAndDelay)
|
|
{
|
|
colStartOrder.Visible = false;
|
|
colDelay.Visible = false;
|
|
|
|
nudOrder.Visible = nudStartDelay.Visible = false;
|
|
labelStartOrder.Visible = labelStartDelay.Visible = labelStartDelayUnits.Visible = false;
|
|
}
|
|
|
|
UpdateMenuItems();
|
|
PopulateVMs();
|
|
|
|
haNtolIndicator.Connection = value;
|
|
haNtolIndicator.Settings = getCurrentSettings();
|
|
}
|
|
}
|
|
|
|
private void UpdateMenuItems()
|
|
{
|
|
List<VM.HA_Restart_Priority> restartPriorities = VM.GetAvailableRestartPriorities(connection);
|
|
|
|
//When this line: m_dropDownButtonRestartPriority.ContextMenuStrip = this.contextMenuStrip
|
|
//was called in the designer a "dummy" item was added to the contextMenuStrip by the m_dropDownButtonRestartPriority,
|
|
//however here it is cleared so no need to remove it explicitly later when contextMenuStrip.Items is called
|
|
contextMenuStrip.Items.Clear();
|
|
|
|
foreach (var restartPriority in restartPriorities)
|
|
{
|
|
var menuItem = contextMenuStrip.Items.Add(Helpers.RestartPriorityI18n(restartPriority));
|
|
menuItem.Tag = restartPriority;
|
|
menuItem.Click += priority_Click;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called when the current IXenConnection's VM dictionary changes.
|
|
/// </summary>
|
|
private void VM_CollectionChanged(object sender, CollectionChangeEventArgs e)
|
|
{
|
|
Program.AssertOnEventThread();
|
|
|
|
VM vm = (VM)e.Element;
|
|
switch (e.Action)
|
|
{
|
|
case CollectionChangeAction.Add:
|
|
vm.PropertyChanged -= vm_PropertyChanged;
|
|
vm.PropertyChanged += vm_PropertyChanged;
|
|
AddVmRow(vm);
|
|
UpdateVMsAgility(new List<VM> {vm});
|
|
break;
|
|
case CollectionChangeAction.Remove:
|
|
vm.PropertyChanged -= vm_PropertyChanged;
|
|
RemoveVmRow(vm);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The Ntol from the HaNtolIndicator control contained within.
|
|
/// </summary>
|
|
public long Ntol
|
|
{
|
|
get
|
|
{
|
|
return haNtolIndicator.Ntol;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Whether the user has made any changes to VM restart priorities on the server.
|
|
/// </summary>
|
|
public bool ChangesMade { get; private set; }
|
|
|
|
public AssignPriorities()
|
|
{
|
|
InitializeComponent();
|
|
VM_CollectionChangedWithInvoke = Program.ProgramInvokeHandler(VM_CollectionChanged);
|
|
|
|
haNtolIndicator.UpdateInProgressChanged += haNtolIndicator_UpdateInProgressChanged;
|
|
|
|
nudStartDelay.Maximum = long.MaxValue;
|
|
nudOrder.Maximum = long.MaxValue;
|
|
|
|
m_worker = new QueuedBackgroundWorker();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clean up any resources being used.
|
|
/// </summary>
|
|
/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
|
|
protected override void Dispose(bool disposing)
|
|
{
|
|
DeregisterEvents();
|
|
|
|
if (disposing && (components != null))
|
|
{
|
|
haNtolIndicator.UpdateInProgressChanged -= haNtolIndicator_UpdateInProgressChanged;
|
|
components.Dispose();
|
|
}
|
|
|
|
StopNtolUpdate();
|
|
|
|
base.Dispose(disposing);
|
|
}
|
|
|
|
private void RegisterEvents()
|
|
{
|
|
// Add listeners
|
|
connection.Cache.RegisterCollectionChanged<VM>(VM_CollectionChangedWithInvoke);
|
|
|
|
foreach (VM vm in connection.Cache.VMs)
|
|
{
|
|
vm.PropertyChanged -= vm_PropertyChanged;
|
|
vm.PropertyChanged += vm_PropertyChanged;
|
|
}
|
|
}
|
|
|
|
private void DeregisterEvents()
|
|
{
|
|
// Remove listeners
|
|
connection.Cache.DeregisterCollectionChanged<VM>(VM_CollectionChangedWithInvoke);
|
|
|
|
foreach (VM vm in connection.Cache.VMs)
|
|
vm.PropertyChanged -= vm_PropertyChanged;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets all agile VMs to state 'Protected' and all non-agile VMs to 'Restart if possible'.
|
|
/// Important: call before setting the Connection property.
|
|
/// </summary>
|
|
internal bool ProtectVmsByDefault { get; set; }
|
|
|
|
internal void StartNtolUpdate()
|
|
{
|
|
haNtolIndicator.StartNtolUpdate();
|
|
}
|
|
|
|
internal void StopNtolUpdate()
|
|
{
|
|
haNtolIndicator.StopNtolUpdate();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Must be called on the event thread.
|
|
/// </summary>
|
|
private void PopulateVMs()
|
|
{
|
|
Program.AssertOnEventThread();
|
|
|
|
try
|
|
{
|
|
dataGridViewVms.SuspendLayout();
|
|
dataGridViewVms.Rows.Clear();
|
|
|
|
var newRows = new List<DataGridViewRow>();
|
|
var vms = connection.Cache.VMs.Where(v => v.HaCanProtect(Properties.Settings.Default.ShowHiddenVMs));
|
|
|
|
// see if HA is being activated for the first time.
|
|
bool firstTime = IsHaActivatedFirstTime(vms);
|
|
|
|
foreach (VM vm in connection.Cache.VMs)
|
|
{
|
|
if (!vm.HaCanProtect(Properties.Settings.Default.ShowHiddenVMs))
|
|
continue;
|
|
|
|
// Create a new row for this VM.
|
|
// The priority for this row is either initially null (which means 'fill in the restart priority with
|
|
// Protected/Restart if possible when we've determined if the VM is agile'), or its current restart priority.
|
|
// The first case is for the HA wizard when priorities are being configured for the first time,
|
|
// the second is for the edit dialog, when HA is already enabled.
|
|
|
|
VM.HA_Restart_Priority? priority = firstTime ? (VM.HA_Restart_Priority?)null : vm.HARestartPriority;
|
|
var row = new VmWithSettingsRow(vm, priority);
|
|
newRows.Add(row);
|
|
}
|
|
|
|
dataGridViewVms.Rows.AddRange(newRows.ToArray());
|
|
var addedVms = from row in dataGridViewVms.Rows.Cast<VmWithSettingsRow>() select row.Vm;
|
|
UpdateVMsAgility(addedVms);
|
|
}
|
|
finally
|
|
{
|
|
dataGridViewVms.ResumeLayout();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Starts a new background thread that updates the displayed agility status for each VM.
|
|
/// </summary>
|
|
private void UpdateVMsAgility(IEnumerable<VM> vms)
|
|
{
|
|
Debug.Assert(connection != null, "Connection property must have been set to non-null before calling this function");
|
|
|
|
//worker starts on UI (main) thread
|
|
m_worker.RunWorkerAsync((sender, arg) => worker_DoWork(null, vms), worker_RunWorkerCompleted);
|
|
}
|
|
|
|
private object worker_DoWork(object sender, object arg)
|
|
{
|
|
var vms = arg as IEnumerable<VM>;
|
|
Debug.Assert(vms != null);
|
|
|
|
Session session = connection.DuplicateSession();
|
|
var results = new Dictionary<VM, string>();
|
|
|
|
foreach (VM vm in vms)
|
|
{
|
|
try
|
|
{
|
|
VM.assert_agile(session, vm.opaque_ref);
|
|
results[vm] = null;
|
|
}
|
|
catch (Failure failure)//The VM wasn't agile
|
|
{
|
|
results[vm] = failure.ErrorDescription[0];
|
|
}
|
|
}
|
|
|
|
return results;
|
|
}
|
|
|
|
private void worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
|
|
{
|
|
if (e.Error != null)
|
|
{
|
|
log.Error(e.Error);
|
|
return;
|
|
}
|
|
|
|
var result = e.Result as Dictionary<VM, string>;
|
|
Debug.Assert(result != null);
|
|
|
|
foreach (var pair in result)
|
|
{
|
|
VM vm = pair.Key;
|
|
string nonAgileReason = pair.Value;
|
|
bool isNowAgile = nonAgileReason == null;
|
|
|
|
//worker started on main thread => this event handler will be on
|
|
//main thread too, so no need to invoke
|
|
|
|
VmWithSettingsRow row = findItemFromVM(vm);
|
|
if (row == null)
|
|
return;
|
|
|
|
// We previously had no restart priority assigned => protectVmsByDefault.
|
|
// Now we know whether the VM is agile, so we can assign it the highest protection available.
|
|
if (row.RestartPriority == null)
|
|
{
|
|
Debug.Assert(ProtectVmsByDefault);
|
|
|
|
var priority = isNowAgile ? VM.HaHighestProtectionAvailable(connection) : VM.HA_Restart_Priority.BestEffort;
|
|
|
|
row.UpdateRestartPriority(priority);
|
|
haNtolIndicator.Settings = getCurrentSettings();
|
|
}
|
|
else if (!isNowAgile
|
|
&& row.RestartPriority != VM.HA_Restart_Priority.BestEffort
|
|
&& row.RestartPriority != VM.HA_Restart_Priority.DoNotRestart)
|
|
{
|
|
row.UpdateRestartPriority(VM.HA_Restart_Priority.BestEffort);
|
|
haNtolIndicator.Settings = getCurrentSettings();
|
|
}
|
|
|
|
row.UpdateAgile(isNowAgile);
|
|
row.FriendlyNonAgileReason = nonAgileReason;
|
|
}
|
|
updateButtons();
|
|
}
|
|
|
|
private bool IsHaActivatedFirstTime(IEnumerable<VM> vms)
|
|
{
|
|
return ProtectVmsByDefault && vms.All(v => string.IsNullOrEmpty(v.ha_restart_priority));
|
|
}
|
|
|
|
private void AddVmRow(VM vm)
|
|
{
|
|
Program.AssertOnEventThread();
|
|
|
|
if (!vm.HaCanProtect(Properties.Settings.Default.ShowHiddenVMs))
|
|
return;
|
|
|
|
// see if HA is being activated for the first time
|
|
var vms = connection.Cache.VMs.Where(v => v.HaCanProtect(Properties.Settings.Default.ShowHiddenVMs));
|
|
bool firstTime = IsHaActivatedFirstTime(vms);
|
|
|
|
VM.HA_Restart_Priority? priority = firstTime ? (VM.HA_Restart_Priority?)null : vm.HARestartPriority;
|
|
var row = new VmWithSettingsRow(vm, priority);
|
|
dataGridViewVms.Rows.Add(row);
|
|
}
|
|
|
|
private void RemoveVmRow(VM vm)
|
|
{
|
|
Program.AssertOnEventThread();
|
|
|
|
var row = findItemFromVM(vm);
|
|
if (row != null)
|
|
dataGridViewVms.Rows.Remove(row);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Finds the ListViewItem for the given VM. Will return null if no corresponding item could be found.
|
|
/// Must be called on the event thread.
|
|
/// </summary>
|
|
private VmWithSettingsRow findItemFromVM(VM vm)
|
|
{
|
|
Program.AssertOnEventThread();
|
|
return dataGridViewVms.Rows.Cast<VmWithSettingsRow>().FirstOrDefault(r => r.Vm == vm);
|
|
}
|
|
|
|
private void vm_PropertyChanged(object sender, PropertyChangedEventArgs e)
|
|
{
|
|
Program.Invoke(this, () =>
|
|
{
|
|
VM vm = (VM)sender;
|
|
if (vm == null)
|
|
return;
|
|
|
|
// Find row for VM
|
|
var row = findItemFromVM(vm);
|
|
|
|
try
|
|
{
|
|
dataGridViewVms.SuspendLayout();
|
|
|
|
if (row == null)
|
|
AddVmRow(vm);
|
|
else
|
|
{
|
|
row.UpdateVm(vm);
|
|
row.SetAgileCalculating();
|
|
}
|
|
|
|
UpdateVMsAgility(new List<VM> {vm});
|
|
}
|
|
finally
|
|
{
|
|
dataGridViewVms.ResumeLayout();
|
|
}
|
|
});
|
|
}
|
|
|
|
private void haNtolIndicator_UpdateInProgressChanged(object sender, EventArgs e)
|
|
{
|
|
// Signal to anyone who cares that this page is good to continue, or not.
|
|
OnPageUpdated();
|
|
|
|
if (!haNtolIndicator.UpdateInProgress)
|
|
{
|
|
if (haNtolIndicator.Ntol == -1)
|
|
{
|
|
labelHaStatus.Text = Messages.HA_UNABLE_TO_CALCULATE_MESSAGE;
|
|
labelHaStatus.ForeColor = Color.Red;
|
|
pictureBoxStatus.Image = Resources._000_Alert2_h32bit_16;
|
|
return;
|
|
}
|
|
|
|
if (haNtolIndicator.Overcommitted || haNtolIndicator.Ntol == 0)
|
|
{
|
|
labelHaStatus.Text = Messages.HA_OVERCOMMIT_MESSAGE;
|
|
labelHaStatus.ForeColor = Color.Red;
|
|
pictureBoxStatus.Image = Resources._000_Alert2_h32bit_16;
|
|
return;
|
|
}
|
|
|
|
labelHaStatus.Text = string.Format(Messages.HA_GUARANTEED_MESSAGE, haNtolIndicator.NtolMax);
|
|
labelHaStatus.ForeColor = SystemColors.ControlText;
|
|
pictureBoxStatus.Image = Resources._000_Tick_h32bit_16;
|
|
}
|
|
}
|
|
|
|
private void dataGridViewVms_KeyDown(object sender, KeyEventArgs e)
|
|
{
|
|
if (e.Control && e.KeyCode == Keys.A)
|
|
{
|
|
try
|
|
{
|
|
dataGridViewVms.SuspendLayout();
|
|
dataGridViewVms.SelectAll();
|
|
}
|
|
finally
|
|
{
|
|
dataGridViewVms.ResumeLayout();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called when the user clicks one of the restart priorities in the context menu.
|
|
/// </summary>
|
|
private void priority_Click(object sender, EventArgs e)
|
|
{
|
|
var menuitem = (ToolStripMenuItem)sender;
|
|
VM.HA_Restart_Priority pri = (VM.HA_Restart_Priority)menuitem.Tag;
|
|
|
|
bool changesMade = false;
|
|
foreach (var row in dataGridViewVms.SelectedRows.Cast<VmWithSettingsRow>())
|
|
{
|
|
if (row.RestartPriority != pri)
|
|
{
|
|
changesMade = true;
|
|
row.UpdateRestartPriority(pri);
|
|
}
|
|
}
|
|
|
|
if (changesMade)
|
|
{
|
|
ChangesMade = true;
|
|
haNtolIndicator.Settings = getCurrentSettings();
|
|
// Will trigger a ntol update under this revised plan
|
|
updateButtons();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the current (uncommitted) VM restart priorities. Must be called on the GUI thread.
|
|
/// </summary>
|
|
public Dictionary<VM, VM.HA_Restart_Priority> getCurrentSettings()
|
|
{
|
|
Program.AssertOnEventThread();
|
|
Dictionary<VM, VM.HA_Restart_Priority> result = new Dictionary<VM, VM.HA_Restart_Priority>();
|
|
|
|
foreach (var row in dataGridViewVms.Rows.Cast<VmWithSettingsRow>())
|
|
{
|
|
// If the restart priority is null, it means we don't know if the VM is agile yet, and we have
|
|
// protectVmsByDefault == true.
|
|
result[row.Vm] = row.RestartPriority ?? VM.HA_Restart_Priority.BestEffort;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private void dataGridViewVms_SelectionChanged(object sender, EventArgs e)
|
|
{
|
|
updateButtons();
|
|
}
|
|
|
|
private void m_dropDownButtonRestartPriority_Click(object sender, EventArgs e)
|
|
{
|
|
var selectedRows = dataGridViewVms.SelectedRows.Cast<VmWithSettingsRow>();
|
|
|
|
foreach (ToolStripMenuItem item in contextMenuStrip.Items)
|
|
{
|
|
var itemRestartPriority = ((VM.HA_Restart_Priority)item.Tag);
|
|
item.Checked = selectedRows.Count() > 0 && selectedRows.All(s => s.RestartPriority == itemRestartPriority);
|
|
}
|
|
}
|
|
|
|
private void updateButtons()
|
|
{
|
|
Program.AssertOnEventThread();
|
|
|
|
var selectedRows = dataGridViewVms.SelectedRows.Cast<VmWithSettingsRow>();
|
|
|
|
if (dataGridViewVms.SelectedRows.Count == 0)
|
|
{
|
|
m_dropDownButtonRestartPriority.Enabled = false;
|
|
m_dropDownButtonRestartPriority.Text = "";
|
|
if (showStartOrderAndDelay)
|
|
{
|
|
nudOrder.Enabled = nudStartDelay.Enabled = false;
|
|
nudOrder.Text = nudStartDelay.Text = "";
|
|
}
|
|
return;
|
|
}
|
|
|
|
// if there is a VM with null priority in the selection disable all buttons. We are waiting on the background thread
|
|
// to see if the VM is agile before giving it a starting value
|
|
if (selectedRows.Any(r => r.RestartPriority == null))
|
|
{
|
|
m_dropDownButtonRestartPriority.Enabled = true;
|
|
m_dropDownButtonRestartPriority.Text = "";
|
|
if (showStartOrderAndDelay)
|
|
{
|
|
nudOrder.Enabled = nudStartDelay.Enabled = true;
|
|
nudOrder.Text = nudStartDelay.Text = "";
|
|
}
|
|
return;
|
|
}
|
|
|
|
m_dropDownButtonRestartPriority.Enabled = true;
|
|
|
|
//now set the drop down button text
|
|
|
|
bool allSamePriority = false;
|
|
|
|
foreach (ToolStripMenuItem item in contextMenuStrip.Items)
|
|
{
|
|
VM.HA_Restart_Priority itemRestartPriority = (VM.HA_Restart_Priority)item.Tag;
|
|
|
|
if (selectedRows.All(r => r.RestartPriority == itemRestartPriority))
|
|
{
|
|
allSamePriority = true;
|
|
m_dropDownButtonRestartPriority.Text = Helpers.RestartPriorityI18n(itemRestartPriority);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!allSamePriority && dataGridViewVms.SelectedRows.Count > 1)
|
|
{
|
|
m_dropDownButtonRestartPriority.Text = Messages.HA_ASSIGN_PRIORITIES_MIXED_PROTECTION_LEVELS;
|
|
}
|
|
|
|
// set the order and delay NUDs
|
|
if (showStartOrderAndDelay)
|
|
{
|
|
nudOrder.Enabled = nudStartDelay.Enabled = true;
|
|
|
|
var orderDistList = (from row in selectedRows select row.StartOrder).Distinct();
|
|
nudOrder.Text = orderDistList.Count() == 1 ? orderDistList.ElementAt(0).ToString() : "";
|
|
|
|
var delayDistList = (from row in selectedRows select row.StartDelay).Distinct();
|
|
nudStartDelay.Text = delayDistList.Count() == 1 ? delayDistList.ElementAt(0).ToString() : "";
|
|
}
|
|
|
|
// check that all the VMs selected in the list are agile and make sure the protect button is disabled with the relevant reason
|
|
VmWithSettingsRow nonAgileRow = selectedRows.FirstOrDefault(r => !r.IsAgile);
|
|
|
|
// Now set the buttons and tooltips)
|
|
foreach (ToolStripMenuItem menuItem in contextMenuStrip.Items)
|
|
{
|
|
var priority = (VM.HA_Restart_Priority)menuItem.Tag;
|
|
|
|
if (VM.HaPriorityIsRestart(connection, priority))
|
|
{
|
|
menuItem.Enabled = priority == VM.HA_Restart_Priority.AlwaysRestartHighPriority
|
|
? (nonAgileRow == null && Helpers.CowleyOrGreater(connection))
|
|
: (nonAgileRow == null);
|
|
|
|
menuItem.ToolTipText = (nonAgileRow == null)
|
|
? ""
|
|
: nonAgileRow.FriendlyNonAgileReason;
|
|
}
|
|
else
|
|
{
|
|
menuItem.Enabled = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void nudOrder_ValueChanged(object sender, EventArgs e)
|
|
{
|
|
long newValue = (long)nudOrder.Value;
|
|
bool changesMade = false;
|
|
|
|
foreach (var row in dataGridViewVms.SelectedRows.Cast<VmWithSettingsRow>())
|
|
{
|
|
if (row.StartOrder != newValue)
|
|
{
|
|
changesMade = true;
|
|
row.UpdateStartOrder(newValue);
|
|
}
|
|
}
|
|
|
|
if (changesMade)
|
|
{
|
|
ChangesMade = true;
|
|
updateButtons();
|
|
}
|
|
}
|
|
|
|
private void nudStartDelay_ValueChanged(object sender, EventArgs e)
|
|
{
|
|
long newValue = (long)nudStartDelay.Value;
|
|
bool changesMade = false;
|
|
|
|
foreach (var row in dataGridViewVms.SelectedRows.Cast<VmWithSettingsRow>())
|
|
{
|
|
if (row.StartDelay != newValue)
|
|
{
|
|
changesMade = true;
|
|
row.UpdateStartDelay(newValue);
|
|
}
|
|
}
|
|
|
|
if (changesMade)
|
|
{
|
|
ChangesMade = true;
|
|
updateButtons();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the current (uncommitted) VM startup options. Must be called on the GUI thread.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public Dictionary<VM, VMStartupOptions> GetCurrentStartupOptions()
|
|
{
|
|
Program.AssertOnEventThread();
|
|
Dictionary<VM, VMStartupOptions> result = new Dictionary<VM, VMStartupOptions>();
|
|
|
|
foreach (var curRow in dataGridViewVms.Rows.Cast<VmWithSettingsRow>())
|
|
{
|
|
result[curRow.Vm] = new VMStartupOptions(curRow.StartOrder,
|
|
curRow.StartDelay,
|
|
curRow.RestartPriority ?? VM.HA_Restart_Priority.BestEffort);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private void linkLabelTellMeMore_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
|
|
{
|
|
Help.HelpManager.Launch("HaNtolZero");
|
|
}
|
|
|
|
#region XentabPage overrides
|
|
|
|
public override string Text
|
|
{
|
|
get { return Messages.HAWIZARD_ASSIGNRIORITIESPAGE_TEXT; }
|
|
}
|
|
|
|
public override string PageTitle
|
|
{
|
|
get
|
|
{
|
|
return showStartOrderAndDelay ? Messages.HAWIZARD_ASSIGNRIORITIESPAGE_TITLE : Messages.HAWIZARD_ASSIGNRIORITIESPAGE_TITLE_NOORDER;
|
|
}
|
|
}
|
|
|
|
public override bool EnableNext()
|
|
{
|
|
return !haNtolIndicator.UpdateInProgress && Ntol >= 0 && !haNtolIndicator.Overcommitted;
|
|
}
|
|
|
|
public override void PageCancelled()
|
|
{
|
|
StopNtolUpdate();
|
|
}
|
|
|
|
public override void PageLoaded(PageLoadedDirection direction)
|
|
{
|
|
base.PageLoaded(direction);
|
|
StartNtolUpdate();
|
|
}
|
|
|
|
public override void PageLeave(PageLoadedDirection direction, ref bool cancel)
|
|
{
|
|
StopNtolUpdate();
|
|
base.PageLeave(direction, ref cancel);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Nested classes
|
|
|
|
private class VmWithSettingsRow : DataGridViewRow
|
|
{
|
|
private readonly DataGridViewImageCell cellImage;
|
|
private readonly DataGridViewTextBoxCell cellVm;
|
|
private readonly DataGridViewTextBoxCell cellRestartPriority;
|
|
private readonly DataGridViewTextBoxCell cellStartOrder;
|
|
private readonly DataGridViewTextBoxCell cellDelay;
|
|
private readonly DataGridViewTextBoxCell cellAgile;
|
|
private string _nonAgileReason;
|
|
|
|
public VM Vm { get; private set; }
|
|
public long StartDelay { get; private set; }
|
|
public long StartOrder { get; private set; }
|
|
public VM.HA_Restart_Priority? RestartPriority { get; private set; }
|
|
public bool IsAgile { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Returns a short version of the agility violation for the error type stored in NonAgileReason.
|
|
/// Returns empty string if there is no error.
|
|
/// For a more detailed, technical description use the error translation in FriendlyErrorNames.resx
|
|
/// </summary>
|
|
public string FriendlyNonAgileReason
|
|
{
|
|
get
|
|
{
|
|
switch (_nonAgileReason)
|
|
{
|
|
case null:
|
|
return "";
|
|
case "HA_CONSTRAINT_VIOLATION_SR_NOT_SHARED":
|
|
return Messages.NOT_AGILE_SR_NOT_SHARED;
|
|
case "HA_CONSTRAINT_VIOLATION_NETWORK_NOT_SHARED":
|
|
return Messages.NOT_AGILE_NETWORK_NOT_SHARED;
|
|
case "VM_HAS_VGPU":
|
|
return Messages.NOT_AGILE_VM_HAS_VGPU;
|
|
default:
|
|
// We shouldn't really be here unless we have not iterated all the return errors from vm.assert_agile
|
|
return Messages.NOT_AGILE_UNKOWN;
|
|
}
|
|
}
|
|
set
|
|
{
|
|
_nonAgileReason = value;
|
|
}
|
|
}
|
|
|
|
public VmWithSettingsRow(VM vm, VM.HA_Restart_Priority? priority)
|
|
{
|
|
cellImage = new DataGridViewImageCell {ValueType = typeof(Image)};
|
|
cellVm = new DataGridViewTextBoxCell();
|
|
cellRestartPriority = new DataGridViewTextBoxCell();
|
|
cellStartOrder = new DataGridViewTextBoxCell();
|
|
cellDelay = new DataGridViewTextBoxCell();
|
|
cellAgile = new DataGridViewTextBoxCell();
|
|
Cells.AddRange(cellImage, cellVm, cellRestartPriority, cellStartOrder, cellDelay, cellAgile);
|
|
|
|
UpdateVm(vm);
|
|
UpdateRestartPriority(priority);
|
|
UpdateStartOrder(vm.order);
|
|
UpdateStartDelay(vm.start_delay);
|
|
SetAgileCalculating();
|
|
}
|
|
|
|
public void UpdateVm(VM vm)
|
|
{
|
|
Vm = vm;
|
|
cellImage.Value = Images.GetImage16For(vm);
|
|
cellVm.Value = vm.Name;
|
|
}
|
|
|
|
public void UpdateStartDelay(long startDelay)
|
|
{
|
|
StartDelay = startDelay;
|
|
cellDelay.Value = string.Format(Messages.TIME_SECONDS, startDelay);
|
|
}
|
|
|
|
public void UpdateStartOrder(long startOrder)
|
|
{
|
|
StartOrder = startOrder;
|
|
cellStartOrder.Value = startOrder.ToString();
|
|
}
|
|
|
|
public void UpdateRestartPriority(VM.HA_Restart_Priority? restartPriority)
|
|
{
|
|
RestartPriority = restartPriority;
|
|
cellRestartPriority.Value = Helpers.RestartPriorityI18n(restartPriority);
|
|
}
|
|
|
|
public void UpdateAgile(bool isAgile)
|
|
{
|
|
IsAgile = isAgile;
|
|
cellAgile.Value = isAgile.ToYesNoStringI18n();
|
|
}
|
|
|
|
public void SetAgileCalculating()
|
|
{
|
|
cellAgile.Value = Messages.HA_CALCULATING_AGILITY;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|