diff options
| -rw-r--r-- | test/test_l2_fib.py | 390 | ||||
| -rw-r--r-- | test/vpp_papi_provider.py | 69 |
2 files changed, 445 insertions, 14 deletions
diff --git a/test/test_l2_fib.py b/test/test_l2_fib.py new file mode 100644 index 00000000000..eb4f4e32d1b --- /dev/null +++ b/test/test_l2_fib.py @@ -0,0 +1,390 @@ +#!/usr/bin/env python +"""L2 FIB Test Case HLD: + +**config 1** + - add 4 pg-l2 interfaces + - configure them into l2bd + - configure 100 MAC entries in L2 fib - 25 MACs per interface + - L2 MAC learning and unknown unicast flooding disabled in l2bd + - configure 100 MAC entries in L2 fib - 25 MACs per interface + +**test 1** + - send L2 MAC frames between all 4 pg-l2 interfaces for all of 100 MAC \ + entries in the FIB + +**verify 1** + - all packets received correctly + +**config 2** + - delete 12 MAC entries - 3 MACs per interface + +**test 2a** + - send L2 MAC frames between all 4 pg-l2 interfaces for non-deleted MAC \ + entries + +**verify 2a** + - all packets received correctly + +**test 2b** + - send L2 MAC frames between all 4 pg-l2 interfaces for all of 12 deleted \ + MAC entries + +**verify 2b** + - no packet received on all 4 pg-l2 interfaces + +**config 3** + - configure new 100 MAC entries in L2 fib - 25 MACs per interface + +**test 3** + - send L2 MAC frames between all 4 pg-l2 interfaces for all of 188 MAC \ + entries in the FIB + +**verify 3** + - all packets received correctly + +**config 4** + - delete 160 MAC entries, 40 MACs per interface + +**test 4a** + - send L2 MAC frames between all 4 pg-l2 interfaces for all of 28 \ + non-deleted MAC entries + +**verify 4a** + - all packets received correctly + +**test 4b** + - try send L2 MAC frames between all 4 pg-l2 interfaces for all of 172 \ + deleted MAC entries + +**verify 4b** + - no packet received on all 4 pg-l2 interfaces +""" + +import unittest +import random + +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 + + +class TestL2fib(VppTestCase): + """ L2 FIB Test Case """ + + @classmethod + def setUpClass(cls): + """ + Perform standard class setup (defined by class method setUpClass in + class VppTestCase) before running the test case, set test case related + 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)) + + # 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] + + # 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) + + # 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 = {} + + def tearDown(self): + """ + Show various debug prints after each test. + """ + 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)) + + def create_hosts(self, count, start=0): + """ + 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. + """ + n_int = len(self.pg_interfaces) + macs_per_if = count / n_int + i = -1 + 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): + """ + Create required number of L2 FIB entries. + + :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): + """ + 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")) + + def create_stream(self, src_if, packet_sizes, deleted=False): + """ + Create input packet stream for defined interface using hosts or + deleted_hosts list. + + :param object src_if: Interface to create packet stream for. + :param list packet_sizes: List of required packet sizes. + :param boolean deleted: Set to True if deleted_hosts list required. + :return: Stream of packets. + """ + 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] + src_host = random.choice(src_hosts) + pkt_info = self.create_packet_info( + src_if.sw_if_index, dst_if.sw_if_index) + 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) / + UDP(sport=1234, dport=1234) / + Raw(payload)) + pkt_info.data = p.copy() + size = random.choice(packet_sizes) + self.extend_packet(p, size) + pkts.append(p) + return pkts + + def verify_capture(self, pg_if, capture): + """ + 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. + """ + last_info = dict() + for i in self.pg_interfaces: + 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])) + try: + ip = packet[IP] + udp = packet[UDP] + packet_index = payload_info.index + self.assertEqual(payload_info.dst, dst_sw_if_index) + 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) + except: + self.logger.error("Unexpected or invalid packet:") + self.logger.error(packet.show()) + raise + for i in self.pg_interfaces: + 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)) + + def run_verify_test(self): + # 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) + + # Enable packet capture and start packet sending + self.pg_enable_capture(self.pg_interfaces) + self.pg_start() + + # Verify + # Verify outgoing packet streams per packet-generator interface + for i in self.pg_interfaces: + 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): + # 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) + + # Enable packet capture and start packet sending + self.pg_enable_capture(self.pg_interfaces) + self.pg_start() + + # Verify + # Verify outgoing packet streams per packet-generator interface + for i in self.pg_interfaces: + capture = i.get_capture() + self.logger.info("Verifying capture on interface %s" % i.name) + try: + self.assertEqual(len(capture), 0) + except AssertionError: + self.logger.error("The capture on interface %s is not empty!" + % i.name) + raise AssertionError("%d != 0" % len(capture)) + + def test_l2_fib_01(self): + """ L2 FIB test 1 - program 100 MAC addresses + """ + # Config 1 + # Create test host entries + self.create_hosts(100) + + # Add first 100 MAC entries to L2 FIB + self.config_l2_fib_entries(100) + + # Test 1 + self.run_verify_test() + + def test_l2_fib_02(self): + """ L2 FIB test 2 - delete 12 MAC entries + """ + # Config 2 + # Delete 12 MAC entries (3 per interface) from L2 FIB + self.delete_l2_fib_entry(12) + + # Test 2a + self.run_verify_test() + + # Verify 2a + self.run_verify_negat_test() + + 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) + + # Add new 100 MAC entries to L2 FIB + self.config_l2_fib_entries(100, start=22) + + # Test 3 + self.run_verify_test() + + def test_l2_fib_04(self): + """ L2 FIB test 4 - delete 160 MAC entries + """ + # Config 4 + # Delete 160 MAC entries (40 per interface) from L2 FIB + self.delete_l2_fib_entry(160) + + # Test 4a + self.run_verify_negat_test() + + +if __name__ == '__main__': + unittest.main(testRunner=VppTestRunner) diff --git a/test/vpp_papi_provider.py b/test/vpp_papi_provider.py index 23a108d9ca2..776d4a68ae8 100644 --- a/test/vpp_papi_provider.py +++ b/test/vpp_papi_provider.py @@ -95,6 +95,9 @@ class VppPapiProvider(object): """ return cli + "\n" + self.cli(cli) + def _convert_mac(self, mac): + return int(mac.replace(":", ""), 16) << 16 + def show_version(self): """ """ return vpp_papi.show_version() @@ -202,16 +205,57 @@ class VppPapiProvider(object): (is_add, is_ipv6, src_addr, dst_addr, encap_vrf_id, decap_next_index, vni)) + def bridge_domain_add_del(self, bd_id, flood=1, uu_flood=1, forward=1, + learn=1, arp_term=0, is_add=1): + """Create/delete bridge domain. + + :param int bd_id: Bridge domain index. + :param int flood: Enable/disable bcast/mcast flooding in the BD. + (Default value = 1) + :param int uu_flood: Enable/disable unknown unicast flood in the BD. + (Default value = 1) + :param int forward: Enable/disable forwarding on all interfaces in + the BD. (Default value = 1) + :param int learn: Enable/disable learning on all interfaces in the BD. + (Default value = 1) + :param int arp_term: Enable/disable arp termination in the BD. + (Default value = 1) + :param int is_add: Add or delete flag. (Default value = 1) + """ + return self.api(vpp_papi.bridge_domain_add_del, + (bd_id, flood, uu_flood, forward, learn, arp_term, + is_add)) + + def l2fib_add_del(self, mac, bd_id, sw_if_index, is_add=1, static_mac=0, + filter_mac=0, bvi_mac=0): + """Create/delete L2 FIB entry. + + :param str mac: MAC address to create FIB entry for. + :param int bd_id: Bridge domain index. + :param int sw_if_index: Software interface index of the interface. + :param int is_add: Add or delete flag. (Default value = 1) + :param int static_mac: Set to 1 to create static MAC entry. + (Default value = 0) + :param int filter_mac: Set to 1 to drop packet that's source or + destination MAC address contains defined MAC address. + (Default value = 0) + :param int bvi_mac: Set to 1 to create entry that points to BVI + interface. (Default value = 0) + """ + return self.api(vpp_papi.l2fib_add_del, + (self._convert_mac(mac), bd_id, sw_if_index, is_add, + static_mac, filter_mac, bvi_mac)) + def sw_interface_set_l2_bridge(self, sw_if_index, bd_id, shg=0, bvi=0, enable=1): - """ - - :param bd_id: - :param sw_if_index: - :param shg: (Default value = 0) - :param bvi: (Default value = 0) - :param enable: (Default value = 1) + """Add/remove interface to/from bridge domain. + :param int sw_if_index: Software interface index of the interface. + :param int bd_id: Bridge domain index. + :param int shg: Split-horizon group index. (Default value = 0) + :param int bvi: Set interface as a bridge group virtual interface. + (Default value = 0) + :param int enable: Add or remove interface. (Default value = 1) """ return self.api(vpp_papi.sw_interface_set_l2_bridge, (sw_if_index, bd_id, shg, bvi, enable)) @@ -221,13 +265,10 @@ class VppPapiProvider(object): """Create or delete unidirectional cross-connect from Tx interface to Rx interface. - :param rx_sw_if_index: Software interface index of Rx interface. - :param tx_sw_if_index: Software interface index of Tx interface. - :param enable: Create cross-connect if equal to 1, delete cross-connect - if equal to 0. - :type rx_sw_if_index: str or int - :type rx_sw_if_index: str or int - :type enable: int + :param int rx_sw_if_index: Software interface index of Rx interface. + :param int tx_sw_if_index: Software interface index of Tx interface. + :param int enable: Create cross-connect if equal to 1, delete + cross-connect if equal to 0. """ return self.api(vpp_papi.sw_interface_set_l2_xconnect, |