X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=test%2Ftest_l2bd_multi_instance.py;h=b51bb5e6c8100a96b8ee7e41a70df46261e36f65;hb=8e7fdddd3;hp=56e663422b77ac1bcc6bff240e20f3f85844df77;hpb=00dad123ab284ab0c9c4a8387c93ccbc056e6440;p=vpp.git diff --git a/test/test_l2bd_multi_instance.py b/test/test_l2bd_multi_instance.py index 56e663422b7..b51bb5e6c81 100644 --- a/test/test_l2bd_multi_instance.py +++ b/test/test_l2bd_multi_instance.py @@ -1,11 +1,11 @@ -#!/usr/bin/env python +#!/usr/bin/env python3 """L2BD Multi-instance Test Case HLD: **NOTES:** - higher number of pg-l2 interfaces causes problems => only 15 pg-l2 \ interfaces in 5 bridge domains are tested - - more then 1 host per pg-l2 interface in configuration with 15 l2-pg \ - interfaces leads to problems too + - jumbo packets in configuration with 14 l2-pg interfaces leads to \ + problems too **config 1** - add 15 pg-l2 interfaces @@ -69,8 +69,8 @@ from scapy.packet import Raw from scapy.layers.l2 import Ether from scapy.layers.inet import IP, UDP -from framework import VppTestCase, VppTestRunner -from util import Host +from framework import VppTestCase, VppTestRunner, running_extended_tests +from util import Host, ppp class TestL2bdMultiInst(VppTestCase): @@ -87,57 +87,56 @@ class TestL2bdMultiInst(VppTestCase): try: # Create pg interfaces - cls.create_pg_interfaces(range(15)) + n_bd = 5 + cls.ifs_per_bd = ifs_per_bd = 3 + n_ifs = n_bd * ifs_per_bd + cls.create_pg_interfaces(range(n_ifs)) # Packet flows mapping pg0 -> pg1, pg2 etc. cls.flows = dict() - for i in range(0, len(cls.pg_interfaces), 3): - cls.flows[cls.pg_interfaces[i]] = [cls.pg_interfaces[i+1], - cls.pg_interfaces[i+2]] - cls.flows[cls.pg_interfaces[i+1]] = [cls.pg_interfaces[i], - cls.pg_interfaces[i+2]] - cls.flows[cls.pg_interfaces[i+2]] = [cls.pg_interfaces[i], - cls.pg_interfaces[i+1]] + for b in range(n_bd): + bd_ifs = cls.bd_if_range(b + 1) + for j in bd_ifs: + cls.flows[cls.pg_interfaces[j]] = [ + cls.pg_interfaces[x] for x in bd_ifs if x != j] + assert( + len(cls.flows[cls.pg_interfaces[j]]) == ifs_per_bd - 1) # Mapping between packet-generator index and lists of test hosts cls.hosts_by_pg_idx = dict() - for pg_if in cls.pg_interfaces: - cls.hosts_by_pg_idx[pg_if.sw_if_index] = [] # Create test host entries - cls.create_hosts(15) + cls.create_hosts(5) - # Packet sizes - cls.pg_if_packet_sizes = [64, 512, 1518, 9018] + # Packet sizes - jumbo packet (9018 bytes) skipped + cls.pg_if_packet_sizes = [64, 512, 1518] # Set up all interfaces for i in cls.pg_interfaces: i.admin_up() - # Create list of BDs - cls.bd_list = list() - - # Create list of deleted BDs - cls.bd_deleted_list = list() - - # Create list of pg_interfaces in BDs - cls.pg_in_bd = list() - - # Create list of pg_interfaces not in BDs - cls.pg_not_in_bd = list() - for pg_if in cls.pg_interfaces: - cls.pg_not_in_bd.append(pg_if) - except Exception: super(TestL2bdMultiInst, cls).tearDownClass() raise + @classmethod + def tearDownClass(cls): + super(TestL2bdMultiInst, cls).tearDownClass() + def setUp(self): """ Clear trace and packet infos before running each test. """ + self.reset_packet_infos() super(TestL2bdMultiInst, self).setUp() - self.packet_infos = {} + # Create list of BDs + self.bd_list = [] + + # Create list of deleted BDs + self.bd_deleted_list = [] + + # Create list of pg_interfaces in BDs + self.pg_in_bd = [] def tearDown(self): """ @@ -149,56 +148,56 @@ class TestL2bdMultiInst(VppTestCase): self.logger.info(self.vapi.ppcli("show bridge-domain")) @classmethod - def create_hosts(cls, count): + def create_hosts(cls, hosts_per_if): """ - Create required number of host MAC addresses and distribute them among - interfaces. Create host IPv4 address for every host MAC address. + Create required number of host MAC addresses and distribute them + among interfaces. Create host IPv4 address for every host MAC + address. - :param int count: Number of hosts to create MAC/IPv4 addresses for. + :param int hosts_per_if: Number of hosts per if to create MAC/IPv4 + addresses for. """ - n_int = len(cls.pg_interfaces) - macs_per_if = count / n_int - i = -1 - for pg_if in cls.pg_interfaces: - i += 1 - start_nr = macs_per_if * i - end_nr = count if i == (n_int - 1) else macs_per_if * (i + 1) - hosts = cls.hosts_by_pg_idx[pg_if.sw_if_index] - for j in range(start_nr, end_nr): - host = Host( - "00:00:00:ff:%02x:%02x" % (pg_if.sw_if_index, j), - "172.17.1%02u.%u" % (pg_if.sw_if_index, j)) - hosts.append(host) + c = hosts_per_if + assert(not cls.hosts_by_pg_idx) + for i in range(len(cls.pg_interfaces)): + pg_idx = cls.pg_interfaces[i].sw_if_index + cls.hosts_by_pg_idx[pg_idx] = [Host( + "00:00:00:ff:%02x:%02x" % (pg_idx, j + 1), + "172.17.1%02u.%u" % (pg_idx, j + 1)) for j in range(c)] + + @classmethod + def bd_if_range(cls, b): + n = cls.ifs_per_bd + start = (b - 1) * n + return range(start, start + n) def create_bd_and_mac_learn(self, count, start=1): - """" - Create required number of bridge domains with MAC learning enabled, put - 3 l2-pg interfaces to every bridge domain and send MAC learning packets. + """ + Create required number of bridge domains with MAC learning enabled, + put 3 l2-pg interfaces to every bridge domain and send MAC learning + packets. :param int count: Number of bridge domains to be created. :param int start: Starting number of the bridge domain ID. (Default value = 1) """ - for i in range(count): - bd_id = i + start - self.vapi.bridge_domain_add_del(bd_id=bd_id) - self.logger.info("Bridge domain ID %d created" % bd_id) - if self.bd_list.count(bd_id) == 0: - self.bd_list.append(bd_id) - if self.bd_deleted_list.count(bd_id) == 1: - self.bd_deleted_list.remove(bd_id) - for j in range(3): - pg_if = self.pg_interfaces[(i+start-1)*3+j] - self.vapi.sw_interface_set_l2_bridge(pg_if.sw_if_index, - bd_id=bd_id) + for b in range(start, start + count): + self.vapi.bridge_domain_add_del(bd_id=b) + self.logger.info("Bridge domain ID %d created" % b) + if self.bd_list.count(b) == 0: + self.bd_list.append(b) + if self.bd_deleted_list.count(b) == 1: + self.bd_deleted_list.remove(b) + for j in self.bd_if_range(b): + pg_if = self.pg_interfaces[j] + self.vapi.sw_interface_set_l2_bridge( + rx_sw_if_index=pg_if.sw_if_index, bd_id=b) self.logger.info("pg-interface %s added to bridge domain ID %d" - % (pg_if.name, bd_id)) + % (pg_if.name, b)) self.pg_in_bd.append(pg_if) - self.pg_not_in_bd.remove(pg_if) - packets = [] - for host in self.hosts_by_pg_idx[pg_if.sw_if_index]: - packet = (Ether(dst="ff:ff:ff:ff:ff:ff", src=host.mac)) - packets.append(packet) + hosts = self.hosts_by_pg_idx[pg_if.sw_if_index] + packets = [Ether(dst="ff:ff:ff:ff:ff:ff", src=host.mac) + for host in hosts] pg_if.add_stream(packets) self.logger.info("Sending broadcast eth frames for MAC learning") self.pg_start() @@ -206,27 +205,25 @@ class TestL2bdMultiInst(VppTestCase): self.logger.info(self.vapi.ppcli("show l2fib")) def delete_bd(self, count, start=1): - """" + """ Delete required number of bridge domains. :param int count: Number of bridge domains to be created. :param int start: Starting number of the bridge domain ID. (Default value = 1) """ - for i in range(count): - bd_id = i + start - self.vapi.bridge_domain_add_del(bd_id=bd_id, is_add=0) - if self.bd_list.count(bd_id) == 1: - self.bd_list.remove(bd_id) - if self.bd_deleted_list.count(bd_id) == 0: - self.bd_deleted_list.append(bd_id) - for j in range(3): - pg_if = self.pg_interfaces[(i+start-1)*3+j] + for b in range(start, start + count): + for j in self.bd_if_range(b): + pg_if = self.pg_interfaces[j] + self.vapi.sw_interface_set_l2_bridge( + rx_sw_if_index=pg_if.sw_if_index, bd_id=b, enable=0) self.pg_in_bd.remove(pg_if) - self.pg_not_in_bd.append(pg_if) - self.logger.info("Bridge domain ID %d deleted" % bd_id) + self.vapi.bridge_domain_add_del(bd_id=b, is_add=0) + self.bd_list.remove(b) + self.bd_deleted_list.append(b) + self.logger.info("Bridge domain ID %d deleted" % b) - def create_stream(self, src_if, packet_sizes): + def create_stream(self, src_if): """ Create input packet stream for defined interface using hosts list. @@ -234,17 +231,15 @@ class TestL2bdMultiInst(VppTestCase): :param list packet_sizes: List of required packet sizes. :return: Stream of packets. """ + packet_sizes = self.pg_if_packet_sizes pkts = [] src_hosts = self.hosts_by_pg_idx[src_if.sw_if_index] for dst_if in self.flows[src_if]: dst_hosts = self.hosts_by_pg_idx[dst_if.sw_if_index] - n_int = len(dst_hosts) - for i in range(0, n_int): - dst_host = dst_hosts[i] - src_host = random.choice(src_hosts) - pkt_info = self.create_packet_info( - src_if.sw_if_index, dst_if.sw_if_index) + for dst_host in dst_hosts: + pkt_info = self.create_packet_info(src_if, dst_if) payload = self.info_to_payload(pkt_info) + src_host = random.choice(src_hosts) p = (Ether(dst=dst_host.mac, src=src_host.mac) / IP(src=src_host.ip4, dst=dst_host.ip4) / UDP(sport=1234, dport=1234) / @@ -257,62 +252,57 @@ class TestL2bdMultiInst(VppTestCase): % (src_if.name, len(pkts))) return pkts - def verify_capture(self, pg_if, capture): + def verify_capture(self, dst_if): """ Verify captured input packet stream for defined interface. - :param object pg_if: Interface to verify captured packet stream for. - :param list capture: Captured packet stream. + :param object dst_if: Interface to verify captured packet stream for. """ last_info = dict() - for i in self.pg_interfaces: + for i in self.flows[dst_if]: last_info[i.sw_if_index] = None - dst_sw_if_index = pg_if.sw_if_index - for packet in capture: - payload_info = self.payload_to_info(str(packet[Raw])) + dst = dst_if.sw_if_index + for packet in dst_if.get_capture(): try: ip = packet[IP] udp = packet[UDP] - packet_index = payload_info.index - self.assertEqual(payload_info.dst, dst_sw_if_index) + info = self.payload_to_info(packet[Raw]) + self.assertEqual(info.dst, dst) self.logger.debug("Got packet on port %s: src=%u (id=%u)" % - (pg_if.name, payload_info.src, packet_index)) - next_info = self.get_next_packet_info_for_interface2( - payload_info.src, dst_sw_if_index, - last_info[payload_info.src]) - last_info[payload_info.src] = next_info - self.assertTrue(next_info is not None) - self.assertEqual(packet_index, next_info.index) - saved_packet = next_info.data - # Check standard fields - self.assertEqual(ip.src, saved_packet[IP].src) - self.assertEqual(ip.dst, saved_packet[IP].dst) - self.assertEqual(udp.sport, saved_packet[UDP].sport) - self.assertEqual(udp.dport, saved_packet[UDP].dport) + (dst_if.name, info.src, info.index)) + last_info[info.src] = self.get_next_packet_info_for_interface2( + info.src, dst, last_info[info.src]) + pkt_info = last_info[info.src] + self.assertTrue(pkt_info is not None) + self.assertEqual(info.index, pkt_info.index) + # Check standard fields against saved data in pkt + saved = pkt_info.data + self.assertEqual(ip.src, saved[IP].src) + self.assertEqual(ip.dst, saved[IP].dst) + self.assertEqual(udp.sport, saved[UDP].sport) + self.assertEqual(udp.dport, saved[UDP].dport) except: - self.logger.error("Unexpected or invalid packet:") - self.logger.error(packet.show()) + self.logger.error(ppp("Unexpected or invalid packet:", packet)) raise - for i in self.pg_interfaces: + s = "" + remaining = 0 + for src in self.flows[dst_if]: remaining_packet = self.get_next_packet_info_for_interface2( - i, dst_sw_if_index, last_info[i.sw_if_index]) - self.assertTrue( - remaining_packet is None, - "Port %u: Packet expected from source %u didn't arrive" % - (dst_sw_if_index, i.sw_if_index)) + src.sw_if_index, dst, last_info[src.sw_if_index]) + if remaining_packet is None: + s += "Port %u: Packet expected from source %u didn't arrive\n"\ + % (dst, src.sw_if_index) + remaining += 1 + self.assertNotEqual(0, remaining, s) def set_bd_flags(self, bd_id, **args): """ Enable/disable defined feature(s) of the bridge domain. :param int bd_id: Bridge domain ID. - :param list args: List of feature/status pairs. Allowed features: - - learn, - - forward, - - flood, - - uu_flood and - - arp_term - Status False means disable, status True means enable the feature. + :param list args: List of feature/status pairs. Allowed features: \ + learn, forward, flood, uu_flood and arp_term. Status False means \ + disable, status True means enable the feature. :raise: ValueError in case of unknown feature in the input. """ for flag in args: @@ -329,7 +319,8 @@ class TestL2bdMultiInst(VppTestCase): else: raise ValueError("Unknown feature used: %s" % flag) is_set = 1 if args[flag] else 0 - self.vapi.bridge_flags(bd_id, is_set, feature_bitmap) + self.vapi.bridge_flags(bd_id=bd_id, is_set=is_set, + flags=feature_bitmap) self.logger.info("Bridge domain ID %d updated" % bd_id) def verify_bd(self, bd_id, **args): @@ -338,13 +329,9 @@ class TestL2bdMultiInst(VppTestCase): of listed features. :param int bd_id: Bridge domain ID. - :param list args: List of feature/status pairs. Allowed features: - - learn, - - forward, - - flood, - - uu_flood and - - arp_term - Status False means disable, status True means enable the feature. + :param list args: List of feature/status pairs. Allowed features: \ + learn, forward, flood, uu_flood and arp_term. Status False means \ + disable, status True means enable the feature. :return: 1 if bridge domain is configured, otherwise return 0. :raise: ValueError in case of unknown feature in the input. """ @@ -374,44 +361,34 @@ class TestL2bdMultiInst(VppTestCase): def run_verify_test(self): """ - Create packet streams for all configured l2-pg interfaces, send all + Create packet streams for all configured l2-pg interfaces, send all \ prepared packet streams and verify that: - - all packets received correctly on all pg-l2 interfaces assigned to - bridge domains - - no packet received on all pg-l2 interfaces not assigned to bridge - domains - - :raise: RuntimeError if no packet captured on l2-pg interface assigned - to the bridge domain or if any packet is captured on l2-pg interface - not assigned to the bridge domain. + - all packets received correctly on all pg-l2 interfaces assigned + to bridge domains + - no packet received on all pg-l2 interfaces not assigned to + bridge domains + + :raise RuntimeError: if no packet captured on l2-pg interface assigned + to the bridge domain or if any packet is captured + on l2-pg interface not assigned to the bridge + domain. """ # Test # Create incoming packet streams for packet-generator interfaces - for pg_if in self.pg_interfaces: - pkts = self.create_stream(pg_if, self.pg_if_packet_sizes) + # for pg_if in self.pg_interfaces: + assert(len(self._packet_count_for_dst_if_idx) == 0) + for pg_if in self.pg_in_bd: + pkts = self.create_stream(pg_if) pg_if.add_stream(pkts) # Enable packet capture and start packet sending - self.pg_enable_capture(self.pg_interfaces) + self.pg_enable_capture(self.pg_in_bd) self.pg_start() # Verify # Verify outgoing packet streams per packet-generator interface - for pg_if in self.pg_interfaces: - capture = pg_if.get_capture() - if pg_if in self.pg_in_bd: - if len(capture) == 0: - raise RuntimeError("Interface %s is in BD but the capture " - "is empty!" % pg_if.name) - self.verify_capture(pg_if, capture) - elif pg_if in self.pg_not_in_bd: - try: - self.assertEqual(len(capture), 0) - except AssertionError: - raise RuntimeError("Interface %s is not in BD but " - "the capture is not empty!" % pg_if.name) - else: - self.logger.error("Unknown interface: %s" % pg_if.name) + for pg_if in self.pg_in_bd: + self.verify_capture(pg_if) def test_l2bd_inst_01(self): """ L2BD Multi-instance test 1 - create 5 BDs @@ -428,12 +405,14 @@ class TestL2bdMultiInst(VppTestCase): # Test 1 # self.vapi.cli("clear trace") self.run_verify_test() + self.delete_bd(5) def test_l2bd_inst_02(self): """ L2BD Multi-instance test 2 - update data of 5 BDs """ # Config 2 # Update data of 5 BDs (disable learn, forward, flood, uu-flood) + self.create_bd_and_mac_learn(5) self.set_bd_flags(self.bd_list[0], learn=False, forward=False, flood=False, uu_flood=False) self.set_bd_flags(self.bd_list[1], forward=False) @@ -454,12 +433,14 @@ class TestL2bdMultiInst(VppTestCase): flood=True, uu_flood=False) self.verify_bd(self.bd_list[4], learn=False, forward=True, flood=True, uu_flood=True) + self.delete_bd(5) def test_l2bd_inst_03(self): - """ L2BD Multi-instance 3 - delete 2 BDs + """ L2BD Multi-instance test 3 - delete 2 BDs """ # Config 3 # Delete 2 BDs + self.create_bd_and_mac_learn(5) self.delete_bd(2) # Verify 3 @@ -470,6 +451,7 @@ class TestL2bdMultiInst(VppTestCase): # Test 3 self.run_verify_test() + self.delete_bd(3, 3) def test_l2bd_inst_04(self): """ L2BD Multi-instance test 4 - add 2 BDs @@ -486,12 +468,14 @@ class TestL2bdMultiInst(VppTestCase): # Test 4 # self.vapi.cli("clear trace") self.run_verify_test() + self.delete_bd(2) def test_l2bd_inst_05(self): - """ L2BD Multi-instance 5 - delete 5 BDs + """ L2BD Multi-instance test 5 - delete 5 BDs """ # Config 5 # Delete 5 BDs + self.create_bd_and_mac_learn(5) self.delete_bd(5) # Verify 5