def test_context_undo_fail_db_update(self):
project = Project(name='p-{}'.format(self.id()))
self.api.project_create(project)
vn_og = VirtualNetwork(name='og-vn-{}'.format(self.id()),
parent_obj=project)
self.api.virtual_network_create(vn_og)
vmi_obj = VirtualMachineInterface('vmi-{}'.format(self.id()),
parent_obj=project)
vmi_obj.set_virtual_network(vn_og)
self.api.virtual_machine_interface_create(vmi_obj)
vmi_obj = self.api.virtual_machine_interface_read(id=vmi_obj.uuid)
# change virtual network for VMI
vn_next = VirtualNetwork(name='next-vn-{}'.format(self.id()),
parent_obj=project)
vn_next.uuid = self.api.virtual_network_create(vn_next)
vmi_obj.set_virtual_network(vn_next)
def stub(*args, **kwargs):
return False, (500, "Fake error")
with ExpectedException(HttpError):
with test_common.flexmocks([(self._api_server._db_conn,
'dbe_update', stub)]):
self.api.virtual_machine_interface_update(vmi_obj)
vmi_obj = self.api.virtual_machine_interface_read(id=vmi_obj.uuid)
vn_ref_fq_names = [n['to'] for n in vmi_obj.get_virtual_network_refs()]
self.assertEqual(len(vn_ref_fq_names), 1)
self.assertEqual(vn_ref_fq_names[0], vn_og.get_fq_name())
def test_context_undo_vpg_fail_db_update(self):
proj_obj, fabric_obj, pr_obj, pi_obj, vn_obj = \
self._create_vpg_prerequisites()
mock_zk = self._api_server._db_conn._zk_db
zk_alloc_count_before = mock_zk._vpg_id_allocator.get_alloc_count()
# Create vmi obj
vmi_name = '%s-1' % self.id()
vmi_obj = VirtualMachineInterface(vmi_name, parent_obj=proj_obj)
vmi_obj.set_virtual_network(vn_obj)
self.api.virtual_machine_interface_create(vmi_obj)
vmi_obj = self.api.virtual_machine_interface_read(id=vmi_obj.uuid)
# Create KV_Pairs for this VMI
pi_fq_name = pi_obj.get_fq_name()
fabric_name = fabric_obj.get_fq_name()
kv_pairs = self._create_kv_pairs(fabric_name, pi_fq_name)
vmi_obj.set_virtual_machine_interface_bindings(kv_pairs)
def stub(*args, **kwargs):
return False, (500, "Fake error")
with ExpectedException(HttpError):
with test_common.flexmocks([(self._api_server._db_conn,
'dbe_update', stub)]):
self.api.virtual_machine_interface_update(vmi_obj)
zk_alloc_count_after = mock_zk._vpg_id_allocator.get_alloc_count()
self.assertEqual(zk_alloc_count_before, zk_alloc_count_after)
def test_context_undo_fail_db_delete(self):
vn_obj = self.create_virtual_network('vn-l2-%s' % self.id())
vn_ipam_refs = vn_obj.get_network_ipam_refs()
mock_zk = self._api_server._db_conn._zk_db
zk_alloc_count_start = mock_zk._vn_id_allocator.get_alloc_count()
def stub(*args, **kwargs):
return (False, (500, "Fake error"))
with ExpectedException(HttpError):
with test_common.flexmocks(
[(self._api_server._db_conn, 'dbe_delete', stub)]):
self.api.virtual_network_delete(id=vn_obj.uuid)
# Make sure ipam refs still present (undo action recreated it)
vn_obj = self.api.virtual_network_read(id=vn_obj.uuid)
vn_ipam_refs_after_delete_fail = vn_obj.get_network_ipam_refs()
self.assertEqual(vn_ipam_refs[0]['to'],
vn_ipam_refs_after_delete_fail[0]['to'])
self.assertEqual(vn_ipam_refs[0]['uuid'],
vn_ipam_refs_after_delete_fail[0]['uuid'])
self.assertEqual(vn_ipam_refs[0]['attr'].ipam_subnets[0].subnet_uuid,
vn_ipam_refs_after_delete_fail[0][
'attr'].ipam_subnets[0].subnet_uuid)
# Make sure allocation counter stays the same
zk_alloc_count_current = mock_zk._vn_id_allocator.get_alloc_count()
self.assertEqual(zk_alloc_count_start, zk_alloc_count_current)
def test_context_undo_fail_db_delete(self):
project = Project(name='p-{}'.format(self.id()))
self.api.project_create(project)
vn = VirtualNetwork(name='vn-{}'.format(self.id()), parent_obj=project)
self.api.virtual_network_create(vn)
vmi_obj = VirtualMachineInterface('vmi-{}'.format(self.id()),
parent_obj=project)
vmi_obj.set_virtual_network(vn)
self.api.virtual_machine_interface_create(vmi_obj)
vmi_obj = self.api.virtual_machine_interface_read(id=vmi_obj.uuid)
mock_zk = self._api_server._db_conn._zk_db
zk_alloc_count_before = mock_zk._vpg_id_allocator.get_alloc_count()
def stub(*args, **kwargs):
return False, (500, "Fake error")
with ExpectedException(HttpError):
with test_common.flexmocks([(self._api_server._db_conn,
'dbe_delete', stub)]):
self.api.virtual_machine_interface_delete(
fq_name=vmi_obj.fq_name)
zk_alloc_count_after = mock_zk._vpg_id_allocator.get_alloc_count()
self.assertEqual(zk_alloc_count_before, zk_alloc_count_after)
def test_context_undo_vxlan_id_fail_db_create(self):
# enable vxlan routing on project
proj = self._vnc_lib.project_read(
fq_name=["default-domain", "default-project"])
proj.set_vxlan_routing(True)
self._vnc_lib.project_update(proj)
mock_zk = self._api_server._db_conn._zk_db
vn_obj = VirtualNetwork('%s-vn' % self.id())
vn_obj_properties = VirtualNetworkType(forwarding_mode='l3')
vn_obj_properties.set_vxlan_network_identifier(6000)
vn_obj.set_virtual_network_properties(vn_obj_properties)
def stub(*args, **kwargs):
return (False, (500, "Fake error"))
zk_alloc_count_start = mock_zk._vn_id_allocator.get_alloc_count()
with ExpectedException(HttpError):
with test_common.flexmocks(
[(self._api_server._db_conn, 'dbe_create', stub)]):
self.api.virtual_network_create(vn_obj)
# make sure allocation counter stays the same
zk_alloc_count_current = mock_zk._vn_id_allocator.get_alloc_count()
self.assertEqual(zk_alloc_count_start, zk_alloc_count_current)
def test_connection_status_change(self):
# up->down->up transition check
proj_id = str(uuid.uuid4())
proj_name = self.id() + 'verify-active'
test_case.get_keystone_client().tenants.add_tenant(proj_id, proj_name)
self._vnc_lib.project_read(id=proj_id)
conn_info = [
ConnectionState._connection_map[x]
for x in ConnectionState._connection_map if x[1] == 'Keystone'
][0]
self.assertThat(conn_info.status.lower(), Equals('up'))
fake_list_invoked = list()
def fake_list(*args, **kwargs):
fake_list_invoked.append(True)
raise Exception("Fake Keystone Projects List exception")
def verify_down():
conn_info = [
ConnectionState._connection_map[x]
for x in ConnectionState._connection_map if x[1] == 'Keystone'
][0]
self.assertThat(conn_info.status.lower(), Equals('down'))
with test_common.flexmocks([(self.openstack_driver._ks.tenants, 'list',
fake_list)]):
# wait for tenants.list is invoked for 2*self.resync_interval max
for x in range(10):
if len(fake_list_invoked) >= 1:
break
gevent.sleep(float(self.resync_interval) / 5.0)
# check that tenants.list was called once
self.assertThat(len(fake_list_invoked), Equals(1))
# wait for 1/10 of self.resync_interval to let code reach
# reset_connection in service
gevent.sleep(float(self.resync_interval) / 10.0)
# verify up->down
verify_down()
# should remain down
gevent.sleep(float(self.resync_interval) * 1.05)
verify_down()
self.assertThat(len(fake_list_invoked), Equals(2))
# sleep for a retry and verify down->up
gevent.sleep(self.resync_interval)
conn_info = [
ConnectionState._connection_map[x]
for x in ConnectionState._connection_map if x[1] == 'Keystone'
][0]
self.assertThat(conn_info.status.lower(), Equals('up'))
def test_context_undo_fail_db_create(self):
mock_zk = self._api_server._db_conn._zk_db
vn_obj = VirtualNetwork('%s-vn' % self.id())
zk_alloc_count_start = mock_zk._vn_id_allocator.get_alloc_count()
def stub(*args, **kwargs):
return (False, (500, "Fake error"))
with ExpectedException(HttpError):
with test_common.flexmocks(
[(self._api_server._db_conn, 'dbe_create', stub)]):
self.api.virtual_network_create(vn_obj)
zk_alloc_count_current = mock_zk._vn_id_allocator.get_alloc_count()
self.assertEqual(zk_alloc_count_start, zk_alloc_count_current)
def test_context_undo_vn_to_vxlan_id_fail_db_update(self):
# Enable vxlan routing on project
proj = self._vnc_lib.project_read(
fq_name=["default-domain", "default-project"])
proj.set_vxlan_routing(True)
self._vnc_lib.project_update(proj)
mock_zk = self._api_server._db_conn._zk_db
vn_obj = VirtualNetwork('%s-vn' % self.id())
self.api.virtual_network_create(vn_obj)
vn_fqname = mock_zk.get_vn_from_id(vn_obj.virtual_network_network_id)
vn_id = vn_obj.virtual_network_network_id
# Change vn to vxlan type
vxlan_id = 6000
vn_obj_properties = VirtualNetworkType(forwarding_mode='l3')
vn_obj_properties.set_vxlan_network_identifier(vxlan_id)
vn_obj_properties.set_forwarding_mode('l2_l3')
vn_obj.set_virtual_network_properties(vn_obj_properties)
def stub(*args, **kwargs):
return (False, (500, "Fake error"))
zk_alloc_count_start = mock_zk._vn_id_allocator.get_alloc_count()
with ExpectedException(HttpError):
with test_common.flexmocks(
[(self._api_server._db_conn, 'dbe_update', stub)]):
self.api.virtual_network_update(vn_obj)
# Make sure vxlan_id was dealocated
new_vxlan_fqname = mock_zk.get_vn_from_id(vxlan_id)
self.assertEqual(new_vxlan_fqname, None)
# Make sure vn id is the same
new_vn_id = vn_obj.virtual_network_network_id
self.assertEqual(vn_id, new_vn_id)
# Make sure fqname is the same fot vn_id
update_vn_fqname = mock_zk.get_vn_from_id(
vn_obj.virtual_network_network_id)
self.assertEqual(vn_fqname, update_vn_fqname)
# Make sure allocation counter stays the same
zk_alloc_count_current = mock_zk._vn_id_allocator.get_alloc_count()
self.assertEqual(zk_alloc_count_start, zk_alloc_count_current)
def test_context_undo_fail_db_create_routing_instance(self):
project = Project('project-%s' % self.id())
self.api.project_create(project)
vn = VirtualNetwork('vn-%s' % self.id(), parent_obj=project)
self.api.virtual_network_create(vn)
mock_zk = self._api_server._db_conn._zk_db
ri_name = 'ri-%s' % self.id()
ri_fq_name = vn.fq_name + [ri_name]
ri = RoutingInstance(ri_name, parent_obj=vn)
ri.set_routing_instance_is_default(False)
self.api.routing_instance_create(ri)
# Make sure we have right zk path (ri_fq_name)
ri_uuid, _ = mock_zk.get_fq_name_to_uuid_mapping(
'routing_instance', ri_fq_name)
self.assertTrue(ri_uuid is not None)
# Clean ri
self.api.routing_instance_delete(id=ri_uuid)
ri = RoutingInstance(ri_name, parent_obj=vn)
ri.set_routing_instance_is_default(False)
def stub(*args, **kwargs):
return (False, (500, "Fake error"))
with ExpectedException(HttpError):
with test_common.flexmocks([(self._api_server._db_conn,
'dbe_create', stub)]):
self.api.routing_instance_create(ri)
# Check if uuid for ri got released during undo action
# using same zk path parameters as above
with ExpectedException(TypeError):
mock_zk.get_fq_name_to_uuid_mapping('routing_instance', ri_fq_name)