def test_pub_sub_update_port(self):
ns = Namespace()
ns.events_num = 0
local_event_num = 0
if not self.do_test:
self.skipTest('pub/sub is not enabled')
return
def _db_change_callback(table, key, action, value, topic):
ns.events_num += 1
subscriber = self._get_subscriber(_db_change_callback)
self.addCleanup(subscriber.close)
network = objects.NetworkTestObj(self.neutron, self.nb_api)
self.addCleanup(network.close)
network_id = network.create()
if cfg.CONF.df.enable_selective_topology_distribution:
topic = network.get_topic()
subscriber.register_topic(topic)
else:
time.sleep(const.DEFAULT_RESOURCE_READY_TIMEOUT)
self.assertNotEqual(local_event_num, ns.events_num)
port = objects.PortTestObj(self.neutron, self.nb_api, network_id)
self.addCleanup(port.close)
local_event_num = ns.events_num
port_id = port.create()
time.sleep(const.DEFAULT_RESOURCE_READY_TIMEOUT)
self.assertNotEqual(local_event_num, ns.events_num)
local_event_num = ns.events_num
update = {'port': {'name': 'test'}}
for i in six.moves.range(100):
name = "test %d" % i
update['port']['name'] = name
self.neutron.update_port(port_id, update)
time.sleep(0)
time.sleep(const.DEFAULT_CMD_TIMEOUT)
self.assertGreaterEqual(ns.events_num, local_event_num + 100)
local_event_num = ns.events_num
port.close()
time.sleep(const.DEFAULT_RESOURCE_READY_TIMEOUT)
self.assertNotEqual(local_event_num, ns.events_num)
local_event_num = ns.events_num
network.close()
time.sleep(const.DEFAULT_RESOURCE_READY_TIMEOUT)
self.assertNotEqual(local_event_num, events_num)
if cfg.CONF.df.enable_selective_topology_distribution:
subscriber.unregister_topic(topic)
self.assertFalse(network.exists())
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_pub_sub_update_port(self):
ns = Namespace()
ns.events_num = 0
local_event_num = 0
if not self.do_test:
return
def _db_change_callback(table, key, action, value, topic):
ns.events_num += 1
subscriber = get_subscriber(_db_change_callback)
network = self.store(objects.NetworkTestObj(self.neutron, self.nb_api))
network_id = network.create()
if cfg.CONF.df.enable_selective_topology_distribution:
topic = network.get_topic()
subscriber.register_topic(topic)
else:
eventlet.sleep(test_utils.DEFAULT_CMD_TIMEOUT)
self.assertNotEqual(local_event_num, ns.events_num)
port = self.store(
objects.PortTestObj(self.neutron, self.nb_api, network_id))
local_event_num = ns.events_num
port_id = port.create()
eventlet.sleep(test_utils.DEFAULT_CMD_TIMEOUT)
self.assertNotEqual(local_event_num, ns.events_num)
local_event_num = ns.events_num
update = {'port': {'name': 'test'}}
for i in six.moves.range(100):
name = "test %d" % i
update['port']['name'] = name
self.neutron.update_port(port_id, update)
eventlet.sleep(0)
eventlet.sleep(1)
self.assertGreaterEqual(ns.events_num, local_event_num + 100)
local_event_num = ns.events_num
port.close()
eventlet.sleep(test_utils.DEFAULT_CMD_TIMEOUT)
self.assertNotEqual(local_event_num, ns.events_num)
local_event_num = ns.events_num
network.close()
eventlet.sleep(test_utils.DEFAULT_CMD_TIMEOUT)
self.assertNotEqual(local_event_num, events_num)
if cfg.CONF.df.enable_selective_topology_distribution:
subscriber.unregister_topic(topic)
subscriber.stop()
self.assertFalse(network.exists())
def test_pub_sub_add_port(self):
global events_num
local_event_num = 0
if not self.do_test:
self.skipTest('pub/sub is not enabled')
return
def _db_change_callback(table, key, action, value, topic):
global events_num
events_num += 1
subscriber = self.get_subscriber(_db_change_callback)
network = self.store(objects.NetworkTestObj(self.neutron, self.nb_api))
network_id = network.create()
if cfg.CONF.df.enable_selective_topology_distribution:
topic = network.get_topic()
subscriber.register_topic(topic)
else:
time.sleep(const.DEFAULT_RESOURCE_READY_TIMEOUT)
self.assertNotEqual(local_event_num, events_num)
local_event_num = events_num
port = self.store(objects.PortTestObj(
self.neutron,
self.nb_api,
network_id
))
port.create()
time.sleep(const.DEFAULT_RESOURCE_READY_TIMEOUT)
self.assertNotEqual(local_event_num, events_num)
local_event_num = events_num
port.close()
time.sleep(const.DEFAULT_RESOURCE_READY_TIMEOUT)
self.assertNotEqual(local_event_num, events_num)
local_event_num = events_num
network.close()
time.sleep(const.DEFAULT_RESOURCE_READY_TIMEOUT)
self.assertNotEqual(local_event_num, events_num)
if cfg.CONF.df.enable_selective_topology_distribution:
subscriber.unregister_topic(topic)
subscriber.close()
self.assertFalse(network.exists())
def test_floatingip_version(self):
with self._prepare_ext_net() as external_network_id:
private_network = objects.NetworkTestObj(self.neutron, self.nb_api)
self.addCleanup(private_network.close)
private_network_id = private_network.create()
self.assertTrue(private_network.exists())
priv_subnet = objects.SubnetTestObj(self.neutron, self.nb_api,
private_network_id)
self.addCleanup(priv_subnet.close)
router = objects.RouterTestObj(self.neutron, self.nb_api)
self.addCleanup(router.close)
port = objects.PortTestObj(self.neutron, self.nb_api,
private_network_id)
self.addCleanup(port.close)
fip = objects.FloatingipTestObj(self.neutron, self.nb_api)
self.addCleanup(fip.close)
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(
l2.LogicalPort(id=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
fip.create(fip_para)
self.assertTrue(fip.exists())
prev_version = fip.get_floatingip().version
# associate with port
fip.update({'port_id': port_id})
fip_obj = fip.get_floatingip()
self.assertEqual(fip_obj.lport.id, port_id)
version = fip_obj.version
self.assertGreater(version, prev_version)
prev_version = version
fip.update({})
fip_obj = fip.get_floatingip()
self.assertIsNone(fip_obj.lport)
version = fip_obj.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())
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_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(
network={'name': 'private'})
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_logical_port(
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.get_lport_id())
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_icmp_ping_pong(self):
# Setup base components - two ports on 1 network
self.topology = app_testing_objects.Topology(self.neutron, self.nb_api)
self.addCleanup(self.topology.close)
self.subnet1 = self.topology.create_subnet(cidr='192.168.12.0/24')
self.port1 = self.subnet1.create_port()
self.port2 = self.subnet1.create_port()
time.sleep(const.DEFAULT_RESOURCE_READY_TIMEOUT)
# Setup VLAN ports
self.network = objects.NetworkTestObj(self.neutron, self.nb_api)
self.addCleanup(self.network.close)
self.network.create()
self.subnet = objects.SubnetTestObj(self.neutron,
self.nb_api,
network_id=self.network.network_id)
self.addCleanup(self.subnet.close)
self.subnet.create()
self.vlan_port1 = objects.PortTestObj(
self.neutron, self.nb_api, network_id=self.network.network_id)
self.addCleanup(self.vlan_port1.close)
self.vlan_port1.create()
self.vlan_port2 = objects.PortTestObj(
self.neutron, self.nb_api, network_id=self.network.network_id)
self.addCleanup(self.vlan_port2.close)
self.vlan_port2.create()
self.cps1 = objects.ChildPortSegmentationTestObj(
self.neutron, self.nb_api)
self.addCleanup(self.cps1.close)
self.cps1.create(self.port1.port.port_id, self.vlan_port1.port_id,
'vlan', 7)
self.addCleanup(self.port1.unbind)
self.cps2 = objects.ChildPortSegmentationTestObj(
self.neutron, self.nb_api)
self.addCleanup(self.cps2.close)
self.cps2.create(self.port2.port.port_id, self.vlan_port2.port_id,
'vlan', 8)
self.addCleanup(self.port2.unbind)
# Setup policy
ignore_action = app_testing_objects.IgnoreAction()
key1 = (self.subnet1.subnet_id, self.port1.port_id)
rules1 = [
app_testing_objects.PortPolicyRule(
# Detect pong, end simulation
app_testing_objects.AndingFilter(
app_testing_objects.OsKenVLANTagFilter(7),
app_testing_objects.OsKenICMPPongFilter(self._get_ping)),
actions=[
app_testing_objects.DisableRuleAction(),
app_testing_objects.StopSimulationAction()
]),
app_testing_objects.PortPolicyRule(
# Ignore gratuitous ARP packets
app_testing_objects.OsKenARPGratuitousFilter(),
actions=[ignore_action]),
app_testing_objects.PortPolicyRule(
# Ignore IPv6 packets
app_testing_objects.OsKenIPv6Filter(),
actions=[ignore_action]),
]
key2 = (self.subnet1.subnet_id, self.port2.port_id)
rules2 = [
app_testing_objects.PortPolicyRule(
# Detect ping, reply with pong
app_testing_objects.AndingFilter(
app_testing_objects.OsKenVLANTagFilter(8),
app_testing_objects.OsKenICMPPingFilter()),
actions=[
app_testing_objects.SendAction(self.subnet1.subnet_id,
self.port2.port_id,
self._create_pong_packet),
app_testing_objects.DisableRuleAction()
]),
app_testing_objects.PortPolicyRule(
# Ignore gratuitous ARP packets
app_testing_objects.OsKenARPGratuitousFilter(),
actions=[ignore_action]),
app_testing_objects.PortPolicyRule(
# Ignore IPv6 packets
app_testing_objects.OsKenIPv6Filter(),
actions=[ignore_action]),
]
raise_action = app_testing_objects.RaiseAction("Unexpected packet")
policy1 = app_testing_objects.PortPolicy(rules=rules1,
default_action=raise_action)
policy2 = app_testing_objects.PortPolicy(rules=rules2,
default_action=raise_action)
port_policies = {key1: policy1, key2: policy2}
initial_packet = self._create_ping_packet()
policy = app_testing_objects.Policy(
initial_actions=[
app_testing_objects.SendAction(
self.subnet1.subnet_id,
self.port1.port_id,
initial_packet,
),
],
port_policies=port_policies,
unknown_port_action=app_testing_objects.IgnoreAction())
self.addCleanup(policy.close)
time.sleep(const.DEFAULT_RESOURCE_READY_TIMEOUT)
# Verify port is up
neutron_vlan_port1 = objects.get_port_by_id(self.neutron,
self.vlan_port1.port_id)
self.assertEqual(n_const.PORT_STATUS_ACTIVE,
neutron_vlan_port1['status'])
neutron_vlan_port2 = objects.get_port_by_id(self.neutron,
self.vlan_port2.port_id)
self.assertEqual(n_const.PORT_STATUS_ACTIVE,
neutron_vlan_port2['status'])
# Verify connectivity
apps.start_policy(policy, self.topology,
const.DEFAULT_RESOURCE_READY_TIMEOUT)
def test_sending_arp_to_controller_flows(self):
"""
Add a VM with allowed address pairs configuration. Verify related
flows is there.
"""
if not self.check_app_loaded("active_port_detection"):
self.skipTest("ActivePortDetectionApp is not enabled")
network = self.store(objects.NetworkTestObj(self.neutron, self.nb_api))
network_id = network.create(network={'name': 'aap_test'})
subnet_obj = self.store(objects.SubnetTestObj(
self.neutron,
self.nb_api,
network_id,
))
subnet = {'network_id': network_id,
'cidr': '192.168.97.0/24',
'gateway_ip': '192.168.97.1',
'ip_version': 4,
'name': 'aap_test',
'enable_dhcp': True}
subnet_obj.create(subnet)
vm = self.store(objects.VMTestObj(self, self.neutron))
vm_id = vm.create(network=network)
vm_port_id = self.vswitch_api.get_port_id_by_vm_id(vm_id)
self.assertIsNotNone(vm_port_id)
vm_port = objects.PortTestObj(self.neutron, self.nb_api, network_id,
vm_port_id)
of_port = self.vswitch_api.get_port_ofport_by_id(vm_port_id)
self.assertIsNotNone(of_port)
vm_lport = vm_port.get_logical_port()
self.assertIsNotNone(vm_lport)
result = self._check_sending_arp_reply_to_controller_flows(
vm_lport.unique_key)
self.assertFalse(result)
result = self._check_sending_gratuitous_arp_to_controller_flows(
vm_lport.unique_key)
self.assertFalse(result)
ip_address1 = '192.168.97.100'
mac_address1 = '1A:22:33:44:55:66'
allowed_address_pairs1 = [{'ip_address': ip_address1,
'mac_address': mac_address1}]
vm_port.update({'allowed_address_pairs': allowed_address_pairs1})
time.sleep(test_const.DEFAULT_CMD_TIMEOUT)
result = self._check_sending_arp_reply_to_controller_flows(
vm_lport.unique_key, ip_address1)
self.assertTrue(result)
result = self._check_sending_gratuitous_arp_to_controller_flows(
vm_lport.unique_key, ip_address1)
self.assertTrue(result)
ip_address2 = '192.168.97.101'
allowed_address_pairs2 = [{'ip_address': ip_address2}]
vm_port.update({'allowed_address_pairs': allowed_address_pairs2})
time.sleep(test_const.DEFAULT_CMD_TIMEOUT)
result = self._check_sending_arp_reply_to_controller_flows(
vm_lport.unique_key, ip_address1)
self.assertFalse(result)
result = self._check_sending_gratuitous_arp_to_controller_flows(
vm_lport.unique_key, ip_address1)
self.assertFalse(result)
result = self._check_sending_arp_reply_to_controller_flows(
vm_lport.unique_key, ip_address2)
self.assertTrue(result)
result = self._check_sending_gratuitous_arp_to_controller_flows(
vm_lport.unique_key, ip_address2)
self.assertTrue(result)
vm.close()
time.sleep(test_const.DEFAULT_CMD_TIMEOUT)
result = self._check_sending_arp_reply_to_controller_flows(
vm_lport.unique_key, ip_address2)
self.assertFalse(result)
result = self._check_sending_gratuitous_arp_to_controller_flows(
vm_lport.unique_key, ip_address2)
self.assertFalse(result)
network.close()
def test_port_with_qospolicy(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=network_id))
subnet.create()
self.assertTrue(subnet.exists())
vm = self.store(objects.VMTestObj(self, self.neutron))
vm_id = vm.create(network=network)
vm_port_id = self.vswitch_api.get_port_id_by_vm_id(vm_id)
self.assertIsNotNone(vm_port_id)
port = objects.PortTestObj(self.neutron, self.nb_api, network_id,
vm_port_id)
qospolicy = self.store(
objects.QosPolicyTestObj(self.neutron, self.nb_api))
qos_policy_id = qospolicy.create()
time.sleep(const.DEFAULT_CMD_TIMEOUT)
self.assertTrue(qospolicy.exists())
qospolicy.create_rule(qos_policy_id, {
'max_kbps': '1000',
'max_burst_kbps': '100'
}, 'bandwidth_limit')
qospolicy.create_rule(qos_policy_id, {'dscp_mark': '10'},
'dscp_marking')
port_param = {'qos_policy_id': qos_policy_id}
port.update(port_param)
time.sleep(const.DEFAULT_CMD_TIMEOUT)
logical_port = port.get_logical_port()
self.assertEqual(qos_policy_id, logical_port.qos_policy.id)
check_columns = {'ingress_policing_rate', 'ingress_policing_burst'}
interface = \
self.vswitch_api.get_interface_by_id_with_specified_columns(
vm_port_id, check_columns)
self.assertIsNotNone(interface)
self.assertEqual(1000, interface.get('ingress_policing_rate'))
self.assertEqual(100, interface.get('ingress_policing_burst'))
queue = self.vswitch_api.get_queue_info_by_port_id(vm_port_id)
self.assertIsNotNone(queue)
self.assertEqual(queue['other_config']['max-rate'], '1024000')
self.assertEqual(queue['other_config']['min-rate'], '1024000')
self.assertEqual(queue['dscp'], 10)
qos = self.vswitch_api.get_qos_info_by_port_id(vm_port_id)
self.assertIsNotNone(qos)
self.assertEqual(qos['queues'][0].uuid, queue['_uuid'])
ovs_port = self.vswitch_api.get_ovs_port_by_id_with_specified_columns(
vm_port_id, {'qos'})
self.assertIsNotNone(ovs_port)
self.assertEqual(ovs_port['qos'], qos['_uuid'])
vm.close()
time.sleep(const.DEFAULT_CMD_TIMEOUT)
queue = self.vswitch_api.get_queue_info_by_port_id(vm_port_id)
self.assertIsNone(queue)
qos = self.vswitch_api.get_qos_info_by_port_id(vm_port_id)
self.assertIsNone(qos)
