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_router_version(self):
network = objects.NetworkTestObj(self.neutron, self.nb_api)
self.addCleanup(network.close)
network_id = network.create()
self.assertTrue(network.exists())
subnet = objects.SubnetTestObj(self.neutron, self.nb_api, network_id)
self.addCleanup(subnet.close)
subnet_id = subnet.create()
self.assertTrue(subnet.exists())
router = objects.RouterTestObj(self.neutron, self.nb_api)
self.addCleanup(router.close)
router_id = router.create()
self.assertTrue(router.exists())
prev_version = self.nb_api.get(l3.LogicalRouter(id=router_id)).version
subnet_msg = {'subnet_id': subnet_id}
self.neutron.add_interface_router(router_id, body=subnet_msg)
version = self.nb_api.get(l3.LogicalRouter(id=router_id)).version
self.assertGreater(version, prev_version)
prev_version = version
self.neutron.remove_interface_router(router_id, body=subnet_msg)
version = self.nb_api.get(l3.LogicalRouter(id=router_id)).version
self.assertGreater(version, prev_version)
router.close()
self.assertFalse(router.exists())
subnet.close()
self.assertFalse(subnet.exists())
network.close()
self.assertFalse(network.exists())
def __init__(self, topology, router_id, subnet_ids):
"""Create a router in the topology. Add router interfaces for each
subnet.
:param topology: The topology to which the router belongs
:type topology: Topology
:param router_id: The ID of the router. Created in Topology.
:type router_id: Number (opaque)
:param subnet_ids: List of subnets to which the router is connected
:type subnet_ids: List
"""
self.topology = topology
self.router_id = router_id
self.subnet_ids = subnet_ids
self.router = objects.RouterTestObj(
self.topology.neutron,
self.topology.nb_api,
)
self.router.create(router={
'admin_state_up': True
})
self.router_interfaces = {}
for subnet_id in self.subnet_ids:
subnet = self.topology.subnets[subnet_id]
subnet_uuid = subnet.subnet.subnet_id
router_interface = self.router.add_interface(subnet_id=subnet_uuid)
self.router_interfaces[subnet_id] = router_interface
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 test_router_version(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()
self.assertTrue(subnet.exists())
router_id = router.create()
self.assertTrue(router.exists())
version = self.nb_api.get_router(router_id).get_version()
self.assertEqual(version, 0)
subnet_msg = {'subnet_id': subnet_id}
self.neutron.add_interface_router(router_id, body=subnet_msg)
version = self.nb_api.get_router(router_id).get_version()
self.assertEqual(version, 1)
self.neutron.remove_interface_router(router_id, body=subnet_msg)
version = self.nb_api.get_router(router_id).get_version()
self.assertEqual(version, 2)
router.close()
self.assertFalse(router.exists())
subnet.close()
self.assertFalse(subnet.exists())
network.close()
self.assertFalse(network.exists())
def test_disassociate_floatingip(self):
with self._prepare_ext_net() as external_network_id:
router = self.store(
objects.RouterTestObj(self.neutron, self.nb_api))
fip = self.store(
objects.FloatingipTestObj(self.neutron, self.nb_api))
router_para = {
'name': 'myrouter1', 'admin_state_up': True,
'external_gateway_info': {"network_id": external_network_id}}
router.create(router=router_para)
self.assertTrue(router.exists())
# private network
private_network = self.store(
objects.NetworkTestObj(self.neutron, self.nb_api))
private_network_id = private_network.create()
self.assertTrue(private_network.exists())
# private subnet
priv_subnet = self.store(objects.SubnetTestObj(
self.neutron,
self.nb_api,
private_network_id,
))
private_subnet_para = {'cidr': '10.0.0.0/24',
'ip_version': 4,
'network_id': private_network_id}
priv_subnet_id = priv_subnet.create(private_subnet_para)
self.assertTrue(priv_subnet.exists())
router_interface = router.add_interface(subnet_id=priv_subnet_id)
router_lport = self.nb_api.get(
l2.LogicalPort(id=router_interface['port_id']))
self.assertIsNotNone(router_lport)
port = self.store(
objects.PortTestObj(self.neutron,
self.nb_api, private_network_id))
port_id = port.create()
self.assertIsNotNone(port.get_logical_port())
fip_para = {'floating_network_id': external_network_id,
'port_id': port_id}
# create
fip.create(fip_para)
self.assertTrue(fip.exists())
# disassociate with port
fip.update({})
fip_obj = fip.get_floatingip()
self.assertIsNone(fip_obj.lport)
fip.close()
self.assertFalse(fip.exists())
port.close()
self.assertFalse(port.exists())
router.close()
self.assertFalse(router.exists())
priv_subnet.close()
self.assertFalse(priv_subnet.exists())
def test_create_delete_router(self):
router = self.store(objects.RouterTestObj(self.neutron, self.nb_api))
router_id = router.create()
self.assertTrue(router.exists())
version1 = self.nb_api.get_router(router_id).get_version()
router.update()
self.assertTrue(router.exists())
version2 = self.nb_api.get_router(router_id).get_version()
self.assertTrue(version1 != version2)
router.close()
self.assertFalse(router.exists())
def test_create_delete_router(self):
router = objects.RouterTestObj(self.neutron, self.nb_api)
self.addCleanup(router.close)
router_id = router.create()
self.assertTrue(router.exists())
version1 = self.nb_api.get(l3.LogicalRouter(id=router_id)).version
router.update()
self.assertTrue(router.exists())
version2 = self.nb_api.get(l3.LogicalRouter(id=router_id)).version
self.assertTrue(version1 != version2)
router.close()
self.assertFalse(router.exists())
def test_delete_router_interface_port(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({
'cidr': '91.126.188.0/24',
'ip_version': 4,
'network_id': network_id
})
router_id = router.create()
self.assertTrue(router.exists())
interface_msg = {'subnet_id': subnet_id}
router_l = self.neutron.add_interface_router(router_id,
body=interface_msg)
routers = self.nb_api.get_all(l3.LogicalRouter)
router2 = None
for r in routers:
if r.id == router_l['id']:
router2 = r
break
self.assertIsNotNone(router2)
interface_port = self.neutron.show_port(router_l['port_id'])
self.assertRaises(n_exc.Conflict, self.neutron.delete_port,
interface_port['port']['id'])
self.assertIsNotNone(
self.nb_api.get(l2.LogicalPort(id=interface_port['port']['id'])))
self.neutron.remove_interface_router(router.router_id,
body=interface_msg)
port2 = self.nb_api.get(
l2.LogicalPort(id=interface_port['port']['id']))
self.assertIsNone(port2)
subnet.close()
router.close()
network.close()
self.assertFalse(router.exists())
self.assertFalse(network.exists())
def test_create_delete_router(self):
router = self.store(objects.RouterTestObj(self.neutron, self.nb_api))
router.create()
self.assertTrue(router.exists())
router.close()
self.assertFalse(router.exists())
def test_icmp_responder(self):
"""
Add a VM. Verify the icmp flow is there.
"""
network = self.store(objects.NetworkTestObj(self.neutron, self.nb_api))
network_id = network.create(network={'name': 'icmp_responder_test'})
subnet_obj = self.store(objects.SubnetTestObj(
self.neutron,
self.nb_api,
network_id,
))
subnet = {'network_id': network_id,
'cidr': '10.10.10.0/24',
'gateway_ip': '10.10.10.1',
'ip_version': 4,
'name': 'arp_responder_test',
'enable_dhcp': True}
subnet_id = subnet_obj.create(subnet)
flows_before = self._get_l3_lookup_table_flows()
router = self.store(objects.RouterTestObj(self.neutron, self.nb_api))
router_id = router.create()
subnet_msg = {'subnet_id': subnet_id}
interface = self.neutron.add_interface_router(router_id,
body=subnet_msg)
port_id = interface['port_id']
router_port = self.neutron.list_ports(id=port_id)['ports'][0]
router_ip = None
for ip in router_port['fixed_ips']:
if ip['subnet_id'] == subnet_id:
router_ip = ip['ip_address']
break
vm = self.store(objects.VMTestObj(self, self.neutron))
vm.create(network=network)
ip = vm.get_first_ipv4()
self.assertIsNotNone(ip)
flows_middle = self._get_l3_lookup_table_flows()
vm.close()
router.close()
time.sleep(test_const.DEFAULT_RESOURCE_READY_TIMEOUT)
flows_delta = [flow for flow in flows_middle
if flow not in flows_before]
self.assertIsNotNone(
self._find_icmp_responder_flow_by_ip(flows_delta, router_ip)
)
condition = lambda: self._check_icmp_flow_removal(router_ip)
try:
test_utils.wait_until_true(
condition, timeout=test_const.DEFAULT_RESOURCE_READY_TIMEOUT,
sleep=1,
exception=RuntimeError(
"Timed out waiting for icmp responder flow from %(ip)s"
" to be removed" % {'ip': router_ip}))
except Exception as e:
self.assertIsNone(e)
finally:
network.close()
def test_add_remove_bgp_network(self):
bgp_speaker = objects.BGPSpeakerTestObj(self.neutron, self.nb_api)
self.addCleanup(bgp_speaker.close)
bgp_speaker.create()
address_scope = objects.AddressScopeTestObj(self.neutron, self.nb_api)
self.addCleanup(address_scope.close)
as_id = address_scope.create()
private_subnetpool = objects.SubnetPoolTestObj(self.neutron,
self.nb_api)
self.addCleanup(private_subnetpool.close)
private_sp_id = private_subnetpool.create(
subnetpool={
'name': "private_sp",
'default_prefixlen': 24,
'prefixes': ["20.0.0.0/8"],
'address_scope_id': as_id
})
public_subnetpool = objects.SubnetPoolTestObj(self.neutron,
self.nb_api)
self.addCleanup(public_subnetpool.close)
public_sp_id = public_subnetpool.create(
subnetpool={
'name': "public_sp",
'default_prefixlen': 24,
'prefixes': ["172.24.4.0/24"],
'address_scope_id': as_id
})
public_network = objects.NetworkTestObj(self.neutron, self.nb_api)
self.addCleanup(public_network.close)
public_network_id = public_network.create(network={
'name': 'public',
'router:external': True
})
public_subnet = objects.SubnetTestObj(self.neutron, self.nb_api,
public_network_id)
self.addCleanup(public_subnet.close)
public_subnet.create(
subnet={
'ip_version': 4,
'network_id': public_network_id,
'subnetpool_id': public_sp_id
})
private_network = objects.NetworkTestObj(self.neutron, self.nb_api)
self.addCleanup(private_network.close)
private_network_id = private_network.create(network={'name': "public"})
private_subnet = objects.SubnetTestObj(self.neutron, self.nb_api,
private_network_id)
self.addCleanup(private_subnet.close)
private_sn_id = private_subnet.create(
subnet={
'ip_version': 4,
'network_id': private_network_id,
'subnetpool_id': private_sp_id
})
bgp_speaker.add_network(public_network_id)
router = objects.RouterTestObj(self.neutron, self.nb_api)
self.addCleanup(router.close)
router_id = router.create()
self.neutron.add_interface_router(router_id,
body={'subnet_id': private_sn_id})
self.neutron.add_gateway_router(router_id,
body={'network_id': public_network_id})
# Finnally, verify the route has been set in nb db.
nb_bgp_speaker = bgp_speaker.get_nb_bgp_speaker()
self.assertEqual(1, len(nb_bgp_speaker.prefix_routes))
vm = objects.VMTestObj(self, self.neutron)
self.addCleanup(vm.close)
vm_id = vm.create(network=private_network)
vm_port = self.neutron.list_ports(device_id=vm_id).get('ports')[0]
vm_port_id = vm_port.get('id')
fip = objects.FloatingipTestObj(self.neutron, self.nb_api)
self.addCleanup(fip.close)
fip.create({
'floating_network_id': public_network_id,
'port_id': vm_port_id
})
fip_addr = fip.get_floatingip().floating_ip_address
nb_bgp_speaker = bgp_speaker.get_nb_bgp_speaker()
self.assertEqual(1, len(nb_bgp_speaker.host_routes))
self.assertIn(
host_route.HostRoute(destination=netaddr.IPNetwork(fip_addr),
nexthop='172.24.4.100'),
nb_bgp_speaker.host_routes)
fip.update({'port_id': None})
nb_bgp_speaker = bgp_speaker.get_nb_bgp_speaker()
self.assertFalse(nb_bgp_speaker.host_routes)
bgp_speaker.remove_network(public_network_id)
nb_bgp_speaker = bgp_speaker.get_nb_bgp_speaker()
self.assertFalse(nb_bgp_speaker.prefix_routes)
def test_floatingip_version(self):
with self._prepare_ext_net() as external_network_id:
private_network = self.store(
objects.NetworkTestObj(self.neutron, self.nb_api))
private_network_id = private_network.create(
network={'name': 'private'})
self.assertTrue(private_network.exists())
priv_subnet = self.store(
objects.SubnetTestObj(
self.neutron,
self.nb_api,
private_network_id,
))
router = self.store(
objects.RouterTestObj(self.neutron, self.nb_api))
port = self.store(
objects.PortTestObj(self.neutron, self.nb_api,
private_network_id))
fip = self.store(
objects.FloatingipTestObj(self.neutron, self.nb_api))
router_para = {
'name': 'myrouter1',
'admin_state_up': True,
'external_gateway_info': {
"network_id": external_network_id
}
}
router.create(router=router_para)
self.assertTrue(router.exists())
private_subnet_para = {
'cidr': '10.0.0.0/24',
'ip_version': 4,
'network_id': private_network_id
}
priv_subnet_id = priv_subnet.create(private_subnet_para)
self.assertTrue(priv_subnet.exists())
router_interface = router.add_interface(subnet_id=priv_subnet_id)
router_lport = self.nb_api.get_logical_port(
router_interface['port_id'])
self.assertIsNotNone(router_lport)
port_id = port.create()
self.assertIsNotNone(port.get_logical_port())
fip_para = {'floating_network_id': external_network_id}
# create
new_fip = fip.create(fip_para)
self.assertTrue(fip.exists())
fip_id = new_fip['id']
prev_version = self.nb_api.get_floatingip(fip_id).get_version()
# associate with port
fip.update({'port_id': port_id})
fip_obj = fip.get_floatingip()
self.assertEqual(fip_obj.get_lport_id(), port_id)
version = self.nb_api.get_floatingip(fip_id).get_version()
self.assertGreater(version, prev_version)
prev_version = version
fip.update({})
fip_obj = fip.get_floatingip()
self.assertIsNone(fip_obj.get_lport_id())
version = self.nb_api.get_floatingip(fip_id).get_version()
self.assertGreater(version, prev_version)
fip.close()
self.assertFalse(fip.exists())
port.close()
self.assertFalse(port.exists())
router.close()
self.assertFalse(router.exists())
priv_subnet.close()
self.assertFalse(priv_subnet.exists())