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 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 _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 _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'))
