DeleteSwitch(
string switchName)
{
ManagementScope scope = new ManagementScope(@"root\virtualization\v2");
//
// Find the switch that we want to delete.
//
using (ManagementObject ethernetSwitch = NetworkingUtilities.FindEthernetSwitch(switchName, scope))
//
// Now that we have the switch object we can delete it.
//
using (ManagementObject switchService = NetworkingUtilities.GetEthernetSwitchManagementService(scope))
using (ManagementBaseObject inParams = switchService.GetMethodParameters("DestroySystem"))
{
inParams["AffectedSystem"] = ethernetSwitch.Path.Path;
using (ManagementBaseObject outParams = switchService.InvokeMethod("DestroySystem", inParams, null))
{
WmiUtilities.ValidateOutput(outParams, scope);
}
}
Console.WriteLine(string.Format(CultureInfo.CurrentCulture,
"The switch '{0}' was deleted successfully.", switchName));
}
ConnectVmToSwitch(
string virtualMachineName,
string switchName)
{
ManagementScope scope = new ManagementScope(@"root\virtualization\v2");
using (ManagementObject managementService = WmiUtilities.GetVirtualMachineManagementService(scope))
//
// Find the Ethernet switch we want to connect to.
//
using (ManagementObject ethernetSwitch = NetworkingUtilities.FindEthernetSwitch(switchName, scope))
//
// Find the virtual machine we want to connect.
//
using (ManagementObject virtualMachine = WmiUtilities.GetVirtualMachine(virtualMachineName, scope))
//
// Get the virtual machine's settings object which is used to make configuration changes.
//
using (ManagementObject virtualMachineSettings = WmiUtilities.GetVirtualMachineSettings(virtualMachine))
//
// Add a new synthetic Network Adapter device to the virtual machine.
//
using (ManagementObject syntheticAdapter = NetworkingUtilities.AddSyntheticAdapter(virtualMachine, scope))
//
// Now that we have added a network adapter to the virtual machine we can configure its
// connection settings.
//
using (ManagementObject connectionSettingsToAdd =
NetworkingUtilities.GetDefaultEthernetPortAllocationSettingData(scope))
{
connectionSettingsToAdd["Parent"] = syntheticAdapter.Path.Path;
connectionSettingsToAdd["HostResource"] = new string[] { ethernetSwitch.Path.Path };
//
// Now add the connection settings.
//
using (ManagementBaseObject addConnectionInParams =
managementService.GetMethodParameters("AddResourceSettings"))
{
addConnectionInParams["AffectedConfiguration"] = virtualMachineSettings.Path.Path;
addConnectionInParams["ResourceSettings"] =
new string[] { connectionSettingsToAdd.GetText(TextFormat.WmiDtd20) };
using (ManagementBaseObject addConnectionOutParams =
managementService.InvokeMethod("AddResourceSettings", addConnectionInParams, null))
{
WmiUtilities.ValidateOutput(addConnectionOutParams, scope);
}
}
}
Console.WriteLine(string.Format(CultureInfo.CurrentCulture,
"Successfully connected virtual machine '{0}' to switch '{1}'.",
virtualMachineName, switchName));
}
CreateExternalSwitch(
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 hosting computer system. The internal port we create needs to be configured
// to connect to the hosting computer system.
//
using (ManagementObject hostComputerSystem = WmiUtilities.GetHostComputerSystem(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 externalPortToCreate =
NetworkingUtilities.GetDefaultEthernetPortAllocationSettingData(scope))
{
externalPortToCreate["ElementName"] = switchName + "_External";
externalPortToCreate["HostResource"] = new string[] { externalAdapter.Path.Path };
//
// Clone the externalPort connection and configure it for the internal port.
// Use the same switch name, appended with "_Internal", for the port name.
// You can use any port name that you like.
//
using (ManagementObject internalPortToCreate =
(ManagementObject)externalPortToCreate.Clone())
{
internalPortToCreate["ElementName"] = switchName + "_Internal";
internalPortToCreate["HostResource"] = new string[] { hostComputerSystem.Path.Path };
//
// Now create the switch with the two ports.
//
ports = new string[] {
externalPortToCreate.GetText(TextFormat.WmiDtd20),
internalPortToCreate.GetText(TextFormat.WmiDtd20)
};
}
}
CreateSwitch(switchName, switchNotes, ports, scope);
Console.WriteLine(string.Format(CultureInfo.CurrentCulture,
"The external switch '{0}' was created successfully.", switchName));
}
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));
}
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));
}
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));
}
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);
}
}
}
RemoveFeatureSettings(
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 remove it.
//
using (ManagementObject bandwidthSetting = WmiUtilities.GetFirstObjectFromCollection(
ethernetSwitchSetting.GetRelated("Msvm_VirtualEthernetSwitchBandwidthSettingData",
"Msvm_VirtualEthernetSwitchSettingDataComponent",
null, null, null, null, false, null)))
{
using (ManagementBaseObject inParams =
managementService.GetMethodParameters("RemoveFeatureSettings"))
{
inParams["FeatureSettings"] = new string[] { bandwidthSetting.Path.Path };
using (ManagementBaseObject outParams =
managementService.InvokeMethod("RemoveFeatureSettings", inParams, null))
{
WmiUtilities.ValidateOutput(outParams, scope);
}
}
}
Console.WriteLine(string.Format(CultureInfo.CurrentCulture,
"Successfully removed bandwidth feature setting from virtual switch '{0}'.",
switchName));
}
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));
}
AddFeatureSettings(
string virtualMachineName,
NetworkingUtilities.PortFeatureType featureType)
{
ManagementScope scope = new ManagementScope(@"root\virtualization\v2");
int connectionsCount = 0;
string featureId = NetworkingUtilities.GetPortFeatureId(featureType);
using (ManagementObject managementService = WmiUtilities.GetVirtualMachineManagementService(scope))
//
// Find the virtual machine whose connections we want to modify.
//
using (ManagementObject virtualMachine = WmiUtilities.GetVirtualMachine(virtualMachineName, scope))
//
// Find all connections for the given virtual machine.
//
using (ManagementObjectCollection connections = NetworkingUtilities.FindConnections(
virtualMachine, scope))
//
// Find the default feature setting for the specified feature type (e.g. Security or ACL).
//
using (ManagementObject defaultFeatureSetting =
NetworkingUtilities.GetDefaultFeatureSetting(featureId, scope))
{
//
// Set the default feature setting's properties, which will differ depending on which type
// of feature setting it is.
//
switch (featureType)
{
case NetworkingUtilities.PortFeatureType.Security:
//
// For example, using a security feature setting, we can disallow MAC spoofing.
//
defaultFeatureSetting["AllowMacSpoofing"] = false;
break;
case NetworkingUtilities.PortFeatureType.Acl:
//
// For example, using an ACL feature setting, we can meter an IP range.
//
//
// Action may be 1 - Allow, 2 - Deny, or 3 - Meter. Here we set up a metering ACL.
//
defaultFeatureSetting["Action"] = 3;
//
// Direction may be 1 - Incoming or 2 - Outgoing. Here we set up an ACL on Outgoing traffic.
//
defaultFeatureSetting["Direction"] = 2;
//
// Applicability may be 1 - Local or 2 - Remote. Here we set up an ACL on the local endpoint.
//
defaultFeatureSetting["Applicability"] = 1;
//
// AclType may be 1 - MAC, 2 - IPv4, or 3 - IPv6. Here we set up an IPv4 ACL.
//
defaultFeatureSetting["AclType"] = 2;
defaultFeatureSetting["RemoteAddress"] = "*.*";
defaultFeatureSetting["RemoteAddressPrefixLength"] = 32;
break;
case NetworkingUtilities.PortFeatureType.Offload:
//
// For example, using an Offload feature setting, we can enable IOV.
//
defaultFeatureSetting["IOVOffloadWeight"] = 100;
break;
default:
//
// Invalid featureType Argument
//
throw new ArgumentOutOfRangeException(featureType.ToString());
}
string defaultFeatureSettingText = defaultFeatureSetting.GetText(TextFormat.WmiDtd20);
connectionsCount = connections.Count;
//
// Now add the feature setting to each connection.
//
try
{
foreach (ManagementObject ethernetConnectionSetting in connections)
{
using (ManagementBaseObject inParams =
managementService.GetMethodParameters("AddFeatureSettings"))
{
inParams["AffectedConfiguration"] = ethernetConnectionSetting.Path.Path;
inParams["FeatureSettings"] = new string[] { defaultFeatureSettingText };
using (ManagementBaseObject outParams =
managementService.InvokeMethod("AddFeatureSettings", inParams, null))
{
WmiUtilities.ValidateOutput(outParams, scope);
}
}
}
}
finally
{
// Dispose of the connections.
foreach (ManagementObject ethernetConnectionSetting in connections)
{
ethernetConnectionSetting.Dispose();
}
}
}
Console.WriteLine(string.Format(CultureInfo.CurrentCulture,
"Successfully modified virtual machine '{0}' so that each of its {1} connection(s) " +
"has an advanced {2} setting added.",
virtualMachineName, connectionsCount, featureType.ToString()));
}
SupportsTrunkMode(
string externalAdapterName)
{
ManagementScope scope = new ManagementScope(@"root\virtualization\v2");
bool supportsTrunkMode = false;
//
// Get the external adapter.
//
using (ManagementObject externalAdapter =
NetworkingUtilities.FindExternalAdapter(externalAdapterName, scope))
//
// From the external adapter we need to follow the associations to get to the
// Msvm_VLANEndpoint object that has the property we can query to see if the
// adapter supports trunk mode. Note however, that these associated objects only
// exist if the adapter is connected to a switch. Until the adapter is connected to
// a switch there is not a way through the Hyper-V WMI API to determine whether it
// supports trunk mode.
//
using (ManagementObjectCollection lanEndpointCollection = externalAdapter.GetRelated("Msvm_LanEndpoint"))
{
if (lanEndpointCollection.Count == 0)
{
throw new ManagementException("This external adapter is not connected to any switch. " +
"Cannot determine trunk mode support.");
}
using (ManagementObject lanEndpoint = WmiUtilities.GetFirstObjectFromCollection(
lanEndpointCollection))
using (ManagementObject otherLanEndpoint = WmiUtilities.GetFirstObjectFromCollection(
lanEndpoint.GetRelated("Msvm_LanEndpoint")))
using (ManagementObject vlanEndpoint = WmiUtilities.GetFirstObjectFromCollection(
otherLanEndpoint.GetRelated("Msvm_VLANEndpoint")))
{
//
// Now that we have the VLAN Endpoint, we can check its SupportedEndpointModes
// property.
//
ushort[] supportedEndpointModes = (ushort[])vlanEndpoint["SupportedEndpointModes"];
foreach (ushort supportedMode in supportedEndpointModes)
{
if (supportedMode == 5) // 5 means "TrunkMode"
{
supportsTrunkMode = true;
break;
}
}
}
}
if (supportsTrunkMode)
{
Console.WriteLine("Successfully determined that the external adapter '{0}' does support trunk mode.",
externalAdapterName);
}
else
{
Console.WriteLine("Successfully determined that the external adapter '{0}' does NOT support trunk mode.",
externalAdapterName);
}
}
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));
}
RemovePorts(
string switchName)
{
ManagementScope scope = new ManagementScope(@"root\virtualization\v2");
List <string> portsToDelete = new List <string>();
//
// Find the switch that we want to modify.
//
using (ManagementObject ethernetSwitch = NetworkingUtilities.FindEthernetSwitch(switchName, scope))
//
// Find its internal and/or external ports to delete, but don't delete any ports that
// are connected to virtual machines.
// Internal ports can be recognized because their HostResource property is set to the
// host computer.
// Likewise, external ports can be recognized through their HostResource property,
// which is always set to the Msvm_ExternalEthernetPort it is connected to.
//
using (ManagementObjectCollection ports = ethernetSwitch.GetRelated("Msvm_EthernetSwitchPort",
"Msvm_SystemDevice",
null, null, null, null, false, null))
{
foreach (ManagementObject port in ports)
{
using (port)
{
//
// The port's connection settings are stored on its related
// Msvm_EthernetPortAllocationSettingData object.
//
using (ManagementObject portSettings = WmiUtilities.GetFirstObjectFromCollection(
port.GetRelated("Msvm_EthernetPortAllocationSettingData",
"Msvm_ElementSettingData",
null, null, null, null, false, null)))
{
string[] hostResource = (string[])portSettings["HostResource"];
if (hostResource != null && hostResource.Length > 0)
{
ManagementPath hostResourcePath = new ManagementPath(hostResource[0]);
if (string.Equals(hostResourcePath.ClassName, "Msvm_ComputerSystem",
StringComparison.OrdinalIgnoreCase))
{
// This is the internal port. Add it to the list to delete.
portsToDelete.Add(portSettings.Path.Path);
}
else if (string.Equals(hostResourcePath.ClassName, "Msvm_ExternalEthernetPort",
StringComparison.OrdinalIgnoreCase))
{
// This is the external port. Add it to the list to delete.
portsToDelete.Add(portSettings.Path.Path);
}
}
}
}
}
}
if (portsToDelete.Count == 0)
{
throw new ManagementException(string.Format(CultureInfo.InvariantCulture,
"The switch '{0}' does not have any internal or external ports to remove.",
switchName));
}
//
// Now that we have the ports we want to delete we can call the RemoveResourceSettings
// method.
//
using (ManagementObject switchService = NetworkingUtilities.GetEthernetSwitchManagementService(scope))
using (ManagementBaseObject inParams = switchService.GetMethodParameters("RemoveResourceSettings"))
{
inParams["ResourceSettings"] = portsToDelete.ToArray();
using (ManagementBaseObject outParams = switchService.InvokeMethod("RemoveResourceSettings", inParams, null))
{
WmiUtilities.ValidateOutput(outParams, scope);
}
}
Console.WriteLine(string.Format(CultureInfo.CurrentCulture,
"We removed the internal and external ports from switch '{0}' successfully.", switchName));
}
RemoveFeatureSettings(
string virtualMachineName,
NetworkingUtilities.PortFeatureType featureType)
{
ManagementScope scope = new ManagementScope(@"root\virtualization\v2");
int connectionsCount = 0;
using (ManagementObject managementService = WmiUtilities.GetVirtualMachineManagementService(scope))
//
// Find the virtual machine whose connections we want to modify.
//
using (ManagementObject virtualMachine = WmiUtilities.GetVirtualMachine(virtualMachineName, scope))
//
// Find all connections for the given virtual machine.
//
using (ManagementObjectCollection connections = NetworkingUtilities.FindConnections(
virtualMachine, scope))
{
string featureSettingClass;
switch (featureType)
{
case NetworkingUtilities.PortFeatureType.Security:
featureSettingClass = "Msvm_EthernetSwitchPortSecuritySettingData";
break;
case NetworkingUtilities.PortFeatureType.Offload:
featureSettingClass = "Msvm_EthernetSwitchPortOffloadSettingData";
break;
case NetworkingUtilities.PortFeatureType.Acl:
featureSettingClass = "Msvm_EthernetSwitchPortAclSettingData";
break;
default:
throw new ArgumentOutOfRangeException(featureType.ToString());
}
connectionsCount = connections.Count;
//
// Now find the feature setting data object associated with each connection, if any.
//
try
{
foreach (ManagementObject ethernetConnectionSetting in connections)
{
List<string> featureSettingPaths = new List<string>();
using (ManagementObjectCollection featureSettingCollection =
ethernetConnectionSetting.GetRelated(featureSettingClass,
"Msvm_EthernetPortSettingDataComponent",
null, null, null, null, false, null))
{
if (featureSettingCollection.Count == 0)
{
continue;
}
foreach (ManagementObject featureSetting in featureSettingCollection)
using (featureSetting)
{
featureSettingPaths.Add(featureSetting.Path.Path);
}
}
using (ManagementBaseObject inParams =
managementService.GetMethodParameters("RemoveFeatureSettings"))
{
//
// We specify which feature setting to remove by giving the WMI path to the feature setting object.
//
inParams["FeatureSettings"] = featureSettingPaths.ToArray();
using (ManagementBaseObject outParams =
managementService.InvokeMethod("RemoveFeatureSettings", inParams, null))
{
WmiUtilities.ValidateOutput(outParams, scope);
}
}
}
}
finally
{
// Dispose of the connections.
foreach (ManagementObject ethernetConnectionSetting in connections)
{
ethernetConnectionSetting.Dispose();
}
}
}
Console.WriteLine(string.Format(CultureInfo.CurrentCulture,
"Successfully modified virtual machine '{0}' to remove advanced {2} settings from " +
"each of its {1} connection(s).",
virtualMachineName, connectionsCount, featureType.ToString()));
}
AddFeatureSettings(
string virtualMachineName,
NetworkingUtilities.PortFeatureType featureType)
{
ManagementScope scope = new ManagementScope(@"root\virtualization\v2");
int connectionsCount = 0;
string featureId = NetworkingUtilities.GetPortFeatureId(featureType);
using (ManagementObject managementService = WmiUtilities.GetVirtualMachineManagementService(scope))
//
// Find the virtual machine whose connections we want to modify.
//
using (ManagementObject virtualMachine = WmiUtilities.GetVirtualMachine(virtualMachineName, scope))
//
// Find all connections for the given virtual machine.
//
using (ManagementObjectCollection connections = NetworkingUtilities.FindConnections(
virtualMachine, scope))
//
// Find the default feature setting for the specified feature type (e.g. Security or ACL).
//
using (ManagementObject defaultFeatureSetting =
NetworkingUtilities.GetDefaultFeatureSetting(featureId, scope))
{
//
// Set the default feature setting's properties, which will differ depending on which type
// of feature setting it is.
//
switch (featureType)
{
case NetworkingUtilities.PortFeatureType.Security:
//
// For example, using a security feature setting, we can disallow MAC spoofing.
//
defaultFeatureSetting["AllowMacSpoofing"] = false;
break;
case NetworkingUtilities.PortFeatureType.Acl:
//
// For example, using an ACL feature setting, we can meter an IP range.
//
//
// Action may be 1 - Allow, 2 - Deny, or 3 - Meter. Here we set up a metering ACL.
//
defaultFeatureSetting["Action"] = 3;
//
// Direction may be 1 - Incoming or 2 - Outgoing. Here we set up an ACL on Outgoing traffic.
//
defaultFeatureSetting["Direction"] = 2;
//
// Applicability may be 1 - Local or 2 - Remote. Here we set up an ACL on the local endpoint.
//
defaultFeatureSetting["Applicability"] = 1;
//
// AclType may be 1 - MAC, 2 - IPv4, or 3 - IPv6. Here we set up an IPv4 ACL.
//
defaultFeatureSetting["AclType"] = 2;
defaultFeatureSetting["RemoteAddress"] = "*.*";
defaultFeatureSetting["RemoteAddressPrefixLength"] = 32;
break;
case NetworkingUtilities.PortFeatureType.Offload:
//
// For example, using an Offload feature setting, we can enable IOV.
//
defaultFeatureSetting["IOVOffloadWeight"] = 100;
break;
default:
//
// Invalid featureType Argument
//
throw new ArgumentOutOfRangeException(featureType.ToString());
}
string defaultFeatureSettingText = defaultFeatureSetting.GetText(TextFormat.WmiDtd20);
connectionsCount = connections.Count;
//
// Now add the feature setting to each connection.
//
try
{
foreach (ManagementObject ethernetConnectionSetting in connections)
{
using (ManagementBaseObject inParams =
managementService.GetMethodParameters("AddFeatureSettings"))
{
inParams["AffectedConfiguration"] = ethernetConnectionSetting.Path.Path;
inParams["FeatureSettings"] = new string[] { defaultFeatureSettingText };
using (ManagementBaseObject outParams =
managementService.InvokeMethod("AddFeatureSettings", inParams, null))
{
WmiUtilities.ValidateOutput(outParams, scope);
}
}
}
}
finally
{
// Dispose of the connections.
foreach (ManagementObject ethernetConnectionSetting in connections)
{
ethernetConnectionSetting.Dispose();
}
}
}
Console.WriteLine(string.Format(CultureInfo.CurrentCulture,
"Successfully modified virtual machine '{0}' so that each of its {1} connection(s) " +
"has an advanced {2} setting added.",
virtualMachineName, connectionsCount, featureType.ToString()));
}
ModifyFeatureSettings(
string virtualMachineName,
NetworkingUtilities.PortFeatureType featureType)
{
ManagementScope scope = new ManagementScope(@"root\virtualization\v2");
int connectionsCount = 0;
using (ManagementObject managementService = WmiUtilities.GetVirtualMachineManagementService(scope))
//
// Find the virtual machine we want to modify the connections of.
//
using (ManagementObject virtualMachine = WmiUtilities.GetVirtualMachine(virtualMachineName, scope))
//
// Find all connections for the given virtual machine.
//
using (ManagementObjectCollection connections = NetworkingUtilities.FindConnections(
virtualMachine, scope))
{
connectionsCount = connections.Count;
//
// Now find the security feature setting data object associated with each connection, if any.
//
try
{
string featureClassName;
switch (featureType)
{
case NetworkingUtilities.PortFeatureType.Security:
featureClassName = "Msvm_EthernetSwitchPortSecuritySettingData";
break;
case NetworkingUtilities.PortFeatureType.Offload:
featureClassName = "Msvm_EthernetSwitchPortOffloadSettingData";
break;
default:
throw new ArgumentOutOfRangeException(featureType.ToString());
}
foreach (ManagementObject ethernetConnectionSetting in connections)
{
using (ManagementObjectCollection featureSettingCollection =
ethernetConnectionSetting.GetRelated(featureClassName,
"Msvm_EthernetPortSettingDataComponent",
null, null, null, null, false, null))
{
//
// For the security/offload feature, each connection can have no more than one instance
// of the feature setting, so we can simply take the first feature setting associated
// with each connection. For other features, it may be necessary to do extra work.
//
if (featureSettingCollection.Count == 0)
{
continue;
}
string featureText;
using (ManagementObject featureSetting =
WmiUtilities.GetFirstObjectFromCollection(featureSettingCollection))
{
switch (featureType)
{
case NetworkingUtilities.PortFeatureType.Security:
//
// Modify the feature setting's properties. Here, we enable MAC spoofing.
//
featureSetting["AllowMacSpoofing"] = true;
break;
case NetworkingUtilities.PortFeatureType.Offload:
//
// Modify the feature setting's properties. Here, we modify IOVQueuePairsRequested.
//
featureSetting["IOVQueuePairsRequested"] = 2;
break;
}
featureText = featureSetting.GetText(TextFormat.WmiDtd20);
}
// Now apply the changes to the Hyper-V server.
using (ManagementBaseObject inParams =
managementService.GetMethodParameters("ModifyFeatureSettings"))
{
inParams["FeatureSettings"] = new string[] { featureText };
using (ManagementBaseObject outParams =
managementService.InvokeMethod("ModifyFeatureSettings", inParams, null))
{
WmiUtilities.ValidateOutput(outParams, scope);
}
}
}
}
}
finally
{
// Dispose of the connections.
foreach (ManagementObject ethernetConnectionSetting in connections)
{
ethernetConnectionSetting.Dispose();
}
}
}
Console.WriteLine(string.Format(CultureInfo.CurrentCulture,
"Successfully modified virtual machine '{0}' so that each of its {1} connection(s) " +
"has its advanced {2} settings modified.",
virtualMachineName, connectionsCount, featureType.ToString()));
}
ModifyPorts(
string switchName,
string newExternalAdapterName)
{
ManagementScope scope = new ManagementScope(@"root\virtualization\v2");
ObjectQuery externalAdapterQuery = new ObjectQuery(string.Format(CultureInfo.InvariantCulture,
"select * from Msvm_ExternalEthernetPort where Name=\"{0}\"", newExternalAdapterName));
//
// Find the switch that we want to modify.
//
using (ManagementObject ethernetSwitch = NetworkingUtilities.FindEthernetSwitch(switchName, scope))
//
// Get the external adapter we are connecting to.
//
using (ManagementObjectSearcher externalAdapterExecute = new ManagementObjectSearcher(scope, externalAdapterQuery))
using (ManagementObjectCollection externalAdapterCollection = externalAdapterExecute.Get())
{
if (externalAdapterCollection.Count == 0)
{
throw new ManagementException("There is no external adapter with the name: " + newExternalAdapterName);
}
string externalAdapterPath;
string externalPortSettingsText = null;
using (ManagementObject externalAdapter = WmiUtilities.GetFirstObjectFromCollection(externalAdapterCollection))
{
externalAdapterPath = externalAdapter.Path.Path;
}
//
// Find the switch's current external port.
//
using (ManagementObjectCollection ports = ethernetSwitch.GetRelated("Msvm_EthernetSwitchPort",
"Msvm_SystemDevice",
null, null, null, null, false, null))
foreach (ManagementObject port in ports)
{
using (port)
{
//
// The port's connection settings are stored on its related
// Msvm_EthernetPortAllocationSettingData object.
// The external port is the one connected to a Msvm_ExternalEthernetPort
// through its HostResource property.
//
using (ManagementObject portSettings = WmiUtilities.GetFirstObjectFromCollection(
port.GetRelated("Msvm_EthernetPortAllocationSettingData",
"Msvm_ElementSettingData",
null, null, null, null, false, null)))
{
string[] hostResource = (string[])portSettings["HostResource"];
if (hostResource != null && hostResource.Length > 0)
{
ManagementPath hostResourcePath = new ManagementPath(hostResource[0]);
if (string.Equals(hostResourcePath.ClassName, "Msvm_ExternalEthernetPort",
StringComparison.OrdinalIgnoreCase))
{
//
// Validate that it isn't already connected to the external adapter we
// are trying to change it to.
//
if (string.Equals(hostResourcePath.Path, externalAdapterPath,
StringComparison.OrdinalIgnoreCase))
{
throw new ManagementException(string.Format(CultureInfo.CurrentCulture,
"The switch '{0}' is already connected to '{1}'.",
switchName, newExternalAdapterName));
}
//
// Now that we have the switch's external port, we can modify it so that it
// is connected to newExternalAdapterName.
//
portSettings["HostResource"] = new string[] { externalAdapterPath };
externalPortSettingsText = portSettings.GetText(TextFormat.WmiDtd20);
break;
}
}
}
}
}
if (externalPortSettingsText == null)
{
throw new ManagementException(string.Format(CultureInfo.CurrentCulture,
"The switch '{0}' is not connected to an external network.", switchName));
}
using (ManagementObject switchService = NetworkingUtilities.GetEthernetSwitchManagementService(scope))
using (ManagementBaseObject inParams = switchService.GetMethodParameters("ModifyResourceSettings"))
{
inParams["ResourceSettings"] = new string[] { externalPortSettingsText };
using (ManagementBaseObject outParams =
switchService.InvokeMethod("ModifyResourceSettings", inParams, null))
{
WmiUtilities.ValidateOutput(outParams, scope);
}
}
}
Console.WriteLine(string.Format(CultureInfo.CurrentCulture,
"Successfully bound the switch '{0}' to the external network '{1}'.",
switchName, newExternalAdapterName));
}
ModifyConnection(
string virtualMachineName,
string currentSwitchName,
string newSwitchName)
{
ManagementScope scope = new ManagementScope(@"root\virtualization\v2");
using (ManagementObject managementService = WmiUtilities.GetVirtualMachineManagementService(scope))
//
// Find the Ethernet switch we want to disconnect from and the one we want to connect to.
//
using (ManagementObject currentEthernetSwitch = NetworkingUtilities.FindEthernetSwitch(currentSwitchName, scope))
using (ManagementObject newEthernetSwitch = NetworkingUtilities.FindEthernetSwitch(newSwitchName, scope))
//
// Find the virtual machine we want to modify.
//
using (ManagementObject virtualMachine = WmiUtilities.GetVirtualMachine(virtualMachineName, scope))
{
//
// Find the connections to the current switch.
// Note that this method finds all connections to the switch, including those connections
// that are configured to dynamically select a switch from a switch resource pool and
// reconfigures them to always connect to the new switch. If you only want to modify
// connections that are configured with a hard-affinity to the original switch, modify the
// NetworkingUtilities.FindConnectionsToSwitch method.
//
IList <ManagementObject> currentConnections =
NetworkingUtilities.FindConnectionsToSwitch(virtualMachine, currentEthernetSwitch, scope);
//
// Set each connection to connect to the new switch. If the virtual machine is currently
// running, then it will immediately connect to the new switch. If it is not running, then
// it will connect to the switch when it is turned on.
//
try
{
foreach (ManagementObject connection in currentConnections)
{
connection["HostResource"] = new string[] { newEthernetSwitch.Path.Path };
using (ManagementBaseObject inParams =
managementService.GetMethodParameters("ModifyResourceSettings"))
{
inParams["ResourceSettings"] = new string[] { connection.GetText(TextFormat.WmiDtd20) };
using (ManagementBaseObject outParams =
managementService.InvokeMethod("ModifyResourceSettings", inParams, null))
{
WmiUtilities.ValidateOutput(outParams, scope);
}
}
}
}
finally
{
// Dispose of the connections.
foreach (ManagementObject connection in currentConnections)
{
connection.Dispose();
}
}
}
Console.WriteLine(string.Format(CultureInfo.CurrentCulture,
"Successfully modified virtual machine '{0}' so that every connection to '{1}' is now " +
"connected to '{2}'.", virtualMachineName, currentSwitchName, newSwitchName));
}
EnumerateSwitch(
string switchName)
{
ManagementScope scope = new ManagementScope(@"root\virtualization\v2");
//
// Initialize our SwitchInfo structure to hold information about the switch.
//
SwitchInfo ethernetSwitchInfo = new SwitchInfo();
ethernetSwitchInfo.Name = switchName;
ethernetSwitchInfo.Type = SwitchConnectionType.Private;
ethernetSwitchInfo.PortList = new List <PortInfo>();
ethernetSwitchInfo.SwitchFeatureList = new List <NetworkingUtilities.SwitchFeatureType>();
using (ManagementObject ethernetSwitch = NetworkingUtilities.FindEthernetSwitch(switchName, scope))
{
//
// Enumerate the switch's ports.
//
using (ManagementObjectCollection portCollection = ethernetSwitch.GetRelated("Msvm_EthernetSwitchPort",
"Msvm_SystemDevice",
null, null, null, null, false, null))
{
foreach (ManagementObject port in portCollection)
{
using (port)
{
//
// Initialize a PortInfo structure to hold information about this port.
//
PortInfo portInfo = new PortInfo();
portInfo.Type = PortConnectionType.Nothing;
portInfo.FeatureList = new List <NetworkingUtilities.PortFeatureType>();
//
// The port's connection settings are stored on its related
// Msvm_EthernetPortAllocationSettingData object.
//
using (ManagementObject portSettings = WmiUtilities.GetFirstObjectFromCollection(
port.GetRelated("Msvm_EthernetPortAllocationSettingData",
"Msvm_ElementSettingData",
null, null, null, null, false, null)))
{
//
// Determine the port's connection type.
//
portInfo.Type = DeterminePortType(portSettings);
if (portInfo.Type == PortConnectionType.VirtualMachine)
{
// Get the name of the connected virtual machine.
using (ManagementObject virtualMachineSettings = WmiUtilities.GetFirstObjectFromCollection(
portSettings.GetRelated("Msvm_VirtualSystemSettingData",
"Msvm_VirtualSystemSettingDataComponent",
null, null, null, null, false, null)))
{
portInfo.ConnectedName = (string)virtualMachineSettings["ElementName"];
}
}
else if (portInfo.Type == PortConnectionType.External)
{
// Get the name of the external connection.
using (ManagementObject externalAdapter = new ManagementObject(
((string[])portSettings["HostResource"])[0]))
{
portInfo.ConnectedName = (string)externalAdapter["ElementName"];
}
}
//
// Now determine which advanced properties are configured for this port.
// Each Feature has its own class definition and is related to the portSettings
// through the Msvm_EthernetPortSettingDataComponent association.
//
using (ManagementObjectCollection portFeatureCollection =
portSettings.GetRelated("Msvm_EthernetSwitchPortFeatureSettingData",
"Msvm_EthernetPortSettingDataComponent",
null, null, null, null, false, null))
{
foreach (ManagementObject portFeature in portFeatureCollection)
{
using (portFeature)
{
portInfo.FeatureList.Add(DeterminePortFeatureType(portFeature));
}
}
}
}
ethernetSwitchInfo.PortList.Add(portInfo);
}
}
}
//
// Then enumerate the switch's features.
//
using (ManagementObject ethernetSwitchSetting = WmiUtilities.GetFirstObjectFromCollection(
ethernetSwitch.GetRelated("Msvm_VirtualEthernetSwitchSettingData",
"Msvm_SettingsDefineState",
null, null, null, null, false, null)))
using (ManagementObjectCollection switchFeatures = ethernetSwitchSetting.GetRelated(
"Msvm_EthernetSwitchFeatureSettingData",
"Msvm_VirtualEthernetSwitchSettingDataComponent",
null, null, null, null, false, null))
foreach (ManagementObject switchFeature in switchFeatures)
{
using (switchFeature)
{
ethernetSwitchInfo.SwitchFeatureList.Add(DetermineSwitchFeatureType(switchFeature));
}
}
}
//
// Now that we have enumerated all of the switch's ports, we can determine the
// switch's connection type.
//
ethernetSwitchInfo.Type = DetermineSwitchConnectionType(ethernetSwitchInfo.PortList);
//
// We now have all of the information we need - output it to the console.
//
OutputSwitchInfo(ethernetSwitchInfo);
}
SetRequiredFeature(
string vmName,
string featureName,
bool required)
{
ManagementScope scope = new ManagementScope(@"root\virtualization\v2");
List <string> connectionsToModify = new List <string>();
//
// Find the feature capability object.
//
using (ManagementObject feature = NetworkingUtilities.FindFeatureByName(featureName, scope))
//
// Find all the Ethernet connections associated with the virtual machine.
//
using (ManagementObject virtualMachine = WmiUtilities.GetVirtualMachine(vmName, scope))
using (ManagementObjectCollection connectionCollection = NetworkingUtilities.FindConnections(virtualMachine, scope))
{
foreach (ManagementObject connection in connectionCollection)
{
using (connection)
{
//
// Look at the current list of required features, and find out whether the
// specified feature is already present in the list. Each element of the
// list is the WMI path to a feature capability object.
//
string[] requiredFeatures = (string[])connection["RequiredFeatures"];
int featureIndex = -1;
for (int idx = 0; idx < requiredFeatures.Length; ++idx)
{
using (ManagementObject requiredFeature = new ManagementObject(requiredFeatures[idx]))
{
requiredFeature.Get();
if (String.Equals(
(string)requiredFeature["ElementName"],
featureName,
StringComparison.OrdinalIgnoreCase))
{
featureIndex = idx;
break;
}
}
}
if (((featureIndex == -1) && !required) ||
((featureIndex != -1) && required))
{
//
// The feature is not required and not present in the list,
// or required and already present in the list. In either case
// there's nothing left to do for this connection.
//
continue;
}
string[] newRequiredFeatures = null;
if (required)
{
//
// Append the new feature at the end of list.
//
newRequiredFeatures = new string[requiredFeatures.Length + 1];
for (int idx = 0; idx < requiredFeatures.Length; ++idx)
{
newRequiredFeatures[idx] = requiredFeatures[idx];
}
newRequiredFeatures[newRequiredFeatures.Length - 1] = feature.Path.Path;
}
else
{
//
// Remove the feature from the list.
//
newRequiredFeatures = new string[requiredFeatures.Length - 1];
for (int idx = 0; idx < featureIndex; ++idx)
{
newRequiredFeatures[idx] = requiredFeatures[idx];
}
for (int idx = featureIndex; idx < newRequiredFeatures.Length; ++idx)
{
newRequiredFeatures[idx] = requiredFeatures[idx + 1];
}
}
connection["RequiredFeatures"] = newRequiredFeatures;
connectionsToModify.Add(connection.GetText(TextFormat.WmiDtd20));
}
}
}
if (connectionsToModify.Count > 0)
{
using (ManagementObject managementService = WmiUtilities.GetVirtualMachineManagementService(scope))
using (ManagementBaseObject inParams = managementService.GetMethodParameters("ModifyResourceSettings"))
{
inParams["ResourceSettings"] = connectionsToModify.ToArray();
using (ManagementBaseObject outParams =
managementService.InvokeMethod("ModifyResourceSettings", inParams, null))
{
WmiUtilities.ValidateOutput(outParams, scope);
}
}
}
Console.WriteLine(string.Format(CultureInfo.CurrentCulture,
"Feature '{0}' is {1} the list of required features for virtual machine '{2}'.",
featureName,
required ? "added to" : "removed from",
vmName));
}
SetExtensionEnabledState(
string switchName,
string extensionName,
bool enabled)
{
bool found = false;
ManagementScope scope = new ManagementScope(@"root\virtualization\v2");
//
// Get the switch we want to modify.
//
using (ManagementObject ethernetSwitch = NetworkingUtilities.FindEthernetSwitch(switchName, scope))
//
// To make modifications to the switch, we need to modify its configuration object.
//
using (ManagementObjectCollection extensions = ethernetSwitch.GetRelated(
"Msvm_EthernetSwitchExtension",
"Msvm_HostedEthernetSwitchExtension",
null,
null,
null,
null,
false,
null))
{
foreach (ManagementObject extension in extensions)
{
using (extension)
{
if (!String.Equals(
(string)extension["ElementName"],
extensionName,
StringComparison.OrdinalIgnoreCase))
{
continue;
}
found = true;
if ((UInt16)extension["EnabledState"] == CimEnabledStateNotApplicable)
{
Console.WriteLine("The enabled state of the specified extension cannot be changed.");
continue;
}
if (((UInt16)extension["EnabledState"] == CimEnabledStateEnabled) && enabled)
{
Console.WriteLine("The specified extension is already enabled.");
continue;
}
if (((UInt16)extension["EnabledState"] == CimEnabledStateDisabled) && !enabled)
{
Console.WriteLine("The specified extension is already disabled.");
continue;
}
using (ManagementBaseObject inParams = extension.GetMethodParameters("RequestStateChange"))
{
inParams["RequestedState"] = enabled ? CimEnabledStateEnabled : CimEnabledStateDisabled;
using (ManagementBaseObject outParams =
extension.InvokeMethod("RequestStateChange", inParams, null))
{
WmiUtilities.ValidateOutput(outParams, scope);
Console.WriteLine(string.Format(
CultureInfo.CurrentCulture,
"Extension '{0}' was successfully {1} on switch '{2}'.",
extensionName,
enabled ? "enabled" : "disabled",
switchName));
}
}
}
}
}
if (!found)
{
throw new ApplicationException(String.Format(
CultureInfo.CurrentCulture,
"Could not find extension '{0}' on switch '{1}'.",
extensionName,
switchName));
}
}
ModifyFeatureSettings(
string virtualMachineName,
NetworkingUtilities.PortFeatureType featureType)
{
ManagementScope scope = new ManagementScope(@"root\virtualization\v2");
int connectionsCount = 0;
using (ManagementObject managementService = WmiUtilities.GetVirtualMachineManagementService(scope))
//
// Find the virtual machine we want to modify the connections of.
//
using (ManagementObject virtualMachine = WmiUtilities.GetVirtualMachine(virtualMachineName, scope))
//
// Find all connections for the given virtual machine.
//
using (ManagementObjectCollection connections = NetworkingUtilities.FindConnections(
virtualMachine, scope))
{
connectionsCount = connections.Count;
//
// Now find the security feature setting data object associated with each connection, if any.
//
try
{
string featureClassName;
switch (featureType)
{
case NetworkingUtilities.PortFeatureType.Security:
featureClassName = "Msvm_EthernetSwitchPortSecuritySettingData";
break;
case NetworkingUtilities.PortFeatureType.Offload:
featureClassName = "Msvm_EthernetSwitchPortOffloadSettingData";
break;
default:
throw new ArgumentOutOfRangeException(featureType.ToString());
}
foreach (ManagementObject ethernetConnectionSetting in connections)
{
using (ManagementObjectCollection featureSettingCollection =
ethernetConnectionSetting.GetRelated(featureClassName,
"Msvm_EthernetPortSettingDataComponent",
null, null, null, null, false, null))
{
//
// For the security/offload feature, each connection can have no more than one instance
// of the feature setting, so we can simply take the first feature setting associated
// with each connection. For other features, it may be necessary to do extra work.
//
if (featureSettingCollection.Count == 0)
{
continue;
}
string featureText;
using (ManagementObject featureSetting =
WmiUtilities.GetFirstObjectFromCollection(featureSettingCollection))
{
switch (featureType)
{
case NetworkingUtilities.PortFeatureType.Security:
//
// Modify the feature setting's properties. Here, we enable MAC spoofing.
//
featureSetting["AllowMacSpoofing"] = true;
break;
case NetworkingUtilities.PortFeatureType.Offload:
//
// Modify the feature setting's properties. Here, we modify IOVQueuePairsRequested.
//
featureSetting["IOVQueuePairsRequested"] = 2;
break;
}
featureText = featureSetting.GetText(TextFormat.WmiDtd20);
}
// Now apply the changes to the Hyper-V server.
using (ManagementBaseObject inParams =
managementService.GetMethodParameters("ModifyFeatureSettings"))
{
inParams["FeatureSettings"] = new string[] { featureText };
using (ManagementBaseObject outParams =
managementService.InvokeMethod("ModifyFeatureSettings", inParams, null))
{
WmiUtilities.ValidateOutput(outParams, scope);
}
}
}
}
}
finally
{
// Dispose of the connections.
foreach (ManagementObject ethernetConnectionSetting in connections)
{
ethernetConnectionSetting.Dispose();
}
}
}
Console.WriteLine(string.Format(CultureInfo.CurrentCulture,
"Successfully modified virtual machine '{0}' so that each of its {1} connection(s) " +
"has its advanced {2} settings modified.",
virtualMachineName, connectionsCount, featureType.ToString()));
}
ConnectVmUsingResourcePool(
string virtualMachineName,
string resourcePoolName)
{
ManagementScope scope = new ManagementScope(@"root\virtualization\v2");
using (ManagementObject managementService = WmiUtilities.GetVirtualMachineManagementService(scope))
//
// Find the virtual machine we want to connect.
//
using (ManagementObject virtualMachine = WmiUtilities.GetVirtualMachine(virtualMachineName, scope))
//
// As a sanity check, verify that the specified resource pool exists by querying for it.
//
using (ManagementObject resourcePool = WmiUtilities.GetResourcePool(
"33",
"Microsoft:Hyper-V:Ethernet Connection",
resourcePoolName,
scope))
//
// Get the virtual machine's settings object which is used to make configuration changes.
//
using (ManagementObject virtualMachineSettings = WmiUtilities.GetVirtualMachineSettings(virtualMachine))
//
// Add a new synthetic Network Adapter device to the virtual machine.
//
using (ManagementObject syntheticAdapter = NetworkingUtilities.AddSyntheticAdapter(virtualMachine, scope))
//
// Now that we have added a network adapter to the virtual machine, we can configure its
// connection settings.
//
using (ManagementObject connectionSettingsToAdd =
NetworkingUtilities.GetDefaultEthernetPortAllocationSettingData(scope))
{
connectionSettingsToAdd["Parent"] = syntheticAdapter.Path.Path;
//
// Rather than specifying which switch to connect to, we specify which pool to look in.
//
connectionSettingsToAdd["PoolId"] = resourcePoolName;
//
// Now add the connection settings.
//
using (ManagementBaseObject addConnectionInParams =
managementService.GetMethodParameters("AddResourceSettings"))
{
addConnectionInParams["AffectedConfiguration"] = virtualMachineSettings.Path.Path;
addConnectionInParams["ResourceSettings"] =
new string[] { connectionSettingsToAdd.GetText(TextFormat.WmiDtd20) };
using (ManagementBaseObject addConnectionOutParams =
managementService.InvokeMethod("AddResourceSettings", addConnectionInParams, null))
{
WmiUtilities.ValidateOutput(addConnectionOutParams, scope);
}
}
}
Console.WriteLine(string.Format(CultureInfo.CurrentCulture,
"Successfully created dynamic connection from virtual machine '{0}' to resource pool '{1}'.",
virtualMachineName, resourcePoolName));
}
DisconnectVmFromSwitch(
string virtualMachineName,
string switchName)
{
ManagementScope scope = new ManagementScope(@"root\virtualization\v2");
using (ManagementObject managementService = WmiUtilities.GetVirtualMachineManagementService(scope))
//
// Find the Ethernet switch we want to disconnect from.
//
using (ManagementObject ethernetSwitch = NetworkingUtilities.FindEthernetSwitch(switchName, scope))
//
// Find the virtual machine we want to disconnect.
//
using (ManagementObject virtualMachine = WmiUtilities.GetVirtualMachine(virtualMachineName, scope))
{
//
// Find all of the connections to this switch.
//
IList <ManagementObject> connectionsToSwitch =
NetworkingUtilities.FindConnectionsToSwitch(virtualMachine, ethernetSwitch, scope);
//
// Now that we have found all of the connections to the switch we can go through and
// disable each connection so that it is not connected to anything. Note that you can also
// delete the connection object, but disabling the connection is sometimes preferable because
// it preserves all of the connection's configuration options along with any metrics
// associated with the connection.
//
try
{
foreach (ManagementObject connection in connectionsToSwitch)
{
connection["EnabledState"] = 3; // 3 means "Disabled"
using (ManagementBaseObject inParams =
managementService.GetMethodParameters("ModifyResourceSettings"))
{
inParams["ResourceSettings"] = new string[] { connection.GetText(TextFormat.WmiDtd20) };
using (ManagementBaseObject outParams =
managementService.InvokeMethod("ModifyResourceSettings", inParams, null))
{
WmiUtilities.ValidateOutput(outParams, scope);
}
}
}
}
finally
{
// Dispose of the connectionsToSwitch.
foreach (ManagementObject connection in connectionsToSwitch)
{
connection.Dispose();
}
}
}
Console.WriteLine(string.Format(CultureInfo.CurrentCulture,
"Successfully disconnected virtual machine '{0}' from switch '{1}'.",
virtualMachineName, switchName));
}
RemoveFeatureSettings(
string virtualMachineName,
NetworkingUtilities.PortFeatureType featureType)
{
ManagementScope scope = new ManagementScope(@"root\virtualization\v2");
int connectionsCount = 0;
using (ManagementObject managementService = WmiUtilities.GetVirtualMachineManagementService(scope))
//
// Find the virtual machine whose connections we want to modify.
//
using (ManagementObject virtualMachine = WmiUtilities.GetVirtualMachine(virtualMachineName, scope))
//
// Find all connections for the given virtual machine.
//
using (ManagementObjectCollection connections = NetworkingUtilities.FindConnections(
virtualMachine, scope))
{
string featureSettingClass;
switch (featureType)
{
case NetworkingUtilities.PortFeatureType.Security:
featureSettingClass = "Msvm_EthernetSwitchPortSecuritySettingData";
break;
case NetworkingUtilities.PortFeatureType.Offload:
featureSettingClass = "Msvm_EthernetSwitchPortOffloadSettingData";
break;
case NetworkingUtilities.PortFeatureType.Acl:
featureSettingClass = "Msvm_EthernetSwitchPortAclSettingData";
break;
default:
throw new ArgumentOutOfRangeException(featureType.ToString());
}
connectionsCount = connections.Count;
//
// Now find the feature setting data object associated with each connection, if any.
//
try
{
foreach (ManagementObject ethernetConnectionSetting in connections)
{
List <string> featureSettingPaths = new List <string>();
using (ManagementObjectCollection featureSettingCollection =
ethernetConnectionSetting.GetRelated(featureSettingClass,
"Msvm_EthernetPortSettingDataComponent",
null, null, null, null, false, null))
{
if (featureSettingCollection.Count == 0)
{
continue;
}
foreach (ManagementObject featureSetting in featureSettingCollection)
{
using (featureSetting)
{
featureSettingPaths.Add(featureSetting.Path.Path);
}
}
}
using (ManagementBaseObject inParams =
managementService.GetMethodParameters("RemoveFeatureSettings"))
{
//
// We specify which feature setting to remove by giving the WMI path to the feature setting object.
//
inParams["FeatureSettings"] = featureSettingPaths.ToArray();
using (ManagementBaseObject outParams =
managementService.InvokeMethod("RemoveFeatureSettings", inParams, null))
{
WmiUtilities.ValidateOutput(outParams, scope);
}
}
}
}
finally
{
// Dispose of the connections.
foreach (ManagementObject ethernetConnectionSetting in connections)
{
ethernetConnectionSetting.Dispose();
}
}
}
Console.WriteLine(string.Format(CultureInfo.CurrentCulture,
"Successfully modified virtual machine '{0}' to remove advanced {2} settings from " +
"each of its {1} connection(s).",
virtualMachineName, connectionsCount, featureType.ToString()));
}
MoveExtension(
string switchName,
string extensionName,
int offset)
{
ManagementScope scope = new ManagementScope(@"root\virtualization\v2");
//
// Get the switch we want to modify.
//
using (ManagementObject ethernetSwitch = NetworkingUtilities.FindEthernetSwitch(switchName, 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)))
{
string[] extensionOrder = (string[])ethernetSwitchSettings["ExtensionOrder"];
byte[] extensionTypes = new byte[extensionOrder.Length];
int extensionIndex = -1;
for (int idx = 0; idx < extensionOrder.Length; ++idx)
{
using (ManagementObject extension = new ManagementObject(extensionOrder[idx]))
{
extension.Get();
extensionTypes[idx] = (byte)extension["ExtensionType"];
if (String.Equals(
(string)extension["ElementName"],
extensionName,
StringComparison.OrdinalIgnoreCase))
{
extensionIndex = idx;
}
}
}
if (extensionIndex == -1)
{
throw new ApplicationException(String.Format(
CultureInfo.CurrentCulture,
"Could not find extension '{0}' on switch '{1}'.",
extensionName,
switchName));
}
//
// Ensure that this is a valid move operation. The new extension index must
// be in range, and the extension cannot be interleaved with other extensions of
// a different type.
//
int newExtensionIndex = extensionIndex + offset;
if ((newExtensionIndex < 0) || (newExtensionIndex >= extensionOrder.Length))
{
throw new ApplicationException("Invalid move operation.");
}
if (extensionTypes[newExtensionIndex] != extensionTypes[extensionIndex])
{
throw new ApplicationException("Invalid move operation.");
}
//
// Reorder the extensions and apply the switch settings changes.
//
string temp = extensionOrder[newExtensionIndex];
extensionOrder[newExtensionIndex] = extensionOrder[extensionIndex];
extensionOrder[extensionIndex] = temp;
ethernetSwitchSettings["ExtensionOrder"] = extensionOrder;
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,
"Extension '{0}' was successfully reordered on switch '{1}'.",
extensionName,
switchName));
}
