def add_dvPort_group(si, dv_switch, vlanId, name, bw): dv_pg_spec = vim.dvs.DistributedVirtualPortgroup.ConfigSpec() dv_pg_spec.name = name dv_pg_spec.numPorts = 32 dv_pg_spec.type = vim.dvs.DistributedVirtualPortgroup.PortgroupType.earlyBinding policy = vim.dvs.DistributedVirtualPortgroup.PortgroupPolicy() policy.shapingOverrideAllowed = True dv_pg_spec.policy = policy dv_pg_spec.defaultPortConfig = vim.dvs.VmwareDistributedVirtualSwitch.VmwarePortConfigPolicy() dv_pg_spec.defaultPortConfig.securityPolicy = vim.dvs.VmwareDistributedVirtualSwitch.SecurityPolicy() if bw: inShapePolicy = vim.dvs.DistributedVirtualPort.TrafficShapingPolicy() inShapePolicy.enabled = vim.BoolPolicy(value=True) inShapePolicy.averageBandwidth = vim.LongPolicy(value=bw * 1000 * 1000) inShapePolicy.peakBandwidth = vim.LongPolicy(value=bw * 1000 * 1000) dv_pg_spec.defaultPortConfig.inShapingPolicy = inShapePolicy dv_pg_spec.defaultPortConfig.outShapingPolicy = inShapePolicy dv_pg_spec.defaultPortConfig.vlan = vim.dvs.VmwareDistributedVirtualSwitch.VlanIdSpec() dv_pg_spec.defaultPortConfig.vlan.vlanId = vlanId dv_pg_spec.defaultPortConfig.securityPolicy.allowPromiscuous = vim.BoolPolicy(value=False) dv_pg_spec.defaultPortConfig.securityPolicy.forgedTransmits = vim.BoolPolicy(value=False) dv_pg_spec.defaultPortConfig.vlan.inherited = False dv_pg_spec.defaultPortConfig.securityPolicy.macChanges = vim.BoolPolicy(value=False) dv_pg_spec.defaultPortConfig.securityPolicy.inherited = False task = dv_switch.AddDVPortgroup_Task([dv_pg_spec]) wait_for_task(task, si)
def test_serialize_integer(self):
lp = vim.LongPolicy()
lp.inherited = False
lp.value = 100
SoapAdapter.Serialize(lp, version='vim.version.version10')
def build_config(self):
config = vim.dvs.DistributedVirtualPortgroup.ConfigSpec()
# Basic config
config.name = self.module.params['portgroup_name']
config.numPorts = self.module.params['num_ports']
# Default port config
config.defaultPortConfig = vim.dvs.VmwareDistributedVirtualSwitch.VmwarePortConfigPolicy()
if self.module.params['vlan_trunk']:
config.defaultPortConfig.vlan = vim.dvs.VmwareDistributedVirtualSwitch.TrunkVlanSpec()
config.defaultPortConfig.vlan.vlanId = list(map(lambda x: vim.NumericRange(start=x[0], end=x[1]), self.create_vlan_list()))
elif self.module.params['vlan_private']:
# Check that private VLAN exists in dvs
if self.module.params['vlan_private']:
pvlan_exists = self.check_dvs_pvlan()
if not pvlan_exists:
self.module.fail_json(msg="No private vlan with id %s in distributed vSwitch %s"
% (self.module.params['vlan_id'], self.module.params['switch_name']))
config.defaultPortConfig.vlan = vim.dvs.VmwareDistributedVirtualSwitch.PvlanSpec()
config.defaultPortConfig.vlan.pvlanId = int(self.module.params['vlan_id'])
else:
config.defaultPortConfig.vlan = vim.dvs.VmwareDistributedVirtualSwitch.VlanIdSpec()
config.defaultPortConfig.vlan.vlanId = int(self.module.params['vlan_id'])
config.defaultPortConfig.vlan.inherited = False
# If the dvSwitch supports MAC learning, it's a version where securityPolicy is deprecated
if dvs_supports_mac_learning(self.dv_switch):
config.defaultPortConfig.macManagementPolicy = vim.dvs.VmwareDistributedVirtualSwitch.MacManagementPolicy()
config.defaultPortConfig.macManagementPolicy.allowPromiscuous = self.module.params['network_policy']['promiscuous']
config.defaultPortConfig.macManagementPolicy.forgedTransmits = self.module.params['network_policy']['forged_transmits']
config.defaultPortConfig.macManagementPolicy.macChanges = self.module.params['network_policy']['mac_changes']
macLearning = self.module.params['mac_learning']
if macLearning:
macLearningPolicy = vim.dvs.VmwareDistributedVirtualSwitch.MacLearningPolicy()
if macLearning['allow_unicast_flooding'] is not None:
macLearningPolicy.allowUnicastFlooding = macLearning['allow_unicast_flooding']
if macLearning['enabled'] is not None:
macLearningPolicy.enabled = macLearning['enabled']
if macLearning['limit'] is not None:
macLearningPolicy.limit = macLearning['limit']
if macLearning['limit_policy']:
macLearningPolicy.limitPolicy = macLearning['limit_policy']
config.defaultPortConfig.macManagementPolicy.macLearningPolicy = macLearningPolicy
else:
config.defaultPortConfig.securityPolicy = vim.dvs.VmwareDistributedVirtualSwitch.SecurityPolicy()
config.defaultPortConfig.securityPolicy.allowPromiscuous = vim.BoolPolicy(value=self.module.params['network_policy']['promiscuous'])
config.defaultPortConfig.securityPolicy.forgedTransmits = vim.BoolPolicy(value=self.module.params['network_policy']['forged_transmits'])
config.defaultPortConfig.securityPolicy.macChanges = vim.BoolPolicy(value=self.module.params['network_policy']['mac_changes'])
# Teaming Policy
teamingPolicy = vim.dvs.VmwareDistributedVirtualSwitch.UplinkPortTeamingPolicy()
teamingPolicy.policy = vim.StringPolicy(value=self.module.params['teaming_policy']['load_balance_policy'])
if self.module.params['teaming_policy']['inbound_policy'] is not None:
teamingPolicy.reversePolicy = vim.BoolPolicy(value=self.module.params['teaming_policy']['inbound_policy'])
teamingPolicy.notifySwitches = vim.BoolPolicy(value=self.module.params['teaming_policy']['notify_switches'])
teamingPolicy.rollingOrder = vim.BoolPolicy(value=self.module.params['teaming_policy']['rolling_order'])
if self.module.params['teaming_policy']['active_uplinks'] or self.module.params['teaming_policy']['standby_uplinks']:
teamingPolicy.uplinkPortOrder = vim.dvs.VmwareDistributedVirtualSwitch.UplinkPortOrderPolicy()
if self.module.params['teaming_policy']['active_uplinks']:
teamingPolicy.uplinkPortOrder.activeUplinkPort = self.module.params['teaming_policy']['active_uplinks']
if self.module.params['teaming_policy']['standby_uplinks']:
teamingPolicy.uplinkPortOrder.standbyUplinkPort = self.module.params['teaming_policy']['standby_uplinks']
config.defaultPortConfig.uplinkTeamingPolicy = teamingPolicy
# PG policy (advanced_policy)
config.policy = vim.dvs.VmwareDistributedVirtualSwitch.VMwarePortgroupPolicy()
config.policy.blockOverrideAllowed = self.module.params['port_policy']['block_override']
config.policy.ipfixOverrideAllowed = self.module.params['port_policy']['ipfix_override']
config.policy.livePortMovingAllowed = self.module.params['port_policy']['live_port_move']
config.policy.networkResourcePoolOverrideAllowed = self.module.params['port_policy']['network_rp_override']
config.policy.portConfigResetAtDisconnect = self.module.params['port_policy']['port_config_reset_at_disconnect']
config.policy.securityPolicyOverrideAllowed = self.module.params['port_policy']['security_override']
config.policy.shapingOverrideAllowed = self.module.params['port_policy']['shaping_override']
config.policy.trafficFilterOverrideAllowed = self.module.params['port_policy']['traffic_filter_override']
config.policy.uplinkTeamingOverrideAllowed = self.module.params['port_policy']['uplink_teaming_override']
config.policy.vendorConfigOverrideAllowed = self.module.params['port_policy']['vendor_config_override']
config.policy.vlanOverrideAllowed = self.module.params['port_policy']['vlan_override']
# NetFlow
config.defaultPortConfig.ipfixEnabled = vim.BoolPolicy()
if self.module.params['net_flow']:
config.defaultPortConfig.ipfixEnabled.inherited = False
config.defaultPortConfig.ipfixEnabled.value = self.module.params['net_flow']
else:
config.defaultPortConfig.ipfixEnabled.inherited = True
# Ingress traffic shaping
config.defaultPortConfig.inShapingPolicy = vim.dvs.DistributedVirtualPort.TrafficShapingPolicy()
config.defaultPortConfig.inShapingPolicy.averageBandwidth = vim.LongPolicy()
config.defaultPortConfig.inShapingPolicy.burstSize = vim.LongPolicy()
config.defaultPortConfig.inShapingPolicy.peakBandwidth = vim.LongPolicy()
config.defaultPortConfig.inShapingPolicy.enabled = vim.BoolPolicy()
if self.module.params['in_traffic_shaping']:
config.defaultPortConfig.inShapingPolicy.inherited = False
# enabled
config.defaultPortConfig.inShapingPolicy.enabled.inherited = False
config.defaultPortConfig.inShapingPolicy.enabled.value = self.module.params['in_traffic_shaping']['enabled']
# adverage bandwidth
config.defaultPortConfig.inShapingPolicy.averageBandwidth.inherited = False
config.defaultPortConfig.inShapingPolicy.averageBandwidth.value = self.module.params['in_traffic_shaping']['average_bandwidth'] * 1000
# burst size
config.defaultPortConfig.inShapingPolicy.burstSize.inherited = False
config.defaultPortConfig.inShapingPolicy.burstSize.value = self.module.params['in_traffic_shaping']['burst_size'] * 1024
# peak bandwidth
config.defaultPortConfig.inShapingPolicy.peakBandwidth.inherited = False
config.defaultPortConfig.inShapingPolicy.peakBandwidth.value = self.module.params['in_traffic_shaping']['peak_bandwidth'] * 1000
else:
config.defaultPortConfig.inShapingPolicy.inherited = True
config.defaultPortConfig.inShapingPolicy.enabled.inherited = True
config.defaultPortConfig.inShapingPolicy.averageBandwidth.inherited = True
config.defaultPortConfig.inShapingPolicy.burstSize.inherited = True
config.defaultPortConfig.inShapingPolicy.peakBandwidth.inherited = True
# Egress traffic shaping
config.defaultPortConfig.outShapingPolicy = vim.dvs.DistributedVirtualPort.TrafficShapingPolicy()
config.defaultPortConfig.outShapingPolicy.averageBandwidth = vim.LongPolicy()
config.defaultPortConfig.outShapingPolicy.burstSize = vim.LongPolicy()
config.defaultPortConfig.outShapingPolicy.peakBandwidth = vim.LongPolicy()
config.defaultPortConfig.outShapingPolicy.enabled = vim.BoolPolicy()
if self.module.params['out_traffic_shaping']:
config.defaultPortConfig.outShapingPolicy.inherited = False
# enabled
config.defaultPortConfig.outShapingPolicy.enabled.inherited = False
config.defaultPortConfig.outShapingPolicy.enabled.value = self.module.params['out_traffic_shaping']['enabled']
# adverage bandwidth
config.defaultPortConfig.outShapingPolicy.averageBandwidth.inherited = False
config.defaultPortConfig.outShapingPolicy.averageBandwidth.value = self.module.params['out_traffic_shaping']['average_bandwidth'] * 1000
# burst size
config.defaultPortConfig.outShapingPolicy.burstSize.inherited = False
config.defaultPortConfig.outShapingPolicy.burstSize.value = self.module.params['out_traffic_shaping']['burst_size'] * 1024
# peak bandwidth
config.defaultPortConfig.outShapingPolicy.peakBandwidth.inherited = False
config.defaultPortConfig.outShapingPolicy.peakBandwidth.value = self.module.params['out_traffic_shaping']['peak_bandwidth'] * 1000
else:
config.defaultPortConfig.outShapingPolicy.inherited = True
config.defaultPortConfig.outShapingPolicy.enabled.inherited = True
config.defaultPortConfig.outShapingPolicy.averageBandwidth.inherited = True
config.defaultPortConfig.outShapingPolicy.burstSize.inherited = True
config.defaultPortConfig.outShapingPolicy.peakBandwidth.inherited = True
# PG Type
if self.module.params['port_binding'] == 'ephemeral':
config.type = 'ephemeral'
else:
config.type = 'earlyBinding'
if self.port_allocation == 'elastic':
config.autoExpand = True
else:
config.autoExpand = False
return config
def doUpdatePort(dpg, vm, vnic_device):
outputstr = 'Try to update mac address:\n'
outputstr += 'Current mac address: %s \n'%(vnic_device.macAddress)
outputstr += 'New mac address: %s \n'%(NEW_MAC_ADDRESS)
vnic_spec = vim.vm.device.VirtualDeviceSpec()
vnic_spec.operation = vim.vm.device.VirtualDeviceSpec.Operation.edit
vnic_spec.device = vnic_device
vnic_spec.device.key = vnic_device.key
vnic_spec.device.macAddress = NEW_MAC_ADDRESS
vnic_spec.device.backing = vnic_device.backing
vnic_spec.device.backing.port = vnic_device.backing.port
vnic_spec.device.wakeOnLanEnabled = vnic_device.wakeOnLanEnabled
vnic_spec.device.connectable = vnic_device.connectable
dev_changes = []
dev_changes.append(vnic_spec)
vm_spec = vim.vm.ConfigSpec()
vm_spec.deviceChange = dev_changes
# CHANGE vm.config.networkShaper NOT WORK, SO REMOVE IT!!!
# outputstr += 'Try to update shaping policy:\n'
# newShaping = vim.vm.NetworkShaperInfo()
# newShaping.enabled = (SHAPING_ENABLE=='true')
# newShaping.peakBps = SHAPING_PEAK_BPS
# newShaping.averageBps = SHAPING_AVERAGE_BPS
# newShaping.burstSize = 0
# vm_spec.networkShaper = newShaping
# curShaping = vm.config.networkShaper
# if curShaping != None:
# outputstr += 'Current shaping policy: enabled:%s,peakBps:%s,averageBps:%s'%(curShaping.enabled,curShaping.peakBps,curShaping.averageBps)
# outputstr += 'New shaping policy: enabled:%s,peakBps:%s,averageBps:%s'%(newShaping.enabled,newShaping.peakBps,newShaping.averageBps)
vm_task = vm.ReconfigVM_Task(vm_spec)
state = WaitForTask(task=vm_task, si=serviceInstance, onProgressUpdate=OnTaskProgressUpdate)
outputstr += 'ReconfigVM Task completed, state: %s \n\n'%(state)
outputstr += 'Try to update shaping policy:\n'
dvs = dpg.config.distributedVirtualSwitch
portCriteria = vim.dvs.PortCriteria()
portCriteria.portKey = [vnic_device.backing.port.portKey]
dvPorts = dvs.FetchDVPorts(portCriteria)
ciShapping = dvPorts[0].config.setting.inShapingPolicy
coShapping = dvPorts[0].config.setting.outShapingPolicy
if ciShapping!=None:
outputstr += 'Current in shaping policy: enabled:%s,averageBps:%s,peakBps:%s\n'% \
(ciShapping.enabled.value,ciShapping.averageBandwidth.value,ciShapping.peakBandwidth.value)
if coShapping!=None:
outputstr += 'Current out shaping policy: enabled:%s,averageBps:%s,peakBps:%s\n'% \
(coShapping.enabled.value,coShapping.averageBandwidth.value,coShapping.peakBandwidth.value)
outputstr += 'New in shaping policy: enabled:%s,averageBps:%s,peakBps:%s\n'%(IN_SHAPING_ENABLE,IN_SHAPING_AVERAGE_BPS,IN_SHAPING_PEAK_BPS)
outputstr += 'New out shaping policy: enabled:%s,averageBps:%s,peakBps:%s\n'%(OUT_SHAPING_ENABLE,OUT_SHAPING_AVERAGE_BPS,OUT_SHAPING_PEAK_BPS)
port_spec = vim.dvs.DistributedVirtualPort.ConfigSpec()
port_spec.operation = vim.ConfigSpecOperation.edit
port_spec.key = vnic_device.backing.port.portKey
port_setting = vim.dvs.DistributedVirtualPort.Setting()
port_inshaping = vim.dvs.DistributedVirtualPort.TrafficShapingPolicy()
port_outshaping = vim.dvs.DistributedVirtualPort.TrafficShapingPolicy()
port_inshaping.enabled = vim.BoolPolicy(value=(IN_SHAPING_ENABLE=='true'))
port_inshaping.averageBandwidth = vim.LongPolicy(value=IN_SHAPING_AVERAGE_BPS)
port_inshaping.peakBandwidth = vim.LongPolicy(value=IN_SHAPING_PEAK_BPS)
port_outshaping.enabled = vim.BoolPolicy(value=(OUT_SHAPING_ENABLE=='true'))
port_outshaping.averageBandwidth = vim.LongPolicy(value=OUT_SHAPING_AVERAGE_BPS)
port_outshaping.peakBandwidth = vim.LongPolicy(value=OUT_SHAPING_PEAK_BPS)
port_setting.inShapingPolicy = port_inshaping
port_setting.outShapingPolicy = port_outshaping
port_spec.setting = port_setting
port_task = dvs.ReconfigureDVPort_Task([port_spec])
state2 = WaitForTask(task=port_task, si=serviceInstance, onProgressUpdate=OnTaskProgressUpdate)
outputstr += 'ReconfigDVPort Task completed, state: %s \n'%(state2)
output(outputstr)