def _wait_for_server_delete(self, timeout=const.DEFAULT_RESOURCE_READY_TIMEOUT): if self.server is None: return utils.wait_until_none(self._get_VM_port, timeout, exception=Exception('VM is not deleted'))
def test_create_router_interface(self): router = self.store(objects.RouterTestObj(self.neutron, self.nb_api)) network = self.store(objects.NetworkTestObj(self.neutron, self.nb_api)) network_id = network.create() self.assertTrue(network.exists()) subnet = self.store(objects.SubnetTestObj( self.neutron, self.nb_api, network_id, )) subnet_id = subnet.create() router_id = router.create() self.assertTrue(router.exists()) subnet_msg = {'subnet_id': subnet_id} port = self.neutron.add_interface_router(router_id, body=subnet_msg) port2 = self.nb_api.get_logical_port(port['port_id']) self.assertIsNotNone(port2) router.close() utils.wait_until_none( lambda: self.nb_api.get_logical_port(port['port_id']), exception=Exception('Port was not deleted') ) subnet.close() network.close() self.assertFalse(router.exists()) self.assertFalse(network.exists())
def test_create_update_subnet_without_dhcp(self): ovs = utils.OvsFlowsParser() flows_before_change = ovs.dump() network = self.store(objects.NetworkTestObj(self.neutron, self.nb_api)) network_id = network.create() subnet = { 'network_id': network_id, 'cidr': '10.20.0.0/24', 'gateway_ip': '10.20.0.1', 'ip_version': 4, 'name': 'subnet-test', 'enable_dhcp': False } subnet = self.neutron.create_subnet({'subnet': subnet}) subnet_id = subnet['subnet']['id'] time.sleep(utils.DEFAULT_CMD_TIMEOUT) flows_after_change = ovs.dump() # change dhcp updated_subnet = {'enable_dhcp': True} self.neutron.update_subnet(subnet_id, {'subnet': updated_subnet}) dhcp_ip = utils.wait_until_is_and_return( lambda: self.get_dhcp_ip(network_id, subnet_id), exception=Exception('DHCP IP was not generated')) self.assertFalse(self.check_dhcp_rule(flows_before_change, dhcp_ip)) self.assertFalse(self.check_dhcp_rule(flows_after_change, dhcp_ip)) wait_until_true( lambda: self.check_dhcp_rule(ovs.dump(), dhcp_ip), exception=Exception('DHCP ip was not found in OpenFlow rules'), timeout=5) network.close() utils.wait_until_none( lambda: self.check_dhcp_rule(ovs.dump(), dhcp_ip), exception=Exception('DHCP IP was not removed from OpenFlow rules'), timeout=30)
def _remove_vm(self, vm): vm_mac = vm.get_first_mac() vm.server.stop() vm.close() wait_until_none(lambda: 1 if any(self._get_vm_flows(vm_mac)) else None, timeout=60, exception=Exception('VM flow was not deleted'))
def test_create_router_interface(self): ovs = utils.OvsFlowsParser() flows_before_change = ovs.dump(self.integration_bridge) router = self.store(objects.RouterTestObj(self.neutron, self.nb_api)) network = self.store(objects.NetworkTestObj(self.neutron, self.nb_api)) network_id = network.create() subnet = {'network_id': network_id, 'cidr': '10.30.0.0/24', 'gateway_ip': '10.30.0.1', 'ip_version': 4, 'name': 'subnet-test', 'enable_dhcp': True} subnet = self.neutron.create_subnet({'subnet': subnet}) subnet_id = subnet['subnet']['id'] router_id = router.create() self.assertTrue(router.exists()) subnet_msg = {'subnet_id': subnet_id} time.sleep(utils.DEFAULT_CMD_TIMEOUT) self.neutron.add_interface_router(router_id, body=subnet_msg) dhcp_ip = utils.wait_until_is_and_return( lambda: self.get_dhcp_ip(network_id, subnet_id), exception=Exception('DHCP IP was not generated') ) flows_after_change = ovs.dump(self.integration_bridge) self.assertFalse(self.check_dhcp_rule(flows_before_change, dhcp_ip)) self.assertTrue(self.check_dhcp_rule(flows_after_change, dhcp_ip)) self.neutron.remove_interface_router(router_id, body=subnet_msg) router.close() network.close() utils.wait_until_none( lambda: self.check_dhcp_rule(ovs.dump(self.integration_bridge), dhcp_ip), exception=Exception('DHCP IP was not removed from OpenFlow rules'), timeout=30 )
def test_create_router_interface(self): ovs = utils.OvsFlowsParser() flows_before_change = ovs.dump(self.integration_bridge) router = self.store(objects.RouterTestObj(self.neutron, self.nb_api)) network = self.store(objects.NetworkTestObj(self.neutron, self.nb_api)) network_id = network.create() subnet = { 'network_id': network_id, 'cidr': '10.30.0.0/24', 'gateway_ip': '10.30.0.1', 'ip_version': 4, 'name': 'subnet-test', 'enable_dhcp': True } subnet = self.neutron.create_subnet({'subnet': subnet}) subnet_id = subnet['subnet']['id'] router_id = router.create() self.assertTrue(router.exists()) subnet_msg = {'subnet_id': subnet_id} time.sleep(const.DEFAULT_RESOURCE_READY_TIMEOUT) self.neutron.add_interface_router(router_id, body=subnet_msg) dhcp_ip = utils.wait_until_is_and_return( lambda: self.get_dhcp_ip(network_id, subnet_id), exception=Exception('DHCP IP was not generated')) flows_after_change = ovs.dump(self.integration_bridge) self.assertFalse(self.check_dhcp_rule(flows_before_change, dhcp_ip)) self.assertTrue(self.check_dhcp_rule(flows_after_change, dhcp_ip)) self.neutron.remove_interface_router(router_id, body=subnet_msg) router.close() network.close() utils.wait_until_none( lambda: self.check_dhcp_rule(ovs.dump(self.integration_bridge), dhcp_ip), exception=Exception('DHCP IP was not removed from OpenFlow rules'), timeout=30)
def _wait_for_server_delete(self, vm_mac, timeout=60): if self.server is None: return wait_until_none( lambda: get_port_by_mac(self.neutron, vm_mac), timeout, exception=Exception('VM is not deleted') )
def _wait_for_server_delete(self, timeout=60): if self.server is None: return wait_until_none( self._get_VM_port, timeout, exception=Exception('VM is not deleted') )
def _remove_vm(self, vm): vm_mac = vm.get_first_mac() vm.server.stop() vm.close() wait_until_none( lambda: 1 if any(self._get_vm_flows(vm_mac)) else None, timeout=60, exception=Exception('VM flow was not deleted') )
def test_remote_port(self): if cfg.CONF.core_plugin == DF_PLUGIN: return network = self.store(objects.NetworkTestObj(self.neutron, self.nb_api)) network_id = network.create(network={'name': 'network1'}) self.assertTrue(network.exists()) subnet_info = { 'network_id': network_id, 'cidr': '192.168.150.0/24', 'gateway_ip': '192.168.150.1', 'ip_version': 4, 'name': 'subnet1', 'enable_dhcp': True } subnet = self.store( objects.SubnetTestObj(self.neutron, self.nb_api, network_id=network_id)) subnet.create(subnet_info) self.assertTrue(subnet.exists()) port = self.store( objects.PortTestObj(self.neutron, self.nb_api, network_id)) port_body = { 'admin_state_up': True, 'name': 'port1', 'network_id': network_id, 'binding:profile': { 'port_key': 'remote_port', 'host_ip': '10.10.10.10' } } port.create(port=port_body) self.assertTrue(port.exists()) ovsdb = utils.OvsDBParser() utils.wait_until_true( lambda: self._get_wanted_tunnel_port(ovsdb, '10.10.10.10'), timeout=const.DEFAULT_RESOURCE_READY_TIMEOUT, sleep=2, exception=Exception('Could not get wanted tunnel port')) port.close() self.assertFalse(port.exists()) utils.wait_until_none( lambda: ovsdb.get_tunnel_ofport('10.10.10.10'), timeout=const.DEFAULT_RESOURCE_READY_TIMEOUT, sleep=2, exception=Exception('Could not delete wanted tunnel port')) subnet.close() network.close()
def test_reply_message(self): network = objects.NetworkTestObj(self.neutron, self.nb_api) self.addCleanup(network.close) network_id = network.create() subnet = objects.SubnetTestObj(self.neutron, self.nb_api, network_id) self.addCleanup(subnet.close) subnet_body = { 'network_id': network_id, 'cidr': '10.20.0.0/24', 'gateway_ip': '10.20.0.1', 'ip_version': 4, 'name': 'private', 'enable_dhcp': True } subnet.create(subnet=subnet_body) self.assertTrue(network.exists()) self.assertTrue(subnet.exists()) vm1 = objects.VMTestObj(self, self.neutron) self.addCleanup(vm1.close) vm1.create(network=network) self.assertIsNotNone(vm1.server.addresses['mynetwork']) mac1 = vm1.server.addresses['mynetwork'][0]['OS-EXT-IPS-MAC:mac_addr'] self.assertIsNotNone(mac1) vm2 = objects.VMTestObj(self, self.neutron) self.addCleanup(vm2.close) vm2.create(network=network) self.assertIsNotNone(vm2.server.addresses['mynetwork']) mac2 = vm2.server.addresses['mynetwork'][0]['OS-EXT-IPS-MAC:mac_addr'] self.assertIsNotNone(mac2) # wait util get the message we want self.set_wanted_vms.clear() utils.wait_until_true( lambda: self._get_all_wanted_vms_online(mac1, mac2), timeout=const.DEFAULT_RESOURCE_READY_TIMEOUT, sleep=1, exception=Exception('Could not get wanted online vm')) vm1.close() vm2.close() utils.wait_until_none( lambda: utils.find_logical_port(self.nb_api, ip=None, mac=mac1), timeout=const.DEFAULT_RESOURCE_READY_TIMEOUT, sleep=1, exception=Exception('Port was not deleted')) utils.wait_until_none( lambda: utils.find_logical_port(self.nb_api, ip=None, mac=mac2), timeout=const.DEFAULT_RESOURCE_READY_TIMEOUT, sleep=1, exception=Exception('Port was not deleted'))
def _remove_vm(self, vm): vm_mac = vm.get_first_mac() if cfg.CONF.df.enable_neutron_notifier: # test port status update vm.server.stop() utils.wait_until_true( lambda: self._is_VM_port_status(vm, 'DOWN'), timeout=60, exception=Exception('Port status not change to DOWN')) # delete vm vm.close() utils.wait_until_none(lambda: 1 if any(self._get_vm_flows(vm_mac)) else None, timeout=60, exception=Exception('VM flow was not deleted'))
def test_reply_message(self): network = self.store(objects.NetworkTestObj(self.neutron, self.nb_api)) network_id = network.create(network={'name': 'private'}) subnet = self.store(objects.SubnetTestObj(self.neutron, self.nb_api, network_id)) subnet_body = {'network_id': network_id, 'cidr': '10.20.0.0/24', 'gateway_ip': '10.20.0.1', 'ip_version': 4, 'name': 'private', 'enable_dhcp': True} subnet.create(subnet=subnet_body) self.assertTrue(network.exists()) self.assertTrue(subnet.exists()) vm1 = self.store(objects.VMTestObj(self, self.neutron)) vm1.create(network=network) self.assertIsNotNone(vm1.server.addresses['private']) mac1 = vm1.server.addresses['private'][0]['OS-EXT-IPS-MAC:mac_addr'] self.assertIsNotNone(mac1) vm2 = self.store(objects.VMTestObj(self, self.neutron)) vm2.create(network=network) self.assertIsNotNone(vm2.server.addresses['private']) mac2 = vm2.server.addresses['private'][0]['OS-EXT-IPS-MAC:mac_addr'] self.assertIsNotNone(mac2) #wait util get the message we want self.set_wanted_vms.clear() wait_until_true( lambda: self._get_all_wanted_vms_online(mac1, mac2), timeout=30, sleep=1, exception=Exception('Could not get wanted online vm') ) vm1.close() vm2.close() utils.wait_until_none( lambda: self._get_vm_port_by_mac_address(mac1), timeout=30, sleep=1, exception=Exception('Port was not deleted') ) utils.wait_until_none( lambda: self._get_vm_port_by_mac_address(mac2), timeout=30, sleep=1, exception=Exception('Port was not deleted') )
def test_reply_message(self): network = self.store(objects.NetworkTestObj(self.neutron, self.nb_api)) network_id = network.create(network={'name': 'private'}) subnet = self.store( objects.SubnetTestObj(self.neutron, self.nb_api, network_id)) subnet_body = { 'network_id': network_id, 'cidr': '10.20.0.0/24', 'gateway_ip': '10.20.0.1', 'ip_version': 4, 'name': 'private', 'enable_dhcp': True } subnet.create(subnet=subnet_body) self.assertTrue(network.exists()) self.assertTrue(subnet.exists()) vm1 = self.store(objects.VMTestObj(self, self.neutron)) vm1.create(network=network) self.assertIsNotNone(vm1.server.addresses['private']) mac1 = vm1.server.addresses['private'][0]['OS-EXT-IPS-MAC:mac_addr'] self.assertIsNotNone(mac1) vm2 = self.store(objects.VMTestObj(self, self.neutron)) vm2.create(network=network) self.assertIsNotNone(vm2.server.addresses['private']) mac2 = vm2.server.addresses['private'][0]['OS-EXT-IPS-MAC:mac_addr'] self.assertIsNotNone(mac2) #wait util get the message we want self.set_wanted_vms.clear() wait_until_true(lambda: self._get_all_wanted_vms_online(mac1, mac2), timeout=30, sleep=1, exception=Exception('Could not get wanted online vm')) vm1.close() vm2.close() utils.wait_until_none(lambda: self._get_vm_port_by_mac_address(mac1), timeout=30, sleep=1, exception=Exception('Port was not deleted')) utils.wait_until_none(lambda: self._get_vm_port_by_mac_address(mac2), timeout=30, sleep=1, exception=Exception('Port was not deleted'))
def test_create_update_subnet_without_dhcp(self): ovs = utils.OvsFlowsParser() flows_before_change = ovs.dump(self.integration_bridge) network, network_id, network_key = self._create_network() subnet = {'network_id': network_id, 'cidr': '10.20.0.0/24', 'gateway_ip': '10.20.0.1', 'ip_version': 4, 'name': 'subnet-test', 'enable_dhcp': False} subnet = self.neutron.create_subnet({'subnet': subnet}) subnet_id = subnet['subnet']['id'] time.sleep(const.DEFAULT_CMD_TIMEOUT) flows_after_change = ovs.dump(self.integration_bridge) # change dhcp updated_subnet = {'enable_dhcp': True} self.neutron.update_subnet(subnet_id, {'subnet': updated_subnet}) dhcp_ip = utils.wait_until_is_and_return( lambda: self.get_dhcp_ip(network_id, subnet_id), exception=Exception('DHCP IP was not generated') ) self.assertIsNotNone(dhcp_ip) self.assertFalse(utils.check_dhcp_network_rule( flows_before_change, network_key)) self.assertFalse(utils.check_dhcp_network_rule( flows_after_change, network_key)) utils.wait_until_true( lambda: utils.check_dhcp_network_rule( ovs.dump(self.integration_bridge), network_key), exception=Exception('DHCP ip was not found in OpenFlow rules'), timeout=5 ) network.close() utils.wait_until_none( lambda: utils.check_dhcp_network_rule( ovs.dump(self.integration_bridge), network_key), exception=Exception('DHCP IP was not removed from OpenFlow rules'), timeout=30 )
def test_notify_message(self): network = self.store(objects.NetworkTestObj(self.neutron, self.nb_api)) network_id = network.create() subnet = self.store( objects.SubnetTestObj(self.neutron, self.nb_api, network_id)) subnet_body = { 'network_id': network_id, 'cidr': '10.10.0.0/24', 'gateway_ip': '10.10.0.1', 'ip_version': 4, 'name': 'private', 'enable_dhcp': True } subnet.create(subnet=subnet_body) self.assertTrue(network.exists()) self.assertTrue(subnet.exists()) vm = self.store(objects.VMTestObj(self, self.neutron)) vm.create(network=network) self.assertIsNotNone(vm.server.addresses['mynetwork']) mac = vm.server.addresses['mynetwork'][0]['OS-EXT-IPS-MAC:mac_addr'] self.assertIsNotNone(mac) # wait util get the message we want utils.wait_until_true( lambda: self._get_wanted_vm_online(mac), timeout=const.DEFAULT_RESOURCE_READY_TIMEOUT, sleep=1, exception=Exception('Could not get wanted online vm')) # wait util get the message we want vm.close() utils.wait_until_true( lambda: self._get_wanted_vm_offline(mac), timeout=const.DEFAULT_RESOURCE_READY_TIMEOUT, sleep=1, exception=Exception('Could not get wanted offline vm')) utils.wait_until_none( lambda: utils.get_vm_port(self.nb_api, ip=None, mac=mac), timeout=const.DEFAULT_RESOURCE_READY_TIMEOUT, sleep=1, exception=Exception('Port was not deleted'))
def test_vm_multicast(self): network = self.store(objects.NetworkTestObj(self.neutron, self.nb_api)) network_id = network.create(network={'name': 'private'}) subnet = {'network_id': network_id, 'cidr': '10.200.0.0/24', 'gateway_ip': '10.200.0.1', 'ip_version': 4, 'name': 'private', 'enable_dhcp': True} subnet = self.neutron.create_subnet({'subnet': subnet}) ovs = utils.OvsFlowsParser() vm = self.store(objects.VMTestObj(self, self.neutron)) vm.create(network=network) ip = vm.get_first_ipv4() self.assertIsNotNone(ip) self.assertIsNotNone(vm.server.addresses['private']) mac = vm.server.addresses['private'][0]['OS-EXT-IPS-MAC:mac_addr'] self.assertIsNotNone(mac) metadataid = utils.wait_until_is_and_return( lambda: self._get_metadata_id(ovs.dump(), ip, mac), exception=Exception('Metadata id was not found in OpenFlow rules') ) port = utils.wait_until_is_and_return( lambda: self._get_vm_port(ip, mac), exception=Exception('No port assigned to VM') ) tunnel_key = port.get_tunnel_key() tunnel_key_hex = hex(tunnel_key) r = self._check_multicast_rule(ovs.dump(), metadataid, tunnel_key_hex) self.assertIsNotNone(r) vm.server.stop() vm.close() utils.wait_until_none( lambda: self.nb_api.get_logical_port(port.get_id()), exception=Exception('VM port was not deleted'), timeout=30 ) network.close()
def test_create_update_subnet_without_dhcp(self): ovs = utils.OvsFlowsParser() flows_before_change = ovs.dump(self.integration_bridge) network = self.store(objects.NetworkTestObj(self.neutron, self.nb_api)) network_id = network.create() subnet = {'network_id': network_id, 'cidr': '10.20.0.0/24', 'gateway_ip': '10.20.0.1', 'ip_version': 4, 'name': 'subnet-test', 'enable_dhcp': False} subnet = self.neutron.create_subnet({'subnet': subnet}) subnet_id = subnet['subnet']['id'] time.sleep(utils.DEFAULT_CMD_TIMEOUT) flows_after_change = ovs.dump(self.integration_bridge) # change dhcp updated_subnet = {'enable_dhcp': True} self.neutron.update_subnet(subnet_id, {'subnet': updated_subnet}) dhcp_ip = utils.wait_until_is_and_return( lambda: self.get_dhcp_ip(network_id, subnet_id), exception=Exception('DHCP IP was not generated') ) self.assertFalse(self.check_dhcp_rule(flows_before_change, dhcp_ip)) self.assertFalse(self.check_dhcp_rule(flows_after_change, dhcp_ip)) wait_until_true( lambda: self.check_dhcp_rule(ovs.dump(self.integration_bridge), dhcp_ip), exception=Exception('DHCP ip was not found in OpenFlow rules'), timeout=5 ) network.close() utils.wait_until_none( lambda: self.check_dhcp_rule(ovs.dump(self.integration_bridge), dhcp_ip), exception=Exception('DHCP IP was not removed from OpenFlow rules'), timeout=30 )
def _wait_for_server_delete(self, vm_mac, timeout=60): if self.server is None: return wait_until_none(lambda: get_port_by_mac(self.neutron, vm_mac), timeout, exception=Exception('VM is not deleted'))