X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=test%2Ftest_l2_fib.py;h=1cee58982e53168f6e9cce5ded21f28d1dc37fd6;hb=8006c6a;hp=4855a3ea383b3f5b868ef2962f61a161ba788cb3;hpb=9225dee9655ce607130f9bab5472441b72e25858;p=vpp.git diff --git a/test/test_l2_fib.py b/test/test_l2_fib.py index 4855a3ea383..1cee58982e5 100644 --- a/test/test_l2_fib.py +++ b/test/test_l2_fib.py @@ -69,11 +69,22 @@ from scapy.layers.inet import IP, UDP from framework import VppTestCase, VppTestRunner from util import Host, ppp +from vpp_papi import mac_pton + +# from src/vnet/l2/l2_fib.h +MAC_EVENT_ACTION_ADD = 0 +MAC_EVENT_ACTION_DELETE = 1 +MAC_EVENT_ACTION_MOVE = 2 class TestL2fib(VppTestCase): """ L2 FIB Test Case """ + @classmethod + def bd_ifs(cls, bd_id): + return range((bd_id - 1) * cls.n_ifs_per_bd, + bd_id * cls.n_ifs_per_bd - 1) + @classmethod def setUpClass(cls): """ @@ -82,59 +93,47 @@ class TestL2fib(VppTestCase): variables and configure VPP. :var int bd_id: Bridge domain ID. - :var int mac_entries_count: Number of MAC entries for bridge-domain. """ super(TestL2fib, cls).setUpClass() - # Test variables - cls.bd_id = 1 - cls.mac_entries_count = 200 - try: - # Create 4 pg interfaces - cls.create_pg_interfaces(range(4)) + n_brs = cls.n_brs = range(1, 3) + cls.n_ifs_per_bd = 4 + n_ifs = range(cls.n_ifs_per_bd * len(cls.n_brs)) + # Create pg interfaces + cls.create_pg_interfaces(n_ifs) - # Packet flows mapping pg0 -> pg1, pg2, pg3 etc. cls.flows = dict() - cls.flows[cls.pg0] = [cls.pg1, cls.pg2, cls.pg3] - cls.flows[cls.pg1] = [cls.pg0, cls.pg2, cls.pg3] - cls.flows[cls.pg2] = [cls.pg0, cls.pg1, cls.pg3] - cls.flows[cls.pg3] = [cls.pg0, cls.pg1, cls.pg2] + for bd_id in n_brs: + # Packet flows mapping pg0 -> pg1, pg2, pg3 etc. + ifs = cls.bd_ifs(bd_id) + for j in ifs: + cls.flows[cls.pg_interfaces[j]] = [ + cls.pg_interfaces[x] for x in ifs if x != j] # Packet sizes cls.pg_if_packet_sizes = [64, 512, 1518, 9018] - # Create BD with MAC learning and unknown unicast flooding disabled - # and put interfaces to this BD - cls.vapi.bridge_domain_add_del(bd_id=cls.bd_id, uu_flood=0, learn=0) - for pg_if in cls.pg_interfaces: - cls.vapi.sw_interface_set_l2_bridge(pg_if.sw_if_index, - bd_id=cls.bd_id) + for bd_id in n_brs: + # Create BD with MAC learning and unknown unicast flooding + # disabled and put interfaces to this BD + cls.vapi.bridge_domain_add_del( + bd_id=bd_id, uu_flood=0, learn=0) + ifs = [cls.pg_interfaces[i] for i in cls.bd_ifs(bd_id)] + for pg_if in ifs: + cls.vapi.sw_interface_set_l2_bridge(pg_if.sw_if_index, + bd_id=bd_id) # Set up all interfaces for i in cls.pg_interfaces: i.admin_up() - - # 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 list of deleted hosts - cls.deleted_hosts_by_pg_idx = dict() - for pg_if in cls.pg_interfaces: - cls.deleted_hosts_by_pg_idx[pg_if.sw_if_index] = [] - except Exception: super(TestL2fib, cls).tearDownClass() raise def setUp(self): - """ - Clear trace and packet infos before running each test. - """ super(TestL2fib, self).setUp() - self.packet_infos = {} + self.reset_packet_infos() def tearDown(self): """ @@ -143,81 +142,119 @@ class TestL2fib(VppTestCase): super(TestL2fib, self).tearDown() if not self.vpp_dead: self.logger.info(self.vapi.ppcli("show l2fib verbose")) - self.logger.info(self.vapi.ppcli("show bridge-domain %s detail" - % self.bd_id)) + for bd_id in self.n_brs: + self.logger.info(self.vapi.ppcli("show bridge-domain %s detail" + % bd_id)) - def create_hosts(self, count, start=0): + def create_hosts(self, n_hosts_per_if, subnet): """ 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 start: Number to start numbering from. + :param int n_hosts_per_if: Number of per interface hosts to + create MAC/IPv4 addresses for. """ - n_int = len(self.pg_interfaces) - macs_per_if = count / n_int - i = -1 + + hosts = dict() + for pg_if in self.pg_interfaces: + swif = pg_if.sw_if_index + + def mac(j): return "00:00:%02x:ff:%02x:%02x" % (subnet, swif, j) + + def ip(j): return "172.%02u.1%02x.%u" % (subnet, swif, j) + + def h(j): return Host(mac(j), ip(j)) + hosts[swif] = [h(j) for j in range(n_hosts_per_if)] + return hosts + + def split_hosts(self, hosts, n): + splits = dict() for pg_if in self.pg_interfaces: - i += 1 - start_nr = macs_per_if * i + start - end_nr = count + start if i == (n_int - 1) \ - else macs_per_if * (i + 1) + start - hosts = self.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%02x.%u" % (pg_if.sw_if_index, j)) - hosts.append(host) - - def config_l2_fib_entries(self, count, start=0): + swif = pg_if.sw_if_index + splits[swif] = hosts[swif][:n] + hosts[swif] = hosts[swif][n:] + return splits + + def learn_hosts(self, bd_id, hosts): """ - Create required number of L2 FIB entries. + Create and send per interface L2 MAC broadcast packet stream to + let the bridge domain learn these MAC addresses. + :param int bd_id: BD to teach + :param dict hosts: dict of hosts per interface + """ + self.vapi.bridge_flags(bd_id, 1, 1) + ifs = [self.pg_interfaces[i] for i in self.bd_ifs(bd_id)] + for pg_if in ifs: + swif = pg_if.sw_if_index + packets = [Ether(dst="ff:ff:ff:ff:ff:ff", src=host.mac) + for host in hosts[swif]] + pg_if.add_stream(packets) + self.logger.info("Sending broadcast eth frames for MAC learning") + self.pg_start() + + def config_l2_fib_entries(self, bd_id, hosts): + """ + Config required number of L2 FIB entries. + + :param int bd_id: BD's id :param int count: Number of L2 FIB entries to be created. :param int start: Starting index of the host list. (Default value = 0) """ - n_int = len(self.pg_interfaces) - percent = 0 - counter = 0.0 - for pg_if in self.pg_interfaces: - end_nr = start + count / n_int - for j in range(start, end_nr): - host = self.hosts_by_pg_idx[pg_if.sw_if_index][j] - self.vapi.l2fib_add_del(host.mac, self.bd_id, pg_if.sw_if_index, - static_mac=1) - counter += 1 - percentage = counter / count * 100 - if percentage > percent: - self.logger.info("Configure %d L2 FIB entries .. %d%% done" - % (count, percentage)) - percent += 1 - self.logger.info(self.vapi.ppcli("show l2fib")) - - def delete_l2_fib_entry(self, count): + ifs = [self.pg_interfaces[i] for i in self.bd_ifs(bd_id)] + for pg_if in ifs: + swif = pg_if.sw_if_index + for host in hosts[swif]: + self.vapi.l2fib_add_del( + mac_pton(host.mac), bd_id, swif, static_mac=1) + + def delete_l2_fib_entry(self, bd_id, hosts): """ Delete required number of L2 FIB entries. :param int count: Number of L2 FIB entries to be created. """ - n_int = len(self.pg_interfaces) - percent = 0 - counter = 0.0 - for pg_if in self.pg_interfaces: - for j in range(count / n_int): - host = self.hosts_by_pg_idx[pg_if.sw_if_index][0] - self.vapi.l2fib_add_del(host.mac, self.bd_id, pg_if.sw_if_index, - is_add=0) - self.deleted_hosts_by_pg_idx[pg_if.sw_if_index].append(host) - del self.hosts_by_pg_idx[pg_if.sw_if_index][0] - counter += 1 - percentage = counter / count * 100 - if percentage > percent: - self.logger.info("Delete %d L2 FIB entries .. %d%% done" - % (count, percentage)) - percent += 1 - self.logger.info(self.vapi.ppcli("show l2fib")) + ifs = [self.pg_interfaces[i] for i in self.bd_ifs(bd_id)] + for pg_if in ifs: + swif = pg_if.sw_if_index + for host in hosts[swif]: + self.vapi.l2fib_add_del( + mac_pton(host.mac), bd_id, swif, is_add=0) + + def flush_int(self, swif, learned_hosts): + """ + Flush swif L2 FIB entries. + + :param int swif: sw if index. + """ + flushed = dict() + self.vapi.l2fib_flush_int(swif) + flushed[swif] = learned_hosts[swif] + learned_hosts[swif] = [] + return flushed - def create_stream(self, src_if, packet_sizes, deleted=False): + def flush_bd(self, bd_id, learned_hosts): + """ + Flush bd_id L2 FIB entries. + + :param int bd_id: Bridge Domain id. + """ + self.vapi.l2fib_flush_bd(bd_id) + flushed = dict() + ifs = [self.pg_interfaces[i] for i in self.bd_ifs(bd_id)] + for pg_if in ifs: + swif = pg_if.sw_if_index + flushed[swif] = learned_hosts[swif] + learned_hosts[swif] = [] + return flushed + + def flush_all(self): + """ + Flush All L2 FIB entries. + """ + self.vapi.l2fib_flush_all() + + def create_stream(self, src_if, packet_sizes, if_src_hosts, if_dst_hosts): """ Create input packet stream for defined interface using hosts or deleted_hosts list. @@ -227,17 +264,18 @@ class TestL2fib(VppTestCase): :param boolean deleted: Set to True if deleted_hosts list required. :return: Stream of packets. """ + src_hosts = if_src_hosts[src_if.sw_if_index] + if not src_hosts: + return [] pkts = [] - src_hosts = self.hosts_by_pg_idx[src_if.sw_if_index] for dst_if in self.flows[src_if]: - dst_hosts = self.deleted_hosts_by_pg_idx[dst_if.sw_if_index]\ - if deleted else 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] + dst_swif = dst_if.sw_if_index + if dst_swif not in if_dst_hosts: + continue + dst_hosts = if_dst_hosts[dst_swif] + for dst_host in dst_hosts: src_host = random.choice(src_hosts) - pkt_info = self.create_packet_info( - src_if.sw_if_index, dst_if.sw_if_index) + pkt_info = self.create_packet_info(src_if, dst_if) payload = self.info_to_payload(pkt_info) p = (Ether(dst=dst_host.mac, src=src_host.mac) / IP(src=src_host.ip4, dst=dst_host.ip4) / @@ -292,90 +330,197 @@ class TestL2fib(VppTestCase): "Port %u: Packet expected from source %u didn't arrive" % (dst_sw_if_index, i.sw_if_index)) - def run_verify_test(self): + def run_verify_test(self, bd_id, src_hosts, dst_hosts): # Test # Create incoming packet streams for packet-generator interfaces - for i in self.pg_interfaces: - pkts = self.create_stream(i, self.pg_if_packet_sizes) - i.add_stream(pkts) - + self.reset_packet_infos() + ifs = [self.pg_interfaces[i] for i in self.bd_ifs(bd_id)] + for i in ifs: + pkts = self.create_stream( + i, self.pg_if_packet_sizes, + if_src_hosts=src_hosts, + if_dst_hosts=dst_hosts) + if pkts: + i.add_stream(pkts) + + self.vapi.bridge_flags(bd_id, 0, 1) # Enable packet capture and start packet sending - self.pg_enable_capture(self.pg_interfaces) + self.pg_enable_capture(ifs) self.pg_start() # Verify # Verify outgoing packet streams per packet-generator interface - for i in self.pg_interfaces: + for i in ifs: + if not dst_hosts[i.sw_if_index]: + continue capture = i.get_capture() self.logger.info("Verifying capture on interface %s" % i.name) self.verify_capture(i, capture) - def run_verify_negat_test(self): + def run_verify_negat_test(self, bd_id, src_hosts, dst_hosts): # Test # Create incoming packet streams for packet-generator interfaces for # deleted MAC addresses - self.packet_infos = {} - for i in self.pg_interfaces: - pkts = self.create_stream(i, self.pg_if_packet_sizes, deleted=True) - i.add_stream(pkts) - + self.reset_packet_infos() + ifs = [self.pg_interfaces[i] for i in self.bd_ifs(bd_id)] + for i in ifs: + pkts = self.create_stream( + i, self.pg_if_packet_sizes, + if_src_hosts=src_hosts, + if_dst_hosts=dst_hosts) + if pkts: + i.add_stream(pkts) + + self.vapi.bridge_flags(bd_id, 0, 1) # Enable packet capture and start packet sending - self.pg_enable_capture(self.pg_interfaces) + self.pg_enable_capture(ifs) self.pg_start() # Verify # Verify outgoing packet streams per packet-generator interface - for i in self.pg_interfaces: + timeout = 1 + for i in ifs: + i.get_capture(0, timeout=timeout) i.assert_nothing_captured(remark="outgoing interface") + timeout = 0.1 - def test_l2_fib_01(self): - """ L2 FIB test 1 - program 100 MAC addresses + def test_l2_fib_program100(self): + """ L2 FIB - program 100 MACs """ - # Config 1 - # Create test host entries - self.create_hosts(100) + bd_id = 1 + hosts = self.create_hosts(100, subnet=17) + self.config_l2_fib_entries(bd_id, hosts) + self.run_verify_test(bd_id, hosts, hosts) - # Add first 100 MAC entries to L2 FIB - self.config_l2_fib_entries(100) + def test_l2_fib_program100_delete12(self): + """ L2 FIB - program 100, delete 12 MACs + """ + bd_id = 1 + hosts = self.create_hosts(100, subnet=17) + self.config_l2_fib_entries(bd_id, hosts) + del_hosts = self.split_hosts(hosts, 12) + self.delete_l2_fib_entry(bd_id, del_hosts) - # Test 1 - self.run_verify_test() + self.run_verify_test(bd_id, hosts, hosts) + self.run_verify_negat_test(bd_id, hosts, del_hosts) - def test_l2_fib_02(self): - """ L2 FIB test 2 - delete 12 MAC entries + def test_l2_fib_program100_add100(self): + """ L2 FIB - program 100, add 100 MACs + """ + bd_id = 1 + hosts = self.create_hosts(100, subnet=17) + self.config_l2_fib_entries(bd_id, hosts) + hosts2 = self.create_hosts(100, subnet=22) + self.config_l2_fib_entries(bd_id, hosts2) + self.run_verify_test(bd_id, hosts, hosts2) + + def test_l2_fib_program10_learn10(self): + """ L2 FIB - program 10 MACs, learn 10 + """ + hosts = self.create_hosts(20, subnet=35) + lhosts = self.split_hosts(hosts, 10) + + bd1 = 1 + bd2 = 2 + self.learn_hosts(bd1, lhosts) + self.learn_hosts(bd2, lhosts) + self.config_l2_fib_entries(bd1, hosts) + self.config_l2_fib_entries(bd2, hosts) + self.run_verify_test(bd1, lhosts, hosts) + self.run_verify_test(bd2, lhosts, hosts) + + def test_l2_fib_flush_int(self): + """ L2 FIB - flush interface + """ + hosts = self.create_hosts(20, subnet=36) + lhosts = self.split_hosts(hosts, 10) + + bd1 = 1 + self.learn_hosts(bd1, lhosts) + self.config_l2_fib_entries(bd1, hosts) + self.run_verify_test(bd1, lhosts, hosts) + flushed = self.flush_int(self.pg_interfaces[0].sw_if_index, lhosts) + self.run_verify_test(bd1, hosts, lhosts) + self.run_verify_negat_test(bd1, hosts, flushed) + + def test_l2_fib_flush_bd(self): + """ L2 FIB - flush BD """ - # Config 2 - # Delete 12 MAC entries (3 per interface) from L2 FIB - self.delete_l2_fib_entry(12) + hosts = self.create_hosts(20, subnet=37) + lhosts = self.split_hosts(hosts, 10) + + bd1 = 1 + self.learn_hosts(bd1, lhosts) + self.config_l2_fib_entries(bd1, hosts) + self.run_verify_test(bd1, lhosts, hosts) + flushed = self.flush_bd(bd1, lhosts) + self.run_verify_negat_test(bd1, hosts, flushed) + + def test_l2_fib_flush_all(self): + """ L2 FIB - flush all + """ + hosts = self.create_hosts(20, subnet=38) + lhosts = self.split_hosts(hosts, 10) - # Test 2a - self.run_verify_test() + bd1 = 1 + bd2 = 2 + self.learn_hosts(bd1, lhosts) + self.learn_hosts(bd2, lhosts) + self.config_l2_fib_entries(bd1, hosts) + self.config_l2_fib_entries(bd2, hosts) + self.run_verify_test(bd1, hosts, lhosts) + self.run_verify_test(bd2, hosts, lhosts) - # Verify 2a - self.run_verify_negat_test() + self.flush_all() - def test_l2_fib_03(self): - """ L2 FIB test 3 - program new 100 MAC addresses - """ - # Config 3 - # Create new test host entries - self.create_hosts(100, start=100) + self.run_verify_negat_test(bd1, hosts, lhosts) + self.run_verify_negat_test(bd2, hosts, lhosts) - # Add new 100 MAC entries to L2 FIB - self.config_l2_fib_entries(100, start=22) + def test_l2_fib_mac_learn_evs(self): + """ L2 FIB - mac learning events + """ + bd1 = 1 + hosts = self.create_hosts(10, subnet=39) - # Test 3 - self.run_verify_test() + self.vapi.want_macs_learn_events() + self.learn_hosts(bd1, hosts) - def test_l2_fib_04(self): - """ L2 FIB test 4 - delete 160 MAC entries + self.sleep(1) + self.logger.info(self.vapi.ppcli("show l2fib")) + evs = self.vapi.collect_events() + learned_macs = { + e.mac[i].mac_addr for e in evs for i in range(e.n_macs) + if e.mac[i].action == MAC_EVENT_ACTION_ADD} + macs = {h.bin_mac for swif in self.bd_ifs(bd1) + for h in hosts[self.pg_interfaces[swif].sw_if_index]} + self.vapi.want_macs_learn_events(enable_disable=0) + self.assertEqual(len(learned_macs ^ macs), 0) + + def test_l2_fib_macs_learn_max(self): + """ L2 FIB - mac learning max macs in event """ - # Config 4 - # Delete 160 MAC entries (40 per interface) from L2 FIB - self.delete_l2_fib_entry(160) + bd1 = 1 + hosts = self.create_hosts(10, subnet=40) + + ev_macs = 1 + self.vapi.want_macs_learn_events(max_macs_in_event=ev_macs) + self.learn_hosts(bd1, hosts) - # Test 4a - self.run_verify_negat_test() + self.sleep(1) + self.logger.info(self.vapi.ppcli("show l2fib")) + evs = self.vapi.collect_events() + self.vapi.want_macs_learn_events(enable_disable=0) + + self.assertGreater(len(evs), 0) + learned_macs = { + e.mac[i].mac_addr for e in evs for i in range(e.n_macs) + if e.mac[i].action == MAC_EVENT_ACTION_ADD} + macs = {h.bin_mac for swif in self.bd_ifs(bd1) + for h in hosts[self.pg_interfaces[swif].sw_if_index]} + + for e in evs: + self.assertLess(len(e), ev_macs * 10) + self.assertEqual(len(learned_macs ^ macs), 0) if __name__ == '__main__':