public async Task <(bool, bool)> GetCBTState(string vmMoRef)
{
if (session == null)
{
throw new Exception("Not Logged");
}
var propertySpec = new PropertySpec
{
pathSet = new string[] { "config.changeTrackingEnabled", "capability.changeTrackingSupported" },
type = "VirtualMachine"
};
var propertyFilterSpec = new PropertyFilterSpec
{
propSet = new PropertySpec[] { propertySpec },
objectSet = new ObjectSpec[] { new ObjectSpec()
{
obj = new ManagedObjectReference {
type = "VirtualMachine", Value = vmMoRef
}
} }
};
var vmPowerStateReq = await Vim25Client.RetrievePropertiesAsync(serviceContent.propertyCollector, new PropertyFilterSpec[] { propertyFilterSpec });
var changeTrackingEnabled = (bool)vmPowerStateReq.returnval[0].propSet.FirstOrDefault(p => p.name == "config.changeTrackingEnabled")?.val;
var changeTrackingSupported = (bool)vmPowerStateReq.returnval[0].propSet.FirstOrDefault(p => p.name == "capability.changeTrackingSupported")?.val;
return(changeTrackingEnabled, changeTrackingSupported);
}
public async Task <VirtualMachinePowerState> GetVMPowerState(string vmMoRef)
{
if (session == null)
{
throw new Exception("Not Logged");
}
var propertySpec = new PropertySpec
{
pathSet = new string[] { "runtime.powerState" },
type = "VirtualMachine"
};
var propertyFilterSpec = new PropertyFilterSpec
{
propSet = new PropertySpec[] { propertySpec },
objectSet = new ObjectSpec[] { new ObjectSpec()
{
obj = new ManagedObjectReference {
type = "VirtualMachine", Value = vmMoRef
}
} }
};
var vmPowerStateReq = await Vim25Client.RetrievePropertiesAsync(serviceContent.propertyCollector, new PropertyFilterSpec[] { propertyFilterSpec });
return((VirtualMachinePowerState)vmPowerStateReq.returnval[0].propSet.FirstOrDefault(p => p.name == "runtime.powerState")?.val);
}
public async Task CreateVM(string folderMoRef, object configSpec, string resourcePoolMoRef, string hostMoRef)
{
if (session == null)
{
throw new Exception("Not Logged");
}
var vmConfig = configSpec as VirtualMachineConfigSpec;
if (vmConfig == null)
{
throw new ArgumentException($"{nameof(configSpec)} must be of type VirtualMachineConfigSpec");
}
var folder = new ManagedObjectReference {
type = "Folder", Value = folderMoRef
};
var pool = new ManagedObjectReference {
type = "ResourcePool", Value = resourcePoolMoRef
};
var host = new ManagedObjectReference {
type = "Host", Value = hostMoRef
};
var createTask = await Vim25Client.CreateVM_TaskAsync(folder, vmConfig, pool, host);
var taskInfo = await WaitForTaskEnd(createTask);
if (taskInfo.state != TaskInfoState.success)
{
throw new Exception(taskInfo.error.localizedMessage);
}
}
public async Task <object> GetVMConfigFromSnapshot(string snapshotMoRef)
{
if (session == null)
{
throw new Exception("Not Logged");
}
var propertySpecSnap = new PropertySpec
{
pathSet = new string[] { "config" },
type = "VirtualMachineSnapshot"
};
var propertyFilterSpecSnap = new PropertyFilterSpec
{
propSet = new PropertySpec[] { propertySpecSnap },
objectSet = new ObjectSpec[] { new ObjectSpec()
{
obj = new ManagedObjectReference {
type = "VirtualMachineSnapshot", Value = snapshotMoRef
}
} }
};
var snapProps = await Vim25Client.RetrievePropertiesAsync(serviceContent.propertyCollector, new PropertyFilterSpec[] { propertyFilterSpecSnap });
return(snapProps.returnval[0].propSet.FirstOrDefault(p => p.name == "config")?.val as VirtualMachineConfigInfo);
}
public async Task <IEnumerable <ManagedEntity> > GetVMs()
{
if (session == null)
{
throw new Exception("Not Logged");
}
////////////////////////////////////////////////////////
var dc2vmFolder = new TraversalSpec
{
type = "Datacenter",
path = "vmFolder",
selectSet = new SelectionSpec[] { new SelectionSpec {
name = "folderTSpec"
} }
};
var folderTS = new TraversalSpec
{
name = "folderTSpec",
type = "Folder",
path = "childEntity",
selectSet = new SelectionSpec[] { new SelectionSpec {
name = "folderTSpec"
}, dc2vmFolder }
};
var ospec = new ObjectSpec
{
obj = serviceContent.rootFolder,
skip = false,
selectSet = new SelectionSpec[] { folderTS }
};
/////////////////////////////////////////////
var vmSp = new PropertySpec
{
type = "VirtualMachine",
all = false,
pathSet = new string[] { "name" }
};
////////////////////////////////////////////
var fs = new PropertyFilterSpec {
objectSet = new ObjectSpec[] { ospec }, propSet = new PropertySpec[] { vmSp }
};
var vmProps = await Vim25Client.RetrievePropertiesAsync(serviceContent.propertyCollector, new PropertyFilterSpec[] { fs });
return(vmProps.returnval
.Select(obj => new ManagedEntity {
MoRef = obj.obj.Value, Type = obj.obj.type, Name = (string)obj.propSet[0].val
}));
}
public async Task Logout()
{
if (session == null)
{
throw new Exception("Not Logged");
}
await Vim25Client.LogoutAsync(serviceContent.sessionManager);
session = null;
}
public async Task RemoveSnapshot(string snapshotMoRef, bool removeChildren, bool consolidate)
{
if (session == null)
{
throw new Exception("Not Logged");
}
var taskRef = await Vim25Client.RemoveSnapshot_TaskAsync(new ManagedObjectReference { type = "VirtualMachineSnapshot", Value = snapshotMoRef }, removeChildren, consolidate);
var taskInfo = await WaitForTaskEnd(taskRef);
if (taskInfo.state != TaskInfoState.success)
{
throw new Exception(taskInfo.error.localizedMessage);
}
}
public async Task <string> CreateSnapshot(string virtualMachineMoRef, string name, string description, bool memory, bool quiesce)
{
if (session == null)
{
throw new Exception("Not Logged");
}
var taskRef = await Vim25Client.CreateSnapshot_TaskAsync(new ManagedObjectReference { type = "VirtualMachine", Value = virtualMachineMoRef }, name, description, memory, quiesce);
var taskInfo = await WaitForTaskEnd(taskRef);
if (taskInfo.state != TaskInfoState.success)
{
throw new Exception(taskInfo.error.localizedMessage);
}
var snapRef = taskInfo.result as ManagedObjectReference;
return(snapRef.Value);
}
public async Task <IEnumerable <(long start, long length)> > GetDiskChangedAreas(string vmMoRef, string snapshotMoRef, int diskKey, long startOffset, string changeId = "*")
{
if (session == null)
{
throw new Exception("Not Logged");
}
var diskChangeInfo = await Vim25Client.QueryChangedDiskAreasAsync(
new ManagedObjectReference { type = "VirtualMachine", Value = vmMoRef },
new ManagedObjectReference { type = "VirtualMachineSnapshot", Value = snapshotMoRef },
diskKey, startOffset, changeId);
if (diskChangeInfo.changedArea == null)
{
return(Enumerable.Empty <(long start, long length)>());
}
return(diskChangeInfo.changedArea.OrderBy(change => change.start).Select(change => (change.start, change.length)));
}
private async Task <TaskInfo> WaitForTaskEnd(ManagedObjectReference task)
{
if (session == null)
{
throw new Exception("Not Logged");
}
if (task.type != "Task")
{
throw new ArgumentException($"{nameof(task)} is not of type \"Task\"");
}
var propertySpecTask = new PropertySpec
{
pathSet = new string[] { "info" },
type = "Task"
};
var propertyFilterSpecTask = new PropertyFilterSpec
{
propSet = new PropertySpec[] { propertySpecTask },
objectSet = new ObjectSpec[] { new ObjectSpec {
obj = task
} }
};
var taskProps = await Vim25Client.RetrievePropertiesAsync(serviceContent.propertyCollector, new PropertyFilterSpec[] { propertyFilterSpecTask });
var configTaskInfo = taskProps.returnval[0].propSet[0].val as TaskInfo;
while (configTaskInfo?.state == TaskInfoState.running)
{
await Task.Delay(2000);
taskProps = await Vim25Client.RetrievePropertiesAsync(serviceContent.propertyCollector, new PropertyFilterSpec[] { propertyFilterSpecTask });
configTaskInfo = taskProps.returnval[0].propSet[0].val as TaskInfo;
}
;
return(configTaskInfo);
}
public async Task Login(string username, string password, string locale = null)
{
if (string.IsNullOrWhiteSpace(username))
{
throw new ArgumentException("Argument cannot be null or empty", nameof(username));
}
if (string.IsNullOrWhiteSpace(password))
{
throw new ArgumentException("Argument cannot be null or empty", nameof(password));
}
var serviceRef = new ManagedObjectReference
{
type = "ServiceInstance",
Value = "ServiceInstance"
};
serviceContent = await Vim25Client.RetrieveServiceContentAsync(serviceRef);
session = await Vim25Client.LoginAsync(serviceContent.sessionManager, username, password, locale);
}
public async Task ConfigureForCBT(string vmMoRef)
{
if (session == null)
{
throw new Exception("Not Logged");
}
var taskRef = await Vim25Client.ReconfigVM_TaskAsync(
new ManagedObjectReference { type = "VirtualMachine", Value = vmMoRef },
new VirtualMachineConfigSpec { changeTrackingEnabled = true });
var configTaskInfo = await WaitForTaskEnd(taskRef);
if (configTaskInfo.state != TaskInfoState.success)
{
throw new Exception(configTaskInfo.error.localizedMessage);
}
var snapTask = await CreateSnapshot(vmMoRef, "Enable CBT", "", false, false);
await RemoveSnapshot(snapTask, false, true);
}
public async Task <IEnumerable <ManagedEntity> > GetPools()
{
if (session == null)
{
throw new Exception("Not Logged");
}
////////////////////////////////////////////////////////
var dc2hostFolder = new TraversalSpec
{
type = "Datacenter",
path = "hostFolder",
selectSet = new SelectionSpec[] { new SelectionSpec {
name = "ressourcesTSpec"
} }
};
var cr2resourcePool = new TraversalSpec
{
type = "ComputeResource",
path = "resourcePool",
selectSet = new SelectionSpec[] { new SelectionSpec {
name = "ressourcesTSpec"
} }
};
var rp2rp = new TraversalSpec
{
type = "ResourcePool",
path = "resourcePool",
selectSet = new SelectionSpec[] { new SelectionSpec {
name = "ressourcesTSpec"
} }
};
var folderTS = new TraversalSpec
{
name = "ressourcesTSpec",
type = "Folder",
path = "childEntity",
selectSet = new SelectionSpec[] { new SelectionSpec {
name = "ressourcesTSpec"
}, dc2hostFolder, cr2resourcePool, rp2rp }
};
var ospec = new ObjectSpec
{
obj = serviceContent.rootFolder,
skip = false,
selectSet = new SelectionSpec[] { folderTS }
};
/////////////////////////////////////////////
var dcSp = new PropertySpec
{
type = "Datacenter",
all = false,
pathSet = new string[] { "parent", "name" }
};
var folderSp = new PropertySpec
{
type = "Folder",
all = false,
pathSet = new string[] { "parent", "name" }
};
var computeSp = new PropertySpec
{
type = "ComputeResource",
all = false,
pathSet = new string[] { "parent", "name" }
};
var rpSp = new PropertySpec
{
type = "ResourcePool",
all = false,
pathSet = new string[] { "parent", "name" }
};
////////////////////////////////////////////
var fs = new PropertyFilterSpec {
objectSet = new ObjectSpec[] { ospec }, propSet = new PropertySpec[] { dcSp, folderSp, computeSp, rpSp }
};
var vmProps = await Vim25Client.RetrievePropertiesAsync(serviceContent.propertyCollector, new PropertyFilterSpec[] { fs });
return(vmProps.returnval
.Select(obj =>
new ManagedEntity
{
MoRef = obj.obj.Value,
Type = obj.obj.type,
Name = (string)obj.propSet.FirstOrDefault(o => o.name == "name")?.val,
Parent = ((ManagedObjectReference)obj.propSet.FirstOrDefault(o => o.name == "parent")?.val)?.Value
}));
}
