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;
}
