diff options
Diffstat (limited to 'vpp/test/test_l2xc.py')
| -rw-r--r-- | vpp/test/test_l2xc.py | 230 |
1 files changed, 230 insertions, 0 deletions
diff --git a/vpp/test/test_l2xc.py b/vpp/test/test_l2xc.py new file mode 100644 index 00000000..37893042 --- /dev/null +++ b/vpp/test/test_l2xc.py @@ -0,0 +1,230 @@ +#!/usr/bin/env python + +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, ppp + + +class TestL2xc(VppTestCase): + """ L2XC 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 hosts_nr: Number of hosts to be created. + :var int dl_pkts_per_burst: Number of packets in burst for dual-loop + test. + :var int sl_pkts_per_burst: Number of packets in burst for single-loop + test. + """ + super(TestL2xc, cls).setUpClass() + + # Test variables + cls.hosts_nr = 10 + cls.dl_pkts_per_burst = 257 + cls.sl_pkts_per_burst = 2 + + 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.flows[cls.pg1] = [cls.pg0] + cls.flows[cls.pg2] = [cls.pg3] + cls.flows[cls.pg3] = [cls.pg2] + + # packet sizes + cls.pg_if_packet_sizes = [64, 512, 1518, 9018] + + cls.interfaces = list(cls.pg_interfaces) + + # Create bi-directional cross-connects between pg0 and pg1 + cls.vapi.sw_interface_set_l2_xconnect( + cls.pg0.sw_if_index, cls.pg1.sw_if_index, enable=1) + cls.vapi.sw_interface_set_l2_xconnect( + cls.pg1.sw_if_index, cls.pg0.sw_if_index, enable=1) + + # Create bi-directional cross-connects between pg2 and pg3 + cls.vapi.sw_interface_set_l2_xconnect( + cls.pg2.sw_if_index, cls.pg3.sw_if_index, enable=1) + cls.vapi.sw_interface_set_l2_xconnect( + cls.pg3.sw_if_index, cls.pg2.sw_if_index, enable=1) + + # mapping between packet-generator index and lists of test hosts + cls.hosts_by_pg_idx = dict() + + # Create host MAC and IPv4 lists + cls.create_host_lists(cls.hosts_nr) + + # setup all interfaces + for i in cls.interfaces: + i.admin_up() + + except Exception: + super(TestL2xc, cls).tearDownClass() + raise + + def setUp(self): + """ + Clear trace and packet infos before running each test. + """ + super(TestL2xc, self).setUp() + self.packet_infos = {} + + def tearDown(self): + """ + Show various debug prints after each test. + """ + super(TestL2xc, self).tearDown() + if not self.vpp_dead: + self.logger.info(self.vapi.ppcli("show l2patch")) + + @classmethod + def create_host_lists(cls, count): + """ + Method to create required number of MAC and IPv4 addresses. + Create required number of host MAC addresses and distribute them among + interfaces. Create host IPv4 address for every host MAC address too. + + :param count: Number of hosts to create MAC and IPv4 addresses for. + """ + for pg_if in cls.pg_interfaces: + cls.hosts_by_pg_idx[pg_if.sw_if_index] = [] + hosts = cls.hosts_by_pg_idx[pg_if.sw_if_index] + for j in range(0, count): + 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 create_stream(self, src_if, packet_sizes, packets_per_burst): + """ + Create input packet stream for defined interface. + + :param object src_if: Interface to create packet stream for. + :param list packet_sizes: List of required packet sizes. + :param int packets_per_burst: Number of packets in burst. + :return: Stream of packets. + """ + pkts = [] + for i in range(0, packets_per_burst): + dst_if = self.flows[src_if][0] + dst_host = random.choice(self.hosts_by_pg_idx[dst_if.sw_if_index]) + src_host = random.choice(self.hosts_by_pg_idx[src_if.sw_if_index]) + 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.interfaces: + last_info[i.sw_if_index] = None + dst_sw_if_index = pg_if.sw_if_index + for packet in capture: + try: + ip = packet[IP] + udp = packet[UDP] + payload_info = self.payload_to_info(str(packet[Raw])) + 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(ppp("Unexpected or invalid packet:", packet)) + raise + for i in self.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_l2xc_test(self, pkts_per_burst): + """ L2XC test """ + + # Create incoming packet streams for packet-generator interfaces + for i in self.interfaces: + pkts = self.create_stream(i, self.pg_if_packet_sizes, + pkts_per_burst) + i.add_stream(pkts) + + # Enable packet capturing and start packet sending + self.pg_enable_capture(self.pg_interfaces) + self.pg_start() + + # 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 test_l2xc_sl(self): + """ L2XC single-loop test + + Test scenario: + 1. config + 2 pairs of 2 interfaces, l2xconnected + + 2. sending l2 eth packets between 4 interfaces + 64B, 512B, 1518B, 9018B (ether_size) + burst of 2 packets per interface + """ + + self.run_l2xc_test(self.sl_pkts_per_burst) + + def test_l2xc_dl(self): + """ L2XC dual-loop test + + Test scenario: + 1. config + 2 pairs of 2 interfaces, l2xconnected + + 2. sending l2 eth packets between 4 interfaces + 64B, 512B, 1518B, 9018B (ether_size) + burst of 257 packets per interface + """ + + self.run_l2xc_test(self.dl_pkts_per_burst) + + +if __name__ == '__main__': + unittest.main(testRunner=VppTestRunner) |