mirror of
https://github.com/xcp-ng/xenadmin.git
synced 2024-12-22 00:16:03 +01:00
ae22560ce8
prevent them from being serialised alongside the API properties. This will also be useful for moving the API bindings out of XenModel. Signed-off-by: Konstantina Chremmou <konstantina.chremmou@citrix.com>
448 lines
17 KiB
C#
448 lines
17 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.Windows.Forms;
|
|
using XenAdmin.Controls;
|
|
using XenAPI;
|
|
|
|
using XenAdmin.Actions.DR;
|
|
|
|
namespace XenAdmin.Wizards.DRWizards
|
|
{
|
|
public partial class DRFailoverWizardAppliancesPage : XenTabPage
|
|
{
|
|
private Pool _pool;
|
|
public Pool Pool
|
|
{
|
|
get { return _pool; }
|
|
set
|
|
{
|
|
_pool = value;
|
|
if (_pool != null)
|
|
labelPageDescription.Text = string.Format(labelPageDescription.Text, Pool.Name());
|
|
}
|
|
}
|
|
|
|
public DRFailoverWizardAppliancesPage()
|
|
{
|
|
InitializeComponent();
|
|
}
|
|
|
|
public override string Text
|
|
{
|
|
get { return Messages.DR_WIZARD_APPLIANCESPAGE_TEXT; }
|
|
}
|
|
|
|
public override string PageTitle
|
|
{
|
|
get
|
|
{
|
|
switch (WizardType)
|
|
{
|
|
case DRWizardType.Failback:
|
|
return Messages.DR_WIZARD_APPLIANCESPAGE_TITLE_FAILBACK;
|
|
default:
|
|
return Messages.DR_WIZARD_APPLIANCESPAGE_TITLE_FAILOVER;
|
|
}
|
|
}
|
|
}
|
|
|
|
public override string HelpID
|
|
{
|
|
get
|
|
{
|
|
switch (WizardType)
|
|
{
|
|
case DRWizardType.Failback:
|
|
return "Failback_vApps";
|
|
case DRWizardType.Dryrun:
|
|
return "Dryrun_vApps";
|
|
default:
|
|
return "Failover_vApps";
|
|
}
|
|
}
|
|
}
|
|
|
|
public override bool EnableNext()
|
|
{
|
|
int checkedItems = ApplianceTreeView.CheckedItems().Count;
|
|
buttonClearAll.Enabled = checkedItems > 0;
|
|
buttonSelectAll.Enabled = checkedItems < ApplianceTreeView.Items.Count;
|
|
return checkedItems > 0;
|
|
}
|
|
|
|
private Dictionary<XenRef<VDI>, PoolMetadata> allPoolMetadata;
|
|
public Dictionary<XenRef<VDI>, PoolMetadata> AllPoolMetadata { set { allPoolMetadata = value; } }
|
|
|
|
private Dictionary<XenRef<VDI>, PoolMetadata> selectedPoolMetadata = new Dictionary<XenRef<VDI>, PoolMetadata>();
|
|
|
|
public DRWizardType WizardType { private get; set; }
|
|
|
|
public Dictionary<XenRef<VDI>, PoolMetadata> SelectedPoolMetadata
|
|
{
|
|
get { return selectedPoolMetadata; }
|
|
}
|
|
|
|
public override void PageLoaded(PageLoadedDirection direction)
|
|
{
|
|
base.PageLoaded(direction);
|
|
if (direction == PageLoadedDirection.Forward)
|
|
{
|
|
SetupLabels();
|
|
PopulateTreeView();
|
|
}
|
|
}
|
|
|
|
void SetupLabels()
|
|
{
|
|
switch (WizardType)
|
|
{
|
|
case DRWizardType.Failback:
|
|
labelPageDescription.Text = String.Format(Messages.DR_WIZARD_APPLIANCESPAGE_DESCRIPTION_FAILBACK,
|
|
Pool.Name());
|
|
radioButtonStart.Text = Messages.DR_WIZARD_APPLIANCESPAGE_FAILBACK_START;
|
|
radioButtonPaused.Text = Messages.DR_WIZARD_APPLIANCESPAGE_FAILBACK_STARTPAUSED;
|
|
radioButtonDoNotStart.Text = Messages.DR_WIZARD_APPLIANCESPAGE_FAILBACK_DONOTSTART;
|
|
break;
|
|
default:
|
|
labelPageDescription.Text = Messages.DR_WIZARD_APPLIANCESPAGE_DESCRIPTION_FAILOVER;
|
|
radioButtonStart.Text = Messages.DR_WIZARD_APPLIANCESPAGE_FAILOVER_START;
|
|
radioButtonPaused.Text = Messages.DR_WIZARD_APPLIANCESPAGE_FAILOVER_STARTPAUSED;
|
|
radioButtonDoNotStart.Text = Messages.DR_WIZARD_APPLIANCESPAGE_FAILOVER_DONOTSTART;
|
|
break;
|
|
}
|
|
|
|
var dryrun = WizardType == DRWizardType.Dryrun;
|
|
radioButtonPaused.Visible = dryrun;
|
|
radioButtonPaused.Checked = dryrun;
|
|
radioButtonStart.Visible = !dryrun;
|
|
}
|
|
|
|
private void PopulateTreeView(PoolMetadata poolMetadata, CustomTreeNode parentNode)
|
|
{
|
|
ApplianceTreeView.BeginUpdate();
|
|
ApplianceTreeView.Cursor = Cursors.WaitCursor;
|
|
try
|
|
{
|
|
if (poolMetadata.VmAppliances != null && poolMetadata.VmAppliances.Count > 0)
|
|
{
|
|
foreach (var applianceItem in poolMetadata.VmAppliances)
|
|
{
|
|
ApplianceNode applianceNode = new ApplianceNode(applianceItem.Key, applianceItem.Value);
|
|
if (parentNode != null)
|
|
{
|
|
ApplianceTreeView.AddChildNode(parentNode, applianceNode);
|
|
applianceNode.Enabled = parentNode.Enabled;
|
|
}
|
|
else
|
|
ApplianceTreeView.AddNode(applianceNode);
|
|
|
|
foreach (XenRef<VM> vmRef in applianceItem.Value.VMs)
|
|
{
|
|
if (poolMetadata.Vms.ContainsKey(vmRef))
|
|
{
|
|
VmNode vmNode = new VmNode(vmRef, poolMetadata.Vms[vmRef], false);
|
|
ApplianceTreeView.AddChildNode(applianceNode, vmNode);
|
|
vmNode.Enabled = applianceNode.Enabled;
|
|
}
|
|
}
|
|
applianceNode.Expanded = false;
|
|
}
|
|
}
|
|
|
|
if (poolMetadata.Vms != null || poolMetadata.Vms.Count > 0)
|
|
{
|
|
foreach (var vmItem in poolMetadata.Vms)
|
|
{
|
|
if (vmItem.Value.appliance.opaque_ref != null && vmItem.Value.appliance.opaque_ref.StartsWith("OpaqueRef:") && vmItem.Value.appliance.opaque_ref != "OpaqueRef:NULL")
|
|
{
|
|
//VM included in an appliance
|
|
continue;
|
|
}
|
|
VmNode vmNode = new VmNode(vmItem.Key, vmItem.Value, true);
|
|
if (parentNode != null)
|
|
{
|
|
ApplianceTreeView.AddChildNode(parentNode, vmNode);
|
|
vmNode.Enabled = parentNode.Enabled;
|
|
}
|
|
else
|
|
ApplianceTreeView.AddNode(vmNode);
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
ApplianceTreeView.EndUpdate();
|
|
ApplianceTreeView.Cursor = Cursors.Default;
|
|
}
|
|
}
|
|
|
|
private void PopulateTreeView()
|
|
{
|
|
ApplianceTreeView.BeginUpdate();
|
|
ApplianceTreeView.Cursor = Cursors.WaitCursor;
|
|
try
|
|
{
|
|
ApplianceTreeView.ClearAllNodes();
|
|
foreach (var vdiRef in allPoolMetadata.Keys)
|
|
{
|
|
PoolMetadata poolMetadata = allPoolMetadata[vdiRef];
|
|
//if (!String.IsNullOrEmpty(poolMetadata.Pool.Name))
|
|
{
|
|
string description = poolMetadata.Pool.uuid == Pool.uuid ? Messages.DR_WIZARD_APPLIANCESPAGE_CURRENT_POOL : string.Empty;
|
|
PoolNode poolNode = new PoolNode(vdiRef, poolMetadata.Pool.Name(), description);
|
|
ApplianceTreeView.AddNode(poolNode);
|
|
poolNode.Enabled = (poolMetadata.Pool.uuid != Pool.uuid);
|
|
PopulateTreeView(poolMetadata, poolNode);
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
ApplianceTreeView.EndUpdate();
|
|
ApplianceTreeView.Cursor = Cursors.Default;
|
|
}
|
|
}
|
|
|
|
private void ApplianceTreeView_ItemCheckChanged(object sender, EventArgs e)
|
|
{
|
|
CustomTreeNode node = sender as CustomTreeNode;
|
|
|
|
var poolNode = node.ParentNode as PoolNode;
|
|
if (poolNode == null)
|
|
return;
|
|
|
|
XenRef<VDI> vdiRef = poolNode.VdiRef;
|
|
|
|
// add pool if needed
|
|
if (node.State == CheckState.Checked && !selectedPoolMetadata.ContainsKey(vdiRef))
|
|
{
|
|
selectedPoolMetadata.Add(vdiRef, new PoolMetadata(allPoolMetadata[vdiRef].Pool, allPoolMetadata[vdiRef].Vdi));
|
|
}
|
|
if (!selectedPoolMetadata.ContainsKey(vdiRef))
|
|
return;
|
|
|
|
DoOnNodeStateChanged(node, vdiRef);
|
|
|
|
// remove pool if no appliance or vm selected
|
|
if (selectedPoolMetadata[vdiRef].VmAppliances.Count == 0 && selectedPoolMetadata[vdiRef].Vms.Count == 0)
|
|
{
|
|
selectedPoolMetadata.Remove(vdiRef);
|
|
}
|
|
|
|
OnPageUpdated();
|
|
}
|
|
|
|
private void DoOnNodeStateChanged(CustomTreeNode node, XenRef<VDI> vdiRef)
|
|
{
|
|
var applianceNode = node as ApplianceNode;
|
|
if (applianceNode != null)
|
|
{
|
|
switch (applianceNode.State)
|
|
{
|
|
case CheckState.Checked:
|
|
if (!selectedPoolMetadata[vdiRef].VmAppliances.ContainsKey(applianceNode.ApplianceRef))
|
|
selectedPoolMetadata[vdiRef].VmAppliances.Add(applianceNode.ApplianceRef, applianceNode.Appliance);
|
|
break;
|
|
case CheckState.Unchecked:
|
|
if (selectedPoolMetadata[vdiRef].VmAppliances.ContainsKey(applianceNode.ApplianceRef))
|
|
selectedPoolMetadata[vdiRef].VmAppliances.Remove(applianceNode.ApplianceRef);
|
|
break;
|
|
}
|
|
|
|
foreach (var childNode in applianceNode.ChildNodes)
|
|
{
|
|
childNode.State = applianceNode.State;
|
|
DoOnNodeStateChanged(childNode, vdiRef);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
var vmNode = node as VmNode;
|
|
if (vmNode != null)
|
|
{
|
|
switch (vmNode.State)
|
|
{
|
|
case CheckState.Checked:
|
|
if (!selectedPoolMetadata[vdiRef].Vms.ContainsKey(vmNode.VmRef))
|
|
selectedPoolMetadata[vdiRef].Vms.Add(vmNode.VmRef, vmNode.Vm);
|
|
break;
|
|
case CheckState.Unchecked:
|
|
if (selectedPoolMetadata[vdiRef].Vms.ContainsKey(vmNode.VmRef))
|
|
selectedPoolMetadata[vdiRef].Vms.Remove(vmNode.VmRef);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void buttonSelectAll_Click(object sender, EventArgs e)
|
|
{
|
|
foreach (CustomTreeNode node in ApplianceTreeView.Items)
|
|
{
|
|
if (!node.HideCheckbox)
|
|
{
|
|
node.State = CheckState.Checked;
|
|
ApplianceTreeView_ItemCheckChanged(node, new EventArgs());
|
|
}
|
|
}
|
|
ApplianceTreeView.Refresh();
|
|
}
|
|
|
|
private void buttonClearAll_Click(object sender, EventArgs e)
|
|
{
|
|
foreach (CustomTreeNode node in ApplianceTreeView.Items)
|
|
{
|
|
if (!node.HideCheckbox)
|
|
{
|
|
node.State = CheckState.Unchecked;
|
|
ApplianceTreeView_ItemCheckChanged(node, new EventArgs());
|
|
}
|
|
}
|
|
ApplianceTreeView.Refresh();
|
|
}
|
|
|
|
public StartActionAfterRecovery StartActionAfterRecovery
|
|
{
|
|
get
|
|
{
|
|
if (radioButtonStart.Checked)
|
|
return StartActionAfterRecovery.Start;
|
|
if (radioButtonPaused.Checked)
|
|
return StartActionAfterRecovery.StartPaused;
|
|
return StartActionAfterRecovery.None;
|
|
}
|
|
}
|
|
|
|
public string GetSelectedPowerStateDescription()
|
|
{
|
|
switch (StartActionAfterRecovery)
|
|
{
|
|
case StartActionAfterRecovery.Start:
|
|
return WizardType == DRWizardType.Failback
|
|
? Messages.DR_WIZARD_APPLIANCESPAGE_FAILBACK_START_NOAMP
|
|
: Messages.DR_WIZARD_APPLIANCESPAGE_FAILOVER_START_NOAMP;
|
|
case StartActionAfterRecovery.StartPaused:
|
|
return WizardType == DRWizardType.Failback
|
|
? Messages.DR_WIZARD_APPLIANCESPAGE_FAILBACK_STARTPAUSED_NOAMP
|
|
: Messages.DR_WIZARD_APPLIANCESPAGE_FAILOVER_STARTPAUSED_NOAMP;
|
|
default:
|
|
return WizardType == DRWizardType.Failback
|
|
? Messages.DR_WIZARD_APPLIANCESPAGE_FAILBACK_DONOTSTART_NOAMP
|
|
: Messages.DR_WIZARD_APPLIANCESPAGE_FAILOVER_DONOTSTART_NOAMP;
|
|
}
|
|
}
|
|
}
|
|
|
|
class PoolNode : CustomTreeNode
|
|
{
|
|
public string PoolName;
|
|
public XenRef<VDI> VdiRef;
|
|
private string description;
|
|
|
|
public PoolNode(XenRef<VDI> vdiRef, string poolName, string description)
|
|
: base(true)
|
|
{
|
|
PoolName = poolName;
|
|
VdiRef = vdiRef;
|
|
this.description = description;
|
|
Update();
|
|
}
|
|
|
|
private void Update()
|
|
{
|
|
Text = PoolName;
|
|
Image = Images.GetImage16For(Icons.Pool);
|
|
|
|
Description = description;
|
|
Enabled = true;
|
|
HideCheckbox = true;
|
|
Expanded = true;
|
|
}
|
|
}
|
|
|
|
class ApplianceNode : CustomTreeNode
|
|
{
|
|
public XenRef<VM_appliance> ApplianceRef;
|
|
public VM_appliance Appliance;
|
|
|
|
public ApplianceNode(XenRef<VM_appliance> applianceRef, VM_appliance appliance)
|
|
: base(true)
|
|
{
|
|
ApplianceRef = applianceRef;
|
|
Appliance = appliance;
|
|
Update();
|
|
}
|
|
|
|
private void Update()
|
|
{
|
|
Text = Appliance.Name();
|
|
Image = Images.GetImage16For(Appliance);
|
|
|
|
Description = "";
|
|
Enabled = true;
|
|
HideCheckbox = false;
|
|
}
|
|
}
|
|
|
|
class VmNode : CustomTreeNode, IEquatable<VmNode>
|
|
{
|
|
public XenRef<VM> VmRef;
|
|
public VM Vm;
|
|
|
|
public VmNode(XenRef<VM> vmRef, VM vm, bool selectable)
|
|
: base(selectable)
|
|
{
|
|
VmRef = vmRef;
|
|
Vm = vm;
|
|
Update();
|
|
}
|
|
|
|
private void Update()
|
|
{
|
|
Text = Vm.Name();
|
|
Image = Images.GetImage16For(Icons.VM);
|
|
Description = "";
|
|
Enabled = true;
|
|
HideCheckbox = !Selectable;
|
|
}
|
|
|
|
public bool Equals(VmNode other)
|
|
{
|
|
return VmRef == other.VmRef;
|
|
}
|
|
}
|
|
|
|
public enum StartActionAfterRecovery { Start, StartPaused, None }
|
|
}
|