protected override bool CanExecuteCore(SelectedItemCollection selection)
{
if (selection.AllItemsAre <IStorageLinkObject>())
{
StorageLinkConnection con = ((IStorageLinkObject)selection.First).StorageLinkConnection;
// check all selected SL items are on the same SL connection.
if (con != null &&
con.ConnectionState == StorageLinkConnectionState.Connected &&
selection.AllItemsAre <IStorageLinkObject>(s => s.StorageLinkConnection.Equals(con)))
{
return(true);
}
}
return(false);
}
protected override bool CanExecuteCore(SelectedItemCollection selection)
{
// Can execute criteria: A selection of VMs in the same pool which has CBT feature licensed, where at least one VM having CBT enabled
return(selection.AllItemsAre <VM>(CbtLicensed) &&
selection.GetConnectionOfAllItems() != null &&
selection.AtLeastOneXenObjectCan <VM>(CanExecute));
}
protected override void ExecuteCore(SelectedItemCollection selection)
{
if (selection != null && selection.AllItemsAre<IXenObject>(x => x is Host || x is Pool))
MainWindowCommandInterface.ShowForm(typeof(BugToolWizard), selection.AsXenObjects<IXenObject>().ToArray());
else
MainWindowCommandInterface.ShowForm(typeof(BugToolWizard));
}
protected override bool CanExecuteCore(SelectedItemCollection selection)
{
if (!selection.AllItemsAre <VM>())
{
return(false);
}
IXenConnection connection = null;
bool atLeaseOneCanExecute = false;
foreach (SelectedItem item in selection)
{
VM vm = (VM)item.XenObject;
// all VMs must be on the same connection
if (connection != null && vm.Connection != connection)
{
return(false);
}
if (CanExecute(item.XenObject as VM))
{
atLeaseOneCanExecute = true;
}
}
return(atLeaseOneCanExecute);
}
public override bool IsValid(SelectedItemCollection selection)
{
List <string> types = new List <string>();
if (selection.AllItemsAre <IXenObject>())
{
foreach (SelectedItem item in selection)
{
string name = item.XenObject.GetType().Name;
VM vm = item.XenObject as VM;
if (vm != null && vm.is_a_template)
{
name = vm.is_a_snapshot ? "snapshot" : "template";
}
if (!types.Contains(name))
{
types.Add(name);
}
}
}
if (types.Count > 1)
{
// if types only contains a mix of vms and templates then don't use this Builder. MixedVMsAndTemplates should be used instead.
types.Remove("VM");
types.Remove("template");
return(types.Count > 0);
}
return(false);
}
protected override bool CanExecuteCore(SelectedItemCollection selection)
{
if (selection.AllItemsAre <DockerContainer>())
{
return(selection.AtLeastOneXenObjectCan <DockerContainer>(CanExecute));
}
return(false);
}
protected override bool CanExecuteCore(SelectedItemCollection selection)
{
if (selection.AllItemsAre <VM>() && new CrossPoolMoveVMCommand(MainWindowCommandInterface, selection).CanExecute())
{
return(true);
}
return(selection.ContainsOneItemOfType <VM>() && selection.AtLeastOneXenObjectCan <VM>(CanExecute));
}
protected override bool CanExecuteCore(SelectedItemCollection selection)
{
if (!selection.AllItemsAre <Host>() || selection.Count > 1)
{
return(false);
}
return(CanExecute(selection.AsXenObjects <Host>().FirstOrDefault()));
}
protected override bool CanExecuteCore(SelectedItemCollection selection)
{
Host hostAncestor = selection.HostAncestorFromConnection;
Pool poolAncestor = selection.PooAncestorFromConnection;
if ((poolAncestor != null || hostAncestor != null) && //CA-61207: this check ensures there's no cross-pool selection
(selection.FirstIs <Pool>() || selection.FirstIs <Host>() || selection.FirstIsRealVM || selection.FirstIs <VM_appliance>()))
{
if (selection.AllItemsAre <VM>())
{
return(selection.AtLeastOneXenObjectCan <VM>(CanExportVm));
}
if (selection.AllItemsAre <VM_appliance>())
{
if (selection.Count != 1)
{
return(false);
}
var appliance = ((VM_appliance)selection.FirstAsXenObject);
return(appliance.VMs.TrueForAll(vmRef =>
{
var vm = appliance.Connection.Resolve(vmRef);
return vm != null &&
CanExportVm(vm);
}));
}
if ((hostAncestor != null && hostAncestor.enabled && hostAncestor.IsLive && selection[0].Connection.IsConnected) ||
(poolAncestor != null && Helpers.PoolHasEnabledHosts(poolAncestor)))
{
var vms = selection.FirstAsXenObject.Connection.Cache.VMs.Where(vm => vm.is_a_real_vm && CanExportVm(vm) && vm.Show(Properties.Settings.Default.ShowHiddenVMs)).ToList();
if (vms.Count > 0)
{
return(vms.Any(CanExportVm));
}
}
}
return(false);
}
protected override void ExecuteCore(SelectedItemCollection selection)
{
var appsToShutDown = new List <VM_appliance>();
if (selection.AllItemsAre <VM_appliance>())
{
appsToShutDown = (from IXenObject obj in selection.AsXenObjects()
let app = (VM_appliance)obj
where CanShutDownAppliance(app)
select app).ToList();
}
else if (selection.AllItemsAre <VM>())
{
var firstVm = (VM)selection.First;
appsToShutDown.Add(firstVm.Connection.Resolve(firstVm.appliance));
}
foreach (var app in appsToShutDown)
{
(new ShutDownApplianceAction(app)).RunAsync();
}
}
protected override bool CanExecuteCore(SelectedItemCollection selection)
{
if (selection.AllItemsAre <VM_appliance>())
{
return(selection.AtLeastOneXenObjectCan <VM_appliance>(CanShutDownAppliance));
}
if (selection.AllItemsAre <VM>())
{
var firstVm = (VM)selection.First;
if (firstVm.IsAssignedToVapp)
{
var firstVapp = firstVm.appliance;
if (selection.AsXenObjects <VM>().All(vm => vm.appliance != null && vm.appliance.opaque_ref == firstVapp.opaque_ref))
{
return(CanShutDownAppliance(firstVm.Connection.Resolve(firstVapp)));
}
}
}
return(false);
}
protected override bool CanExecuteCore(SelectedItemCollection selection)
{
// Can execute criteria: A selection of VMs in the same pool, where at least one doesn't have PVS read caching enabled
if (selection.Any() && selection.AllItemsAre <VM>() && selection.GetConnectionOfAllItems() != null)
{
var vms = selection.AsXenObjects <VM>();
if (vms.Any(vm => vm.PvsProxy != null))
{
return(true);
}
}
return(false);
}
protected override bool CanExecuteCore(SelectedItemCollection selection)
{
if (!selection.AllItemsAre <Host>())
{
return(false);
}
foreach (SelectedItem item in selection)
{
if (CanExecute((Host)item.XenObject))
{
return(true);
}
}
return(false);
}
protected override bool CanExecuteCore(SelectedItemCollection selection)
{
if (selection.AllItemsAre <IStorageLinkObject>())
{
var connections = new List <StorageLinkConnection>();
foreach (IStorageLinkObject s in selection.AsXenObjects <IStorageLinkObject>())
{
if (s.StorageLinkConnection.ConnectionState != StorageLinkConnectionState.Connected)
{
return(false);
}
}
return(true);
}
return(false);
}
protected override void ExecuteCore(SelectedItemCollection selection)
{
var dockerContainers = new List <DockerContainer>();
if (selection.AllItemsAre <DockerContainer>())
{
dockerContainers = (from IXenObject obj in selection.AsXenObjects()
let container = (DockerContainer)obj
where CanExecute(container)
select container).ToList();
}
foreach (var container in dockerContainers)
{
(new StopDockerContainerAction(container)).RunAsync();
}
}
protected override bool CanExecuteCore(SelectedItemCollection selection)
{
// you can only remove a storagelink server from XC if there isn't an SR using it.
List <StorageLinkConnection> slCons = new List <StorageLinkConnection>();
if (selection.AllItemsAre <IStorageLinkObject>())
{
foreach (IStorageLinkObject s in selection.AsXenObjects())
{
if (!slCons.Contains(s.StorageLinkConnection))
{
slCons.Add(s.StorageLinkConnection);
}
}
}
return(slCons.Count == 1);
}
protected override bool CanExecuteCore(SelectedItemCollection selection)
{
// Must have a selection, of all VMs
if (selection.Any() && selection.AllItemsAre <VM>())
{
// Must all be in the same pool, which must have at least one PVS site
var connection = selection.GetConnectionOfAllItems();
if (connection == null || !connection.Cache.PVS_sites.Any())
{
return(false);
}
// At least one must not currently have a PVS Proxy
var vms = selection.AsXenObjects <VM>();
if (vms.Any(vm => vm.PvsProxy() == null))
{
return(true);
}
}
return(false);
}
protected override bool CanExecuteCore(SelectedItemCollection selection)
{
if (selection.AllItemsAre <Host>())
{
// all hosts must be in same pool.
Pool commonPool = null;
foreach (Host host in selection.AsXenObjects <Host>())
{
if (!CanExecute(host))
{
return(false);
}
Pool pool = Helpers.GetPool(host.Connection);
if (commonPool != null && !pool.Equals(commonPool))
{
return(false);
}
commonPool = pool;
}
return(true);
}
return(false);
}
protected override bool CanExecuteCore(SelectedItemCollection selection)
{
if (!selection.AllItemsAre <Host>() || selection.Count > 1)
{
return(false);
}
var host = selection.AsXenObjects <Host>().FirstOrDefault();
if (host == null)
{
return(false);
}
if (!Helpers.StockholmOrGreater(host))
{
return(false);
}
var pool = Helpers.GetPoolOfOne(host.Connection);
return(pool != null && !pool.ha_enabled);
}
protected override bool CanExecuteCore(SelectedItemCollection selection)
{
return(selection.AllItemsAre <Host>() && selection.AtLeastOneXenObjectCan <Host>(CanExecute));
}
public override bool IsValid(SelectedItemCollection selection)
{
return(selection.AllItemsAre <GroupingTag>(IsValid) && selection.Count > 1);
}
protected override bool CanExecuteCore(SelectedItemCollection selection)
{
return(selection.AllItemsAre <Host>() && selection.Any(item => ((Host)item.XenObject).IsLive()));
}
protected override bool CanExecuteCore(SelectedItemCollection selection)
{
return(selection.AllItemsAre <IStorageLinkObject>());
}
protected override bool CanExecuteCore(SelectedItemCollection selection)
{
return(selection.AllItemsAre <VM>(CBTDisabled) &&
(new CrossPoolMoveVMCommand(MainWindowCommandInterface, selection).CanExecute() ||
selection.ContainsOneItemOfType <VM>(CanExecute)));
}
protected override bool CanExecuteCore(SelectedItemCollection selection)
{
return(selection.AllItemsAre <VM>() && selection.AtLeastOneXenObjectCan <VM>(CanExecute) &&
(selection.PoolAncestor != null || selection.HostAncestor != null)); //CA-61207: this check ensures there's no cross-pool selection
}
public override bool IsValid(SelectedItemCollection selection)
{
return(selection.AllItemsAre <VM_appliance>());
}
public override bool IsValid(SelectedItemCollection selection)
{
return(selection.Count > 1 && selection.AllItemsAre <SR>());
}
public override bool IsValid(SelectedItemCollection selection)
{
return(selection.AllItemsAre <DockerContainer>());
}
protected override bool CanExecuteCore(SelectedItemCollection selection)
{
return(selection.AllItemsAre <GroupingTag>(CanExecute));
}
protected override bool CanExecuteCore(SelectedItemCollection selection)
{
return(selection.AllItemsAre <Folder>(CanExecute));
}