A set of Neutron drivers for the VMware NSX.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 

990 lines
43 KiB

# Copyright 2014 VMware, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from neutron_lib import exceptions
from oslo_log import log as logging
from oslo_utils import excutils
from oslo_vmware import vim_util
from vmware_nsx.common import exceptions as nsx_exc
from vmware_nsx.dvs import dvs_utils
LOG = logging.getLogger(__name__)
PORTGROUP_PREFIX = 'dvportgroup'
API_FIND_ALL_BY_UUID = 'FindAllByUuid'
# QoS related constants
QOS_IN_DIRECTION = 'incomingPackets'
QOS_AGENT_NAME = 'dvfilter-generic-vmware'
DSCP_RULE_DESCRIPTION = 'Openstack Dscp Marking RUle'
class SingleDvsManager(object):
"""Management class for dvs related tasks for the dvs plugin
For the globally configured dvs.
the moref of the configured DVS will be learnt. This will be used in
the operations supported by the manager.
"""
def __init__(self):
self.dvs = DvsManager()
self._dvs_moref = self._get_dvs_moref_by_name(
self.dvs.get_vc_session(),
dvs_utils.dvs_name_get())
def _get_dvs_moref_by_name(self, session, dvs_name):
"""Get the moref of the configured DVS."""
return self.dvs.get_dvs_moref_by_name(dvs_name, session)
def add_port_group(self, net_id, vlan_tag=None, trunk_mode=False):
return self.dvs.add_port_group(self._dvs_moref, net_id,
vlan_tag=vlan_tag,
trunk_mode=trunk_mode)
def delete_port_group(self, net_id):
return self.dvs.delete_port_group(self._dvs_moref, net_id)
def get_port_group_info(self, net_id):
return self.dvs.get_port_group_info(self._dvs_moref, net_id)
def net_id_to_moref(self, net_id):
return self.dvs._net_id_to_moref(self._dvs_moref, net_id)
class VCManagerBase(object):
"""Base class for all VC related classes, to initialize the session"""
def __init__(self):
"""Initializer.
A global session with the VC will be established.
NOTE: the DVS port group name will be the Neutron network UUID.
"""
self._session = dvs_utils.dvs_create_session()
def get_vc_session(self):
return self._session
class DvsManager(VCManagerBase):
"""Management class for dvs related tasks
The dvs-id is not a class member, since multiple dvs-es can be supported.
"""
def get_dvs_moref_by_name(self, dvs_name, session=None):
"""Get the moref of DVS."""
if not session:
session = self.get_vc_session()
results = session.invoke_api(vim_util,
'get_objects',
session.vim,
'DistributedVirtualSwitch',
100)
while results:
for dvs in results.objects:
for prop in dvs.propSet:
if dvs_name == prop.val:
vim_util.cancel_retrieval(session.vim, results)
return dvs.obj
results = vim_util.continue_retrieval(session.vim, results)
raise nsx_exc.DvsNotFound(dvs=dvs_name)
def _get_dvs_moref_by_id(self, dvs_id):
return vim_util.get_moref(dvs_id, 'VmwareDistributedVirtualSwitch')
def _get_vlan_spec(self, vlan_tag):
"""Gets portgroup vlan spec."""
# Create the spec for the vlan tag
client_factory = self._session.vim.client.factory
spec_ns = 'ns0:VmwareDistributedVirtualSwitchVlanIdSpec'
vl_spec = client_factory.create(spec_ns)
vl_spec.vlanId = vlan_tag
vl_spec.inherited = '0'
return vl_spec
def _get_trunk_vlan_spec(self, start=0, end=4094):
"""Gets portgroup trunk vlan spec."""
client_factory = self._session.vim.client.factory
spec_ns = 'ns0:VmwareDistributedVirtualSwitchTrunkVlanSpec'
range = client_factory.create('ns0:NumericRange')
range.start = start
range.end = end
vlan_tag = range
vl_spec = client_factory.create(spec_ns)
vl_spec.vlanId = vlan_tag
vl_spec.inherited = '0'
return vl_spec
def _get_port_group_spec(self, net_id, vlan_tag, trunk_mode=False,
pg_spec=None):
"""Gets the port groups spec for net_id and vlan_tag."""
client_factory = self._session.vim.client.factory
if not pg_spec:
pg_spec = client_factory.create('ns0:DVPortgroupConfigSpec')
pg_spec.name = net_id
pg_spec.type = 'ephemeral'
config = client_factory.create('ns0:VMwareDVSPortSetting')
if trunk_mode:
config.vlan = self._get_trunk_vlan_spec()
elif vlan_tag:
config.vlan = self._get_vlan_spec(vlan_tag)
pg_spec.defaultPortConfig = config
return pg_spec
def add_port_group(self, dvs_moref, net_id, vlan_tag=None,
trunk_mode=False):
"""Add a new port group to the configured DVS."""
pg_spec = self._get_port_group_spec(net_id, vlan_tag,
trunk_mode=trunk_mode)
task = self._session.invoke_api(self._session.vim,
'CreateDVPortgroup_Task',
dvs_moref,
spec=pg_spec)
try:
# NOTE(garyk): cache the returned moref
self._session.wait_for_task(task)
except Exception:
# NOTE(garyk): handle more specific exceptions
with excutils.save_and_reraise_exception():
LOG.exception('Failed to create port group for '
'%(net_id)s with tag %(tag)s.',
{'net_id': net_id, 'tag': vlan_tag})
LOG.info("%(net_id)s with tag %(vlan_tag)s created on %(dvs)s.",
{'net_id': net_id,
'vlan_tag': vlan_tag,
'dvs': dvs_moref.value})
def _get_portgroup(self, net_id):
"""Get the port group moref of the net_id."""
results = self._session.invoke_api(vim_util,
'get_objects',
self._session.vim,
'DistributedVirtualPortgroup',
100)
while results:
for pg in results.objects:
for prop in pg.propSet:
if net_id == prop.val:
vim_util.cancel_retrieval(self._session.vim, results)
return pg.obj
results = vim_util.continue_retrieval(self._session.vim, results)
raise exceptions.NetworkNotFound(net_id=net_id)
def _net_id_to_moref(self, dvs_moref, net_id):
"""Gets the moref for the specific neutron network."""
# NOTE(garyk): return this from a cache if not found then invoke
# code below.
if dvs_moref:
port_groups = self._session.invoke_api(vim_util,
'get_object_properties',
self._session.vim,
dvs_moref,
['portgroup'])
if len(port_groups) and hasattr(port_groups[0], 'propSet'):
for prop in port_groups[0].propSet:
for val in prop.val[0]:
props = self._session.invoke_api(
vim_util,
'get_object_properties',
self._session.vim,
val, ['name'])
if len(props) and hasattr(props[0], 'propSet'):
for prop2 in props[0].propSet:
# match name or mor id
if net_id == prop2.val or net_id == val.value:
# NOTE(garyk): update cache
return val
raise exceptions.NetworkNotFound(net_id=net_id)
return self._get_portgroup(net_id)
def _is_vlan_network_by_moref(self, moref):
"""
This can either be a VXLAN or a VLAN network. The type is determined
by the prefix of the moref.
"""
return moref.startswith(PORTGROUP_PREFIX)
def _copy_port_group_spec(self, orig_spec):
client_factory = self._session.vim.client.factory
pg_spec = client_factory.create('ns0:DVPortgroupConfigSpec')
pg_spec.autoExpand = orig_spec['autoExpand']
pg_spec.configVersion = orig_spec['configVersion']
pg_spec.defaultPortConfig = orig_spec['defaultPortConfig']
pg_spec.name = orig_spec['name']
pg_spec.numPorts = orig_spec['numPorts']
pg_spec.policy = orig_spec['policy']
pg_spec.type = orig_spec['type']
return pg_spec
def update_port_group_spec_qos(self, pg_spec, qos_data):
port_conf = pg_spec.defaultPortConfig
# Update the in bandwidth shaping policy
# Note: openstack refers to the directions from the VM point of view,
# while the NSX refers to the vswitch point of view.
# so open stack egress is actually inShaping here.
inPol = port_conf.inShapingPolicy
if qos_data.egress.bandwidthEnabled:
inPol.inherited = False
inPol.enabled.inherited = False
inPol.enabled.value = True
inPol.averageBandwidth.inherited = False
inPol.averageBandwidth.value = qos_data.egress.averageBandwidth
inPol.peakBandwidth.inherited = False
inPol.peakBandwidth.value = qos_data.egress.peakBandwidth
inPol.burstSize.inherited = False
inPol.burstSize.value = qos_data.egress.burstSize
else:
inPol.inherited = True
outPol = port_conf.outShapingPolicy
if qos_data.ingress.bandwidthEnabled:
outPol.inherited = False
outPol.enabled.inherited = False
outPol.enabled.value = True
outPol.averageBandwidth.inherited = False
outPol.averageBandwidth.value = qos_data.ingress.averageBandwidth
outPol.peakBandwidth.inherited = False
outPol.peakBandwidth.value = qos_data.ingress.peakBandwidth
outPol.burstSize.inherited = False
outPol.burstSize.value = qos_data.ingress.burstSize
else:
outPol.inherited = True
# Update the DSCP marking
if (port_conf.filterPolicy.inherited or
len(port_conf.filterPolicy.filterConfig) == 0 or
len(port_conf.filterPolicy.filterConfig[
0].trafficRuleset.rules) == 0):
if qos_data.dscpMarkEnabled:
# create the entire structure
client_factory = self._session.vim.client.factory
filter_rule = client_factory.create('ns0:DvsTrafficRule')
filter_rule.description = DSCP_RULE_DESCRIPTION
filter_rule.action = client_factory.create(
'ns0:DvsUpdateTagNetworkRuleAction')
filter_rule.action.dscpTag = qos_data.dscpMarkValue
# mark only incoming packets (openstack egress = nsx ingress)
filter_rule.direction = QOS_IN_DIRECTION
# Add IP any->any qualifier
qualifier = client_factory.create(
'ns0:DvsIpNetworkRuleQualifier')
qualifier.protocol = 0
qualifier.sourceAddress = None
qualifier.destinationAddress = None
filter_rule.qualifier = [qualifier]
traffic_filter_config = client_factory.create(
'ns0:DvsTrafficFilterConfig')
traffic_filter_config.trafficRuleset.rules = [filter_rule]
traffic_filter_config.trafficRuleset.enabled = True
traffic_filter_config.agentName = QOS_AGENT_NAME
traffic_filter_config.inherited = False
port_conf.filterPolicy = client_factory.create(
'ns0:DvsFilterPolicy')
port_conf.filterPolicy.filterConfig = [
traffic_filter_config]
port_conf.filterPolicy.inherited = False
else:
# The structure was already initialized
filter_policy = port_conf.filterPolicy
if qos_data.dscpMarkEnabled:
# just update the DSCP value
traffic_filter_config = filter_policy.filterConfig[0]
filter_rule = traffic_filter_config.trafficRuleset.rules[0]
filter_rule.action.dscpTag = qos_data.dscpMarkValue
else:
# delete the filter policy data
filter_policy.filterConfig = []
def _reconfigure_port_group(self, pg_moref, spec_update_calback,
spec_update_data):
# Get the current configuration of the port group
pg_spec = self._session.invoke_api(vim_util,
'get_object_properties',
self._session.vim,
pg_moref, ['config'])
if len(pg_spec) == 0 or len(pg_spec[0].propSet[0]) == 0:
LOG.error('Failed to get object properties of %s', pg_moref)
raise nsx_exc.DvsNotFound(dvs=pg_moref)
# Convert the extracted config to DVPortgroupConfigSpec
new_spec = self._copy_port_group_spec(pg_spec[0].propSet[0].val)
# Update the configuration using the callback & data
spec_update_calback(new_spec, spec_update_data)
# Update the port group configuration
task = self._session.invoke_api(self._session.vim,
'ReconfigureDVPortgroup_Task',
pg_moref, spec=new_spec)
try:
self._session.wait_for_task(task)
except Exception:
LOG.error('Failed to reconfigure DVPortGroup %s', pg_moref)
raise nsx_exc.DvsNotFound(dvs=pg_moref)
# Update the dvs port groups config for a vxlan/vlan network
# update the spec using a callback and user data
def update_port_groups_config(self, dvs_id, net_id, net_moref,
spec_update_calback, spec_update_data):
is_vlan = self._is_vlan_network_by_moref(net_moref)
if is_vlan:
return self._update_net_port_groups_config(net_moref,
spec_update_calback,
spec_update_data)
dvs_moref = self._get_dvs_moref_by_id(dvs_id)
return self._update_vxlan_port_groups_config(dvs_moref,
net_id,
net_moref,
spec_update_calback,
spec_update_data)
# Update the dvs port groups config for a vxlan network
# Searching the port groups for a partial match to the network id & moref
# update the spec using a callback and user data
def _update_vxlan_port_groups_config(self,
dvs_moref,
net_id,
net_moref,
spec_update_calback,
spec_update_data):
port_groups = self._session.invoke_api(vim_util,
'get_object_properties',
self._session.vim,
dvs_moref,
['portgroup'])
found = False
if len(port_groups) and hasattr(port_groups[0], 'propSet'):
for prop in port_groups[0].propSet:
for pg_moref in prop.val[0]:
props = self._session.invoke_api(vim_util,
'get_object_properties',
self._session.vim,
pg_moref, ['name'])
if len(props) and hasattr(props[0], 'propSet'):
for prop2 in props[0].propSet:
if net_id in prop2.val and net_moref in prop2.val:
found = True
self._reconfigure_port_group(
pg_moref,
spec_update_calback,
spec_update_data)
if not found:
raise exceptions.NetworkNotFound(net_id=net_id)
# Update the dvs port groups config for a vlan network
# Finding the port group using the exact moref of the network
# update the spec using a callback and user data
def _update_net_port_groups_config(self,
net_moref,
spec_update_calback,
spec_update_data):
pg_moref = vim_util.get_moref(net_moref,
"DistributedVirtualPortgroup")
self._reconfigure_port_group(pg_moref,
spec_update_calback,
spec_update_data)
def delete_port_group(self, dvs_moref, net_id):
"""Delete a specific port group."""
moref = self._net_id_to_moref(dvs_moref, net_id)
task = self._session.invoke_api(self._session.vim,
'Destroy_Task',
moref)
try:
self._session.wait_for_task(task)
except Exception:
# NOTE(garyk): handle more specific exceptions
with excutils.save_and_reraise_exception():
LOG.exception('Failed to delete port group for %s.',
net_id)
LOG.info("%(net_id)s delete from %(dvs)s.",
{'net_id': net_id,
'dvs': dvs_moref.value})
def get_port_group_info(self, dvs_moref, net_id):
"""Get portgroup information."""
pg_moref = self._net_id_to_moref(dvs_moref, net_id)
# Expand the properties to collect on need basis.
properties = ['name']
pg_info = self._session.invoke_api(vim_util,
'get_object_properties_dict',
self._session.vim,
pg_moref, properties)
return pg_info, pg_moref
def _get_dvs_moref_from_teaming_data(self, teaming_data):
"""Get the moref dvs that belongs to the teaming data"""
if 'switchObj' in teaming_data:
if 'objectId' in teaming_data['switchObj']:
dvs_id = teaming_data['switchObj']['objectId']
return vim_util.get_moref(
dvs_id, 'VmwareDistributedVirtualSwitch')
def update_port_group_spec_teaming(self, pg_spec, teaming_data):
mapping = {'FAILOVER_ORDER': 'failover_explicit',
'ETHER_CHANNEL': 'loadbalance_ip',
'LACP_ACTIVE': 'loadbalance_ip',
'LACP_PASSIVE': 'loadbalance_ip',
'LACP_V2': 'loadbalance_ip',
'LOADBALANCE_SRCID': 'loadbalance_srcid',
'LOADBALANCE_SRCMAC': 'loadbalance_srcmac',
'LOADBALANCE_LOADBASED': 'loadbalance_loadbased'}
dvs_moref = self._get_dvs_moref_from_teaming_data(teaming_data)
port_conf = pg_spec.defaultPortConfig
policy = port_conf.uplinkTeamingPolicy
policy.inherited = False
policy.policy.inherited = False
policy.policy.value = mapping[teaming_data['teamingPolicy']]
policy.uplinkPortOrder.inherited = False
ports = teaming_data['failoverUplinkPortNames']
policy.uplinkPortOrder.activeUplinkPort = ports
# The standby port will be those not configure as active ones
uplinks = self._session.invoke_api(vim_util,
"get_object_property",
self._session.vim,
dvs_moref,
"config.uplinkPortPolicy")
# VC does not support LAG and normal uplinks. So need to check
# if we need to configure standby links
if set(ports) & set(uplinks.uplinkPortName):
standby = list(set(uplinks.uplinkPortName) - set(ports))
policy.uplinkPortOrder.standbyUplinkPort = standby
def update_port_group_spec_name(self, pg_spec, name):
pg_spec.name = name
def update_port_group_spec_trunk(self, pg_spec, trunk_data):
port_conf = pg_spec.defaultPortConfig
port_conf.vlan = self._get_trunk_vlan_spec()
def update_port_group_security_policy(self, pg_spec, status):
policy = pg_spec.policy
policy.securityPolicyOverrideAllowed = status
def _update_port_security_policy(self, dvs_moref, port, status):
client_factory = self._session.vim.client.factory
ps = client_factory.create('ns0:DVPortConfigSpec')
ps.key = port.portKey
ps.operation = 'edit'
policy = client_factory.create('ns0:DVSSecurityPolicy')
bp = client_factory.create('ns0:BoolPolicy')
bp.inherited = False
bp.value = status
policy.allowPromiscuous = bp
policy.forgedTransmits = bp
policy.inherited = False
setting = client_factory.create('ns0:VMwareDVSPortSetting')
setting.securityPolicy = policy
ps.setting = setting
task = self._session.invoke_api(self._session.vim,
'ReconfigureDVPort_Task',
dvs_moref,
port=ps)
try:
self._session.wait_for_task(task)
LOG.info("Updated port security status")
except Exception as e:
LOG.error("Failed to update port %s. Reason: %s",
port.key, e)
class VMManager(VCManagerBase):
"""Management class for VMs related VC tasks."""
def get_vm_moref_obj(self, instance_uuid):
"""Get reference to the VM.
The method will make use of FindAllByUuid to get the VM reference.
This method finds all VM's on the backend that match the
instance_uuid, more specifically all VM's on the backend that have
'config_spec.instanceUuid' set to 'instance_uuid'.
"""
vm_refs = self._session.invoke_api(
self._session.vim,
API_FIND_ALL_BY_UUID,
self._session.vim.service_content.searchIndex,
uuid=instance_uuid,
vmSearch=True,
instanceUuid=True)
if vm_refs:
return vm_refs[0]
def get_vm_moref(self, instance_uuid):
"""Get reference to the VM.
"""
vm_ref = self.get_vm_moref_obj(instance_uuid)
if vm_ref:
return vm_ref.value
def get_vm_spec(self, vm_moref):
vm_specs = self._session.invoke_api(vim_util,
'get_object_properties',
self._session.vim,
vm_moref, ['network'])
if vm_specs:
return vm_specs[0]
def _build_vm_spec_attach(self, neutron_port_id, port_mac,
nsx_net_id, device_type):
# Code inspired by nova: _create_vif_spec
client_factory = self._session.vim.client.factory
vm_spec = client_factory.create('ns0:VirtualMachineConfigSpec')
device_change = client_factory.create('ns0:VirtualDeviceConfigSpec')
device_change.operation = "add"
net_device = client_factory.create('ns0:' + device_type)
net_device.key = -47
net_device.addressType = "manual"
# configure the neutron port id and mac
net_device.externalId = neutron_port_id
net_device.macAddress = port_mac
net_device.wakeOnLanEnabled = True
backing = client_factory.create(
'ns0:VirtualEthernetCardOpaqueNetworkBackingInfo')
# configure the NSX network Id
backing.opaqueNetworkId = nsx_net_id
backing.opaqueNetworkType = "nsx.LogicalSwitch"
net_device.backing = backing
connectable_spec = client_factory.create(
'ns0:VirtualDeviceConnectInfo')
connectable_spec.startConnected = True
connectable_spec.allowGuestControl = True
connectable_spec.connected = True
net_device.connectable = connectable_spec
device_change.device = net_device
vm_spec.deviceChange = [device_change]
return vm_spec
def attach_vm_interface(self, vm_moref, neutron_port_id,
port_mac, nsx_net_id, device_type):
new_spec = self._build_vm_spec_attach(
neutron_port_id, port_mac, nsx_net_id, device_type)
task = self._session.invoke_api(self._session.vim,
'ReconfigVM_Task',
vm_moref,
spec=new_spec)
try:
self._session.wait_for_task(task)
LOG.info("Updated VM moref %(moref)s spec - "
"attached an interface",
{'moref': vm_moref.value})
except Exception as e:
LOG.error("Failed to reconfigure VM %(moref)s spec: %(e)s",
{'moref': vm_moref.value, 'e': e})
def _build_vm_spec_update(self, devices):
client_factory = self._session.vim.client.factory
vm_spec = client_factory.create('ns0:VirtualMachineConfigSpec')
vm_spec.deviceChange = [devices]
return vm_spec
def update_vm_interface(self, vm_moref, devices):
update_spec = self._build_vm_spec_update(devices)
task = self._session.invoke_api(self._session.vim,
'ReconfigVM_Task',
vm_moref,
spec=update_spec)
try:
self._session.wait_for_task(task)
LOG.info("Updated VM moref %(moref)s spec - "
"attached an interface",
{'moref': vm_moref.value})
except Exception as e:
LOG.error("Failed to reconfigure VM %(moref)s spec: %(e)s",
{'moref': vm_moref.value, 'e': e})
def _build_vm_spec_detach(self, device):
"""Builds the vif detach config spec."""
# Code inspired by nova: get_network_detach_config_spec
client_factory = self._session.vim.client.factory
config_spec = client_factory.create('ns0:VirtualMachineConfigSpec')
virtual_device_config = client_factory.create(
'ns0:VirtualDeviceConfigSpec')
virtual_device_config.operation = "remove"
virtual_device_config.device = device
config_spec.deviceChange = [virtual_device_config]
return config_spec
def detach_vm_interface(self, vm_moref, device):
new_spec = self._build_vm_spec_detach(device)
task = self._session.invoke_api(self._session.vim,
'ReconfigVM_Task',
vm_moref,
spec=new_spec)
try:
self._session.wait_for_task(task)
LOG.info("Updated VM %(moref)s spec - detached an interface",
{'moref': vm_moref.value})
except Exception as e:
LOG.error("Failed to reconfigure vm moref %(moref)s: %(e)s",
{'moref': vm_moref.value, 'e': e})
def get_vm_interfaces_info(self, vm_moref):
hardware_devices = self._session.invoke_api(vim_util,
"get_object_property",
self._session.vim,
vm_moref,
"config.hardware.device")
return hardware_devices
def _get_device_port(self, device_id, mac_address):
vm_moref = self.get_vm_moref_obj(device_id)
hardware_devices = self.get_vm_interfaces_info(vm_moref)
if not hardware_devices:
return
if hardware_devices.__class__.__name__ == "ArrayOfVirtualDevice":
hardware_devices = hardware_devices.VirtualDevice
for device in hardware_devices:
if hasattr(device, 'macAddress'):
if device.macAddress == mac_address:
return device.backing.port
def update_port_security_policy(self, dvs_id, net_id, net_moref,
device_id, mac_address, status):
dvs_moref = self._get_dvs_moref_by_id(dvs_id)
port = self._get_device_port(device_id, mac_address)
if port:
self._update_port_security_policy(dvs_moref, port, status)
def update_vm_network(self, device, name='VM Network'):
# In order to live migrate need a common network for interfaces
client_factory = self._session.vim.client.factory
network_spec = client_factory.create('ns0:VirtualDeviceConfigSpec')
network_spec.operation = 'edit'
backing = client_factory.create(
'ns0:VirtualEthernetCardNetworkBackingInfo')
backing.deviceName = name
device.backing = backing
network_spec.device = device
return network_spec
def update_vm_opaque_spec(self, vif_info, device):
"""Updates the backing for the VIF spec."""
client_factory = self._session.vim.client.factory
network_spec = client_factory.create('ns0:VirtualDeviceConfigSpec')
network_spec.operation = 'edit'
backing = client_factory.create(
'ns0:VirtualEthernetCardOpaqueNetworkBackingInfo')
backing.opaqueNetworkId = vif_info['nsx_id']
backing.opaqueNetworkType = 'nsx.LogicalSwitch'
# Configure externalId
device.externalId = vif_info['iface_id']
device.backing = backing
network_spec.device = device
return network_spec
def relocate_vm_spec(self, client_factory, respool_moref=None,
datastore_moref=None, host_moref=None,
disk_move_type="moveAllDiskBackingsAndAllowSharing"):
rel_spec = client_factory.create('ns0:VirtualMachineRelocateSpec')
if datastore_moref:
datastore = vim_util.get_moref(datastore_moref, 'Datastore')
else:
datastore = None
rel_spec.datastore = datastore
host = vim_util.get_moref(host_moref, 'HostSystem')
rel_spec.host = host
res_pool = vim_util.get_moref(respool_moref, 'ResourcePool')
rel_spec.pool = res_pool
return rel_spec
def relocate_vm(self, vm_ref, respool_moref=None, datastore_moref=None,
host_moref=None,
disk_move_type="moveAllDiskBackingsAndAllowSharing"):
client_factory = self._session.vim.client.factory
rel_spec = self.relocate_vm_spec(client_factory, respool_moref,
datastore_moref, host_moref,
disk_move_type)
task = self._session.invoke_api(self._session.vim, "RelocateVM_Task",
vm_ref, spec=rel_spec)
self._session.wait_for_task(task)
class ClusterManager(VCManagerBase):
"""Management class for Cluster related VC tasks."""
def _reconfigure_cluster(self, session, cluster, config_spec):
"""Reconfigure a cluster in vcenter"""
try:
reconfig_task = session.invoke_api(
session.vim, "ReconfigureComputeResource_Task",
cluster, spec=config_spec, modify=True)
session.wait_for_task(reconfig_task)
except Exception as excep:
LOG.exception('Failed to reconfigure cluster %s', excep)
def _create_vm_group_spec(self, client_factory, name, vm_refs,
group=None):
if group is None:
group = client_factory.create('ns0:ClusterVmGroup')
group.name = name
operation = 'add'
else:
operation = 'edit'
# On vCenter UI, it is not possible to create VM group without
# VMs attached to it. But, using APIs, it is possible to create
# VM group without VMs attached. Therefore, check for existence
# of vm attribute in the group to avoid exceptions
if hasattr(group, 'vm'):
group.vm += vm_refs
else:
group.vm = vm_refs
group_spec = client_factory.create('ns0:ClusterGroupSpec')
group_spec.operation = operation
group_spec.info = group
return [group_spec]
def _create_cluster_rules_spec(self, client_factory, name, vm_group_name,
host_group_name):
rules_spec = client_factory.create('ns0:ClusterRuleSpec')
rules_spec.operation = 'add'
policy_class = 'ns0:ClusterVmHostRuleInfo'
rules_info = client_factory.create(policy_class)
rules_info.enabled = True
rules_info.mandatory = False
rules_info.name = name
rules_info.vmGroupName = vm_group_name
rules_info.affineHostGroupName = host_group_name
rules_spec.info = rules_info
return rules_spec
def _group_name(self, index, host_group_names):
return 'neutron-group-%s-%s' % (index, host_group_names[index - 1])
def _rule_name(self, index, host_group_names):
return 'neutron-rule-%s-%s' % (index, host_group_names[index - 1])
def get_configured_vms(self, resource_id, host_group_names):
n_host_groups = len(host_group_names)
session = self._session
resource = vim_util.get_moref(resource_id, 'ResourcePool')
# TODO(garyk): cache the cluster details
cluster = session.invoke_api(
vim_util, "get_object_property", self._session.vim, resource,
"owner")
cluster_config = session.invoke_api(
vim_util, "get_object_property", self._session.vim, cluster,
"configurationEx")
configured_vms = []
for index in range(n_host_groups):
vm_group = None
entry_id = index + 1
groups = []
if hasattr(cluster_config, 'group'):
groups = cluster_config.group
for group in groups:
if self._group_name(entry_id, host_group_names) == group.name:
vm_group = group
break
if vm_group and hasattr(vm_group, 'vm'):
for vm in vm_group.vm:
configured_vms.append(vm.value)
return configured_vms
def update_cluster_edge_failover(self, resource_id, vm_moids,
host_group_names):
"""Updates cluster for vm placement using DRS"""
session = self._session
resource = vim_util.get_moref(resource_id, 'ResourcePool')
# TODO(garyk): cache the cluster details
cluster = session.invoke_api(
vim_util, "get_object_property", self._session.vim, resource,
"owner")
cluster_config = session.invoke_api(
vim_util, "get_object_property", self._session.vim, cluster,
"configurationEx")
vms = [vim_util.get_moref(vm_moid, 'VirtualMachine')
if vm_moid else None
for vm_moid in vm_moids]
client_factory = session.vim.client.factory
config_spec = client_factory.create('ns0:ClusterConfigSpecEx')
num_host_groups = len(host_group_names)
rules = []
if hasattr(cluster_config, 'rule'):
rules = cluster_config.rule
for index, vm in enumerate(vms, start=1):
if not vm:
continue
vmGroup = None
groups = []
if hasattr(cluster_config, 'group'):
groups = cluster_config.group
for group in groups:
if self._group_name(index, host_group_names) == group.name:
vmGroup = group
break
# Create/update the VM group
groupSpec = self._create_vm_group_spec(
client_factory,
self._group_name(index, host_group_names),
[vm], vmGroup)
config_spec.groupSpec.append(groupSpec)
config_rule = None
# Create the config rule if it does not exist
for rule in rules:
if self._rule_name(index, host_group_names) == rule.name:
config_rule = rule
break
if config_rule is None and index <= num_host_groups:
ruleSpec = self._create_cluster_rules_spec(
client_factory, self._rule_name(index, host_group_names),
self._group_name(index, host_group_names),
host_group_names[index - 1])
config_spec.rulesSpec.append(ruleSpec)
self._reconfigure_cluster(session, cluster, config_spec)
def validate_host_groups(self, resource_id, host_group_names):
session = self._session
resource = vim_util.get_moref(resource_id, 'ResourcePool')
cluster = session.invoke_api(
vim_util, "get_object_property", self._session.vim, resource,
"owner")
client_factory = session.vim.client.factory
config_spec = client_factory.create('ns0:ClusterConfigSpecEx')
cluster_config = session.invoke_api(
vim_util, "get_object_property", self._session.vim, cluster,
"configurationEx")
groups = []
if hasattr(cluster_config, 'group'):
groups = cluster_config.group
for host_group_name in host_group_names:
found = False
for group in groups:
if host_group_name == group.name:
found = True
break
if not found:
LOG.error("%s does not exist", host_group_name)
raise exceptions.NotFound()
update_cluster = False
num_host_groups = len(host_group_names)
rules = []
if hasattr(cluster_config, 'rule'):
rules = cluster_config.rule
# Ensure that the VM groups are created
for index in range(num_host_groups):
entry_id = index + 1
vmGroup = None
for group in groups:
if self._group_name(entry_id, host_group_names) == group.name:
vmGroup = group
break
if vmGroup is None:
groupSpec = self._create_vm_group_spec(
client_factory,
self._group_name(entry_id, host_group_names),
[], vmGroup)
config_spec.groupSpec.append(groupSpec)
update_cluster = True
config_rule = None
# Create the config rule if it does not exist
for rule in rules:
if self._rule_name(entry_id, host_group_names) == rule.name:
config_rule = rule
break
if config_rule is None and index < num_host_groups:
ruleSpec = self._create_cluster_rules_spec(
client_factory, self._rule_name(entry_id,
host_group_names),
self._group_name(entry_id, host_group_names),
host_group_names[index - 1])
config_spec.rulesSpec.append(ruleSpec)
update_cluster = True
if update_cluster:
try:
self._reconfigure_cluster(session, cluster, config_spec)
except Exception as e:
LOG.error('Unable to update cluster for host groups %s', e)
def _delete_vm_group_spec(self, client_factory, name):
group_spec = client_factory.create('ns0:ClusterGroupSpec')
group = client_factory.create('ns0:ClusterVmGroup')
group.name = name
group_spec.operation = 'remove'
group_spec.removeKey = name
group_spec.info = group
return [group_spec]
def _delete_cluster_rules_spec(self, client_factory, rule):
rules_spec = client_factory.create('ns0:ClusterRuleSpec')
rules_spec.operation = 'remove'
rules_spec.removeKey = int(rule.key)
policy_class = 'ns0:ClusterVmHostRuleInfo'
rules_info = client_factory.create(policy_class)
rules_info.name = rule.name
rules_info.vmGroupName = rule.vmGroupName
rules_info.affineHostGroupName = rule.affineHostGroupName
rules_spec.info = rules_info
return rules_spec
def cluster_host_group_cleanup(self, resource_id, host_group_names):
n_host_groups = len(host_group_names)
session = self._session
resource = vim_util.get_moref(resource_id, 'ResourcePool')
# TODO(garyk): cache the cluster details
cluster = session.invoke_api(
vim_util, "get_object_property", self._session.vim, resource,
"owner")
client_factory = session.vim.client.factory
config_spec = client_factory.create('ns0:ClusterConfigSpecEx')
cluster_config = session.invoke_api(
vim_util, "get_object_property", self._session.vim, cluster,
"configurationEx")
groups = []
if hasattr(cluster_config, 'group'):
groups = cluster_config.group
rules = []
if hasattr(cluster_config, 'rule'):
rules = cluster_config.rule
groupSpec = []
ruleSpec = []
for index in range(n_host_groups):
entry_id = index + 1
for group in groups:
if self._group_name(entry_id, host_group_names) == group.name:
groupSpec.append(self._delete_vm_group_spec(
client_factory, group.name))
# Delete the config rule if it exists
for rule in rules:
if self._rule_name(entry_id, host_group_names) == rule.name:
ruleSpec.append(self._delete_cluster_rules_spec(
client_factory, rule))
if groupSpec:
config_spec.groupSpec = groupSpec
if ruleSpec:
config_spec.rulesSpec = ruleSpec
if groupSpec or ruleSpec:
self._reconfigure_cluster(session, cluster, config_spec)
class VCManager(DvsManager, VMManager, ClusterManager):
"""Management class for all vc related tasks."""