def __init__(self, topology, subnet_id, cidr):
"""Create the subnet under the given topology, with the given ID, and
the given address range.
:param topology: The topology to which the subnet belongs
:type topology: Topology
:param subnet_id: The subnet's ID in the topology. Created by topology
:type subnet_id: Number (Opaque)
:param cidr: The address range for this subnet. Format IP/MaskLen
:type cidr: String
"""
self.topology = topology
self.subnet_id = subnet_id
self.ports = []
self.subnet = objects.SubnetTestObj(
self.topology.neutron,
self.topology.nb_api,
self.topology.network.network_id
)
self.subnet.create(subnet={
'cidr': cidr,
'ip_version': 4,
'network_id': topology.network.network_id,
'host_routes': [
{
'destination': '1.1.1.0/24',
'nexthop': '2.2.2.2'
},
{
'destination': '1.1.2.0/24',
'nexthop': '3.3.3.3'
},
]
})
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 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 __init__(self, topology, network, subnet_id, cidr, enable_dhcp):
"""Create the subnet under the given topology, with the given ID, and
the given address range.
:param topology: The topology to which the subnet belongs
:type topology: Topology
:param network: The network to which the subnet belongs
:type network: NetworkTestObj
:param subnet_id: The subnet's ID in the topology. Created by topology
:type subnet_id: Number (Opaque)
:param cidr: The address range for this subnet. Format IP/MaskLen.
If it is None, the cidr will be allocated from
default subnetpool.
:type cidr: String
:param enable_dhcp: Whether to enable dhcp for this subnet.
:type cidr: Boolean
"""
self.topology = topology
self.subnet_id = subnet_id
self.ports = []
self.network = network
self.subnet = objects.SubnetTestObj(
self.topology.neutron,
self.topology.nb_api,
self.network.network_id
)
if cidr:
ip_version = self._get_ip_version(cidr)
self.subnet.create(subnet={
'cidr': cidr,
'enable_dhcp': enable_dhcp,
'ip_version': ip_version,
'network_id': self.network.network_id
})
else:
self.subnet.create()
def test_create_subnet_with_host_routes(self):
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_data = {
'cidr':
'192.168.199.0/24',
'ip_version':
4,
'network_id':
network_id,
'host_routes': [
{
'destination': '1.1.1.0/24',
'nexthop': '2.2.2.2'
},
{
'destination': '1.1.2.0/24',
'nexthop': '3.3.3.3'
},
]
}
subnet.create(subnet_data)
lswitch = self.nb_api.get_lswitch(network_id)
subnet = lswitch.get_subnets()
self.assertEqual(
0, cmp(subnet_data['host_routes'], subnet[0].get_host_routes()))
def test_port_version(self):
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.create()
self.assertTrue(subnet.exists())
port = self.store(
objects.PortTestObj(self.neutron, self.nb_api, network_id))
port_id = port.create()
self.assertTrue(port.exists())
prev_version = self.nb_api.get_logical_port(port_id).get_version()
port.update()
self.assertTrue(port.exists())
version = self.nb_api.get_logical_port(port_id).get_version()
self.assertGreater(version, prev_version)
port.close()
self.assertFalse(port.exists())
subnet.close()
self.assertFalse(subnet.exists())
network.close()
self.assertFalse(network.exists())
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 _prepare_ext_net(self):
external_net = objects.find_first_network(self.neutron,
{'router:external': True})
if not external_net:
network = objects.NetworkTestObj(self.neutron, self.nb_api)
self.addCleanup(network.close)
external_net_para = {'name': 'public', 'router:external': True}
external_network_id = network.create(network=external_net_para)
self.assertTrue(network.exists())
ext_subnet = objects.SubnetTestObj(self.neutron, self.nb_api,
external_network_id)
self.addCleanup(ext_subnet.close)
external_subnet_para = {
'cidr': '192.168.199.0/24',
'ip_version': 4,
'network_id': external_network_id
}
ext_subnet.create(external_subnet_para)
self.assertTrue(ext_subnet.exists())
else:
external_network_id = external_net['id']
self.assertIsNotNone(external_network_id)
# return external network
yield external_network_id
if not external_net:
ext_subnet.close()
self.assertFalse(ext_subnet.exists())
network.close()
self.assertFalse(network.exists())
def test_port_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.create()
self.assertTrue(subnet.exists())
port = objects.PortTestObj(self.neutron, self.nb_api, network_id)
self.addCleanup(port.close)
port_id = port.create()
self.assertTrue(port.exists())
prev_version = self.nb_api.get(l2.LogicalPort(id=port_id)).version
port.update()
self.assertTrue(port.exists())
version = self.nb_api.get(l2.LogicalPort(id=port_id)).version
self.assertGreater(version, prev_version)
port.close()
self.assertFalse(port.exists())
subnet.close()
self.assertFalse(subnet.exists())
network.close()
self.assertFalse(network.exists())
def test_create_subnet_with_host_routes(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_data = {
'cidr':
'192.168.199.0/24',
'ip_version':
4,
'network_id':
network_id,
'host_routes': [
{
'destination': '1.1.1.0/24',
'nexthop': '2.2.2.2'
},
{
'destination': '1.1.2.0/24',
'nexthop': '3.3.3.3'
},
]
}
subnet.create(subnet_data)
db_subnet = subnet.get_subnet()
self.assertEqual(
subnet_data['host_routes'],
[host_route.to_struct() for host_route in db_subnet.host_routes])
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_remote_port(self):
network = objects.NetworkTestObj(self.neutron, self.nb_api)
self.addCleanup(network.close)
network_id = network.create()
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 = objects.SubnetTestObj(self.neutron,
self.nb_api,
network_id=network_id)
self.addCleanup(subnet.close)
subnet.create(subnet_info)
self.assertTrue(subnet.exists())
port = objects.PortTestObj(self.neutron, self.nb_api, network_id)
self.addCleanup(port.close)
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())
time.sleep(test_const.DEFAULT_CMD_TIMEOUT)
network_obj = network.get_network()['network']
network_type = network_obj['provider:network_type']
segmentation_id = network_obj['provider:segmentation_id']
port_num = self.vswitch_api.get_vtp_ofport(network_type)
port_unique_key = port.get_logical_port().unique_key
match = "reg7=" + str(hex(port_unique_key))
action = ("set_field:10.10.10.10" + "->tun_dst,set_field:" +
str(hex(segmentation_id)) + "->tun_id,output:" +
str(port_num))
ovs = utils.OvsFlowsParser()
matched = False
for flow in ovs.dump(self.integration_bridge):
if flow['table'] == str(const.EGRESS_TABLE):
if match in flow['match']:
matched = True
self.assertEqual(action, flow['actions'])
if not matched:
raise Exception("Can't find flows for remote port!")
def _create_network(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.create()
self.assertTrue(subnet.exists())
return network
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 _create_network(self):
network = self.store(objects.NetworkTestObj(self.neutron, self.nb_api))
network_id = network.create(network={'name': 'private'})
self.assertTrue(network.exists())
subnet = self.store(objects.SubnetTestObj(
self.neutron,
self.nb_api,
network_id,
))
subnet.create()
self.assertTrue(subnet.exists())
return network
def test_arp_responder(self):
"""
Add a VM. Verify it's ARP flow is there.
"""
network = self.store(objects.NetworkTestObj(self.neutron, self.nb_api))
network_id = network.create(network={'name': 'arp_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 = subnet_obj.create(subnet)
flows_before = self._get_arp_table_flows()
vm = self.store(objects.VMTestObj(self, self.neutron))
vm.create(network=network)
ip = vm.get_first_ipv4()
self.assertIsNotNone(ip)
flows_middle = self._get_arp_table_flows()
vm.server.stop()
vm.close()
eventlet.sleep(test_utils.DEFAULT_CMD_TIMEOUT)
flows_delta = [
flow for flow in flows_middle if flow not in flows_before
]
self.assertIsNotNone(
self._find_arp_responder_flow_by_ip(flows_delta, ip))
condition = lambda: self._check_arp_flow_removal(ip)
try:
utils.wait_until_true(
condition,
timeout=40,
sleep=1,
exception=RuntimeError(
"Timed out waiting for arp responedr flow from %(ip)s"
" to be removed" % {'ip': ip}))
except Exception as e:
self.assertIsNone(e)
finally:
network.close()
def test_anti_spoof_flows(self):
network = self.store(objects.NetworkTestObj(self.neutron, self.nb_api))
network_id = network.create(network={'name': 'test_network1'})
self.assertTrue(network.exists())
subnet_info = {'network_id': network_id,
'cidr': '192.168.130.0/24',
'gateway_ip': '192.168.130.1',
'ip_version': 4,
'name': 'test_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())
vm = self.store(objects.VMTestObj(self, self.neutron))
vm.create(network=network)
addresses = vm.server.addresses['test_network1']
self.assertIsNotNone(addresses)
ip = addresses[0]['addr']
self.assertIsNotNone(ip)
mac = addresses[0]['OS-EXT-IPS-MAC:mac_addr']
self.assertIsNotNone(mac)
port = utils.wait_until_is_and_return(
lambda: self._get_vm_port(ip, mac),
exception=Exception('No port assigned to VM')
)
ovsdb = utils.OvsDBParser()
of_port = ovsdb.get_ofport(port.get_id())
self.assertIsNotNone(of_port)
# Check if the associating flows were installed.
expected_flow_list = self._get_anti_spoof_expected_flows(
ip, mac, of_port
)
self._check_all_flows_existed(expected_flow_list)
vm.server.stop()
vm.close()
time.sleep(utils.DEFAULT_CMD_TIMEOUT)
# Check if the associating flows were removed.
expected_flow_list = self._get_anti_spoof_expected_flows(
ip, mac, of_port
)
self._check_not_flow_existed(expected_flow_list)
def test_create_delete_subnet(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())
self.assertEqual(subnet_id, subnet.get_subnet().id)
subnet.close()
self.assertFalse(subnet.exists())
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 test_add_remove_allowed_address_pairs(self):
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.create({
'cidr': '192.168.127.0/24',
'ip_version': 4,
'network_id': network_id
})
self.assertTrue(subnet.exists())
port = self.store(
objects.PortTestObj(self.neutron, self.nb_api, network_id))
expected_pairs = [{
"ip_address": "192.168.127.201",
"mac_address": "11:22:33:44:55:66"
}, {
"ip_address": "192.168.127.202",
"mac_address": "22:22:33:44:55:66"
}]
port.create({
'admin_state_up': True,
'name': 'port1',
'network_id': network_id,
'allowed_address_pairs': expected_pairs
})
lport = port.get_logical_port()
self.assertIsNotNone(lport)
real_pairs = lport.get_allow_address_pairs()
self.assertEqual(expected_pairs, real_pairs)
expected_pairs = [{
"ip_address": "192.168.127.211",
"mac_address": "33:22:33:44:55:66"
}, {
"ip_address": "192.168.127.212",
"mac_address": "44:22:33:44:55:66"
}]
port.update({'allowed_address_pairs': expected_pairs})
lport = port.get_logical_port()
self.assertIsNotNone(lport)
real_pairs = lport.get_allow_address_pairs()
self.assertEqual(expected_pairs, real_pairs)
def test_create_delete_subnet(self):
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())
self.assertEqual(subnet_id, subnet.get_subnet().get_id())
subnet.close()
self.assertFalse(subnet.exists())
network.close()
def test_add_remove_allowed_address_pairs(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.create({
'cidr': '192.168.127.0/24',
'ip_version': 4,
'network_id': network_id
})
self.assertTrue(subnet.exists())
port = objects.PortTestObj(self.neutron, self.nb_api, network_id)
self.addCleanup(port.close)
expected_pairs = [{
"ip_address": "192.168.127.201",
"mac_address": "00:22:33:44:55:66"
}, {
"ip_address": "192.168.127.202",
"mac_address": "22:22:33:44:55:66"
}]
port.create({
'admin_state_up': True,
'name': 'port1',
'network_id': network_id,
'allowed_address_pairs': expected_pairs
})
lport = port.get_logical_port()
self.assertIsNotNone(lport)
real_pairs = [aap.to_struct() for aap in lport.allowed_address_pairs]
self.assertItemsEqual(expected_pairs, real_pairs)
expected_pairs = [{
"ip_address": "192.168.127.211",
"mac_address": "00:22:33:44:55:66"
}, {
"ip_address": "192.168.127.212",
"mac_address": "44:22:33:44:55:66"
}]
port.update({'allowed_address_pairs': expected_pairs})
lport = port.get_logical_port()
self.assertIsNotNone(lport)
real_pairs = [aap.to_struct() for aap in lport.allowed_address_pairs]
self.assertItemsEqual(expected_pairs, real_pairs)
def _test_anti_spoof_flows(self, subnet_info):
network = objects.NetworkTestObj(self.neutron, self.nb_api)
self.addCleanup(network.close)
network_id = network.create()
self.assertTrue(network.exists())
subnet_info['network_id'] = network_id
subnet = objects.SubnetTestObj(self.neutron,
self.nb_api,
network_id=network_id)
self.addCleanup(subnet.close)
subnet.create(subnet_info)
self.assertTrue(subnet.exists())
vm = objects.VMTestObj(self, self.neutron)
self.addCleanup(vm.close)
vm.create(network=network)
addresses = vm.server.addresses['mynetwork']
self.assertIsNotNone(addresses)
ip = addresses[0]['addr']
self.assertIsNotNone(ip)
mac = addresses[0]['OS-EXT-IPS-MAC:mac_addr']
self.assertIsNotNone(mac)
port = utils.wait_until_is_and_return(
lambda: utils.find_logical_port(self.nb_api, ip, mac),
exception=Exception('No port assigned to VM'))
of_port = self.vswitch_api.get_port_ofport_by_id(port.id)
self.assertIsNotNone(of_port)
unique_key = port.unique_key
# Check if the associating flows were installed.
expected_flow_list = self._get_anti_spoof_expected_flows(
ip, mac, unique_key)
self._check_all_flows_existed(expected_flow_list)
vm.close()
time.sleep(test_const.DEFAULT_RESOURCE_READY_TIMEOUT)
# Check if the associating flows were removed.
expected_flow_list = self._get_anti_spoof_expected_flows(
ip, mac, unique_key)
self._check_not_flow_existed(expected_flow_list)
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_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_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_network_version(self):
network = self.store(objects.NetworkTestObj(self.neutron, self.nb_api))
network_id = network.create()
self.assertTrue(network.exists())
version = self.nb_api.get_lswitch(network_id).get_version()
subnet = self.store(
objects.SubnetTestObj(self.neutron, self.nb_api, network_id))
subnet.create()
self.assertTrue(subnet.exists())
new_version = self.nb_api.get_lswitch(network_id).get_version()
self.assertGreater(new_version, version)
subnet.close()
self.assertFalse(subnet.exists())
version = new_version
new_version = self.nb_api.get_lswitch(network_id).get_version()
self.assertGreater(new_version, version)
network.close()
self.assertFalse(network.exists())
def test_network_version(self):
network = objects.NetworkTestObj(self.neutron, self.nb_api)
self.addCleanup(network.close)
network_id = network.create()
lean_lswitch = l2.LogicalSwitch(id=network_id)
self.assertTrue(network.exists())
version = self.nb_api.get(lean_lswitch).version
subnet = objects.SubnetTestObj(self.neutron, self.nb_api, network_id)
self.addCleanup(subnet.close)
subnet.create()
self.assertTrue(subnet.exists())
new_version = self.nb_api.get(lean_lswitch).version
self.assertGreater(new_version, version)
subnet.close()
self.assertFalse(subnet.exists())
version = new_version
new_version = self.nb_api.get(lean_lswitch).version
self.assertGreater(new_version, version)
network.close()
self.assertFalse(network.exists())
def test_enable_disable_portsec(self):
network = self.store(objects.NetworkTestObj(self.neutron, self.nb_api))
network_id = network.create()
self.assertTrue(network.exists())
network2 = self.store(objects.NetworkTestObj(self.neutron,
self.nb_api))
network_id2 = network2.create({
'name': 'mynetwork1',
'admin_state_up': True,
'port_security_enabled': False
})
self.assertTrue(network2.exists())
subnet = self.store(
objects.SubnetTestObj(
self.neutron,
self.nb_api,
network_id,
))
subnet.create({
'cidr': '192.168.125.0/24',
'ip_version': 4,
'network_id': network_id
})
self.assertTrue(subnet.exists())
subnet2 = self.store(
objects.SubnetTestObj(
self.neutron,
self.nb_api,
network_id2,
))
subnet2.create({
'cidr': '192.168.126.0/24',
'ip_version': 4,
'network_id': network_id2
})
self.assertTrue(subnet2.exists())
network_portsec_switch = True
port = self.store(
objects.PortTestObj(self.neutron, self.nb_api, network_id))
port.create()
lport = port.get_logical_port()
self.assertIsNotNone(lport)
real_switch = lport.get_port_security_enable()
self.assertEqual(network_portsec_switch, real_switch)
network_portsec_switch = False
port = self.store(
objects.PortTestObj(self.neutron, self.nb_api, network_id2))
port.create()
lport = port.get_logical_port()
self.assertIsNotNone(lport)
real_switch = lport.get_port_security_enable()
self.assertEqual(network_portsec_switch, real_switch)
port = self.store(
objects.PortTestObj(self.neutron, self.nb_api, network_id))
expected_switch = False
port.create({
'admin_state_up': True,
'name': 'port1',
'network_id': network_id,
'port_security_enabled': expected_switch
})
lport = port.get_logical_port()
self.assertIsNotNone(lport)
real_switch = lport.get_port_security_enable()
self.assertEqual(expected_switch, real_switch)
expected_switch = True
port.update({'port_security_enabled': expected_switch})
lport = port.get_logical_port()
self.assertIsNotNone(lport)
real_switch = lport.get_port_security_enable()
self.assertEqual(expected_switch, real_switch)
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()