public RevertToSnapshotCommand(IMainWindow mainWindow, IEnumerable<SelectedItem> selection, VM snapshot)
     : base(mainWindow, selection)
 {
     Util.ThrowIfParameterNull(snapshot, "snapshot");
     _snapshot = snapshot;
     _VM = _snapshot.Connection.Resolve(_snapshot.snapshot_of);
 }

 public VNCPasswordDialog(Exception error, VM vm)
     : base(vm.Connection)
 {
     InitializeComponent();
     Icon = Properties.Resources.AppIcon;
     passwordFailure1.Visible = error is VNCAuthenticationException || error is CryptographicException;
 }

        public MoveVMDialog(VM vm)
        {
            InitializeComponent();
            this.vm = vm;
            srPicker1.ItemSelectionNotNull += srPicker1_ItemSelectionNotNull;
            srPicker1.ItemSelectionNull += srPicker1_ItemSelectionNull;
            srPicker1.DoubleClickOnRow += srPicker1_DoubleClickOnRow;
            srPicker1.SrHint.Visible = false;
            Host affinity = vm.Home();
            srPicker1.Usage = SrPicker.SRPickerType.MoveOrCopy;
            //this has to be set after ImportTemplate, otherwise the usage will be reset to VM
            var vdis = (from VBD vbd in vm.Connection.ResolveAll(vm.VBDs)
                                           where vbd.IsOwner
                                           let vdi = vm.Connection.Resolve(vbd.VDI)
                                           where vdi != null
                                           select vdi).ToArray();
            srPicker1.SetExistingVDIs(vdis);
            srPicker1.Connection = vm.Connection;
            srPicker1.DiskSize = vm.TotalVMSize;
            srPicker1.SetAffinity(affinity);
            srPicker1.srListBox.Invalidate();
            srPicker1.selectDefaultSROrAny();

            EnableMoveButton();
        }

 private void Execute(VM snapshot)
 {
     if (snapshot != null)
     {
         new ExportVMCommand(MainWindowCommandInterface, new SelectedItem(snapshot, snapshot.Connection, null, null)).Execute();
     }
 }

        protected VMProblem(Check check, VM vm)
            : base(check)
        {
            _vm = vm;

            ResidentOn = VM.Connection.Resolve(VM.resident_on);
        }

        public override void PageLoaded(PageLoadedDirection direction)
        {
            base.PageLoaded(direction);

            VM template = SelectedTemplate;
            
            if (!template.Equals(_template))
            {
                _template = template;
                ServersGridView.Rows.Clear();

                if (Helpers.MidnightRideOrGreater(Connection) && template.DefaultTemplate)
                {
                    List<Host> hosts = new List<Host>(Connection.Cache.Hosts);
                    hosts.Sort();
                    foreach (Host host in hosts)
                    {
                        ServerGridRow row = new ServerGridRow(host, false);
                        ServersGridView.Rows.Add(row);

                        if (host == _affinity)
                        {
                            row.Selected = true;
                        }
                    }
                }
                ServersGridView.Enabled = template.DefaultTemplate;
            }
        }

        public static new bool CanExecute(VM vm, Host preSelectedHost)
        {
            if (vm == null || !vm.is_a_template || vm.DefaultTemplate || vm.Locked)
                return false;

            return CrossPoolMigrateCommand.CanExecute(vm, preSelectedHost);
        }

 public SetVMOtherConfigAction(IXenConnection connection, VM vm, string key, string val)
     : base(connection, Messages.ACTION_SET_VM_OTHER_CONFIG_TITLE, true)
 {
     VM = vm;
     Key = key;
     Val = val;
 }

 public VMSnapshotRevertAction(VM snapshot)
     : base(snapshot.Connection, String.Format(Messages.ACTION_VM_REVERT_SNAPSHOT_TITLE, snapshot.Name))
 {
     this.VM = Connection.Resolve<VM>(snapshot.snapshot_of);
     this.m_Snapshot = snapshot;
     Description = String.Format(Messages.VM_REVERTING, m_Snapshot.Name);
 }

 public ChangeVCPUSettingsAction(VM vm, long VCPUs_max, long VCPUs_at_startup)
     : base(vm.Connection, "", true)
 {
     m_VM = vm;
     m_VCPUs_max = VCPUs_max;
     m_VCPUs_at_startup = VCPUs_at_startup;
 }

        protected override void Run()
        {
            Description = Messages.STARTING_IN_RECOVERY_MODE;
            string oldPolicy = VM.HVM_boot_policy;
            string oldOrder  = VM.BootOrder;

            vmCopy = (VM)VM.Clone();
            vmCopy.HVM_boot_policy = "BIOS order";
            vmCopy.BootOrder = "DN";

            VM.Locked = true;
            vmCopy.SaveChanges(Session);
            VM.Locked = false;

            XenAPI.VM.start(Session, VM.opaque_ref, false, false);

            vmCopy.HVM_boot_policy = oldPolicy;
            vmCopy.BootOrder = oldOrder;

            VM.Locked = true;
            vmCopy.SaveChanges(Session);
            VM.Locked = false;

            Description = Messages.STARTED_IN_RECOVERY_MODE;
        }

 public RevertDialog(VM vm,string snapshotName)
 {
     InitializeComponent();
     this.questionLabel.Text = string.Format(questionLabel.Text, snapshotName.Ellipsise(40));
     this.takeSnapshotBeforeCheckBox.Enabled = vm.allowed_operations.Contains(vm_operations.snapshot);
     this.takeSnapshotBeforeCheckBox.Checked = this.takeSnapshotBeforeCheckBox.Enabled;
 }

 public UpdateVIFCommand(IMainWindow mainWindow, VM vm, VIF vif, Proxy_VIF proxyVIF)
     : base(mainWindow, vm)
 {
     _vm = vm;
     _vif = vif;
     _proxyVIF = proxyVIF;
 }

 public GpuAssignAction(VM vm, GPU_group gpu_group, VGPU_type vgpuType)
     : base(vm.Connection, "Set GPU", true)
 {
     this.vm = vm;
     this.gpu_group = gpu_group;
     this.vgpuType = vgpuType;
 }

        public ChangeMemorySettingsAction(VM vm, string title,
            long static_min, long dynamic_min, long dynamic_max, long static_max, Action<VM, bool> warningDialogHAInvalidConfig, Action<VMStartAbstractAction, Failure> startDiagnosticForm, bool suppressHistory)
            : base(vm.Connection, title, suppressHistory)
        {
            _warningDialogHAInvalidConfig = warningDialogHAInvalidConfig;
            _startDiagnosticForm = startDiagnosticForm;
            VM = vm;
            this.static_min = static_min;
            this.dynamic_min = dynamic_min;
            this.dynamic_max = dynamic_max;
            this.static_max = static_max;

            #region RBAC Dependencies

            if (staticChanged)
                ApiMethodsToRoleCheck.Add("vm.set_memory_limits");
            else
                ApiMethodsToRoleCheck.Add("vm.set_memory_dynamic_range");

            if (needReboot)
            {
                if (VM.allowed_operations.Contains(XenAPI.vm_operations.clean_shutdown))
                    ApiMethodsToRoleCheck.Add("vm.clean_shutdown");
                else
                    ApiMethodsToRoleCheck.Add("vm.hard_shutdown");
                ApiMethodsToRoleCheck.Add("vm.start_on");
            }

            #endregion
        }

        protected override void Run()
        {
            // get the VM from the cache again, to check its vCPU fields before trying to change them
            m_VM = Connection.Resolve(new XenRef<VM>(m_VM.opaque_ref));
            if (m_VM == null) // VM has disappeared
                return;

            if (m_VM.power_state == vm_power_state.Running) // if the VM is running, we can only change the vCPUs number, not the max.
            {
                if (m_VM.VCPUs_at_startup > m_VCPUs_at_startup) // reducing VCPU_at_startup is not allowed for live VMs
                {
                    throw new Exception(string.Format(Messages.VM_VCPU_CANNOT_UNPLUG_LIVE, m_VM.VCPUs_at_startup));
                }
                VM.set_VCPUs_number_live(Session, m_VM.opaque_ref, m_VCPUs_at_startup);
                return;
            }

            if (m_VM.VCPUs_at_startup > m_VCPUs_at_startup) // reducing VCPUs_at_startup: we need to change this value first, and then the VCPUs_max
            {
                VM.set_VCPUs_at_startup(Session, m_VM.opaque_ref, m_VCPUs_at_startup);
                VM.set_VCPUs_max(Session, m_VM.opaque_ref, m_VCPUs_max);
            }
            else // increasing VCPUs_at_startup: we need to change the VCPUs_max first
            {
                VM.set_VCPUs_max(Session, m_VM.opaque_ref, m_VCPUs_max);
                VM.set_VCPUs_at_startup(Session, m_VM.opaque_ref, m_VCPUs_at_startup);
            }
        }

 public CreateVIFAction(VM vm, Proxy_VIF proxyVIF)
     : base(vm.Connection, String.Format(Messages.ACTION_VIF_CREATING_TITLE, vm.Name))
 {
     _proxyVIF = proxyVIF;
     VM = vm;
     XmlRpcMethods.ForEach( method => ApiMethodsToRoleCheck.Add( method ) );
 }

        public override void PageLoaded(PageLoadedDirection direction)
        {
            base.PageLoaded(direction);
            VM template = SelectedTemplate;
            bool installMethodIsNetwork = SelectedInstallMethod == InstallMethod.Network;

            if (template == Template && InstallMethodIsNetwork == installMethodIsNetwork)
                return;

            Template = template;

            InstallMethodIsNetwork = installMethodIsNetwork;
            if ((!Template.DefaultTemplate && !Template.HasAtLeastOneDisk)
                || (Template.IsHVM && InstallMethodIsNetwork)) // CA-46213 The default should be "diskless" if the install method is "boot from network"
            {
                DisklessVMRadioButton.Checked = true;
            }
            else
                DisksRadioButton.Checked = true;
            DisksGridView.Rows.Clear();
            LoadDisks();
            UpdateEnablement();
            UpdateCloneCheckboxEnablement(true);
            DisksGridView.Select();
        }

        public HAUnprotectVMAction(VM vm)
            : base(vm.Connection, string.Format(Messages.ACTION_HA_UNPROTECT_VM_TITLE, Helpers.GetName(vm),
            Helpers.RestartPriorityI18n(XenAPI.VM.HA_Restart_Priority.DoNotRestart)), Messages.ACTION_HA_UNPROTECT_VM_DESCRIPTION)
        {
            VM = vm;

        }

 public SetVMOtherConfigAction(IXenConnection connection, VM vm, string key, string val)
     : base(connection, "Set VM other_config", true)
 {
     VM = vm;
     Key = key;
     Val = val;
 }