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)