public void AddDisk(string opaqueref, bool owner, bool isShared) { VM.VBDs.Add(new XenRef <VBD>(opaqueref)); _mockConnection.Setup(x => x.Resolve <VDI>(new XenRef <VDI>(opaqueref))).Returns(new VDI() { opaque_ref = opaqueref, Connection = _mockConnection.Object, SR = new XenRef <SR>(opaqueref), managed = true, missing = false }); VBD vbd = new VBD { opaque_ref = opaqueref, VDI = new XenRef <VDI>(opaqueref), other_config = new Dictionary <string, string>(), Connection = _mockConnection.Object }; vbd.SetIsOwner(owner); _vbds.Add(vbd); _mockConnection.Setup(x => x.Resolve <VBD>(new XenRef <VBD>(opaqueref))).Returns(vbd); _mockConnection.Setup(x => x.Resolve <SR>(new XenRef <SR>(opaqueref))).Returns(new SR() { Connection = _mockConnection.Object, shared = isShared, PBDs = new List <XenRef <PBD> >() { new XenRef <PBD>(opaqueref) } }); _mockConnection.Setup(x => x.Resolve <PBD>(It.IsAny <XenRef <PBD> >())).Returns(new PBD()); }
private void OkBtn_Click(object sender, EventArgs e) { DiskListVdiItem item = DiskListTreeView.SelectedItem as DiskListVdiItem; if (item == null) { return; } VDI TheVDI = item.TheVDI; // Run this stuff off the event thread, since it involves a server call System.Threading.ThreadPool.QueueUserWorkItem(delegate { // Get a spare userdevice string[] uds = VM.get_allowed_VBD_devices(connection.DuplicateSession(), TheVM.opaque_ref); if (uds.Length == 0) { Program.Invoke(Program.MainWindow, delegate() { using (var dlg = new ErrorDialog(FriendlyErrorNames.VBDS_MAX_ALLOWED) { WindowTitle = Messages.DISK_ATTACH }) { dlg.ShowDialog(Program.MainWindow); } }); return; } string ud = uds[0]; VBD vbd = new VBD(); vbd.VDI = new XenRef <VDI>(TheVDI); vbd.VM = new XenRef <VM>(TheVM); vbd.bootable = ud == "0"; vbd.device = ""; vbd.SetIsOwner(TheVDI.VBDs.Count == 0); vbd.empty = false; vbd.userdevice = ud; vbd.type = vbd_type.Disk; vbd.mode = ReadOnlyCheckBox.Checked ? vbd_mode.RO : vbd_mode.RW; vbd.unpluggable = true; // Try to hot plug the VBD. var action = new VbdSaveAndPlugAction(TheVM, vbd, TheVDI.Name(), null, false); action.ShowUserInstruction += Action_ShowUserInstruction; action.RunAsync(); }); Close(); }
public VBD NewDevice() { VBD vbd = new VBD(); vbd.Connection = connection; vbd.device = ""; vbd.empty = false; vbd.type = XenAPI.vbd_type.Disk; vbd.mode = XenAPI.vbd_mode.RW; vbd.SetIsOwner(true); vbd.unpluggable = true; return(vbd); }
/// <summary> /// Create a VBD /// /// ** vbd.bootable ** /// 1. Windows ignores bootable flag /// 2. Eliloader changes the device "0" to bootable when booting linux /// </summary> /// <param name="disk"></param> /// <param name="vdi"></param> /// <param name="progress1"></param> /// <param name="progress2"></param> /// <param name="bootable">Set VBD.bootable to this value - see comments above</param> private void CreateVbd(DiskDescription disk, VDI vdi, double progress1, double progress2, bool bootable) { List <string> devices = AllowedVBDs; if (devices.Count == 0) { throw new Exception(Messages.NO_MORE_USERDEVICES); } VBD vbd = new VBD(); vbd.SetIsOwner(true); vbd.bootable = bootable; vbd.empty = false; vbd.unpluggable = true; vbd.mode = vbd_mode.RW; vbd.type = vbd_type.Disk; vbd.userdevice = devices.Contains(disk.Device.userdevice) ? disk.Device.userdevice : devices[0]; vbd.device = ""; vbd.VM = new XenRef <VM>(VM.opaque_ref); vbd.VDI = new XenRef <VDI>(vdi.opaque_ref); RelatedTask = VBD.async_create(Session, vbd); PollToCompletion(progress1, progress2); Connection.WaitForCache(new XenRef <VBD>(Result)); }
protected override void Run() { this.Description = Messages.ACTION_VM_MOVING; try { var vbds = Connection.ResolveAll(VM.VBDs); int halfstep = (int)(90 / (vbds.Count * 2)); // move the progress bar above 0, it's more reassuring to see than a blank bar as we copy the first disk PercentComplete += 10; Exception exn = null; foreach (VBD oldVBD in vbds) { if (!oldVBD.GetIsOwner()) { continue; } var curVdi = Connection.Resolve(oldVBD.VDI); if (curVdi == null) { continue; } if (StorageMapping == null || !StorageMapping.ContainsKey(oldVBD.VDI.opaque_ref)) { continue; } SR sr = StorageMapping[oldVBD.VDI.opaque_ref]; if (sr == null || curVdi.SR.opaque_ref == sr.opaque_ref) { continue; } RelatedTask = XenAPI.VDI.async_copy(Session, oldVBD.VDI.opaque_ref, sr.opaque_ref); PollToCompletion(PercentComplete, PercentComplete + halfstep); var newVDI = Connection.WaitForCache(new XenRef <VDI>(Result)); var newVBD = new VBD { userdevice = oldVBD.userdevice, bootable = oldVBD.bootable, mode = oldVBD.mode, type = oldVBD.type, unpluggable = oldVBD.unpluggable, other_config = oldVBD.other_config, VDI = new XenRef <VDI>(newVDI.opaque_ref), VM = new XenRef <VM>(VM.opaque_ref) }; newVBD.SetIsOwner(oldVBD.GetIsOwner()); VBD vbd = oldVBD; BestEffort(ref exn, () => VDI.destroy(Session, vbd.VDI.opaque_ref)); Connection.WaitForCache <VBD>(VBD.create(Session, newVBD)); PercentComplete += halfstep; } if (SR != null) { VM.set_suspend_SR(Session, VM.opaque_ref, SR.opaque_ref); } if (exn != null) { throw exn; } } catch (CancelledException) { this.Description = string.Format(Messages.MOVE_CANCELLED, VM.Name()); throw; } this.Description = Messages.MOVED; }
protected override void Run() { Description = string.Format(Messages.ACTION_MOVING_VDI, Helpers.GetName(vdi)); PercentComplete = 10; log.DebugFormat("Moving VDI '{0}'", Helpers.GetName(vdi)); RelatedTask = VDI.async_copy(Session, vdi.opaque_ref, SR.opaque_ref); PollToCompletion(PercentComplete, 60); VDI newVdi = Connection.WaitForCache(new XenRef <VDI>(Result)); // if the original is a suspend VDI, link the suspended VM to the new VDI if (vdi.type == vdi_type.suspend) { var suspendedVm = (from vm in Connection.Cache.VMs let suspendVdi = Connection.Resolve(vm.suspend_VDI) where suspendVdi != null && suspendVdi.uuid == vdi.uuid select vm).FirstOrDefault(); if (suspendedVm != null) { VM.set_suspend_VDI(Session, suspendedVm.opaque_ref, newVdi.opaque_ref); } } PercentComplete = 60; var newVbds = new List <VBD>(); foreach (var vbdRef in vdi.VBDs) { var oldVbd = Connection.Resolve(vbdRef); if (oldVbd == null) { continue; } var newVbd = new VBD { userdevice = oldVbd.userdevice, bootable = oldVbd.bootable, mode = oldVbd.mode, type = oldVbd.type, unpluggable = oldVbd.unpluggable, other_config = oldVbd.other_config, VDI = new XenRef <VDI>(newVdi.opaque_ref), VM = new XenRef <VM>(oldVbd.VM) }; newVbd.SetIsOwner(oldVbd.GetIsOwner()); newVbds.Add(newVbd); try { if (oldVbd.currently_attached && oldVbd.allowed_operations.Contains(vbd_operations.unplug)) { VBD.unplug(Session, vbdRef); } } finally { if (!oldVbd.currently_attached) { VBD.destroy(Session, vbdRef); } } } PercentComplete = 80; VDI.destroy(Session, vdi.opaque_ref); foreach (var newVbd in newVbds) { Connection.WaitForCache(VBD.create(Session, newVbd)); } PercentComplete = 100; Description = Messages.MOVED; log.DebugFormat("Moved VDI '{0}'", Helpers.GetName(vdi)); }
protected override void Run() { Description = Messages.ACTION_PREPARING; // move the progress bar above 0, it's more reassuring to see than a blank bar as we copy the first disk PercentComplete += 10; int halfstep = 90 / (VM.VBDs.Count * 2); var exceptions = new List <Exception>(); foreach (var vbdRef in VM.VBDs) { if (Cancelling) { throw new CancelledException(); } var oldVBD = Connection.Resolve(vbdRef); if (oldVBD == null || !oldVBD.GetIsOwner()) { continue; } if (_storageMapping == null || !_storageMapping.TryGetValue(oldVBD.VDI.opaque_ref, out SR sr) || sr == null) { continue; } var curVdi = Connection.Resolve(oldVBD.VDI); if (curVdi == null) { continue; } if (curVdi.SR.opaque_ref == sr.opaque_ref) { continue; } Description = string.Format(Messages.ACTION_MOVING_VDI_TO_SR, Helpers.GetName(curVdi), Helpers.GetName(sr)); RelatedTask = VDI.async_copy(Session, oldVBD.VDI.opaque_ref, sr.opaque_ref); PollToCompletion(PercentComplete, PercentComplete + halfstep); var newVDI = Connection.WaitForCache(new XenRef <VDI>(Result)); var newVBD = new VBD { userdevice = oldVBD.userdevice, bootable = oldVBD.bootable, mode = oldVBD.mode, type = oldVBD.type, unpluggable = oldVBD.unpluggable, other_config = oldVBD.other_config, VDI = new XenRef <VDI>(newVDI.opaque_ref), VM = new XenRef <VM>(VM.opaque_ref) }; newVBD.SetIsOwner(oldVBD.GetIsOwner()); try { VDI.destroy(Session, oldVBD.VDI.opaque_ref); } catch (Exception e) { log.ErrorFormat("Failed to destroy old VDI {0}", oldVBD.VDI.opaque_ref); exceptions.Add(e); } Connection.WaitForCache(VBD.create(Session, newVBD)); PercentComplete += halfstep; } if (SR != null) { VM.set_suspend_SR(Session, VM.opaque_ref, SR.opaque_ref); } if (exceptions.Count > 0) { throw new Exception(Messages.ACTION_VM_MOVING_VDI_DESTROY_FAILURE); } Description = Messages.MOVED; }