/// <returns>The host to which the given SR belongs, or null if the SR is shared or completely disconnected.</returns>
public Host GetStorageHost()
{
if (shared || PBDs.Count != 1)
{
return(null);
}
PBD pbd = Connection.Resolve(PBDs[0]);
return(pbd == null ? null : Connection.Resolve(pbd.host));
}
private bool CheckMultipathString(String status)
{
int current;
int max;
if (!PBD.ParsePathCounts(status, out current, out max))
{
return(true);
}
return(current >= max);
}
public PBD GetPBDTo(SR sr)
{
foreach (XenRef <PBD> pbd in PBDs)
{
PBD thePBD = sr.Connection.Resolve <PBD>(pbd);
if (thePBD != null && thePBD.SR.opaque_ref == sr.opaque_ref)
{
return(thePBD);
}
}
return(null);
}
public bool HasPBDTo(SR sr)
{
foreach (XenRef <PBD> pbd in PBDs)
{
PBD thePBD = sr.Connection.Resolve <PBD>(pbd);
if (thePBD != null && thePBD.SR.opaque_ref == sr.opaque_ref)
{
return(true);
}
}
return(false);
}
public static List <PBD> GetUnpluggedPBDsFor(IEnumerable <VM> vms)
{
List <PBD> unpluggedPBDs = new List <PBD>();
foreach (PBD pbd in PBD.GetPBDsFor(vms))
{
if (!pbd.currently_attached)
{
unpluggedPBDs.Add(pbd);
}
}
return(unpluggedPBDs);
}
/// <summary>
/// Get the given SR's home, i.e. the host under which we are going to display it. May return null, if this SR should live
/// at the pool level.
/// </summary>
public Host Home()
{
if (shared || PBDs.Count != 1)
{
return(null);
}
PBD pbd = Connection.Resolve(PBDs[0]);
if (pbd == null)
{
return(null);
}
return(Connection.Resolve(pbd.host));
}
private static bool WaitForPlug(Session session, string pbdOpaqueRef)
{
int timeout = 120; //Wait 2 min for PBD to plug
while (timeout > 0)
{
if (PBD.get_currently_attached(session, pbdOpaqueRef))
{
return(true);
}
Thread.Sleep(1000);
timeout--;
}
return(false);
}
public Dictionary <PBD, String> GetMultiPathStatusLunPerSR()
{
Dictionary <PBD, String> result =
new Dictionary <PBD, String>();
if (Connection == null)
{
return(result);
}
foreach (PBD pbd in Connection.ResolveAll(PBDs))
{
if (!pbd.MultipathActive())
{
continue;
}
String status = String.Empty;
foreach (KeyValuePair <String, String> kvp in pbd.other_config)
{
if (!kvp.Key.StartsWith(MPATH))
{
continue;
}
status = kvp.Value;
break;
}
int current;
int max;
if (!PBD.ParsePathCounts(status, out current, out max))
{
continue;
}
result[pbd] = status;
}
return(result);
}
/// <summary>
/// Wait about two minutes for all the PBDs on this host to become plugged:
/// if they do not, try and plug them. (Refs: CA-41219, CA-41305, CA-66496).
/// </summary>
public void CheckAndPlugPBDs()
{
bool allPBDsReady = false;
int timeout = 120;
do
{
if (this.enabled) // if the Host is not yet enabled, pbd.currently_attached may not be accurate: see CA-66496.
{
allPBDsReady = true;
foreach (PBD pbd in Connection.ResolveAll(PBDs))
{
if (!pbd.currently_attached)
{
allPBDsReady = false;
break;
}
}
}
if (!allPBDsReady)
{
Thread.Sleep(1000);
timeout--;
}
} while (!allPBDsReady && timeout > 0);
if (!allPBDsReady)
{
foreach (var pbd in Connection.ResolveAll(PBDs))
{
if (!pbd.currently_attached)
{
Session session = Connection.DuplicateSession();
// If we still havent plugged, then try and plug it - this will probably
// fail, but at least we'll get a better error message.
PBD.NonchalantPlug(session, pbd.opaque_ref);
}
}
}
}
public Dictionary <VM, Dictionary <VDI, String> > GetMultiPathStatusLunPerVDI()
{
Dictionary <VM, Dictionary <VDI, String> > result =
new Dictionary <VM, Dictionary <VDI, String> >();
if (Connection == null)
{
return(result);
}
foreach (PBD pbd in Connection.ResolveAll(PBDs))
{
if (!pbd.MultipathActive())
{
continue;
}
foreach (KeyValuePair <String, String> kvp in pbd.other_config)
{
if (!kvp.Key.StartsWith(MPATH))
{
continue;
}
int current;
int max;
if (!PBD.ParsePathCounts(kvp.Value, out current, out max))
{
continue;
}
String scsiIdKey = String.Format("scsi-{0}", kvp.Key.Substring(MPATH.Length + 1));
if (!sm_config.ContainsKey(scsiIdKey))
{
continue;
}
String vdiUUID = sm_config[scsiIdKey];
VDI vdi = null;
foreach (VDI candidate in Connection.ResolveAll(VDIs))
{
if (candidate.uuid != vdiUUID)
{
continue;
}
vdi = candidate;
break;
}
if (vdi == null)
{
continue;
}
foreach (VBD vbd in Connection.ResolveAll(vdi.VBDs))
{
VM vm = Connection.Resolve(vbd.VM);
if (vm == null)
{
continue;
}
if (vm.power_state != vm_power_state.Running)
{
continue;
}
if (!result.ContainsKey(vm))
{
result[vm] = new Dictionary <VDI, String>();
}
result[vm][vdi] = kvp.Value;
}
}
}
return(result);
}
protected override void Run()
{
log.Debug("Running SR Reconfigure Action");
log.DebugFormat("SR uuid = '{0}'", sr.uuid);
log.DebugFormat("name = '{0}'", name);
log.DebugFormat("description = '{0}'", description);
Description = Messages.ACTION_SR_ATTACHING;
// Repair the SR with new PBDs for each host in the pool
PBD pbdTemplate = new PBD();
pbdTemplate.currently_attached = false;
pbdTemplate.device_config = dconf;
pbdTemplate.SR = new XenRef<SR>(sr.opaque_ref);
int delta = 100 / (Connection.Cache.HostCount * 2);
foreach (Host host in Connection.Cache.Hosts)
{
// Create the PBD
log.DebugFormat("Creating PBD for host {0}", host.Name);
this.Description = String.Format(Messages.ACTION_SR_REPAIR_CREATE_PBD, Helpers.GetName(host));
pbdTemplate.host = new XenRef<Host>(host.opaque_ref);
RelatedTask = PBD.async_create(this.Session, pbdTemplate);
PollToCompletion(PercentComplete, PercentComplete + delta);
XenRef<PBD> pbdRef = new XenRef<PBD>(this.Result);
// Now plug the PBD
log.DebugFormat("Plugging PBD for host {0}", host.Name);
this.Description = String.Format(Messages.ACTION_SR_REPAIR_PLUGGING_PBD, Helpers.GetName(host));
RelatedTask = PBD.async_plug(this.Session, pbdRef);
PollToCompletion(PercentComplete, PercentComplete + delta);
}
// Update the name and description of the SR
XenAPI.SR.set_name_label(Session, sr.opaque_ref, name);
XenAPI.SR.set_name_description(Session, sr.opaque_ref, description);
Description = Messages.ACTION_SR_ATTACH_SUCCESSFUL;
}
/// <summary>
/// Check currently LUN against miami host
/// </summary>
/// <param name="connection"></param>
/// <param name="pbd"></param>
/// <returns></returns>
private bool UniquenessCheckMiami(IXenConnection connection, PBD pbd)
{
if (!pbd.device_config.ContainsKey(SCSIID))
return false;
String scsiID = pbd.device_config[SCSIID];
String myLUN = getIscsiLUN();
if (!LunMap.ContainsKey(myLUN))
return false;
ISCSIInfo info = LunMap[myLUN];
return info.ScsiID == scsiID;
}
protected override void Run()
{
log.Debug("Running SR.Introduce");
log.DebugFormat("SR uuid='{0}'", _srUuid);
log.DebugFormat("name='{0}'", _srName);
log.DebugFormat("description='{0}'", _srDescription);
log.DebugFormat("type='{0}'", _srType);
log.DebugFormat("content type='{0}'", _srContentType);
log.DebugFormat("is shared='{0}'", _srIsShared);
Description = Messages.ACTION_SR_ATTACHING;
// If SR is already attached, forget it (it may be in a broken invisible state with no PBDs)
try
{
log.Debug("Performing preemptive SR.forget()");
RelatedTask = XenAPI.SR.async_forget(this.Session, XenAPI.SR.get_by_uuid(this.Session,
_srUuid).opaque_ref);
PollToCompletion(0, 5);
}
catch (Failure)
{
// Allow failure
}
// Introduce the existing SR
RelatedTask = XenAPI.SR.async_introduce(this.Session, _srUuid, _srName,
_srDescription, _srType.ToString(), _srContentType,
_srIsShared, new Dictionary<string, string>());
PollToCompletion(5, 10);
// cache result, in order to reassign it later
string introducedSr = Result;
// Now repair the SR with new PBDs for each host in the pool
XenAPI.PBD pbdTemplate = new PBD();
pbdTemplate.currently_attached = false;
pbdTemplate.device_config = _dconf;
pbdTemplate.SR = new XenRef<SR>(Result);
int delta = 90 / Connection.Cache.HostCount / 2;
foreach (Host host in Connection.Cache.Hosts)
{
// Create the PBD
log.DebugFormat("Creating PBD for host {0}", host.Name);
this.Description = string.Format(Messages.ACTION_SR_REPAIR_CREATE_PBD, Helpers.GetName(host));
pbdTemplate.host = new XenRef<Host>(host.opaque_ref);
RelatedTask = PBD.async_create(this.Session, pbdTemplate);
PollToCompletion(PercentComplete, PercentComplete + delta);
XenRef<PBD> pbdRef = new XenRef<PBD>(this.Result);
// Now plug the PBD
log.DebugFormat("Plugging PBD for host {0}", host.Name);
this.Description = string.Format(Messages.ACTION_SR_REPAIR_PLUGGING_PBD, Helpers.GetName(host));
RelatedTask = XenAPI.PBD.async_plug(this.Session, pbdRef);
PollToCompletion(PercentComplete, PercentComplete + delta);
}
// reassign result
Result = introducedSr;
if (isFirstSharedNonISOSR())
{
SR new_sr = Connection.WaitForCache(new XenRef<SR>(Result), GetCancelling);
if (Cancelling)
throw new CancelledException();
if (new_sr == null)
throw new Failure(Failure.HANDLE_INVALID, "SR", Result);
// Set this SR to be the default
new SrAction(SrActionKind.SetAsDefault, new_sr).RunExternal(Session);
}
Description = Messages.ACTION_SR_ATTACH_SUCCESSFUL;
}
public RepairTreeNode(SR sr, Host host, PBD pdb)
{
SR = sr;
Host = host;
PBD = pdb;
if (host == null)
{
Text = sr.Name;
}
else
{
Text = host.Name;
}
}
protected override void ProcessRecord()
{
GetSession();
if (Record == null && HashTable == null)
{
Record = new XenAPI.PBD();
Record.host = XenHost == null ? null : new XenRef <XenAPI.Host>(XenHost.opaque_ref);
Record.SR = SR == null ? null : new XenRef <XenAPI.SR>(SR.opaque_ref);
Record.device_config = CommonCmdletFunctions.ConvertHashTableToDictionary <string, string>(DeviceConfig);
Record.other_config = CommonCmdletFunctions.ConvertHashTableToDictionary <string, string>(OtherConfig);
}
else if (Record == null)
{
Record = new XenAPI.PBD(HashTable);
}
if (!ShouldProcess(session.Url, "PBD.create"))
{
return;
}
RunApiCall(() =>
{
var contxt = _context as XenServerCmdletDynamicParameters;
if (contxt != null && contxt.Async)
{
taskRef = XenAPI.PBD.async_create(session, Record);
if (PassThru)
{
XenAPI.Task taskObj = null;
if (taskRef != "OpaqueRef:NULL")
{
taskObj = XenAPI.Task.get_record(session, taskRef.opaque_ref);
taskObj.opaque_ref = taskRef.opaque_ref;
}
WriteObject(taskObj, true);
}
}
else
{
string objRef = XenAPI.PBD.create(session, Record);
if (PassThru)
{
XenAPI.PBD obj = null;
if (objRef != "OpaqueRef:NULL")
{
obj = XenAPI.PBD.get_record(session, objRef);
obj.opaque_ref = objRef;
}
WriteObject(obj, true);
}
}
});
UpdateSessions();
}
protected override void ProcessRecord()
{
XenAPI.Session session = XenObject as XenAPI.Session;
if (session != null)
{
WriteObject(new XenRef <XenAPI.Session>(session));
return;
}
XenAPI.Auth auth = XenObject as XenAPI.Auth;
if (auth != null)
{
WriteObject(new XenRef <XenAPI.Auth>(auth));
return;
}
XenAPI.Subject subject = XenObject as XenAPI.Subject;
if (subject != null)
{
WriteObject(new XenRef <XenAPI.Subject>(subject));
return;
}
XenAPI.Role role = XenObject as XenAPI.Role;
if (role != null)
{
WriteObject(new XenRef <XenAPI.Role>(role));
return;
}
XenAPI.Task task = XenObject as XenAPI.Task;
if (task != null)
{
WriteObject(new XenRef <XenAPI.Task>(task));
return;
}
XenAPI.Event evt = XenObject as XenAPI.Event;
if (evt != null)
{
WriteObject(new XenRef <XenAPI.Event>(evt));
return;
}
XenAPI.Pool pool = XenObject as XenAPI.Pool;
if (pool != null)
{
WriteObject(new XenRef <XenAPI.Pool>(pool));
return;
}
XenAPI.Pool_patch pool_patch = XenObject as XenAPI.Pool_patch;
if (pool_patch != null)
{
WriteObject(new XenRef <XenAPI.Pool_patch>(pool_patch));
return;
}
XenAPI.Pool_update pool_update = XenObject as XenAPI.Pool_update;
if (pool_update != null)
{
WriteObject(new XenRef <XenAPI.Pool_update>(pool_update));
return;
}
XenAPI.VM vm = XenObject as XenAPI.VM;
if (vm != null)
{
WriteObject(new XenRef <XenAPI.VM>(vm));
return;
}
XenAPI.VM_metrics vm_metrics = XenObject as XenAPI.VM_metrics;
if (vm_metrics != null)
{
WriteObject(new XenRef <XenAPI.VM_metrics>(vm_metrics));
return;
}
XenAPI.VM_guest_metrics vm_guest_metrics = XenObject as XenAPI.VM_guest_metrics;
if (vm_guest_metrics != null)
{
WriteObject(new XenRef <XenAPI.VM_guest_metrics>(vm_guest_metrics));
return;
}
XenAPI.VMPP vmpp = XenObject as XenAPI.VMPP;
if (vmpp != null)
{
WriteObject(new XenRef <XenAPI.VMPP>(vmpp));
return;
}
XenAPI.VMSS vmss = XenObject as XenAPI.VMSS;
if (vmss != null)
{
WriteObject(new XenRef <XenAPI.VMSS>(vmss));
return;
}
XenAPI.VM_appliance vm_appliance = XenObject as XenAPI.VM_appliance;
if (vm_appliance != null)
{
WriteObject(new XenRef <XenAPI.VM_appliance>(vm_appliance));
return;
}
XenAPI.DR_task dr_task = XenObject as XenAPI.DR_task;
if (dr_task != null)
{
WriteObject(new XenRef <XenAPI.DR_task>(dr_task));
return;
}
XenAPI.Host host = XenObject as XenAPI.Host;
if (host != null)
{
WriteObject(new XenRef <XenAPI.Host>(host));
return;
}
XenAPI.Host_crashdump host_crashdump = XenObject as XenAPI.Host_crashdump;
if (host_crashdump != null)
{
WriteObject(new XenRef <XenAPI.Host_crashdump>(host_crashdump));
return;
}
XenAPI.Host_patch host_patch = XenObject as XenAPI.Host_patch;
if (host_patch != null)
{
WriteObject(new XenRef <XenAPI.Host_patch>(host_patch));
return;
}
XenAPI.Host_metrics host_metrics = XenObject as XenAPI.Host_metrics;
if (host_metrics != null)
{
WriteObject(new XenRef <XenAPI.Host_metrics>(host_metrics));
return;
}
XenAPI.Host_cpu host_cpu = XenObject as XenAPI.Host_cpu;
if (host_cpu != null)
{
WriteObject(new XenRef <XenAPI.Host_cpu>(host_cpu));
return;
}
XenAPI.Network network = XenObject as XenAPI.Network;
if (network != null)
{
WriteObject(new XenRef <XenAPI.Network>(network));
return;
}
XenAPI.VIF vif = XenObject as XenAPI.VIF;
if (vif != null)
{
WriteObject(new XenRef <XenAPI.VIF>(vif));
return;
}
XenAPI.VIF_metrics vif_metrics = XenObject as XenAPI.VIF_metrics;
if (vif_metrics != null)
{
WriteObject(new XenRef <XenAPI.VIF_metrics>(vif_metrics));
return;
}
XenAPI.PIF pif = XenObject as XenAPI.PIF;
if (pif != null)
{
WriteObject(new XenRef <XenAPI.PIF>(pif));
return;
}
XenAPI.PIF_metrics pif_metrics = XenObject as XenAPI.PIF_metrics;
if (pif_metrics != null)
{
WriteObject(new XenRef <XenAPI.PIF_metrics>(pif_metrics));
return;
}
XenAPI.Bond bond = XenObject as XenAPI.Bond;
if (bond != null)
{
WriteObject(new XenRef <XenAPI.Bond>(bond));
return;
}
XenAPI.VLAN vlan = XenObject as XenAPI.VLAN;
if (vlan != null)
{
WriteObject(new XenRef <XenAPI.VLAN>(vlan));
return;
}
XenAPI.SM sm = XenObject as XenAPI.SM;
if (sm != null)
{
WriteObject(new XenRef <XenAPI.SM>(sm));
return;
}
XenAPI.SR sr = XenObject as XenAPI.SR;
if (sr != null)
{
WriteObject(new XenRef <XenAPI.SR>(sr));
return;
}
XenAPI.LVHD lvhd = XenObject as XenAPI.LVHD;
if (lvhd != null)
{
WriteObject(new XenRef <XenAPI.LVHD>(lvhd));
return;
}
XenAPI.VDI vdi = XenObject as XenAPI.VDI;
if (vdi != null)
{
WriteObject(new XenRef <XenAPI.VDI>(vdi));
return;
}
XenAPI.VBD vbd = XenObject as XenAPI.VBD;
if (vbd != null)
{
WriteObject(new XenRef <XenAPI.VBD>(vbd));
return;
}
XenAPI.VBD_metrics vbd_metrics = XenObject as XenAPI.VBD_metrics;
if (vbd_metrics != null)
{
WriteObject(new XenRef <XenAPI.VBD_metrics>(vbd_metrics));
return;
}
XenAPI.PBD pbd = XenObject as XenAPI.PBD;
if (pbd != null)
{
WriteObject(new XenRef <XenAPI.PBD>(pbd));
return;
}
XenAPI.Crashdump crashdump = XenObject as XenAPI.Crashdump;
if (crashdump != null)
{
WriteObject(new XenRef <XenAPI.Crashdump>(crashdump));
return;
}
XenAPI.VTPM vtpm = XenObject as XenAPI.VTPM;
if (vtpm != null)
{
WriteObject(new XenRef <XenAPI.VTPM>(vtpm));
return;
}
XenAPI.Console console = XenObject as XenAPI.Console;
if (console != null)
{
WriteObject(new XenRef <XenAPI.Console>(console));
return;
}
XenAPI.User user = XenObject as XenAPI.User;
if (user != null)
{
WriteObject(new XenRef <XenAPI.User>(user));
return;
}
XenAPI.Data_source data_source = XenObject as XenAPI.Data_source;
if (data_source != null)
{
WriteObject(new XenRef <XenAPI.Data_source>(data_source));
return;
}
XenAPI.Blob blob = XenObject as XenAPI.Blob;
if (blob != null)
{
WriteObject(new XenRef <XenAPI.Blob>(blob));
return;
}
XenAPI.Message message = XenObject as XenAPI.Message;
if (message != null)
{
WriteObject(new XenRef <XenAPI.Message>(message));
return;
}
XenAPI.Secret secret = XenObject as XenAPI.Secret;
if (secret != null)
{
WriteObject(new XenRef <XenAPI.Secret>(secret));
return;
}
XenAPI.Tunnel tunnel = XenObject as XenAPI.Tunnel;
if (tunnel != null)
{
WriteObject(new XenRef <XenAPI.Tunnel>(tunnel));
return;
}
XenAPI.PCI pci = XenObject as XenAPI.PCI;
if (pci != null)
{
WriteObject(new XenRef <XenAPI.PCI>(pci));
return;
}
XenAPI.PGPU pgpu = XenObject as XenAPI.PGPU;
if (pgpu != null)
{
WriteObject(new XenRef <XenAPI.PGPU>(pgpu));
return;
}
XenAPI.GPU_group gpu_group = XenObject as XenAPI.GPU_group;
if (gpu_group != null)
{
WriteObject(new XenRef <XenAPI.GPU_group>(gpu_group));
return;
}
XenAPI.VGPU vgpu = XenObject as XenAPI.VGPU;
if (vgpu != null)
{
WriteObject(new XenRef <XenAPI.VGPU>(vgpu));
return;
}
XenAPI.VGPU_type vgpu_type = XenObject as XenAPI.VGPU_type;
if (vgpu_type != null)
{
WriteObject(new XenRef <XenAPI.VGPU_type>(vgpu_type));
return;
}
XenAPI.PVS_site pvs_site = XenObject as XenAPI.PVS_site;
if (pvs_site != null)
{
WriteObject(new XenRef <XenAPI.PVS_site>(pvs_site));
return;
}
XenAPI.PVS_server pvs_server = XenObject as XenAPI.PVS_server;
if (pvs_server != null)
{
WriteObject(new XenRef <XenAPI.PVS_server>(pvs_server));
return;
}
XenAPI.PVS_proxy pvs_proxy = XenObject as XenAPI.PVS_proxy;
if (pvs_proxy != null)
{
WriteObject(new XenRef <XenAPI.PVS_proxy>(pvs_proxy));
return;
}
XenAPI.PVS_cache_storage pvs_cache_storage = XenObject as XenAPI.PVS_cache_storage;
if (pvs_cache_storage != null)
{
WriteObject(new XenRef <XenAPI.PVS_cache_storage>(pvs_cache_storage));
return;
}
XenAPI.Feature feature = XenObject as XenAPI.Feature;
if (feature != null)
{
WriteObject(new XenRef <XenAPI.Feature>(feature));
return;
}
XenAPI.SDN_controller sdn_controller = XenObject as XenAPI.SDN_controller;
if (sdn_controller != null)
{
WriteObject(new XenRef <XenAPI.SDN_controller>(sdn_controller));
return;
}
XenAPI.Vdi_nbd_server_info vdi_nbd_server_info = XenObject as XenAPI.Vdi_nbd_server_info;
if (vdi_nbd_server_info != null)
{
WriteObject(new XenRef <XenAPI.Vdi_nbd_server_info>(vdi_nbd_server_info));
return;
}
XenAPI.PUSB pusb = XenObject as XenAPI.PUSB;
if (pusb != null)
{
WriteObject(new XenRef <XenAPI.PUSB>(pusb));
return;
}
XenAPI.USB_group usb_group = XenObject as XenAPI.USB_group;
if (usb_group != null)
{
WriteObject(new XenRef <XenAPI.USB_group>(usb_group));
return;
}
XenAPI.VUSB vusb = XenObject as XenAPI.VUSB;
if (vusb != null)
{
WriteObject(new XenRef <XenAPI.VUSB>(vusb));
return;
}
}
