ModifySwitchName(
string existingSwitchName,
string newSwitchName,
string newNotes)
{
ManagementScope scope = new ManagementScope(@"root\virtualization\v2");
//
// Get the switch we want to modify.
//
using (ManagementObject ethernetSwitch = NetworkingUtilities.FindEthernetSwitch(existingSwitchName, scope))
//
// To make modifications to the switch, we need to modify its configuration object.
//
using (ManagementObject ethernetSwitchSettings = WmiUtilities.GetFirstObjectFromCollection(
ethernetSwitch.GetRelated("Msvm_VirtualEthernetSwitchSettingData",
"Msvm_SettingsDefineState",
null, null, null, null, false, null)))
{
//
// Modify its properties as desired.
//
ethernetSwitchSettings["ElementName"] = newSwitchName;
ethernetSwitchSettings["Notes"] = new string[] { newNotes };
//
// This is how you can modify the IOV Preferred property from its current value.
// We leave this commented out because it could potentially fail for a system that doesn't
// support IOV.
//
// ethernetSwitchSettings["IOVPreferred"] = !((bool)ethernetSwitchSettings["IOVPreferred"]);
//
// Now call the ModifySystemSettings method to apply the changes.
//
using (ManagementObject switchService = NetworkingUtilities.GetEthernetSwitchManagementService(scope))
using (ManagementBaseObject inParams = switchService.GetMethodParameters("ModifySystemSettings"))
{
inParams["SystemSettings"] = ethernetSwitchSettings.GetText(TextFormat.WmiDtd20);
using (ManagementBaseObject outParams =
switchService.InvokeMethod("ModifySystemSettings", inParams, null))
{
WmiUtilities.ValidateOutput(outParams, scope);
}
}
}
Console.WriteLine(string.Format(CultureInfo.CurrentCulture,
"The switch '{0}' was renamed to '{1}' successfully.",
existingSwitchName, newSwitchName));
}
internal void DefineSystem(ManagementObject systemSettings, ManagementObject[] resourceSettings, out ManagementObject resultingSystem)
{
using (ManagementBaseObject inputParameters = vmms.GetMethodParameters("DefineSystem"))
{
inputParameters["SystemSettings"] = systemSettings.GetText(TextFormat.WmiDtd20);
inputParameters["ResourceSettings"] = resourceSettings.ToStringArray();
using (ManagementBaseObject outputParameters = vmms.InvokeMethod("DefineSystem", inputParameters, null))
{
ValidateOutput(outputParameters);
resultingSystem = new ManagementObject((string)outputParameters["ResultingSystem"]);
}
}
}
VmAndStorageMigrationSimple(
string sourceHost,
string destinationHost,
string vmName
)
{
ManagementScope srcScope = new ManagementScope(
@"\\" + sourceHost + @"\root\virtualization\v2", null);
using (ManagementObject migrationSettingData = GetMigrationSettingData(srcScope))
using (ManagementObject vm = WmiUtilities.GetVirtualMachine(vmName, srcScope))
{
migrationSettingData["MigrationType"] = MigrationType.VirtualSystemAndStorage;
migrationSettingData["TransportType"] = TransportType.TCP;
// Get the VHD SASDs.
string[] sasds = null;
ManagementObject[] vhdList = WmiUtilities.GetVhdSettings(vm);
if (vhdList != null)
{
sasds = new string[vhdList.Length];
for (uint index = 0; index < vhdList.Length; ++index)
{
using (ManagementObject vhd = vhdList[index])
{
// Change the VHD path to an empty string, which will force
// the system to use resource pools to get the right path at
// the destination node.
vhd["HostResource"] = new string[] { "" };
// Create an array of embedded instances.
sasds[index] = vhd.GetText(TextFormat.CimDtd20);
}
}
}
else
{
Console.WriteLine("No VHDs found associated with the VM. Skipping VHDs...");
}
// Perform migration.
Console.WriteLine("Performing migration...");
Migrate(srcScope,
vmName,
destinationHost,
migrationSettingData.GetText(TextFormat.CimDtd20),
null,
sasds);
}
}
private void AddVirtualNetwork(string vmName, string nicName, string address)
{
if (string.IsNullOrEmpty(vmName))
{
throw new ArgumentNullException("vmName");
}
using (ManagementObject service = Utility.GetServiceObject(managementScope, "Msvm_VirtualSystemManagementService"))
using (ManagementObject vm = Utility.GetTargetComputer(vmName, managementScope))
using (ManagementBaseObject inP = service.GetMethodParameters("AddVirtualSystemResources"))
using (ManagementObject nicDefault = Utility.GetResourceDataDefault(
managementScope, ResourceType.EthernetAdapter, ResourceSubType.EthernetSynthetic, null))
{
if (address != null)
{
nicDefault["StaticMacAddress"] = true;
nicDefault["Address"] = address;
}
else
{
nicDefault["StaticMacAddress"] = false;
}
nicDefault["ElementName"] = nicName;
var identifiers = new String[1];
identifiers[0] = string.Format(CultureInfo.InvariantCulture, "{{{0}}}", Guid.NewGuid());
nicDefault["VirtualSystemIdentifiers"] = identifiers;
var rasDs = new string[1];
rasDs[0] = nicDefault.GetText(TextFormat.CimDtd20);
inP["ResourcesettingData"] = rasDs;
inP["TargetSystem"] = vm.Path.Path;
ManagementBaseObject outP = service.InvokeMethod("AddVirtualSystemResources", inP, null);
if (outP == null)
{
throw new ArgumentException("Could not add virtual network!");
}
if ((UInt32)outP["ReturnValue"] == ReturnCode.Started)
{
NewTask(outP, managementScope);
}
NewTask((UInt32)outP["ReturnValue"]);
}
//ConnectSwitchPort connect = new ConnectSwitchPort(serverName);
//connect.Connect(nicName, nicName + "_ExternalPort", vmName, "synthetic", null);
}
ConfigureMetricsFlushInterval(
TimeSpan interval)
{
ManagementScope scope = new ManagementScope(@"root\virtualization\v2");
//
// Create an instance of the Msvm_MetricServiceSettingData class and set the specified
// metrics flush interval. Note that the TimeSpan must be converted to a DMTF time
// interval first.
//
string dmtfTimeInterval = ManagementDateTimeConverter.ToDmtfTimeInterval(interval);
string serviceSettingDataEmbedded;
using (ManagementClass serviceSettingDataClass = new ManagementClass(
"Msvm_MetricServiceSettingData"))
{
serviceSettingDataClass.Scope = scope;
using (ManagementObject serviceSettingData = serviceSettingDataClass.CreateInstance())
{
serviceSettingData["MetricsFlushInterval"] = dmtfTimeInterval;
serviceSettingDataEmbedded = serviceSettingData.GetText(TextFormat.WmiDtd20);
}
}
//
// Call the Msvm_MetricService::ModifyServiceSettings method. Note that the
// Msvm_MetricServiceSettingData instance must be passed as an embedded instance.
//
using (ManagementObject metricService = MetricUtilities.GetMetricService(scope))
{
using (ManagementBaseObject inParams =
metricService.GetMethodParameters("ModifyServiceSettings"))
{
inParams["SettingData"] = serviceSettingDataEmbedded;
using (ManagementBaseObject outParams =
metricService.InvokeMethod("ModifyServiceSettings", inParams, null))
{
WmiUtilities.ValidateOutput(outParams, scope);
Console.WriteLine(string.Format(CultureInfo.CurrentCulture,
"The MetricsFlushInterval was successfully configured to interval \"{0}\".",
interval.ToString()));
}
}
}
}
AddAuthorizationEntry(
string primaryHostSystem,
string trustGroup,
string replicaStoragePath)
{
ManagementScope scope = new ManagementScope(@"root\virtualization\v2");
//
// Call the Msvm_ReplicationService::AddAuthorizationEntry method. Note that the
// Msvm_ReplicationAuthorizationSettingData instance must be passed as an embedded instance.
//
using (ManagementObject replicationService =
ReplicaUtilities.GetVirtualMachineReplicationService(scope))
{
//
// Create an instance of the Msvm_ReplicationAuthorizationSettingData.
//
string authSettingDataEmbedded;
using (ManagementClass authSettingDataClass = new ManagementClass(
"Msvm_ReplicationAuthorizationSettingData"))
{
authSettingDataClass.Scope = scope;
using (ManagementObject authSettingData = authSettingDataClass.CreateInstance())
{
authSettingData["AllowedPrimaryHostSystem"] = primaryHostSystem;
authSettingData["TrustGroup"] = trustGroup;
authSettingData["ReplicaStorageLocation"] = replicaStoragePath;
authSettingDataEmbedded = authSettingData.GetText(TextFormat.WmiDtd20);
using (ManagementBaseObject inParams =
replicationService.GetMethodParameters("AddAuthorizationEntry"))
{
inParams["AuthorizationEntry"] = authSettingDataEmbedded;
using (ManagementBaseObject outParams =
replicationService.InvokeMethod("AddAuthorizationEntry", inParams, null))
{
WmiUtilities.ValidateOutput(outParams, scope);
}
Console.WriteLine(string.Format(CultureInfo.CurrentCulture,
"Replication is authorized for \"{0}\".", primaryHostSystem));
}
}
}
}
}
public static int ModifyDevice(this ManagementObject VM, ManagementObject Device, out ManagementObject Job)
{
Job = null;
switch (VM["__CLASS"].ToString().ToUpperInvariant())
{
case "MSVM_COMPUTERSYSTEM":
ManagementObject ServiceObj = GetServiceObject(VM.GetScope(), ServiceNames.VSManagement);
Job = new ManagementObject();
return((Int32)ServiceObj.InvokeMethod("ModifyVirtualSystemResources",
new object[] { VM.Path.Path, Device.GetText(TextFormat.WmiDtd20), null, Job }));
default:
return(-1);
}
}
AddFeatureSettings(
string switchName)
{
ManagementScope scope = new ManagementScope(@"root\virtualization\v2");
string featureId = NetworkingUtilities.GetSwitchFeatureId(NetworkingUtilities.SwitchFeatureType.Bandwidth);
using (ManagementObject managementService = NetworkingUtilities.GetEthernetSwitchManagementService(scope))
//
// Find the specified switch.
//
using (ManagementObject ethernetSwitch = NetworkingUtilities.FindEthernetSwitch(switchName, scope))
using (ManagementObject ethernetSwitchSetting = WmiUtilities.GetFirstObjectFromCollection(
ethernetSwitch.GetRelated("Msvm_VirtualEthernetSwitchSettingData",
"Msvm_SettingsDefineState",
null, null, null, null, false, null)))
//
// Add a new bandwidth setting instance.
//
using (ManagementObject bandwidthSetting =
NetworkingUtilities.GetDefaultFeatureSetting(featureId, scope))
{
//
// Set the default bandwidth reservation to 10 Mbps.
//
bandwidthSetting["DefaultFlowReservation"] = 12500000; // in bytes/sec
using (ManagementBaseObject inParams =
managementService.GetMethodParameters("AddFeatureSettings"))
{
inParams["AffectedConfiguration"] = ethernetSwitchSetting.Path.Path;
inParams["FeatureSettings"] = new string[] { bandwidthSetting.GetText(TextFormat.WmiDtd20) };
using (ManagementBaseObject outParams =
managementService.InvokeMethod("AddFeatureSettings", inParams, null))
{
WmiUtilities.ValidateOutput(outParams, scope);
}
}
}
Console.WriteLine(string.Format(CultureInfo.CurrentCulture,
"Successfully added bandwidth feature setting to virtual switch '{0}'.",
switchName));
}
ModifyFeatureSettings(
string switchName)
{
ManagementScope scope = new ManagementScope(@"root\virtualization\v2");
using (ManagementObject managementService = NetworkingUtilities.GetEthernetSwitchManagementService(scope))
//
// Find the specified switch.
//
using (ManagementObject ethernetSwitch = NetworkingUtilities.FindEthernetSwitch(switchName, scope))
using (ManagementObject ethernetSwitchSetting = WmiUtilities.GetFirstObjectFromCollection(
ethernetSwitch.GetRelated("Msvm_VirtualEthernetSwitchSettingData",
"Msvm_SettingsDefineState",
null, null, null, null, false, null)))
//
// Find the existing bandwidth setting and modify it.
//
using (ManagementObject bandwidthSetting = WmiUtilities.GetFirstObjectFromCollection(
ethernetSwitchSetting.GetRelated("Msvm_VirtualEthernetSwitchBandwidthSettingData",
"Msvm_VirtualEthernetSwitchSettingDataComponent",
null, null, null, null, false, null)))
{
//
// Increase the current reservation by 1 Mbps.
//
bandwidthSetting["DefaultFlowReservation"] =
(UInt64)bandwidthSetting["DefaultFlowReservation"] + 125000; // in bytes/sec
using (ManagementBaseObject inParams =
managementService.GetMethodParameters("ModifyFeatureSettings"))
{
inParams["FeatureSettings"] = new string[] { bandwidthSetting.GetText(TextFormat.WmiDtd20) };
using (ManagementBaseObject outParams =
managementService.InvokeMethod("ModifyFeatureSettings", inParams, null))
{
WmiUtilities.ValidateOutput(outParams, scope);
}
}
}
Console.WriteLine(string.Format(CultureInfo.CurrentCulture,
"Successfully modified bandwidth feature setting on virtual switch '{0}'.",
switchName));
}
CreateSwitch(
string switchName,
string switchNotes,
string[] ports,
ManagementScope scope)
{
string switchSettingText;
//
// Create the configuration object we pass into the CreateSwitch method in order to
// specify details about the switch to create, such as its name and any notes.
//
using (ManagementClass switchSettingClass =
new ManagementClass("Msvm_VirtualEthernetSwitchSettingData"))
{
switchSettingClass.Scope = scope;
using (ManagementObject switchSetting = switchSettingClass.CreateInstance())
{
switchSetting["ElementName"] = switchName;
switchSetting["Notes"] = new string[] { switchNotes };
//
// You can also configure other aspects of the switch before you create it,
// such as its IOVPreferred property.
//
// switchSetting["IOVPreferred"] = true;
switchSettingText = switchSetting.GetText(TextFormat.WmiDtd20);
}
}
//
// Now create the switch with the specified ports.
//
using (ManagementObject switchService = NetworkingUtilities.GetEthernetSwitchManagementService(scope))
using (ManagementBaseObject inParams = switchService.GetMethodParameters("DefineSystem"))
{
inParams["SystemSettings"] = switchSettingText;
inParams["ResourceSettings"] = ports;
using (ManagementBaseObject outParams =
switchService.InvokeMethod("DefineSystem", inParams, null))
{
WmiUtilities.ValidateOutput(outParams, scope);
}
}
}
ReverseReplicationRelationship(
string name)
{
ManagementScope scope = new ManagementScope(@"root\virtualization\v2");
//
// Retrieve the Msvm_ComputerSystem.
//
using (ManagementObject vm = WmiUtilities.GetVirtualMachine(name, scope))
{
string vmPath = vm.Path.Path;
using (ManagementObject replicationSettingData = ReplicaUtilities.GetReplicationSettings(vm))
{
//
// Simply reverse the recovery server name with that of primary, other
// properties are already populated.
//
replicationSettingData["RecoveryConnectionPoint"] =
replicationSettingData["PrimaryConnectionPoint"];
string settingDataEmbedded = replicationSettingData.GetText(TextFormat.WmiDtd20);
using (ManagementObject replicationService =
ReplicaUtilities.GetVirtualMachineReplicationService(scope))
{
using (ManagementBaseObject inParams =
replicationService.GetMethodParameters("ReverseReplicationRelationship"))
{
inParams["ComputerSystem"] = vmPath;
inParams["ReplicationSettingData"] = settingDataEmbedded;
using (ManagementBaseObject outParams =
replicationService.InvokeMethod("ReverseReplicationRelationship",
inParams,
null))
{
WmiUtilities.ValidateOutput(outParams, scope);
}
}
}
Console.WriteLine(string.Format(CultureInfo.CurrentCulture,
"Replication is successfully reversed for virtual machine \"{0}\"", name));
}
}
}
internal static ManagementBaseObject AddResourceSettings(
this ManagementScope scope,
ManagementObject virtualSystemSettingData,
ManagementObject resourceSettingData)
{
var virtualSystemManagementService = scope.GetVirtualSystemManagementService();
var inParameters = virtualSystemManagementService.GetMethodParameters("AddResourceSettings");
inParameters["AffectedConfiguration"] = virtualSystemSettingData;
inParameters["ResourceSettings"] = new string[]
{
resourceSettingData.GetText(TextFormat.WmiDtd20)
};
return(virtualSystemManagementService.InvokeMethod("AddResourceSettings", inParameters, null));
}
ConfigWwnGenerator(
string minWwpn,
string maxWwpn,
string newWwnn)
{
Console.WriteLine("Trying to configure the WWN generator with:");
Console.WriteLine("\tMinimumWWPNAddress = {0}", minWwpn);
Console.WriteLine("\tMaximumWWPNAddress = {0}", maxWwpn);
if (newWwnn == null)
{
Console.WriteLine("\tThe CurrentWWNNAddress will not be modified.");
}
else
{
Console.WriteLine("\tCurrentWWNNAddress = {0}", newWwnn);
}
ManagementScope scope = FibreChannelUtilities.GetFcScope();
using (ManagementObject service =
WmiUtilities.GetVirtualMachineManagementService(scope))
using (ManagementObject settings =
WmiUtilities.GetVirtualMachineManagementServiceSettings(scope))
using (ManagementBaseObject inParams =
service.GetMethodParameters("ModifyServiceSettings"))
{
settings["MinimumWWPNAddress"] = minWwpn;
settings["MaximumWWPNAddress"] = maxWwpn;
if (newWwnn != null)
{
settings["CurrentWWNNAddress"] = newWwnn;
}
inParams["SettingData"] = settings.GetText(TextFormat.WmiDtd20);
using (ManagementBaseObject outParams =
service.InvokeMethod("ModifyServiceSettings",
inParams,
null))
{
WmiUtilities.ValidateOutput(outParams, scope, true, true);
}
}
Console.WriteLine("Successfully configured the WWN Generator.");
}
public static VMJob SetVMResource(VM vm, ManagementObject resource, Dictionary <string, object> Params)
{
ManagementScope scope = new ManagementScope(@"\\" + vm.Host.Name + @"\root\virtualization", vm.Host.HostConnectionOptions);
ManagementObject virtualSystemService = Utility.GetServiceObject(scope, "Msvm_VirtualSystemManagementService");
ManagementBaseObject inParams = virtualSystemService.GetMethodParameters("ModifyVirtualSystemResources");
ManagementObject vmObj = vm.Instance;
//ManagementObject resource = GetMemory(vm);
//memSettings["Limit"] = quantity;
//memSettings["Reservation"] = quantity;
foreach (string key in Params.Keys)
{
resource[key] = Params[key];
}
//resource["VirtualQuantity"] = quantity;
string[] Resources = new string[1];
Resources[0] = resource.GetText(TextFormat.CimDtd20);
//ManagementBaseObject inParams = virtualSystemService.GetMethodParameters("ModifyVirtualSystemResources");
inParams["ComputerSystem"] = vmObj.Path.Path;
inParams["ResourcesettingData"] = Resources;
VMJob ThisJob = null;
ManagementBaseObject outParams = virtualSystemService.InvokeMethod("ModifyVirtualSystemResources", inParams, null);
//MessageBox.Show(outParams.GetText(TextFormat.Mof));
string jobPath = (string)outParams["Job"];
UInt32 returnValue = (UInt32)outParams["ReturnValue"];
if (jobPath != null)
{
ManagementObject jobObj = new ManagementObject(scope, new ManagementPath(jobPath), null);
ThisJob = new VMJob(jobObj);
}
inParams.Dispose();
//resource.Dispose();
outParams.Dispose();
vmObj.Dispose();
virtualSystemService.Dispose();
if ((jobPath == null) && (returnValue != ReturnCode.Completed) && (returnValue != ReturnCode.Started))
{
throw new VMResourcesUpdateException(returnValue);
}
return(ThisJob);
}
private static string GetVirtualSystemGlobalSettingDataInstance(ManagementScope scope, string machineName)
{
var settingPath = new ManagementPath("Msvm_VirtualSystemGlobalsettingData");
using (var globalSettingClass = new ManagementClass(scope, settingPath, null))
{
using (ManagementObject globalSettingData = globalSettingClass.CreateInstance())
{
if (globalSettingData == null)
{
throw new ArgumentException("Could not get global machine settings.");
}
globalSettingData["ElementName"] = machineName;
return(globalSettingData.GetText(TextFormat.CimDtd20));
}
}
}
ModifyServiceSettings(
bool enableReplicaServer)
{
ManagementScope scope = new ManagementScope(@"root\virtualization\v2");
string serviceSettingDataEmbedded;
//
// Call the Msvm_ReplicationService::ModifyServiceSettings method. Note that the
// Msvm_ReplicationServiceSettingData instance must be passed as an embedded instance.
//
using (ManagementObject replicationService =
ReplicaUtilities.GetVirtualMachineReplicationService(scope))
{
//
// Gets an instance of the Msvm_ReplicationServiceSettingData class and set the
// RecoveryServerEnabled field. Note that this sample enables the replication server
// for integrated authentication.
//
using (ManagementObject serviceSettingData =
ReplicaUtilities.GetReplicationServiceSettings(replicationService))
{
serviceSettingData["RecoveryServerEnabled"] = enableReplicaServer;
serviceSettingData["AllowedAuthenticationType"] = 1;
serviceSettingDataEmbedded = serviceSettingData.GetText(TextFormat.WmiDtd20);
using (ManagementBaseObject inParams =
replicationService.GetMethodParameters("ModifyServiceSettings"))
{
inParams["SettingData"] = serviceSettingDataEmbedded;
using (ManagementBaseObject outParams =
replicationService.InvokeMethod("ModifyServiceSettings", inParams, null))
{
WmiUtilities.ValidateOutput(outParams, scope);
}
Console.WriteLine(string.Format(CultureInfo.CurrentCulture,
"The replication service was successfully {0}.",
enableReplicaServer ? "enabled" : "disabled"));
}
}
}
}
SetAuthorizationEntry(
string name,
string primaryHostSystem)
{
ManagementScope scope = new ManagementScope(@"root\virtualization\v2");
//
// Retrieve the Msvm_ComputerSystem.
//
using (ManagementObject vm = WmiUtilities.GetVirtualMachine(name, scope))
{
string vmPath = vm.Path.Path;
using (ManagementObject authEntry =
ReplicaUtilities.GetAuthorizationEntry(primaryHostSystem))
{
string authEntryEmbedded = authEntry.GetText(TextFormat.WmiDtd20);
using (ManagementObject replicationService =
ReplicaUtilities.GetVirtualMachineReplicationService(scope))
{
using (ManagementBaseObject inParams =
replicationService.GetMethodParameters("SetAuthorizationEntry"))
{
inParams["ComputerSystem"] = vmPath;
inParams["AuthorizationEntry"] = authEntryEmbedded;
using (ManagementBaseObject outParams =
replicationService.InvokeMethod("SetAuthorizationEntry",
inParams,
null))
{
WmiUtilities.ValidateOutput(outParams, scope);
}
}
}
Console.WriteLine(string.Format(CultureInfo.CurrentCulture,
"Replication for virtual machine \"{0}\" is successfully associated with \"{1}\"",
name, primaryHostSystem));
}
}
}
public bool ExportVirtualSystem(VirtualMachine virtualMachine, SnapshotExport snapshotExport)
{
virtualMachine.ExportPercentComplete = 0;
bool exportSuccess = true;
var scope = WmiRoutines.GetScope(WmiRoutines.NAMESPACE_HYPER_V);
using (ManagementObject virtualSystemService = WmiRoutines.GetServiceObject(scope, "Msvm_VirtualSystemManagementService"))
using (ManagementObject srv = GetVirtualMachine(scope, virtualMachine.Name))
using (ManagementBaseObject inParams = virtualSystemService.GetMethodParameters("ExportSystemDefinition"))
{
if (!Directory.Exists(virtualMachine.ExportPath))
{
Directory.CreateDirectory(virtualMachine.ExportPath);
}
ManagementPath settingPath = new ManagementPath("Msvm_VirtualSystemExportSettingData");
using (ManagementClass exportSettingDataClass = new ManagementClass(scope, settingPath, null))
using (ManagementObject exportSettingData = exportSettingDataClass.CreateInstance())
{
exportSettingData["CopySnapshotConfiguration"] = snapshotExport;
exportSettingData["CopyVmRuntimeInformation"] = true;
exportSettingData["CopyVmStorage"] = true;
exportSettingData["CreateVmExportSubdirectory"] = true;
string settingData = exportSettingData.GetText(TextFormat.CimDtd20);
inParams["ComputerSystem"] = srv.Path.Path;
inParams["ExportDirectory"] = virtualMachine.ExportPath;
inParams["ExportSettingData"] = settingData;
}
using (ManagementBaseObject outParams = virtualSystemService.InvokeMethod("ExportSystemDefinition",
inParams, null))
{
exportSuccess = ValidateOutput(virtualMachine, outParams, scope, false, true);
}
}
virtualMachine.ExportPercentComplete = 100;
return(exportSuccess);
}
Enable(
string serverName,
bool set,
bool enable)
{
ManagementScope scope = new ManagementScope(@"\\" + serverName + @"\root\virtualization\v2", null);
using (ManagementObject settings = WmiUtilities.GetVirtualMachineManagementServiceSettings(scope))
using (ManagementObject service = WmiUtilities.GetVirtualMachineManagementService(scope))
{
if (set)
{
using (ManagementBaseObject inParams = service.GetMethodParameters("ModifyServiceSettings"))
{
settings["EnhancedSessionModeEnabled"] = enable;
inParams["SettingData"] = settings.GetText(TextFormat.WmiDtd20);
using (ManagementBaseObject outParams =
service.InvokeMethod("ModifyServiceSettings",
inParams,
null))
{
WmiUtilities.ValidateOutput(outParams, scope, true, true);
}
}
Console.WriteLine("Successfully {0} enhanced session mode.", enable ? "enabled" : "disabled");
return;
}
bool enabled = (bool)settings["EnhancedSessionModeEnabled"];
if (enabled)
{
Console.WriteLine("Enhanced Session Mode is enabled");
}
else
{
Console.WriteLine("Enhanced Session Mode is disabled");
}
}
}
SetGeneration2BootProtocol(
string serverName,
string vmName,
UInt16 protocol)
{
ManagementScope scope = new ManagementScope(@"\\" + serverName + @"\root\virtualization\v2", null);
using (ManagementObject vm = WmiUtilities.GetVirtualMachine(vmName, scope))
using (ManagementObject vmSettings = WmiUtilities.GetVirtualMachineSettings(vm))
{
string virtualSystemSubType = (string)vmSettings["VirtualSystemSubType"];
if (!string.Equals(virtualSystemSubType, "Microsoft:Hyper-V:SubType:2", StringComparison.OrdinalIgnoreCase))
{
Console.WriteLine("VM {0} on server {1} is not generation 2", vmName, serverName);
return;
}
//
// Modify the virtual system to use the new protocol.
//
vmSettings["NetworkBootPreferredProtocol"] = protocol;
using (ManagementObject service = WmiUtilities.GetVirtualMachineManagementService(scope))
using (ManagementBaseObject inParams = service.GetMethodParameters("ModifySystemSettings"))
{
inParams["SystemSettings"] = vmSettings.GetText(TextFormat.WmiDtd20);
using (ManagementBaseObject outParams =
service.InvokeMethod("ModifySystemSettings",
inParams,
null))
{
WmiUtilities.ValidateOutput(outParams, scope, true, true);
}
Console.WriteLine("Successfully modified boot protocol");
return;
}
}
}
public static void NewVM(string serverName, string vmName)
{
ManagementPath classPath = new ManagementPath()
{
Server = serverName,
NamespacePath = @"\root\virtualization\v2",
ClassName = "Msvm_VirtualSystemSettingData"
};
using (ManagementClass virtualSystemSettingClass = new ManagementClass(classPath))
{
Credentials.conOpts.Username = Credentials.username;
Credentials.conOpts.SecurePassword = Credentials.password;
Credentials.conOpts.Authority = Credentials.domain;
Credentials.conOpts.Impersonation = ImpersonationLevel.Impersonate;
ManagementScope scope = new ManagementScope(@"\\" + serverName + @"\root\virtualization\v2", Credentials.conOpts);
virtualSystemSettingClass.Scope = scope;
using (ManagementObject virtualSystemSetting = virtualSystemSettingClass.CreateInstance())
{
virtualSystemSetting["ElementName"] = vmName;
virtualSystemSetting["VirtualsystemSubtype"] = "Microsoft:Hyper-V:Subtype:2";
string embeddedInstance = virtualSystemSetting.GetText(TextFormat.WmiDtd20);
using (ManagementObject service = Functions.getVMManagementService(scope))
using (ManagementBaseObject inParams = service.GetMethodParameters("DefineSystem"))
{
inParams["SystemSettings"] = embeddedInstance;
using (ManagementBaseObject outParams = service.InvokeMethod("DefineSystem", inParams, null))
{
Console.WriteLine("ret={0}", outParams["ReturnValue"]);
}
}
}
}
}
public static ManagementObject AddDevice(this ManagementObject VM, ManagementObject Device)
{
switch (VM["__CLASS"].ToString().ToUpperInvariant())
{
case "MSVM_COMPUTERSYSTEM":
ManagementObject ServiceObj = GetServiceObject(VM.GetScope(), ServiceNames.VSManagement);
ManagementBaseObject inputs = ServiceObj.GetMethodParameters("AddVirtualSystemResources");
inputs["TargetSystem"] = VM.Path.Path;
inputs["ResourceSettingData"] = new string[] { Device.GetText(TextFormat.WmiDtd20) };
var result = ServiceObj.InvokeMethod("AddVirtualSystemResources", inputs, null);
switch (Int32.Parse(result["ReturnValue"].ToString()))
{
case (int)ReturnCodes.OK:
var tmp = result["NewResources"];
return(GetObject(((string[])result["NewResources"]).First()));
case (int)ReturnCodes.JobStarted:
var job = GetObject(result["Job"].ToString());
var r = WaitForJob(job);
if (r == 0)
{
var res = result["NewResources"];
var arr = (string[])res;
var path = arr.First();
var o = GetObject(path);
return(GetObject(((string[])result["NewResources"]).First()));
}
var jobres = job.InvokeMethod("GetError", new ManagementObject(), null);
var errStr = jobres["Error"].ToString();
var errObj = GetObject(errStr);
return(null);
default:
return(null);
}
default:
return(null);
}
}
SetGeneration2SecureBoot(
string serverName,
string vmName,
bool val)
{
ManagementScope scope = new ManagementScope(@"\\" + serverName + @"\root\virtualization\v2", null);
using (ManagementObject vm = WmiUtilities.GetVirtualMachine(vmName, scope))
{
using (ManagementObject vmSettings = WmiUtilities.GetVirtualMachineSettings(vm))
{
string virtualSystemSubType = (string)vmSettings["VirtualSystemSubType"];
if (!string.Equals(virtualSystemSubType, "Microsoft:Hyper-V:SubType:2", StringComparison.OrdinalIgnoreCase))
{
Console.WriteLine("VM {0} on server {1} is not generation 2", vmName, serverName);
return;
}
vmSettings["SecureBootEnabled"] = val;
using (ManagementObject service = WmiUtilities.GetVirtualMachineManagementService(scope))
using (ManagementBaseObject inParams = service.GetMethodParameters("ModifySystemSettings"))
{
inParams["SystemSettings"] = vmSettings.GetText(TextFormat.WmiDtd20);
using (ManagementBaseObject outParams =
service.InvokeMethod("ModifySystemSettings",
inParams,
null))
{
WmiUtilities.ValidateOutput(outParams, scope, true, true);
}
Console.WriteLine("Successfully set secure boot property.");
return;
}
}
}
}
CreateGeneration2VM(
string serverName,
string vmName)
{
ManagementPath classPath = new ManagementPath()
{
Server = serverName,
NamespacePath = @"\root\virtualization\v2",
ClassName = "Msvm_VirtualSystemSettingData"
};
using (ManagementClass virtualSystemSettingClass = new ManagementClass(classPath))
{
ManagementScope scope = new ManagementScope(@"\\" + serverName + @"\root\virtualization\v2", null);
virtualSystemSettingClass.Scope = scope;
using (ManagementObject virtualSystemSetting = virtualSystemSettingClass.CreateInstance())
{
virtualSystemSetting["ElementName"] = vmName;
virtualSystemSetting["ConfigurationDataRoot"] = "C:\\ProgramData\\Microsoft\\Windows\\Hyper-V\\";
virtualSystemSetting["VirtualSystemSubtype"] = "Microsoft:Hyper-V:SubType:2";
string embeddedInstance = virtualSystemSetting.GetText(TextFormat.WmiDtd20);
// Get the management service, VM object and its settings.
using (ManagementObject service = WmiUtilities.GetVirtualMachineManagementService(scope))
using (ManagementBaseObject inParams = service.GetMethodParameters("DefineSystem"))
{
inParams["SystemSettings"] = embeddedInstance;
using (ManagementBaseObject outParams = service.InvokeMethod("DefineSystem", inParams, null))
{
Console.WriteLine("ret={0}", outParams["ReturnValue"]);
}
}
}
}
}
CreateExternalOnlySwitch(
string externalAdapterName,
string switchName,
string switchNotes)
{
ManagementScope scope = new ManagementScope(@"root\virtualization\v2");
string[] ports;
//
// Get the external adapter we are connecting to.
//
using (ManagementObject externalAdapter =
NetworkingUtilities.FindExternalAdapter(externalAdapterName, scope))
//
// Get the default Msvm_EthernetPortAllocationSettingData instance that we can use to
// configure our external port connection for the switch.
// Use the same switch name, appended with "_External", for the port name.
// You can use any port name that you like.
//
using (ManagementObject portToCreate =
NetworkingUtilities.GetDefaultEthernetPortAllocationSettingData(scope))
{
portToCreate["ElementName"] = switchName + "_External";
portToCreate["HostResource"] = new string[] { externalAdapter.Path.Path };
//
// Now create the switch with the external port.
//
ports = new string[] { portToCreate.GetText(TextFormat.WmiDtd20) };
}
CreateSwitch(switchName, switchNotes, ports, scope);
Console.WriteLine(string.Format(CultureInfo.CurrentCulture,
"The external-only switch '{0}' was created successfully.", switchName));
}
CreateInternalSwitch(
string switchName,
string switchNotes)
{
ManagementScope scope = new ManagementScope(@"root\virtualization\v2");
string[] ports;
//
// Get the hosting computer system. When connecting an internal port, we specify the
// path to the hosting computer system as what the port should connect to.
//
using (ManagementObject hostComputerSystem = WmiUtilities.GetHostComputerSystem(scope))
//
// Get the default Msvm_EthernetPortAllocationSettingData instance that we can use to
// configure our internal port connection for the switch.
// Use the same switch name, appended with "_Internal", for the port name.
// You can use any port name that you like.
//
using (ManagementObject portToCreate =
NetworkingUtilities.GetDefaultEthernetPortAllocationSettingData(scope))
{
portToCreate["ElementName"] = switchName + "_Internal";
portToCreate["HostResource"] = new string[] { hostComputerSystem.Path.Path };
//
// Now create the switch with the internal port.
//
ports = new string[] { portToCreate.GetText(TextFormat.WmiDtd20) };
}
CreateSwitch(switchName, switchNotes, ports, scope);
Console.WriteLine(string.Format(CultureInfo.CurrentCulture,
"The internal switch '{0}' was created successfully.", switchName));
}
EnableCompression(
string sourceHost
)
{
//
// Get the service & service setting values.
//
ManagementScope scope = new ManagementScope(
@"\\" + sourceHost + @"\root\virtualization\v2", null);
using (ManagementObject service = GetVirtualMachineMigrationService(scope))
using (ManagementObject serviceSettings = GetMigrationServiceSettings(service))
{
Console.WriteLine("Is compression enabled: {0}",
serviceSettings["EnableCompression"]);
//
// Set new setting values.
//
serviceSettings["EnableCompression"] = true;
// Perform service setting change.
using (ManagementBaseObject inParams = service.GetMethodParameters("ModifyServiceSettings"))
{
inParams["ServiceSettingData"] = serviceSettings.GetText(TextFormat.CimDtd20);
using (ManagementBaseObject outParams =
service.InvokeMethod("ModifyServiceSettings", inParams, null))
{
WmiUtilities.ValidateOutput(outParams, scope);
}
}
}
}
public static void newVhd(string serverName, string diskType, string diskFormat, string path, string parentPath, int maxInternalSize, int blockSize, int logicalSectorSize, int physicalSectorSize)
{
ManagementPath classPath = new ManagementPath()
{
Server = serverName,
NamespacePath = @"\root\virtualization\v2",
ClassName = "Msvm_VirtualHardDiskSettingData"
};
using (ManagementClass settingsClass = new ManagementClass(classPath))
{
Credentials.conOpts.Username = Credentials.username;
Credentials.conOpts.SecurePassword = Credentials.password;
Credentials.conOpts.Authority = Credentials.domain;
Credentials.conOpts.Impersonation = ImpersonationLevel.Impersonate;
ManagementScope scope = new ManagementScope(@"\\" + serverName + @"\root\virtualization\v2", Credentials.conOpts);
settingsClass.Scope = scope;
using (ManagementObject settingsInstance = settingsClass.CreateInstance())
{
settingsInstance["Type"] = diskType;
settingsInstance["Format"] = diskFormat;
settingsInstance["Path"] = path;
settingsInstance["ParentPath"] = parentPath;
settingsInstance["MaxInternalSize"] = maxInternalSize;
settingsInstance["BlockSize"] = blockSize;
settingsInstance["LogicalSectorSize"] = logicalSectorSize;
settingsInstance["PhysicalSectorSize"] = physicalSectorSize;
string settingsInstanceString = settingsInstance.GetText(TextFormat.WmiDtd20);
// return settingsInstanceString;
}
}
}
VmMigrationOverSmb(
string sourceHost,
string destinationHost,
string vmName
)
{
ManagementScope srcScope = new ManagementScope(
@"\\" + sourceHost + @"\root\virtualization\v2", null);
using (ManagementObject migrationSettingData = GetMigrationSettingData(srcScope))
{
migrationSettingData["MigrationType"] = MigrationType.VirtualSystem;
migrationSettingData["TransportType"] = TransportType.SMB;
// Perform migration.
Console.WriteLine("Performing migration...");
Migrate(srcScope,
vmName,
destinationHost,
migrationSettingData.GetText(TextFormat.CimDtd20),
null,
null);
}
}
AddPorts(
string switchName,
string externalAdapterName)
{
ManagementScope scope = new ManagementScope(@"root\virtualization\v2");
string ethernetSwitchSettingPath;
string portToCreateText;
ObjectQuery externalAdapterQuery = new ObjectQuery(string.Format(CultureInfo.InvariantCulture,
"select * from Msvm_ExternalEthernetPort where Name=\"{0}\"", externalAdapterName));
//
// When modifying the switch, we need to pass in its configuration object.
//
using (ManagementObject ethernetSwitch = NetworkingUtilities.FindEthernetSwitch(switchName, scope))
using (ManagementObject ethernetSwitchSetting = WmiUtilities.GetFirstObjectFromCollection(
ethernetSwitch.GetRelated("Msvm_VirtualEthernetSwitchSettingData",
"Msvm_SettingsDefineState",
null, null, null, null, false, null)))
{
ethernetSwitchSettingPath = ethernetSwitchSetting.Path.Path;
}
//
// Get the external adapter that we want to add a connection to.
//
using (ManagementObjectSearcher externalAdapterExecute =
new ManagementObjectSearcher(scope, externalAdapterQuery))
using (ManagementObjectCollection externalAdapterCollection = externalAdapterExecute.Get())
{
if (externalAdapterCollection.Count == 0)
{
throw new ManagementException(string.Format(CultureInfo.InvariantCulture,
"There is no external adapter with the name {0}.",
externalAdapterName));
}
using (ManagementObject externalAdapter =
WmiUtilities.GetFirstObjectFromCollection(externalAdapterCollection))
//
// Get the default Msvm_EthernetPortAllocationSettingData instance, which we can use to
// configure our external port connection for the switch.
// Use the same switch name, appended with "_External", for the port name.
// You can use any port name that you like.
//
using (ManagementObject portToCreate =
NetworkingUtilities.GetDefaultEthernetPortAllocationSettingData(scope))
{
portToCreate["ElementName"] = switchName + "_External";
portToCreate["HostResource"] = new string[] { externalAdapter.Path.Path };
portToCreateText = portToCreate.GetText(TextFormat.WmiDtd20);
}
}
//
// Now add the port connection to the switch.
//
using (ManagementObject switchService = NetworkingUtilities.GetEthernetSwitchManagementService(scope))
using (ManagementBaseObject inParams =
switchService.GetMethodParameters("AddResourceSettings"))
{
inParams["AffectedConfiguration"] = ethernetSwitchSettingPath;
inParams["ResourceSettings"] = new string[] { portToCreateText };
using (ManagementBaseObject outParams =
switchService.InvokeMethod("AddResourceSettings", inParams, null))
{
WmiUtilities.ValidateOutput(outParams, scope);
}
}
Console.WriteLine(string.Format(CultureInfo.CurrentCulture,
"We added an external port connection to '{0}' on the switch '{1}'.",
externalAdapterName, switchName));
}
