def test_get_portgroup_mor_by_name(self):
dvs_name = "test_dvs"
port_group_name = fake_api.Constants.PORTGROUP_NAME
dvs = fake_api.DataObject()
dvs_config = fake_api.DataObject()
port_group_mors = []
pg1 = fake_api.create_network()
pg1.set("summary.name", "pg1")
port_group_mors.append(pg1)
pg2 = fake_api.create_network()
pg2.set("summary.name", port_group_name)
port_group_mors.append(pg2)
dvs_config.ManagedObjectReference = port_group_mors
with contextlib.nested(
mock.patch.object(vim_util,
'get_properties_for_a_collection_of_objects',
return_value=port_group_mors),
mock.patch.object(network_util,
"get_dvs_mor_by_name",
return_value=dvs),
mock.patch.object(vim_util,
"get_dynamic_property",
return_value=dvs_config)):
port_group = network_util.get_portgroup_mor_by_name(
self.session, dvs_name, port_group_name)
self.assertEqual(port_group.value, pg2.value)
def test_post_create_port_nic_devices_none(self):
try:
vm_id = fake_vmware_api.Constants.VM_UUID
network_uuid = fake_vmware_api.Constants.PORTGROUP_NAME
port = model.Port(name=None,
mac_address=None,
ipaddresses=None,
vm_id=vm_id,
port_status=constants.PORT_STATUS_UP,
network_uuid=network_uuid)
updateSet = fake_vmware_api.DataObject()
updateSet.version = 1
filterSet = []
updateSet.filterSet = filterSet
propFilterUpdate = fake_vmware_api.DataObject()
filterSet.append(propFilterUpdate)
objectSet = []
propFilterUpdate.objectSet = objectSet
objectUpdate = fake_vmware_api.DataObject()
objectSet.append(objectUpdate)
with mock.patch.object(vim_util, "wait_for_updates_ex",
return_value=updateSet):
self.vc_driver.post_create_port(port)
except Exception:
self.assertFalse(fake_vmware_api.
is_task_done("ReconfigureDVPort_Task"))
def test_post_create_port_vm_deleted(self):
vm_id = fake_vmware_api.Constants.VM_UUID
network_uuid = fake_vmware_api.Constants.PORTGROUP_NAME
port = model.Port(name=None,
mac_address=None,
ipaddresses=None,
vm_id=vm_id,
port_status=constants.PORT_STATUS_UP,
network_uuid=network_uuid)
updateSet = fake_vmware_api.DataObject()
updateSet.version = 1
filterSet = []
updateSet.filterSet = filterSet
propFilterUpdate = fake_vmware_api.DataObject()
filterSet.append(propFilterUpdate)
objectSet = []
propFilterUpdate.objectSet = objectSet
objectUpdate = fake_vmware_api.DataObject()
objectUpdate.kind = "leave"
objectSet.append(objectUpdate)
with mock.patch.object(vim_util,
"wait_for_updates_ex",
return_value=updateSet) as wait_update:
self.vc_driver.post_create_port(port)
self.assertTrue(wait_update.called)
def test_process_update_set_objectset_none(self):
updateSet = fake_vmware_api.DataObject()
updateSet.version = 1
filterSet = []
updateSet.filterSet = filterSet
propFilterUpdate = fake_vmware_api.DataObject()
filterSet.append(propFilterUpdate)
propFilterUpdate.objectSet = None
events = self.vc_driver._process_update_set(updateSet)
self.assertEqual(len(events), 0)
def test_delete_port_group_exc(self, mock_get_dy_prop, mock_mor):
dvs_name = "test_dvs"
pg_name = fake_api.Constants.PORTGROUP_NAME
task_info = fake_api.DataObject()
task_info.name = "Destroy_Task"
task_info.key = "task-777"
task_info.state = "error"
task_info.error = fake_api.DataObject()
mock_mor.return_value = True
mock_get_dy_prop.return_value = task_info
raised = self.assertRaises(error_util.RunTimeError,
network_util.delete_port_group,
self.session, dvs_name, pg_name)
self.assertTrue(raised)
def test_enable_disable_port_of_vm_non_existing(self):
pg = fake_api._db_content["DistributedVirtualPortgroup"].values()[0]
backing = fake_api.DataObject()
backing.port = fake_api.DataObject()
backing.port.portgroupKey = pg.value
backing.port.portKey = pg.portKeys[0]
backing.port.switchUuid = fake_api._db_content[
"DistributedVirtualPortgroup"].keys()[0]
vm_key = fake_api._db_content["VirtualMachine"].keys()[0]
fake_api._db_content["VirtualMachine"][vm_key].propSet[
6].val.VirtualDevice[0].backing = backing
self.assertFalse(
network_util.enable_disable_port_of_vm(
self.session,
fake_api._db_content["VirtualMachine"].values()[0],
"11:99:88:77:66:ab", True))
def test_create_port_invalid_cluster(self):
vm_id = fake_vmware_api.Constants.VM_UUID
vlan = model.Vlan(vlan_ids=["1001"])
network_config = model.NetworkConfig(vlan)
network = model.Network(name="net-1234",
network_type=p_const.TYPE_VLAN,
config=network_config)
net_id = "net"
port = model.Port(name=None,
mac_address=None,
ipaddresses=None,
vm_id=vm_id)
virtual_nic = model.VirtualNic(mac_address=None,
port_uuid=None,
vm_id=vm_id,
vm_name=None,
nic_type=None,
pg_id=None)
cluster_mor = fake_vmware_api.DataObject()
cluster_mor.value = "invalid_id"
cache.VCCache.add_cluster_mor_for_vm(vm_id, cluster_mor)
exc = self.assertRaises(error.VcenterConfigurationError,
self.vc_driver.create_port, network, net_id,
port, virtual_nic)
self.assertIn("Cluster for VM %s could not be determined" % vm_id,
str(exc))
def test_create_port_group_existing(self, mock_get_prop, mock_mor):
dvs_name = "test_dvs"
pg_name = fake_api.Constants.PORTGROUP_NAME
vlanid = "100"
pg = fake_api.DataObject()
defaultPortConfig = fake_api.DataObject()
vlan = fake_api.DataObject()
vlan.vlanId = vlanid
defaultPortConfig.vlan = vlan
port_group_config = fake_api.DataObject()
port_group_config.defaultPortConfig = defaultPortConfig
mock_mor.return_value = pg
mock_get_prop.return_value = port_group_config
network_util.create_port_group(self.session, dvs_name, pg_name,
vlanid)
self.assertTrue(mock_get_prop.called)
def test_create_port_group_err_status(self, mock_get_dy_prop, mock_mor):
dvs_name = "test_dvs"
pg_name = fake_api.Constants.PORTGROUP_NAME
net_id = "net"
vlanid = "5001"
task_info = fake_api.DataObject()
task_info.name = "AddDVPortgroup_Task"
task_info.key = "task-1234"
task_info.state = "error"
task_info.error = fake_api.DataObject()
mock_mor.return_value = None
mock_get_dy_prop.return_value = task_info
raised = self.assertRaises(error_util.RunTimeError,
network_util.create_port_group,
self.session, dvs_name, pg_name, net_id,
vlanid)
self.assertTrue(raised)
def test_get_portgroup_mor_by_name_not_found(
self, mock_get_dy_pro, mock_get_dvs_mor, mock_get_pro):
dvs_name = "test_dvs"
port_group_name = fake_api.Constants.PORTGROUP_NAME
dvs = fake_api.DataObject()
dvs_config = fake_api.DataObject()
port_group_mors = []
pg1 = fake_api.create_network()
pg1.set("summary.name", "pg1")
port_group_mors.append(pg1)
dvs_config.ManagedObjectReference = port_group_mors
mock_get_pro.return_value = port_group_mors
mock_get_dvs_mor.return_value = dvs
mock_get_dy_pro.return_value = dvs_config
port_group = network_util.get_portgroup_mor_by_name(
self.session, dvs_name, port_group_name)
self.assertIsNone(port_group)
def test_process_update_set_leave(self):
updateSet = fake_vmware_api.DataObject()
updateSet.version = 1
filterSet = []
updateSet.filterSet = filterSet
propFilterUpdate = fake_vmware_api.DataObject()
filterSet.append(propFilterUpdate)
objectSet = []
propFilterUpdate.objectSet = objectSet
objectUpdate = fake_vmware_api.DataObject()
objectUpdate.obj = (
fake_vmware_api._db_content["VirtualMachine"].values()[0])
objectUpdate.kind = "leave"
changeSet = []
objectUpdate.changeSet = changeSet
objectSet.append(objectUpdate)
events = self.vc_driver._process_update_set(updateSet)
self.assertEqual(len(events), 0)
def test_delete_port_group_exc(self):
dvs_name = "test_dvs"
pg_name = fake_api.Constants.PORTGROUP_NAME
task_info = fake_api.DataObject()
task_info.name = "Destroy_Task"
task_info.key = "task-777"
task_info.state = "error"
task_info.error = fake_api.DataObject()
with contextlib.nested(
mock.patch.object(network_util,
"get_portgroup_mor_by_name",
return_value=True),
mock.patch.object(vim_util,
"get_dynamic_property",
return_value=task_info)):
raised = self.assertRaises(error_util.RunTimeError,
network_util.delete_port_group,
self.session, dvs_name, pg_name)
self.assertTrue(raised)
def test_get_portgroup_mor_by_net_id_with_net_name(self, mock_get_dy_pro,
mock_get_dvs_mor,
mock_get_pro):
dvs_name = "test_dvs"
port_group_name = fake_api.Constants.PORTGROUP_NAME
net_id = "net"
dvs = fake_api.DataObject()
dvs_config = fake_api.DataObject()
port_group_mors = []
pg2 = fake_api.create_network()
pg2.set("summary.name", net_id)
port_group_mors.append(pg2)
dvs_config.ManagedObjectReference = port_group_mors
mock_get_pro.return_value = port_group_mors
mock_get_dvs_mor.return_value = dvs
mock_get_dy_pro.return_value = dvs_config
port_group = network_util.get_portgroup_mor_by_net_id(
self.session, dvs_name, port_group_name, net_id)
self.assertEqual(port_group.value, pg2.value)
def test_create_port_group_with_invalid_vlanid(self, mock_get_dy_prop,
mock_mor):
dvs_name = "test_dvs"
pg_name = fake_api.Constants.PORTGROUP_NAME
vlanid = "100"
pg = fake_api.DataObject()
defaultPortConfig = fake_api.DataObject()
vlan = fake_api.DataObject()
vlan.vlanId = "200"
defaultPortConfig.vlan = vlan
port_group_config = fake_api.DataObject()
port_group_config.defaultPortConfig = defaultPortConfig
mock_mor.return_value = pg
mock_get_dy_prop.return_value = port_group_config
raised = self.assertRaises(error_util.RunTimeError,
network_util.create_port_group,
self.session,
dvs_name, pg_name, vlanid)
self.assertTrue(raised)
def test_process_update_set_snapshot(self):
updateSet = fake_vmware_api.DataObject()
updateSet.version = 1
filterSet = []
updateSet.filterSet = filterSet
propFilterUpdate = fake_vmware_api.DataObject()
filterSet.append(propFilterUpdate)
objectSet = []
propFilterUpdate.objectSet = objectSet
objectUpdate = fake_vmware_api.DataObject()
objectUpdate.obj = (
fake_vmware_api._db_content["VirtualMachine"].values()[0])
objectUpdate.kind = "modify"
changeSet = []
objectUpdate.changeSet = changeSet
for prop in objectUpdate.obj.propSet:
if prop.name == "runtime.host":
delattr(prop, "val")
changeSet.append(prop)
objectSet.append(objectUpdate)
events = self.vc_driver._process_update_set(updateSet)
self.assertEqual(len(events), 1)
self.assertEqual(events[0].event_type, constants.VM_CREATED)
self.assertTrue(
VcCache.get_vm_mor_for_uuid(fake_vmware_api.Constants.VM_UUID))
self.assertEqual(
VcCache.get_vm_mor_for_uuid(
fake_vmware_api.Constants.VM_UUID).value,
objectUpdate.obj.value)
obj_orig = objectUpdate.obj
objectUpdate.obj = copy.deepcopy(objectUpdate.obj)
object.__setattr__(objectUpdate.obj, 'value',
'aaaa-bbbbb-ccccc-ddddd-eeeee')
events = self.vc_driver._process_update_set(updateSet)
self.assertEqual(len(events), 0)
self.assertNotEqual(objectUpdate.obj.value, obj_orig.value)
self.assertEqual(
objectUpdate.obj.get('config.extraConfig["nvp.vm-uuid"]').value,
obj_orig.get('config.extraConfig["nvp.vm-uuid"]').value)
self.assertEqual(
VcCache.get_vm_mor_for_uuid(
fake_vmware_api.Constants.VM_UUID).value, obj_orig.value)
def test_remove_vm_for_uuid(self):
uuid = "VM-1234-5678"
vm_mor = fake_vmware_api.DataObject()
vm_mor.value = "vm-123"
cache.VCCache.add_vm_mor_for_uuid(uuid, vm_mor)
self.assertEqual(cache.VCCache.get_vm_mor_for_uuid(uuid), vm_mor)
self.assertEqual(cache.VCCache.get_vmuuid_for_moid(vm_mor.value), uuid)
cache.VCCache.remove_vm_for_uuid(uuid)
self.assertIsNone(cache.VCCache.get_vm_mor_for_uuid(uuid))
self.assertIsNone(cache.VCCache.get_vmuuid_for_moid(vm_mor.value))
def test_create_port_group_err_status(self):
dvs_name = "test_dvs"
pg_name = fake_api.Constants.PORTGROUP_NAME
vlanid = "5001"
task_info = fake_api.DataObject()
task_info.name = "AddDVPortgroup_Task"
task_info.key = "task-1234"
task_info.state = "error"
task_info.error = fake_api.DataObject()
with contextlib.nested(
mock.patch.object(network_util,
"get_portgroup_mor_by_name",
return_value=None),
mock.patch.object(vim_util,
"get_dynamic_property",
return_value=task_info)):
raised = self.assertRaises(error_util.RunTimeError,
network_util.create_port_group,
self.session, dvs_name, pg_name, vlanid)
self.assertTrue(raised)
def test_process_update_set_invalid(self):
updateSet = fake_vmware_api.DataObject()
updateSet.version = 1
filterSet = []
updateSet.filterSet = filterSet
propFilterUpdate = fake_vmware_api.DataObject()
filterSet.append(propFilterUpdate)
objectSet = []
propFilterUpdate.objectSet = objectSet
objectUpdate = fake_vmware_api.DataObject()
objectUpdate.obj = (
fake_vmware_api._db_content["ClusterComputeResource"].values()[0])
objectUpdate.kind = "enter"
changeSet = []
objectUpdate.changeSet = changeSet
for prop in objectUpdate.obj.propSet:
changeSet.append(prop)
objectSet.append(objectUpdate)
events = self.vc_driver._process_update_set(updateSet)
self.assertEqual(len(events), 0)
def test_get_portgroup_mor_by_names_plus_cluster_id(
self, mock_get_dy_pro, mock_get_dvs_mor, mock_get_pro):
dvs_name = "test_dvs"
network_id = fake_api.Constants.PORTGROUP_NAME
cluster_id = "cluster1"
dvs = fake_api.DataObject()
dvs_config = fake_api.DataObject()
port_group_mors = []
pg1 = fake_api.create_network()
pg1.set("summary.name", "pg1")
port_group_mors.append(pg1)
pg2 = fake_api.create_network()
pg2.set("summary.name", network_id + "-" + cluster_id)
port_group_mors.append(pg2)
dvs_config.ManagedObjectReference = port_group_mors
mock_get_pro.return_value = port_group_mors
mock_get_dvs_mor.return_value = dvs
mock_get_dy_pro.return_value = dvs_config
port_group = network_util.get_portgroup_mor_by_names(
self.session, dvs_name, network_id, cluster_id)
self.assertEqual(port_group, network_id + "-" + cluster_id)
def test_create_port_group_existing(self):
dvs_name = "test_dvs"
pg_name = fake_api.Constants.PORTGROUP_NAME
vlanid = "100"
pg = fake_api.DataObject()
defaultPortConfig = fake_api.DataObject()
vlan = fake_api.DataObject()
vlan.vlanId = vlanid
defaultPortConfig.vlan = vlan
port_group_config = fake_api.DataObject()
port_group_config.defaultPortConfig = defaultPortConfig
with contextlib.nested(
mock.patch.object(network_util,
"get_portgroup_mor_by_name",
return_value=pg),
mock.patch.object(
vim_util,
"get_dynamic_property",
return_value=port_group_config)) as (mor, get_prop):
network_util.create_port_group(self.session, dvs_name, pg_name,
vlanid)
self.assertTrue(get_prop.called)
def test_wait_until_dvs_portgroup_unavailable(self):
vm_ref = fake_api._db_content["VirtualMachine"].values()[0].obj
hs_key = fake_api._db_content["HostSystem"].keys()[0]
dvs_key = fake_api._db_content["DistributedVirtualPortgroup"].keys()[0]
dvs_obj = fake_api._db_content["DistributedVirtualPortgroup"][
dvs_key].obj
network_obj = fake_api.DataObject()
network_obj.name = fake_api.Constants.PORTGROUP_NAME
network_obj.ManagedObjectReference = [dvs_obj]
fake_api._db_content["HostSystem"][hs_key].propSet[2].val = network_obj
self.assertFalse(
network_util.wait_until_dvs_portgroup_available(
self.session, vm_ref, "invalid_pg", 3))
def test_process_update_set_invalid_extraConfig(self):
updateSet = fake_vmware_api.DataObject()
updateSet.version = 1
filterSet = []
updateSet.filterSet = filterSet
propFilterUpdate = fake_vmware_api.DataObject()
filterSet.append(propFilterUpdate)
objectSet = []
propFilterUpdate.objectSet = objectSet
objectUpdate = fake_vmware_api.DataObject()
objectUpdate.obj = (
fake_vmware_api._db_content["VirtualMachine"].values()[0])
objectUpdate.kind = "modify"
changeSet = []
objectUpdate.changeSet = changeSet
for prop in objectUpdate.obj.propSet:
if prop.name == 'config.extraConfig["nvp.vm-uuid"]':
delattr(prop, "val")
changeSet.append(prop)
objectSet.append(objectUpdate)
events = self.vc_driver._process_update_set(updateSet)
self.assertEqual(len(events), 0)
def test_create_port_group_with_invalid_vlanid(self):
dvs_name = "test_dvs"
pg_name = fake_api.Constants.PORTGROUP_NAME
vlanid = "100"
pg = fake_api.DataObject()
defaultPortConfig = fake_api.DataObject()
vlan = fake_api.DataObject()
vlan.vlanId = "200"
defaultPortConfig.vlan = vlan
port_group_config = fake_api.DataObject()
port_group_config.defaultPortConfig = defaultPortConfig
with contextlib.nested(
mock.patch.object(network_util,
"get_portgroup_mor_by_name",
return_value=pg),
mock.patch.object(vim_util,
"get_dynamic_property",
return_value=port_group_config)):
raised = self.assertRaises(error_util.RunTimeError,
network_util.create_port_group,
self.session, dvs_name, pg_name, vlanid)
self.assertTrue(raised)
def test_process_update_set_modify(self):
updateSet = fake_vmware_api.DataObject()
updateSet.version = 1
filterSet = []
updateSet.filterSet = filterSet
propFilterUpdate = fake_vmware_api.DataObject()
filterSet.append(propFilterUpdate)
objectSet = []
propFilterUpdate.objectSet = objectSet
objectUpdate = fake_vmware_api.DataObject()
objectUpdate.obj = (
fake_vmware_api._db_content["VirtualMachine"].values()[0])
objectUpdate.kind = "modify"
changeSet = []
objectUpdate.changeSet = changeSet
for prop in objectUpdate.obj.propSet:
if prop.name == "runtime.host":
delattr(prop, "val")
changeSet.append(prop)
objectSet.append(objectUpdate)
events = self.vc_driver._process_update_set(updateSet)
self.assertEqual(len(events), 1)
self.assertEqual(events[0].event_type, constants.VM_CREATED)
def test_add_vm_mor_for_uuid(self):
uuid = "VM-1234-5678"
vm_mor = fake_vmware_api.DataObject()
vm_mor.value = "vm-123"
cache.VCCache.add_vm_mor_for_uuid(uuid, vm_mor)
self.assertEqual(vm_mor, cache.VCCache.get_vm_mor_for_uuid(uuid))
def test_process_update_set_filterset_none(self):
updateSet = fake_vmware_api.DataObject()
updateSet.version = 1
updateSet.filterSet = None
events = self.vc_driver._process_update_set(updateSet)
self.assertEqual(len(events), 0)
