mirror of
https://github.com/xcp-ng/xenadmin.git
synced 2024-12-22 16:36:03 +01:00
f5bee7102c
from this interface. Signed-off-by: Konstantina Chremmou <konstantina.chremmou@citrix.com>
497 lines
21 KiB
C#
497 lines
21 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.Text;
|
|
using XenAPI;
|
|
using System.Windows.Forms;
|
|
using XenAdmin.Actions;
|
|
using XenAdmin.TabPages;
|
|
using XenAdmin.Core;
|
|
using XenAdmin.Commands.Controls;
|
|
using XenAdmin.Dialogs;
|
|
|
|
|
|
namespace XenAdmin.Commands
|
|
{
|
|
class DeleteVirtualDiskCommand : Command
|
|
{
|
|
private static readonly log4net.ILog log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
|
|
|
|
/// <summary>
|
|
/// Allows auto unplug and delete on running VMs
|
|
/// </summary>
|
|
public bool AllowRunningVMDelete = false;
|
|
|
|
/// <summary>
|
|
/// Allows deletion of the VDI when multiple VMs are using this VDI. If the VMs are running you also need to set AllowRunningVMDelete
|
|
/// </summary>
|
|
public bool AllowMultipleVBDDelete = false;
|
|
|
|
public DeleteVirtualDiskCommand(IMainWindow mainWindow, IEnumerable<SelectedItem> selection)
|
|
: base(mainWindow, selection)
|
|
{
|
|
|
|
}
|
|
|
|
public DeleteVirtualDiskCommand(IMainWindow mainWindow, VDI vdi)
|
|
: base(mainWindow, vdi)
|
|
{
|
|
|
|
}
|
|
|
|
public override string ContextMenuText
|
|
{
|
|
get
|
|
{
|
|
bool allSnaps = true;
|
|
foreach (VDI vdi in GetSelection().AsXenObjects<VDI>())
|
|
{
|
|
if (vdi.is_a_snapshot)
|
|
continue;
|
|
allSnaps = false;
|
|
break;
|
|
}
|
|
// Default to Virtual Disk in the mixed case of snaps/non snaps as it is the more general term
|
|
return allSnaps ? Messages.DELETE_SNAPSHOT_MENU_ITEM : Messages.DELETE_VIRTUAL_DISK;
|
|
}
|
|
}
|
|
|
|
|
|
protected override bool CanExecuteCore(SelectedItemCollection selection)
|
|
{
|
|
return selection.AllItemsAre<VDI>(CanExecute);
|
|
}
|
|
|
|
protected override bool ConfirmationRequired
|
|
{
|
|
get
|
|
{
|
|
// We always do some sort of confirmation for this delete
|
|
return true;
|
|
}
|
|
}
|
|
|
|
protected override string ConfirmationDialogText
|
|
{
|
|
get
|
|
{
|
|
if (!NeedMultipleWarnings)
|
|
{
|
|
// In the single warning type case we use the in built confirmation dialog to show a single warning
|
|
// if there are mixed vdi types then we will use the multiple warning dialog in confirm() override
|
|
SelectedItemCollection selectedItems = GetSelection();
|
|
VDI vdi = selectedItems[0].XenObject as VDI;
|
|
SR sr = vdi.Connection.Resolve<SR>(vdi.SR);
|
|
bool single = selectedItems.Count == 1;
|
|
switch (vdi.VDIType)
|
|
{
|
|
case VDI.FriendlyType.SNAPSHOT:
|
|
return single ? Messages.MESSAGEBOX_DELETE_SNAPSHOT : Messages.MESSAGEBOX_DELETE_SNAPSHOT_MULTIPLE;
|
|
case VDI.FriendlyType.ISO:
|
|
return single ? string.Format(Messages.MESSAGEBOX_DELETE_ISO, Helpers.GetName(vdi)) : Messages.MESSAGEBOX_DELETE_ISO_MULTIPLE;
|
|
case VDI.FriendlyType.SYSTEM_DISK:
|
|
return single ? Messages.MESSAGEBOX_DELETE_SYS_DISK : Messages.MESSAGEBOX_DELETE_SYS_DISK_MULTIPLE;
|
|
case VDI.FriendlyType.VIRTUAL_DISK:
|
|
return single ? Messages.MESSAGEBOX_DELETE_VD : Messages.MESSAGEBOX_DELETE_VD_MULTIPLE;
|
|
case VDI.FriendlyType.NONE:
|
|
return "";
|
|
}
|
|
}
|
|
return base.ConfirmationDialogText;
|
|
}
|
|
}
|
|
|
|
protected override string ConfirmationDialogTitle
|
|
{
|
|
get
|
|
{
|
|
if (!NeedMultipleWarnings)
|
|
{
|
|
// In the single warning type case we use the in built confirmation dialog to show a single warning
|
|
// if there are mixed vdi types then we will use the multiple warning dialog in confirm() override
|
|
SelectedItemCollection selectedItems = GetSelection();
|
|
VDI vdi = selectedItems[0].XenObject as VDI;
|
|
SR sr = vdi.Connection.Resolve<SR>(vdi.SR);
|
|
bool single = selectedItems.Count == 1;
|
|
switch (vdi.VDIType)
|
|
{
|
|
case VDI.FriendlyType.SNAPSHOT:
|
|
return single ? Messages.MESSAGEBOX_DELETE_SNAPSHOT_TITLE : Messages.MESSAGEBOX_DELETE_SNAPSHOTS_TITLE_MULTIPLE;
|
|
case VDI.FriendlyType.ISO:
|
|
return single ? Messages.MESSAGEBOX_DELETE_ISO_TITLE : Messages.MESSAGEBOX_DELETE_ISO_TITLE_MULTIPLE;
|
|
case VDI.FriendlyType.SYSTEM_DISK:
|
|
return single ? Messages.MESSAGEBOX_DELETE_SYS_DISK_TITLE : Messages.MESSAGEBOX_DELETE_SYS_DISK_TITLE_MULTIPLE;
|
|
case VDI.FriendlyType.VIRTUAL_DISK:
|
|
return single ? Messages.MESSAGEBOX_DELETE_VD_TITLE : Messages.MESSAGEBOX_DELETE_VD_TITLE_MUTLIPLE;
|
|
case VDI.FriendlyType.NONE:
|
|
return "";
|
|
}
|
|
}
|
|
return base.ConfirmationDialogTitle;
|
|
}
|
|
}
|
|
|
|
private bool? _needMultipleWarnings = null;
|
|
private bool NeedMultipleWarnings
|
|
{
|
|
get
|
|
{
|
|
// While just O(n) it does cast an entire list, so we cache the first result.
|
|
if (_needMultipleWarnings.HasValue)
|
|
return _needMultipleWarnings.Value;
|
|
|
|
_needMultipleWarnings = false;
|
|
SelectedItemCollection selection = GetSelection();
|
|
VDI.FriendlyType current = VDI.FriendlyType.NONE;
|
|
VDI.FriendlyType previous = VDI.FriendlyType.NONE;
|
|
if (selection.Count > 1)
|
|
{
|
|
for (int i = 0; i < selection.Count; i++)
|
|
{
|
|
VDI v = selection[i].XenObject as VDI;
|
|
if (v == null)
|
|
current = VDI.FriendlyType.NONE;
|
|
else
|
|
current = v.VDIType;
|
|
|
|
if (i > 0 && current != previous)
|
|
{
|
|
_needMultipleWarnings = true;
|
|
break;
|
|
}
|
|
previous = current;
|
|
}
|
|
}
|
|
return _needMultipleWarnings.Value;
|
|
}
|
|
}
|
|
|
|
protected override bool Confirm()
|
|
{
|
|
if (Program.RunInAutomatedTestMode)
|
|
return true;
|
|
|
|
if (NeedMultipleWarnings)
|
|
{
|
|
MultipleWarningDialog warningDialog = new MultipleWarningDialog(
|
|
Messages.MESSAGEBOX_DELETE_VD_TITLE_MUTLIPLE,
|
|
Messages.MULTI_VDI_DELETE_WARNING,
|
|
Messages.DELETE_ALL_BUTTON_LABEL);
|
|
|
|
SelectedItemCollection selectedItems = GetSelection();
|
|
List<VDI> snapshots = new List<VDI>();
|
|
List<VDI> isos = new List<VDI>();
|
|
List<VDI> systemVDisks = new List<VDI>();
|
|
List<VDI> virtualDisks = new List<VDI>();
|
|
foreach (VDI vdi in selectedItems.AsXenObjects<VDI>())
|
|
{
|
|
switch (vdi.VDIType)
|
|
{
|
|
case VDI.FriendlyType.SNAPSHOT:
|
|
snapshots.Add(vdi);
|
|
break;
|
|
case VDI.FriendlyType.ISO:
|
|
isos.Add(vdi);
|
|
break;
|
|
case VDI.FriendlyType.SYSTEM_DISK:
|
|
systemVDisks.Add(vdi);
|
|
break;
|
|
case VDI.FriendlyType.VIRTUAL_DISK:
|
|
virtualDisks.Add(vdi);
|
|
break;
|
|
case VDI.FriendlyType.NONE:
|
|
break;
|
|
}
|
|
}
|
|
if (snapshots.Count == 1)
|
|
{
|
|
warningDialog.AddWarningMessage(
|
|
Messages.MESSAGEBOX_DELETE_SNAPSHOT_TITLE,
|
|
Messages.WARNING_DELETE_SNAPSHOT,
|
|
snapshots.ConvertAll<IXenObject>(delegate(VDI v){return (IXenObject)v;}));
|
|
}
|
|
else if (snapshots.Count > 1)
|
|
{
|
|
warningDialog.AddWarningMessage(
|
|
Messages.MESSAGEBOX_DELETE_SNAPSHOTS_TITLE_MULTIPLE,
|
|
Messages.WARNING_DELETE_SNAPSHOT_MULTIPLE,
|
|
snapshots.ConvertAll<IXenObject>(delegate(VDI v){return (IXenObject)v;}));
|
|
}
|
|
|
|
if (isos.Count == 1)
|
|
{
|
|
warningDialog.AddWarningMessage(
|
|
Messages.MESSAGEBOX_DELETE_ISO_TITLE,
|
|
Messages.WARNING_DELETE_ISO,
|
|
isos.ConvertAll<IXenObject>(delegate(VDI v) { return (IXenObject)v; }));
|
|
}
|
|
else if (isos.Count > 1)
|
|
{
|
|
warningDialog.AddWarningMessage(
|
|
Messages.MESSAGEBOX_DELETE_ISO_TITLE_MULTIPLE,
|
|
Messages.WARNING_DELETE_ISO_MULTIPLE,
|
|
isos.ConvertAll<IXenObject>(delegate(VDI v) { return (IXenObject)v; }));
|
|
}
|
|
|
|
if (systemVDisks.Count == 1)
|
|
{
|
|
warningDialog.AddWarningMessage(
|
|
Messages.MESSAGEBOX_DELETE_SYS_DISK_TITLE,
|
|
Messages.WARNING_DELETE_SYS_DISK,
|
|
systemVDisks.ConvertAll<IXenObject>(delegate(VDI v) { return (IXenObject)v; }));
|
|
}
|
|
else if (systemVDisks.Count > 1)
|
|
{
|
|
warningDialog.AddWarningMessage(
|
|
Messages.MESSAGEBOX_DELETE_SYS_DISK_TITLE_MULTIPLE,
|
|
Messages.WARNING_DELETE_SYS_DISK_MULTIPLE,
|
|
systemVDisks.ConvertAll<IXenObject>(delegate(VDI v) { return (IXenObject)v; }));
|
|
}
|
|
|
|
if (virtualDisks.Count == 1)
|
|
{
|
|
warningDialog.AddWarningMessage(
|
|
Messages.MESSAGEBOX_DELETE_VD_TITLE,
|
|
Messages.WARNING_DELETE_VD,
|
|
virtualDisks.ConvertAll<IXenObject>(delegate(VDI v) { return (IXenObject)v; }));
|
|
}
|
|
else if (virtualDisks.Count > 1)
|
|
{
|
|
warningDialog.AddWarningMessage(
|
|
Messages.MESSAGEBOX_DELETE_VD_TITLE_MUTLIPLE,
|
|
Messages.WARNING_DELETE_VD_MULTIPLE,
|
|
virtualDisks.ConvertAll<IXenObject>(delegate(VDI v) { return (IXenObject)v; }));
|
|
}
|
|
return warningDialog.ShowDialog(Parent) == DialogResult.Yes;
|
|
}
|
|
else
|
|
{
|
|
return base.Confirm();
|
|
}
|
|
}
|
|
|
|
protected bool CanExecute(VDI vdi)
|
|
{
|
|
SR sr = vdi.Connection.Resolve<SR>(vdi.SR);
|
|
if (vdi == null || sr == null)
|
|
return false;
|
|
if (vdi.Locked)
|
|
return false;
|
|
if (sr.Physical)
|
|
return false;
|
|
if (sr.IsToolsSR)
|
|
return false;
|
|
if (vdi.IsUsedByHA)
|
|
{
|
|
return false;
|
|
}
|
|
List<VBD> vbds = vdi.Connection.ResolveAll<VBD>(vdi.VBDs);
|
|
if (vbds.Count > 1 && !AllowMultipleVBDDelete)
|
|
return false;
|
|
foreach (VBD vbd in vbds)
|
|
{
|
|
VM vm = vdi.Connection.Resolve<VM>(vbd.VM);
|
|
|
|
if (vdi.type == vdi_type.system)
|
|
{
|
|
|
|
if (vm.power_state == vm_power_state.Running)
|
|
return false;
|
|
}
|
|
if (vbd.Locked)
|
|
return false;
|
|
if (vbd.currently_attached)
|
|
{
|
|
//Check if we can unplug
|
|
DeactivateVBDCommand cmd = new DeactivateVBDCommand(Program.MainWindow, vbd);
|
|
if (!AllowRunningVMDelete || !cmd.CanExecute())
|
|
return false;
|
|
}
|
|
}
|
|
if (sr.HBALunPerVDI)
|
|
return true;
|
|
if (!vdi.allowed_operations.Contains(vdi_operations.destroy))
|
|
{
|
|
if (AllowRunningVMDelete)
|
|
{
|
|
// We deliberately DONT call allowed operations because we assume we know better :)
|
|
// Xapi will think we can't delete because VBDs are plugged. We are going to unplug them.
|
|
|
|
// Known risks of this method that will make us fail because we are disrespecting xapi:
|
|
// - someone else is calling a delete on this vdi already, altering the allowed ops
|
|
// - the storage manager cannot perform a delete on the SR due to drivers
|
|
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
protected override string GetCantExecuteReasonCore(SelectedItem item)
|
|
{
|
|
VDI vdi = item.XenObject as VDI;
|
|
if (vdi == null)
|
|
return base.GetCantExecuteReasonCore(item);
|
|
|
|
SR sr = vdi.Connection.Resolve<SR>(vdi.SR);
|
|
if (sr == null)
|
|
return Messages.SR_COULD_NOT_BE_CONTACTED;
|
|
|
|
VDI.FriendlyType vdiType = vdi.VDIType;
|
|
|
|
if (vdi.Locked)
|
|
return vdiType == VDI.FriendlyType.SNAPSHOT ? Messages.CANNOT_DELETE_SNAPSHOT_IN_USE
|
|
: vdiType == VDI.FriendlyType.ISO ? Messages.CANNOT_DELETE_ISO_IN_USE
|
|
: Messages.CANNOT_DELETE_VD_IN_USE;
|
|
|
|
if (sr.Physical)
|
|
return FriendlyErrorNames.VDI_IS_A_PHYSICAL_DEVICE;
|
|
|
|
if (sr.IsToolsSR)
|
|
return Messages.CANNOT_DELETE_TOOLS_SR;
|
|
|
|
if (vdi.IsUsedByHA)
|
|
return Messages.CANNOT_DELETE_HA_VD;
|
|
|
|
if (vdi.IsMetadataForDR)
|
|
return Messages.CANNOT_DELETE_DR_VD;
|
|
|
|
List<VBD> vbds = vdi.Connection.ResolveAll<VBD>(vdi.VBDs);
|
|
if (vbds.Count > 1 && !AllowMultipleVBDDelete)
|
|
return Messages.CANNOT_DELETE_VDI_MULTIPLE_VBDS;
|
|
|
|
foreach (VBD vbd in vbds)
|
|
{
|
|
VM vm = vdi.Connection.Resolve<VM>(vbd.VM);
|
|
|
|
if (vdiType == VDI.FriendlyType.SYSTEM_DISK)
|
|
{
|
|
|
|
|
|
if (vm.power_state == vm_power_state.Running)
|
|
return string.Format(
|
|
Messages.CANNOT_DELETE_IN_USE_SYS_VD,
|
|
Helpers.GetName(vm).Ellipsise(20));
|
|
}
|
|
if (vbd.Locked)
|
|
return vdiType == VDI.FriendlyType.SNAPSHOT ? Messages.CANNOT_DELETE_SNAPSHOT_IN_USE
|
|
: vdiType == VDI.FriendlyType.ISO ? Messages.CANNOT_DELETE_ISO_IN_USE
|
|
: Messages.CANNOT_DELETE_VD_IN_USE;
|
|
|
|
if (vbd.currently_attached)
|
|
{
|
|
if (!AllowRunningVMDelete)
|
|
{
|
|
return string.Format(Messages.CANNOT_DELETE_VDI_ACTIVE_ON,
|
|
Helpers.GetName(vm).Ellipsise(20));
|
|
}
|
|
DeactivateVBDCommand cmd = new DeactivateVBDCommand(Program.MainWindow, vbd);
|
|
if (!cmd.CanExecute())
|
|
{
|
|
return string.Format(Messages.CANNOT_DELETE_CANNOT_DEACTIVATE_REASON,
|
|
Helpers.GetName(vm).Ellipsise(20), cmd.ToolTipText);
|
|
}
|
|
}
|
|
}
|
|
|
|
// This is a necessary final check, there are other blocking reasons non covered in this method
|
|
// Known examples:
|
|
// - someone else is calling a delete on this vdi already, altering the allowed ops
|
|
// - the storage manager cannot perform a delete on the SR due to drivers
|
|
if (!vdi.allowed_operations.Contains(vdi_operations.destroy))
|
|
return vdiType == VDI.FriendlyType.SNAPSHOT ? Messages.CANNOT_DELETE_SNAPSHOT_GENERIC
|
|
: vdiType == VDI.FriendlyType.ISO ? Messages.CANNOT_DELETE_ISO_GENERIC
|
|
: Messages.CANNOT_DELETE_VD_GENERIC;
|
|
|
|
return base.GetCantExecuteReasonCore(item);
|
|
}
|
|
|
|
protected override XenAdmin.Dialogs.CommandErrorDialog GetErrorDialogCore(IDictionary<SelectedItem, string> cantExecuteReasons)
|
|
{
|
|
return new CommandErrorDialog(Messages.ERROR_DESTROYING_STORAGE_ITEMS_TITLE, Messages.ERROR_DESTROYING_STORAGE_ITEMS_MESSAGE, cantExecuteReasons);
|
|
}
|
|
|
|
protected override void ExecuteCore(SelectedItemCollection selection)
|
|
{
|
|
List<AsyncAction> actionsToComplete = new List<AsyncAction>();
|
|
List<VM> deletedVMSnapshots = new List<VM>();
|
|
|
|
foreach (VDI vdi in selection.AsXenObjects<VDI>())
|
|
{
|
|
if (vdi.Locked || !vdi.Show(XenAdmin.Properties.Settings.Default.ShowHiddenVMs))
|
|
continue;
|
|
|
|
actionsToComplete.AddRange(getDestroyVDIAction(vdi, deletedVMSnapshots));
|
|
}
|
|
if (actionsToComplete.Count > 1)
|
|
RunMultipleActions(actionsToComplete, Messages.ACTION_DELETING_MULTIPLE_STORAGE_ITEMS_TITLE, Messages.ACTION_DELETING_MULTIPLE_STORAGE_ITEMS_STATUS, Messages.COMPLETED, true);
|
|
else
|
|
actionsToComplete[0].RunAsync();
|
|
}
|
|
|
|
private List<AsyncAction> getDestroyVDIAction(VDI vdi, List<VM> deletedVMSnapshots)
|
|
{
|
|
List<AsyncAction> actions = new List<AsyncAction>();
|
|
|
|
// Destroy the entire snapshot if it exists. Else destroy disk
|
|
if (vdi.is_a_snapshot && vdi.GetVMs().Count >= 1)
|
|
{
|
|
foreach (VM vm in vdi.GetVMs())
|
|
{
|
|
if (!vm.is_a_snapshot || deletedVMSnapshots.Contains(vm))
|
|
continue;
|
|
|
|
AsyncAction action = new VMSnapshotDeleteAction(vm);
|
|
actions.Add(action);
|
|
deletedVMSnapshots.Add(vm);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SR sr = vdi.Connection.Resolve(vdi.SR);
|
|
if (sr == null)
|
|
{
|
|
// Nothing we can do here, but this should have been caught in the getcantexecutereason method and prompted
|
|
return actions;
|
|
}
|
|
DestroyDiskAction a = new DestroyDiskAction(vdi);
|
|
a.AllowRunningVMDelete = AllowRunningVMDelete;
|
|
actions.Add(a);
|
|
}
|
|
|
|
return actions;
|
|
}
|
|
}
|
|
}
|