From 31ed74407643595fdce206e9d7487108fb8b33ab Mon Sep 17 00:00:00 2001 From: Neale Ranns Date: Fri, 23 Feb 2018 05:29:09 -0800 Subject: MPLS Unifom mode - support both pipe and uniform modes for all MPLS LSP - all API programming for output-labels requires that the mode (and associated data) is specificed - API changes in MPLS, BIER and IP are involved - new DPO [sub] types for MPLS labels to handle the two modes. Change-Id: I87b76401e996f10dfbdbe4552ff6b19af958783c Signed-off-by: Neale Ranns --- test/test_bier.py | 29 +- test/test_mpls.py | 841 +++++++++++++++++++++----------------- test/test_udp.py | 12 +- test/vpp_bier.py | 29 +- test/vpp_ip_route.py | 44 +- test/vpp_mpls_tunnel_interface.py | 8 +- test/vpp_papi_provider.py | 21 +- 7 files changed, 570 insertions(+), 414 deletions(-) (limited to 'test') diff --git a/test/test_bier.py b/test/test_bier.py index ae7b46a130c..c7ec0eed127 100644 --- a/test/test_bier.py +++ b/test/test_bier.py @@ -6,7 +6,8 @@ import socket from framework import VppTestCase, VppTestRunner, running_extended_tests from vpp_ip_route import VppIpRoute, VppRoutePath, VppMplsRoute, \ VppMplsTable, VppIpMRoute, VppMRoutePath, VppIpTable, \ - MRouteEntryFlags, MRouteItfFlags, MPLS_LABEL_INVALID, DpoProto + MRouteEntryFlags, MRouteItfFlags, MPLS_LABEL_INVALID, DpoProto, \ + VppMplsLabel from vpp_bier import * from vpp_udp_encap import * @@ -99,15 +100,17 @@ class TestBier(VppTestCase): bier_routes = [] for i in range(1, max_bp+1): nh = "10.0.%d.%d" % (i / 255, i % 255) - nh_routes.append(VppIpRoute(self, nh, 32, - [VppRoutePath(self.pg1.remote_ip4, - self.pg1.sw_if_index, - labels=[2000+i])])) + nh_routes.append( + VppIpRoute(self, nh, 32, + [VppRoutePath(self.pg1.remote_ip4, + self.pg1.sw_if_index, + labels=[VppMplsLabel(2000+i)])])) nh_routes[-1].add_vpp_config() - bier_routes.append(VppBierRoute(self, bti, i, - [VppRoutePath(nh, 0xffffffff, - labels=[100+i])])) + bier_routes.append( + VppBierRoute(self, bti, i, + [VppRoutePath(nh, 0xffffffff, + labels=[VppMplsLabel(100+i)])])) bier_routes[-1].add_vpp_config() # @@ -216,20 +219,20 @@ class TestBier(VppTestCase): ip_route_1 = VppIpRoute(self, nh1, 32, [VppRoutePath(self.pg1.remote_ip4, self.pg1.sw_if_index, - labels=[2001])]) + labels=[VppMplsLabel(2001)])]) ip_route_2 = VppIpRoute(self, nh2, 32, [VppRoutePath(self.pg1.remote_ip4, self.pg1.sw_if_index, - labels=[2002])]) + labels=[VppMplsLabel(2002)])]) ip_route_1.add_vpp_config() ip_route_2.add_vpp_config() bier_route_1 = VppBierRoute(self, bti, 1, [VppRoutePath(nh1, 0xffffffff, - labels=[101])]) + labels=[VppMplsLabel(101)])]) bier_route_2 = VppBierRoute(self, bti, 2, [VppRoutePath(nh2, 0xffffffff, - labels=[102])]) + labels=[VppMplsLabel(102)])]) bier_route_1.add_vpp_config() bier_route_2.add_vpp_config() @@ -561,7 +564,7 @@ class TestBier(VppTestCase): ip_route = VppIpRoute(self, nh1, 32, [VppRoutePath(self.pg1.remote_ip4, self.pg1.sw_if_index, - labels=[2001])]) + labels=[VppMplsLabel(2001)])]) ip_route.add_vpp_config() udp_encap = VppUdpEncap(self, 4, diff --git a/test/test_mpls.py b/test/test_mpls.py index aa5e67439b7..33fed680dbe 100644 --- a/test/test_mpls.py +++ b/test/test_mpls.py @@ -6,7 +6,8 @@ import socket from framework import VppTestCase, VppTestRunner from vpp_ip_route import VppIpRoute, VppRoutePath, VppMplsRoute, \ VppMplsIpBind, VppIpMRoute, VppMRoutePath, \ - MRouteItfFlags, MRouteEntryFlags, DpoProto, VppIpTable, VppMplsTable + MRouteItfFlags, MRouteEntryFlags, DpoProto, VppIpTable, VppMplsTable, \ + VppMplsLabel, MplsLspMode from vpp_mpls_tunnel_interface import VppMPLSTunnelInterface from scapy.packet import Raw @@ -25,7 +26,7 @@ def verify_filter(capture, sent): return capture -def verify_mpls_stack(tst, rx, mpls_labels, ttl=255, num=0): +def verify_mpls_stack(tst, rx, mpls_labels): # the rx'd packet has the MPLS label popped eth = rx[Ether] tst.assertEqual(eth.type, 0x8847) @@ -33,12 +34,10 @@ def verify_mpls_stack(tst, rx, mpls_labels, ttl=255, num=0): rx_mpls = rx[MPLS] for ii in range(len(mpls_labels)): - tst.assertEqual(rx_mpls.label, mpls_labels[ii]) - tst.assertEqual(rx_mpls.cos, 0) - if ii == num: - tst.assertEqual(rx_mpls.ttl, ttl) - else: - tst.assertEqual(rx_mpls.ttl, 255) + tst.assertEqual(rx_mpls.label, mpls_labels[ii].value) + tst.assertEqual(rx_mpls.cos, mpls_labels[ii].exp) + tst.assertEqual(rx_mpls.ttl, mpls_labels[ii].ttl) + if ii == len(mpls_labels) - 1: tst.assertEqual(rx_mpls.s, 1) else: @@ -102,11 +101,11 @@ class TestMPLS(VppTestCase): self, src_if, mpls_labels, - mpls_ttl=255, ping=0, ip_itf=None, dst_ip=None, chksum=None, + ip_ttl=64, n=257): self.reset_packet_infos() pkts = [] @@ -116,22 +115,24 @@ class TestMPLS(VppTestCase): p = Ether(dst=src_if.local_mac, src=src_if.remote_mac) for ii in range(len(mpls_labels)): - if ii == len(mpls_labels) - 1: - p = p / MPLS(label=mpls_labels[ii], ttl=mpls_ttl, s=1) - else: - p = p / MPLS(label=mpls_labels[ii], ttl=mpls_ttl, s=0) + p = p / MPLS(label=mpls_labels[ii].value, + ttl=mpls_labels[ii].ttl, + cos=mpls_labels[ii].exp) if not ping: if not dst_ip: - p = (p / IP(src=src_if.local_ip4, dst=src_if.remote_ip4) / + p = (p / IP(src=src_if.local_ip4, + dst=src_if.remote_ip4, + ttl=ip_ttl) / UDP(sport=1234, dport=1234) / Raw(payload)) else: - p = (p / IP(src=src_if.local_ip4, dst=dst_ip) / + p = (p / IP(src=src_if.local_ip4, dst=dst_ip, ttl=ip_ttl) / UDP(sport=1234, dport=1234) / Raw(payload)) else: p = (p / IP(src=ip_itf.remote_ip4, - dst=ip_itf.local_ip4) / + dst=ip_itf.local_ip4, + ttl=ip_ttl) / ICMP()) if chksum: @@ -140,39 +141,58 @@ class TestMPLS(VppTestCase): pkts.append(p) return pkts - def create_stream_ip4(self, src_if, dst_ip): + def create_stream_ip4(self, src_if, dst_ip, ip_ttl=64, ip_dscp=0): self.reset_packet_infos() pkts = [] for i in range(0, 257): info = self.create_packet_info(src_if, src_if) payload = self.info_to_payload(info) p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) / - IP(src=src_if.remote_ip4, dst=dst_ip) / + IP(src=src_if.remote_ip4, dst=dst_ip, + ttl=ip_ttl, tos=ip_dscp) / UDP(sport=1234, dport=1234) / Raw(payload)) info.data = p.copy() pkts.append(p) return pkts - def create_stream_labelled_ip6(self, src_if, mpls_label, mpls_ttl, - dst_ip=None, hlim=64): - if dst_ip is None: - dst_ip = src_if.remote_ip6 + def create_stream_ip6(self, src_if, dst_ip, ip_ttl=64, ip_dscp=0): self.reset_packet_infos() pkts = [] for i in range(0, 257): info = self.create_packet_info(src_if, src_if) payload = self.info_to_payload(info) p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) / - MPLS(label=mpls_label, ttl=mpls_ttl) / - IPv6(src=src_if.remote_ip6, dst=dst_ip, hlim=hlim) / + IPv6(src=src_if.remote_ip6, dst=dst_ip, + hlim=ip_ttl, tc=ip_dscp) / UDP(sport=1234, dport=1234) / Raw(payload)) info.data = p.copy() pkts.append(p) return pkts - def verify_capture_ip4(self, src_if, capture, sent, ping_resp=0): + def create_stream_labelled_ip6(self, src_if, mpls_labels, + hlim=64, dst_ip=None): + if dst_ip is None: + dst_ip = src_if.remote_ip6 + self.reset_packet_infos() + pkts = [] + for i in range(0, 257): + info = self.create_packet_info(src_if, src_if) + payload = self.info_to_payload(info) + p = Ether(dst=src_if.local_mac, src=src_if.remote_mac) + for l in mpls_labels: + p = p / MPLS(label=l.value, ttl=l.ttl, cos=l.exp) + + p = p / (IPv6(src=src_if.remote_ip6, dst=dst_ip, hlim=hlim) / + UDP(sport=1234, dport=1234) / + Raw(payload)) + info.data = p.copy() + pkts.append(p) + return pkts + + def verify_capture_ip4(self, src_if, capture, sent, ping_resp=0, + ip_ttl=None, ip_dscp=0): try: capture = verify_filter(capture, sent) @@ -192,8 +212,12 @@ class TestMPLS(VppTestCase): if not ping_resp: self.assertEqual(rx_ip.src, tx_ip.src) self.assertEqual(rx_ip.dst, tx_ip.dst) - # IP processing post pop has decremented the TTL - self.assertEqual(rx_ip.ttl + 1, tx_ip.ttl) + self.assertEqual(rx_ip.tos, ip_dscp) + if not ip_ttl: + # IP processing post pop has decremented the TTL + self.assertEqual(rx_ip.ttl + 1, tx_ip.ttl) + else: + self.assertEqual(rx_ip.ttl, ip_ttl) else: self.assertEqual(rx_ip.src, tx_ip.dst) self.assertEqual(rx_ip.dst, tx_ip.src) @@ -202,7 +226,7 @@ class TestMPLS(VppTestCase): raise def verify_capture_labelled_ip4(self, src_if, capture, sent, - mpls_labels): + mpls_labels, ip_ttl=None): try: capture = verify_filter(capture, sent) @@ -214,22 +238,46 @@ class TestMPLS(VppTestCase): tx_ip = tx[IP] rx_ip = rx[IP] - # the MPLS TTL is copied from the IP - verify_mpls_stack(self, rx, mpls_labels, rx_ip.ttl, - len(mpls_labels) - 1) + verify_mpls_stack(self, rx, mpls_labels) self.assertEqual(rx_ip.src, tx_ip.src) self.assertEqual(rx_ip.dst, tx_ip.dst) - # IP processing post pop has decremented the TTL - self.assertEqual(rx_ip.ttl + 1, tx_ip.ttl) + if not ip_ttl: + # IP processing post pop has decremented the TTL + self.assertEqual(rx_ip.ttl + 1, tx_ip.ttl) + else: + self.assertEqual(rx_ip.ttl, ip_ttl) + + except: + raise + + def verify_capture_labelled_ip6(self, src_if, capture, sent, + mpls_labels, ip_ttl=None): + try: + capture = verify_filter(capture, sent) + + self.assertEqual(len(capture), len(sent)) + + for i in range(len(capture)): + tx = sent[i] + rx = capture[i] + tx_ip = tx[IPv6] + rx_ip = rx[IPv6] + + verify_mpls_stack(self, rx, mpls_labels) + + self.assertEqual(rx_ip.src, tx_ip.src) + self.assertEqual(rx_ip.dst, tx_ip.dst) + if not ip_ttl: + # IP processing post pop has decremented the TTL + self.assertEqual(rx_ip.hlim + 1, tx_ip.hlim) + else: + self.assertEqual(rx_ip.hlim, ip_ttl) except: raise - def verify_capture_tunneled_ip4(self, src_if, capture, sent, mpls_labels, - ttl=255, top=None): - if top is None: - top = len(mpls_labels) - 1 + def verify_capture_tunneled_ip4(self, src_if, capture, sent, mpls_labels): try: capture = verify_filter(capture, sent) @@ -241,8 +289,7 @@ class TestMPLS(VppTestCase): tx_ip = tx[IP] rx_ip = rx[IP] - # the MPLS TTL is 255 since it enters a new tunnel - verify_mpls_stack(self, rx, mpls_labels, ttl, top) + verify_mpls_stack(self, rx, mpls_labels) self.assertEqual(rx_ip.src, tx_ip.src) self.assertEqual(rx_ip.dst, tx_ip.dst) @@ -253,7 +300,7 @@ class TestMPLS(VppTestCase): raise def verify_capture_labelled(self, src_if, capture, sent, - mpls_labels, ttl=254, num=0): + mpls_labels): try: capture = verify_filter(capture, sent) @@ -261,11 +308,12 @@ class TestMPLS(VppTestCase): for i in range(len(capture)): rx = capture[i] - verify_mpls_stack(self, rx, mpls_labels, ttl, num) + verify_mpls_stack(self, rx, mpls_labels) except: raise - def verify_capture_ip6(self, src_if, capture, sent): + def verify_capture_ip6(self, src_if, capture, sent, + ip_hlim=None, ip_dscp=0): try: self.assertEqual(len(capture), len(sent)) @@ -282,8 +330,12 @@ class TestMPLS(VppTestCase): self.assertEqual(rx_ip.src, tx_ip.src) self.assertEqual(rx_ip.dst, tx_ip.dst) + self.assertEqual(rx_ip.tc, ip_dscp) # IP processing post pop has decremented the TTL - self.assertEqual(rx_ip.hlim + 1, tx_ip.hlim) + if not ip_hlim: + self.assertEqual(rx_ip.hlim + 1, tx_ip.hlim) + else: + self.assertEqual(rx_ip.hlim, ip_hlim) except: raise @@ -323,22 +375,18 @@ class TestMPLS(VppTestCase): route_32_eos = VppMplsRoute(self, 32, 1, [VppRoutePath(self.pg0.remote_ip4, self.pg0.sw_if_index, - labels=[33])]) + labels=[VppMplsLabel(33)])]) route_32_eos.add_vpp_config() # # a stream that matches the route for 10.0.0.1 # PG0 is in the default table # - self.vapi.cli("clear trace") - tx = self.create_stream_labelled_ip4(self.pg0, [32]) - self.pg0.add_stream(tx) - - self.pg_enable_capture(self.pg_interfaces) - self.pg_start() - - rx = self.pg0.get_capture() - self.verify_capture_labelled(self.pg0, rx, tx, [33]) + tx = self.create_stream_labelled_ip4(self.pg0, + [VppMplsLabel(32, ttl=32, exp=1)]) + rx = self.send_and_expect(self.pg0, tx, self.pg0) + self.verify_capture_labelled(self.pg0, rx, tx, + [VppMplsLabel(33, ttl=31, exp=1)]) # # A simple MPLS xconnect - non-eos label in label out @@ -346,22 +394,38 @@ class TestMPLS(VppTestCase): route_32_neos = VppMplsRoute(self, 32, 0, [VppRoutePath(self.pg0.remote_ip4, self.pg0.sw_if_index, - labels=[33])]) + labels=[VppMplsLabel(33)])]) route_32_neos.add_vpp_config() # # a stream that matches the route for 10.0.0.1 # PG0 is in the default table # - self.vapi.cli("clear trace") - tx = self.create_stream_labelled_ip4(self.pg0, [32, 99]) - self.pg0.add_stream(tx) + tx = self.create_stream_labelled_ip4(self.pg0, + [VppMplsLabel(32, ttl=21, exp=7), + VppMplsLabel(99)]) + rx = self.send_and_expect(self.pg0, tx, self.pg0) + self.verify_capture_labelled(self.pg0, rx, tx, + [VppMplsLabel(33, ttl=20, exp=7), + VppMplsLabel(99)]) - self.pg_enable_capture(self.pg_interfaces) - self.pg_start() + # + # A simple MPLS xconnect - non-eos label in label out, uniform mode + # + route_42_neos = VppMplsRoute( + self, 42, 0, + [VppRoutePath(self.pg0.remote_ip4, + self.pg0.sw_if_index, + labels=[VppMplsLabel(43, MplsLspMode.UNIFORM)])]) + route_42_neos.add_vpp_config() - rx = self.pg0.get_capture() - self.verify_capture_labelled(self.pg0, rx, tx, [33, 99]) + tx = self.create_stream_labelled_ip4(self.pg0, + [VppMplsLabel(42, ttl=21, exp=7), + VppMplsLabel(99)]) + rx = self.send_and_expect(self.pg0, tx, self.pg0) + self.verify_capture_labelled(self.pg0, rx, tx, + [VppMplsLabel(43, ttl=20, exp=7), + VppMplsLabel(99)]) # # An MPLS xconnect - EOS label in IP out @@ -372,25 +436,40 @@ class TestMPLS(VppTestCase): labels=[])]) route_33_eos.add_vpp_config() - self.vapi.cli("clear trace") - tx = self.create_stream_labelled_ip4(self.pg0, [33]) - self.pg0.add_stream(tx) - - self.pg_enable_capture(self.pg_interfaces) - self.pg_start() - - rx = self.pg0.get_capture() + tx = self.create_stream_labelled_ip4(self.pg0, [VppMplsLabel(33)]) + rx = self.send_and_expect(self.pg0, tx, self.pg0) self.verify_capture_ip4(self.pg0, rx, tx) # # disposed packets have an invalid IPv4 checkusm # - tx = self.create_stream_labelled_ip4(self.pg0, [33], + tx = self.create_stream_labelled_ip4(self.pg0, [VppMplsLabel(33)], dst_ip=self.pg0.remote_ip4, n=65, chksum=1) self.send_and_assert_no_replies(self.pg0, tx, "Invalid Checksum") + # + # An MPLS xconnect - EOS label in IP out, uniform mode + # + route_3333_eos = VppMplsRoute( + self, 3333, 1, + [VppRoutePath(self.pg0.remote_ip4, + self.pg0.sw_if_index, + labels=[VppMplsLabel(3, MplsLspMode.UNIFORM)])]) + route_3333_eos.add_vpp_config() + + tx = self.create_stream_labelled_ip4( + self.pg0, + [VppMplsLabel(3333, ttl=55, exp=3)]) + rx = self.send_and_expect(self.pg0, tx, self.pg0) + self.verify_capture_ip4(self.pg0, rx, tx, ip_ttl=54, ip_dscp=0x60) + tx = self.create_stream_labelled_ip4( + self.pg0, + [VppMplsLabel(3333, ttl=66, exp=4)]) + rx = self.send_and_expect(self.pg0, tx, self.pg0) + self.verify_capture_ip4(self.pg0, rx, tx, ip_ttl=65, ip_dscp=0x80) + # # An MPLS xconnect - EOS label in IPv6 out # @@ -402,33 +481,18 @@ class TestMPLS(VppTestCase): proto=DpoProto.DPO_PROTO_IP6)]) route_333_eos.add_vpp_config() - self.vapi.cli("clear trace") - tx = self.create_stream_labelled_ip6(self.pg0, [333], 64) - self.pg0.add_stream(tx) - - self.pg_enable_capture(self.pg_interfaces) - self.pg_start() - - rx = self.pg0.get_capture() + tx = self.create_stream_labelled_ip6(self.pg0, [VppMplsLabel(333)]) + rx = self.send_and_expect(self.pg0, tx, self.pg0) self.verify_capture_ip6(self.pg0, rx, tx) # # disposed packets have an TTL expired # - tx = self.create_stream_labelled_ip6(self.pg0, [333], 64, + tx = self.create_stream_labelled_ip6(self.pg0, + [VppMplsLabel(333, ttl=64)], dst_ip=self.pg1.remote_ip6, hlim=1) - - self.vapi.cli("clear trace") - tx = self.create_stream_labelled_ip6(self.pg0, [333], 64, - dst_ip=self.pg1.remote_ip6, - hlim=0) - self.pg0.add_stream(tx) - - self.pg_enable_capture(self.pg_interfaces) - self.pg_start() - - rx = self.pg0.get_capture() + rx = self.send_and_expect(self.pg0, tx, self.pg0) self.verify_capture_ip6_icmp(self.pg0, rx, tx) # @@ -438,33 +502,39 @@ class TestMPLS(VppTestCase): self, 334, 1, [VppRoutePath(self.pg0.remote_ip6, self.pg0.sw_if_index, - labels=[3], + labels=[VppMplsLabel(3)], proto=DpoProto.DPO_PROTO_IP6)]) route_334_eos.add_vpp_config() - self.vapi.cli("clear trace") - tx = self.create_stream_labelled_ip6(self.pg0, [334], 64) - self.pg0.add_stream(tx) + tx = self.create_stream_labelled_ip6(self.pg0, + [VppMplsLabel(334, ttl=64)]) + rx = self.send_and_expect(self.pg0, tx, self.pg0) + self.verify_capture_ip6(self.pg0, rx, tx) - self.pg_enable_capture(self.pg_interfaces) - self.pg_start() + # + # An MPLS xconnect - EOS label in IPv6 out w imp-null in uniform mode + # + route_335_eos = VppMplsRoute( + self, 335, 1, + [VppRoutePath(self.pg0.remote_ip6, + self.pg0.sw_if_index, + labels=[VppMplsLabel(3, MplsLspMode.UNIFORM)], + proto=DpoProto.DPO_PROTO_IP6)]) + route_335_eos.add_vpp_config() - rx = self.pg0.get_capture() - self.verify_capture_ip6(self.pg0, rx, tx) + tx = self.create_stream_labelled_ip6( + self.pg0, + [VppMplsLabel(335, ttl=27, exp=4)]) + rx = self.send_and_expect(self.pg0, tx, self.pg0) + self.verify_capture_ip6(self.pg0, rx, tx, ip_hlim=26, ip_dscp=0x80) # # disposed packets have an TTL expired # - self.vapi.cli("clear trace") - tx = self.create_stream_labelled_ip6(self.pg0, [334], 64, + tx = self.create_stream_labelled_ip6(self.pg0, [VppMplsLabel(334)], dst_ip=self.pg1.remote_ip6, hlim=0) - self.pg0.add_stream(tx) - - self.pg_enable_capture(self.pg_interfaces) - self.pg_start() - - rx = self.pg0.get_capture() + rx = self.send_and_expect(self.pg0, tx, self.pg0) self.verify_capture_ip6_icmp(self.pg0, rx, tx) # @@ -477,33 +547,51 @@ class TestMPLS(VppTestCase): labels=[])]) route_33_neos.add_vpp_config() - self.vapi.cli("clear trace") - tx = self.create_stream_labelled_ip4(self.pg0, [33, 99]) - self.pg0.add_stream(tx) - - self.pg_enable_capture(self.pg_interfaces) - self.pg_start() - self.pg0.assert_nothing_captured( - remark="MPLS non-EOS packets popped and forwarded") + tx = self.create_stream_labelled_ip4(self.pg0, + [VppMplsLabel(33), + VppMplsLabel(99)]) + self.send_and_assert_no_replies( + self.pg0, tx, + "MPLS non-EOS packets popped and forwarded") # # A recursive EOS x-connect, which resolves through another x-connect + # in pipe mode # route_34_eos = VppMplsRoute(self, 34, 1, [VppRoutePath("0.0.0.0", 0xffffffff, nh_via_label=32, - labels=[44, 45])]) + labels=[VppMplsLabel(44), + VppMplsLabel(45)])]) route_34_eos.add_vpp_config() - tx = self.create_stream_labelled_ip4(self.pg0, [34]) - self.pg0.add_stream(tx) + tx = self.create_stream_labelled_ip4(self.pg0, + [VppMplsLabel(34, ttl=3)]) + rx = self.send_and_expect(self.pg0, tx, self.pg0) + self.verify_capture_labelled(self.pg0, rx, tx, + [VppMplsLabel(33), + VppMplsLabel(44), + VppMplsLabel(45, ttl=2)]) - self.pg_enable_capture(self.pg_interfaces) - self.pg_start() + # + # A recursive EOS x-connect, which resolves through another x-connect + # in uniform mode + # + route_35_eos = VppMplsRoute( + self, 35, 1, + [VppRoutePath("0.0.0.0", + 0xffffffff, + nh_via_label=42, + labels=[VppMplsLabel(44)])]) + route_35_eos.add_vpp_config() - rx = self.pg0.get_capture() - self.verify_capture_labelled(self.pg0, rx, tx, [33, 44, 45], num=2) + tx = self.create_stream_labelled_ip4(self.pg0, + [VppMplsLabel(35, ttl=3)]) + rx = self.send_and_expect(self.pg0, tx, self.pg0) + self.verify_capture_labelled(self.pg0, rx, tx, + [VppMplsLabel(43, ttl=2), + VppMplsLabel(44, ttl=2)]) # # A recursive non-EOS x-connect, which resolves through another @@ -513,19 +601,20 @@ class TestMPLS(VppTestCase): [VppRoutePath("0.0.0.0", 0xffffffff, nh_via_label=32, - labels=[44, 46])]) + labels=[VppMplsLabel(44), + VppMplsLabel(46)])]) route_34_neos.add_vpp_config() - self.vapi.cli("clear trace") - tx = self.create_stream_labelled_ip4(self.pg0, [34, 99]) - self.pg0.add_stream(tx) - - self.pg_enable_capture(self.pg_interfaces) - self.pg_start() - - rx = self.pg0.get_capture() + tx = self.create_stream_labelled_ip4(self.pg0, + [VppMplsLabel(34, ttl=45), + VppMplsLabel(99)]) + rx = self.send_and_expect(self.pg0, tx, self.pg0) # it's the 2nd (counting from 0) label in the stack that is swapped - self.verify_capture_labelled(self.pg0, rx, tx, [33, 44, 46, 99], num=2) + self.verify_capture_labelled(self.pg0, rx, tx, + [VppMplsLabel(33), + VppMplsLabel(44), + VppMplsLabel(46, ttl=44), + VppMplsLabel(99)]) # # an recursive IP route that resolves through the recursive non-eos @@ -535,18 +624,16 @@ class TestMPLS(VppTestCase): [VppRoutePath("0.0.0.0", 0xffffffff, nh_via_label=34, - labels=[55])]) + labels=[VppMplsLabel(55)])]) ip_10_0_0_1.add_vpp_config() - self.vapi.cli("clear trace") tx = self.create_stream_ip4(self.pg0, "10.0.0.1") - self.pg0.add_stream(tx) - - self.pg_enable_capture(self.pg_interfaces) - self.pg_start() - - rx = self.pg0.get_capture() - self.verify_capture_labelled_ip4(self.pg0, rx, tx, [33, 44, 46, 55]) + rx = self.send_and_expect(self.pg0, tx, self.pg0) + self.verify_capture_labelled_ip4(self.pg0, rx, tx, + [VppMplsLabel(33), + VppMplsLabel(44), + VppMplsLabel(46), + VppMplsLabel(55)]) ip_10_0_0_1.remove_vpp_config() route_34_neos.remove_vpp_config() @@ -565,7 +652,7 @@ class TestMPLS(VppTestCase): route_10_0_0_1 = VppIpRoute(self, "10.0.0.1", 32, [VppRoutePath(self.pg0.remote_ip4, self.pg0.sw_if_index, - labels=[45])]) + labels=[VppMplsLabel(45)])]) route_10_0_0_1.add_vpp_config() # bind a local label to the route @@ -573,37 +660,24 @@ class TestMPLS(VppTestCase): binding.add_vpp_config() # non-EOS stream - self.vapi.cli("clear trace") - tx = self.create_stream_labelled_ip4(self.pg0, [44, 99]) - self.pg0.add_stream(tx) - - self.pg_enable_capture(self.pg_interfaces) - self.pg_start() - - rx = self.pg0.get_capture() - self.verify_capture_labelled(self.pg0, rx, tx, [45, 99]) + tx = self.create_stream_labelled_ip4(self.pg0, + [VppMplsLabel(44), + VppMplsLabel(99)]) + rx = self.send_and_expect(self.pg0, tx, self.pg0) + self.verify_capture_labelled(self.pg0, rx, tx, + [VppMplsLabel(45, ttl=63), + VppMplsLabel(99)]) # EOS stream - self.vapi.cli("clear trace") - tx = self.create_stream_labelled_ip4(self.pg0, [44]) - self.pg0.add_stream(tx) - - self.pg_enable_capture(self.pg_interfaces) - self.pg_start() - - rx = self.pg0.get_capture() - self.verify_capture_labelled(self.pg0, rx, tx, [45]) + tx = self.create_stream_labelled_ip4(self.pg0, [VppMplsLabel(44)]) + rx = self.send_and_expect(self.pg0, tx, self.pg0) + self.verify_capture_labelled(self.pg0, rx, tx, + [VppMplsLabel(45, ttl=63)]) # IP stream - self.vapi.cli("clear trace") tx = self.create_stream_ip4(self.pg0, "10.0.0.1") - self.pg0.add_stream(tx) - - self.pg_enable_capture(self.pg_interfaces) - self.pg_start() - - rx = self.pg0.get_capture() - self.verify_capture_labelled_ip4(self.pg0, rx, tx, [45]) + rx = self.send_and_expect(self.pg0, tx, self.pg0) + self.verify_capture_labelled_ip4(self.pg0, rx, tx, [VppMplsLabel(45)]) # # cleanup @@ -620,22 +694,16 @@ class TestMPLS(VppTestCase): route_10_0_0_1 = VppIpRoute(self, "10.0.0.1", 32, [VppRoutePath(self.pg0.remote_ip4, self.pg0.sw_if_index, - labels=[32])]) + labels=[VppMplsLabel(32)])]) route_10_0_0_1.add_vpp_config() # # a stream that matches the route for 10.0.0.1 # PG0 is in the default table # - self.vapi.cli("clear trace") tx = self.create_stream_ip4(self.pg0, "10.0.0.1") - self.pg0.add_stream(tx) - - self.pg_enable_capture(self.pg_interfaces) - self.pg_start() - - rx = self.pg0.get_capture() - self.verify_capture_labelled_ip4(self.pg0, rx, tx, [32]) + rx = self.send_and_expect(self.pg0, tx, self.pg0) + self.verify_capture_labelled_ip4(self.pg0, rx, tx, [VppMplsLabel(32)]) # # Add a non-recursive route with a 3 out labels @@ -643,22 +711,56 @@ class TestMPLS(VppTestCase): route_10_0_0_2 = VppIpRoute(self, "10.0.0.2", 32, [VppRoutePath(self.pg0.remote_ip4, self.pg0.sw_if_index, - labels=[32, 33, 34])]) + labels=[VppMplsLabel(32), + VppMplsLabel(33), + VppMplsLabel(34)])]) route_10_0_0_2.add_vpp_config() + tx = self.create_stream_ip4(self.pg0, "10.0.0.2", + ip_ttl=44, ip_dscp=0xff) + rx = self.send_and_expect(self.pg0, tx, self.pg0) + self.verify_capture_labelled_ip4(self.pg0, rx, tx, + [VppMplsLabel(32), + VppMplsLabel(33), + VppMplsLabel(34)], + ip_ttl=43) + # - # a stream that matches the route for 10.0.0.1 - # PG0 is in the default table + # Add a non-recursive route with a single out label in uniform mode # - self.vapi.cli("clear trace") - tx = self.create_stream_ip4(self.pg0, "10.0.0.2") - self.pg0.add_stream(tx) + route_10_0_0_3 = VppIpRoute( + self, "10.0.0.3", 32, + [VppRoutePath(self.pg0.remote_ip4, + self.pg0.sw_if_index, + labels=[VppMplsLabel(32, + mode=MplsLspMode.UNIFORM)])]) + route_10_0_0_3.add_vpp_config() - self.pg_enable_capture(self.pg_interfaces) - self.pg_start() + tx = self.create_stream_ip4(self.pg0, "10.0.0.3", + ip_ttl=54, ip_dscp=0xbe) + rx = self.send_and_expect(self.pg0, tx, self.pg0) + self.verify_capture_labelled_ip4(self.pg0, rx, tx, + [VppMplsLabel(32, ttl=53, exp=5)]) - rx = self.pg0.get_capture() - self.verify_capture_labelled_ip4(self.pg0, rx, tx, [32, 33, 34]) + # + # Add a IPv6 non-recursive route with a single out label in + # uniform mode + # + route_2001_3 = VppIpRoute( + self, "2001::3", 128, + [VppRoutePath(self.pg0.remote_ip6, + self.pg0.sw_if_index, + proto=DpoProto.DPO_PROTO_IP6, + labels=[VppMplsLabel(32, + mode=MplsLspMode.UNIFORM)])], + is_ip6=1) + route_2001_3.add_vpp_config() + + tx = self.create_stream_ip6(self.pg0, "2001::3", + ip_ttl=54, ip_dscp=0xbe) + rx = self.send_and_expect(self.pg0, tx, self.pg0) + self.verify_capture_labelled_ip6(self.pg0, rx, tx, + [VppMplsLabel(32, ttl=53, exp=5)]) # # add a recursive path, with output label, via the 1 label route @@ -666,22 +768,18 @@ class TestMPLS(VppTestCase): route_11_0_0_1 = VppIpRoute(self, "11.0.0.1", 32, [VppRoutePath("10.0.0.1", 0xffffffff, - labels=[44])]) + labels=[VppMplsLabel(44)])]) route_11_0_0_1.add_vpp_config() # # a stream that matches the route for 11.0.0.1, should pick up # the label stack for 11.0.0.1 and 10.0.0.1 # - self.vapi.cli("clear trace") tx = self.create_stream_ip4(self.pg0, "11.0.0.1") - self.pg0.add_stream(tx) - - self.pg_enable_capture(self.pg_interfaces) - self.pg_start() - - rx = self.pg0.get_capture() - self.verify_capture_labelled_ip4(self.pg0, rx, tx, [32, 44]) + rx = self.send_and_expect(self.pg0, tx, self.pg0) + self.verify_capture_labelled_ip4(self.pg0, rx, tx, + [VppMplsLabel(32), + VppMplsLabel(44)]) # # add a recursive path, with 2 labels, via the 3 label route @@ -689,23 +787,22 @@ class TestMPLS(VppTestCase): route_11_0_0_2 = VppIpRoute(self, "11.0.0.2", 32, [VppRoutePath("10.0.0.2", 0xffffffff, - labels=[44, 45])]) + labels=[VppMplsLabel(44), + VppMplsLabel(45)])]) route_11_0_0_2.add_vpp_config() # # a stream that matches the route for 11.0.0.1, should pick up # the label stack for 11.0.0.1 and 10.0.0.1 # - self.vapi.cli("clear trace") tx = self.create_stream_ip4(self.pg0, "11.0.0.2") - self.pg0.add_stream(tx) - - self.pg_enable_capture(self.pg_interfaces) - self.pg_start() - - rx = self.pg0.get_capture() - self.verify_capture_labelled_ip4( - self.pg0, rx, tx, [32, 33, 34, 44, 45]) + rx = self.send_and_expect(self.pg0, tx, self.pg0) + self.verify_capture_labelled_ip4(self.pg0, rx, tx, + [VppMplsLabel(32), + VppMplsLabel(33), + VppMplsLabel(34), + VppMplsLabel(44), + VppMplsLabel(45)]) # # cleanup @@ -715,16 +812,18 @@ class TestMPLS(VppTestCase): route_10_0_0_2.remove_vpp_config() route_10_0_0_1.remove_vpp_config() - def test_tunnel(self): - """ MPLS Tunnel Tests """ + def test_tunnel_pipe(self): + """ MPLS Tunnel Tests - Pipe """ # # Create a tunnel with a single out label # - mpls_tun = VppMPLSTunnelInterface(self, - [VppRoutePath(self.pg0.remote_ip4, - self.pg0.sw_if_index, - labels=[44, 46])]) + mpls_tun = VppMPLSTunnelInterface( + self, + [VppRoutePath(self.pg0.remote_ip4, + self.pg0.sw_if_index, + labels=[VppMplsLabel(44), + VppMplsLabel(46)])]) mpls_tun.add_vpp_config() mpls_tun.admin_up() @@ -744,7 +843,9 @@ class TestMPLS(VppTestCase): self.pg_start() rx = self.pg0.get_capture() - self.verify_capture_tunneled_ip4(self.pg0, rx, tx, [44, 46]) + self.verify_capture_tunneled_ip4(self.pg0, rx, tx, + [VppMplsLabel(44), + VppMplsLabel(46)]) # # add a labelled route through the new tunnel @@ -763,35 +864,88 @@ class TestMPLS(VppTestCase): self.pg_start() rx = self.pg0.get_capture() - self.verify_capture_tunneled_ip4(self.pg0, rx, tx, [44, 46, 33], - ttl=63, top=2) + self.verify_capture_tunneled_ip4(self.pg0, rx, tx, + [VppMplsLabel(44), + VppMplsLabel(46), + VppMplsLabel(33, ttl=255)]) - def test_v4_exp_null(self): - """ MPLS V4 Explicit NULL test """ + def test_tunnel_uniform(self): + """ MPLS Tunnel Tests - Uniform """ # - # The first test case has an MPLS TTL of 0 - # all packet should be dropped + # Create a tunnel with a single out label + # The label stack is specified here from outer to inner # - tx = self.create_stream_labelled_ip4(self.pg0, [0], 0) + mpls_tun = VppMPLSTunnelInterface( + self, + [VppRoutePath(self.pg0.remote_ip4, + self.pg0.sw_if_index, + labels=[VppMplsLabel(44, ttl=32), + VppMplsLabel(46, MplsLspMode.UNIFORM)])]) + mpls_tun.add_vpp_config() + mpls_tun.admin_up() + + # + # add an unlabelled route through the new tunnel + # + route_10_0_0_3 = VppIpRoute(self, "10.0.0.3", 32, + [VppRoutePath("0.0.0.0", + mpls_tun._sw_if_index)]) + route_10_0_0_3.add_vpp_config() + + self.vapi.cli("clear trace") + tx = self.create_stream_ip4(self.pg0, "10.0.0.3", ip_ttl=24) self.pg0.add_stream(tx) self.pg_enable_capture(self.pg_interfaces) self.pg_start() - self.pg0.assert_nothing_captured(remark="MPLS TTL=0 packets forwarded") + rx = self.pg0.get_capture() + self.verify_capture_tunneled_ip4(self.pg0, rx, tx, + [VppMplsLabel(44, ttl=32), + VppMplsLabel(46, ttl=23)]) # - # a stream with a non-zero MPLS TTL - # PG0 is in the default table + # add a labelled route through the new tunnel # - tx = self.create_stream_labelled_ip4(self.pg0, [0]) + route_10_0_0_4 = VppIpRoute( + self, "10.0.0.4", 32, + [VppRoutePath("0.0.0.0", + mpls_tun._sw_if_index, + labels=[VppMplsLabel(33, ttl=47)])]) + route_10_0_0_4.add_vpp_config() + + self.vapi.cli("clear trace") + tx = self.create_stream_ip4(self.pg0, "10.0.0.4") self.pg0.add_stream(tx) self.pg_enable_capture(self.pg_interfaces) self.pg_start() rx = self.pg0.get_capture() + self.verify_capture_tunneled_ip4(self.pg0, rx, tx, + [VppMplsLabel(44, ttl=32), + VppMplsLabel(46, ttl=47), + VppMplsLabel(33, ttl=47)]) + + def test_v4_exp_null(self): + """ MPLS V4 Explicit NULL test """ + + # + # The first test case has an MPLS TTL of 0 + # all packet should be dropped + # + tx = self.create_stream_labelled_ip4(self.pg0, + [VppMplsLabel(0, ttl=0)]) + self.send_and_assert_no_replies(self.pg0, tx, + "MPLS TTL=0 packets forwarded") + + # + # a stream with a non-zero MPLS TTL + # PG0 is in the default table + # + tx = self.create_stream_labelled_ip4(self.pg0, [VppMplsLabel(0)]) + rx = self.send_and_expect(self.pg0, tx, self.pg0) self.verify_capture_ip4(self.pg0, rx, tx) # @@ -799,15 +953,9 @@ class TestMPLS(VppTestCase): # PG1 is in table 1 # we are ensuring the post-pop lookup occurs in the VRF table # - self.vapi.cli("clear trace") - tx = self.create_stream_labelled_ip4(self.pg1, [0]) - self.pg1.add_stream(tx) - - self.pg_enable_capture(self.pg_interfaces) - self.pg_start() - - rx = self.pg1.get_capture() - self.verify_capture_ip4(self.pg0, rx, tx) + tx = self.create_stream_labelled_ip4(self.pg1, [VppMplsLabel(0)]) + rx = self.send_and_expect(self.pg1, tx, self.pg1) + self.verify_capture_ip4(self.pg1, rx, tx) def test_v6_exp_null(self): """ MPLS V6 Explicit NULL test """ @@ -816,14 +964,8 @@ class TestMPLS(VppTestCase): # a stream with a non-zero MPLS TTL # PG0 is in the default table # - self.vapi.cli("clear trace") - tx = self.create_stream_labelled_ip6(self.pg0, 2, 2) - self.pg0.add_stream(tx) - - self.pg_enable_capture(self.pg_interfaces) - self.pg_start() - - rx = self.pg0.get_capture() + tx = self.create_stream_labelled_ip6(self.pg0, [VppMplsLabel(2)]) + rx = self.send_and_expect(self.pg0, tx, self.pg0) self.verify_capture_ip6(self.pg0, rx, tx) # @@ -831,14 +973,8 @@ class TestMPLS(VppTestCase): # PG1 is in table 1 # we are ensuring the post-pop lookup occurs in the VRF table # - self.vapi.cli("clear trace") - tx = self.create_stream_labelled_ip6(self.pg1, 2, 2) - self.pg1.add_stream(tx) - - self.pg_enable_capture(self.pg_interfaces) - self.pg_start() - - rx = self.pg1.get_capture() + tx = self.create_stream_labelled_ip6(self.pg1, [VppMplsLabel(2)]) + rx = self.send_and_expect(self.pg1, tx, self.pg1) self.verify_capture_ip6(self.pg0, rx, tx) def test_deag(self): @@ -857,15 +993,11 @@ class TestMPLS(VppTestCase): # ping an interface in the default table # PG0 is in the default table # - self.vapi.cli("clear trace") - tx = self.create_stream_labelled_ip4(self.pg0, [34], ping=1, + tx = self.create_stream_labelled_ip4(self.pg0, + [VppMplsLabel(34)], + ping=1, ip_itf=self.pg0) - self.pg0.add_stream(tx) - - self.pg_enable_capture(self.pg_interfaces) - self.pg_start() - - rx = self.pg0.get_capture() + rx = self.send_and_expect(self.pg0, tx, self.pg0) self.verify_capture_ip4(self.pg0, rx, tx, ping_resp=1) # @@ -882,16 +1014,9 @@ class TestMPLS(VppTestCase): # PG0 is in the default table. packet arrive labelled in the # default table and egress unlabelled in the non-default # - self.vapi.cli("clear trace") tx = self.create_stream_labelled_ip4( - self.pg0, [35], ping=1, ip_itf=self.pg1) - self.pg0.add_stream(tx) - - self.pg_enable_capture(self.pg_interfaces) - self.pg_start() - - packet_count = self.get_packet_count_for_if_idx(self.pg0.sw_if_index) - rx = self.pg1.get_capture(packet_count) + self.pg0, [VppMplsLabel(35)], ping=1, ip_itf=self.pg1) + rx = self.send_and_expect(self.pg0, tx, self.pg1) self.verify_capture_ip4(self.pg1, rx, tx, ping_resp=1) # @@ -902,15 +1027,11 @@ class TestMPLS(VppTestCase): 0xffffffff)]) route_36_neos.add_vpp_config() - self.vapi.cli("clear trace") - tx = self.create_stream_labelled_ip4(self.pg0, [36, 35], + tx = self.create_stream_labelled_ip4(self.pg0, + [VppMplsLabel(36), + VppMplsLabel(35)], ping=1, ip_itf=self.pg1) - self.pg0.add_stream(tx) - - self.pg_enable_capture(self.pg_interfaces) - self.pg_start() - - rx = self.pg1.get_capture(len(tx)) + rx = self.send_and_expect(self.pg0, tx, self.pg1) self.verify_capture_ip4(self.pg1, rx, tx, ping_resp=1) route_36_neos.remove_vpp_config() @@ -948,15 +1069,10 @@ class TestMPLS(VppTestCase): # ping an interface in the default table # PG0 is in the default table # - self.vapi.cli("clear trace") - tx = self.create_stream_labelled_ip4(self.pg0, [34], n=257, + tx = self.create_stream_labelled_ip4(self.pg0, + [VppMplsLabel(34)], dst_ip="10.0.0.1") - self.pg0.add_stream(tx) - - self.pg_enable_capture(self.pg_interfaces) - self.pg_start() - - rx = self.pg1.get_capture(257) + rx = self.send_and_expect(self.pg0, tx, self.pg1) self.verify_capture_ip4(self.pg1, rx, tx) def test_mcast_mid_point(self): @@ -976,17 +1092,18 @@ class TestMPLS(VppTestCase): # Add a mcast entry that replicate to pg2 and pg3 # and replicate to a interface-rx (like a bud node would) # - route_3400_eos = VppMplsRoute(self, 3400, 1, - [VppRoutePath(self.pg2.remote_ip4, - self.pg2.sw_if_index, - labels=[3401]), - VppRoutePath(self.pg3.remote_ip4, - self.pg3.sw_if_index, - labels=[3402]), - VppRoutePath("0.0.0.0", - self.pg1.sw_if_index, - is_interface_rx=1)], - is_multicast=1) + route_3400_eos = VppMplsRoute( + self, 3400, 1, + [VppRoutePath(self.pg2.remote_ip4, + self.pg2.sw_if_index, + labels=[VppMplsLabel(3401)]), + VppRoutePath(self.pg3.remote_ip4, + self.pg3.sw_if_index, + labels=[VppMplsLabel(3402)]), + VppRoutePath("0.0.0.0", + self.pg1.sw_if_index, + is_interface_rx=1)], + is_multicast=1) route_3400_eos.add_vpp_config() # @@ -994,7 +1111,9 @@ class TestMPLS(VppTestCase): # PG0 is in the default table # self.vapi.cli("clear trace") - tx = self.create_stream_labelled_ip4(self.pg0, [3400], n=257, + tx = self.create_stream_labelled_ip4(self.pg0, + [VppMplsLabel(3400, ttl=64)], + n=257, dst_ip="10.0.0.1") self.pg0.add_stream(tx) @@ -1005,9 +1124,11 @@ class TestMPLS(VppTestCase): self.verify_capture_ip4(self.pg1, rx, tx) rx = self.pg2.get_capture(257) - self.verify_capture_labelled(self.pg2, rx, tx, [3401]) + self.verify_capture_labelled(self.pg2, rx, tx, + [VppMplsLabel(3401, ttl=63)]) rx = self.pg3.get_capture(257) - self.verify_capture_labelled(self.pg3, rx, tx, [3402]) + self.verify_capture_labelled(self.pg3, rx, tx, + [VppMplsLabel(3402, ttl=63)]) def test_mcast_head(self): """ MPLS Multicast Head-end """ @@ -1015,14 +1136,15 @@ class TestMPLS(VppTestCase): # # Create a multicast tunnel with two replications # - mpls_tun = VppMPLSTunnelInterface(self, - [VppRoutePath(self.pg2.remote_ip4, - self.pg2.sw_if_index, - labels=[42]), - VppRoutePath(self.pg3.remote_ip4, - self.pg3.sw_if_index, - labels=[43])], - is_multicast=1) + mpls_tun = VppMPLSTunnelInterface( + self, + [VppRoutePath(self.pg2.remote_ip4, + self.pg2.sw_if_index, + labels=[VppMplsLabel(42)]), + VppRoutePath(self.pg3.remote_ip4, + self.pg3.sw_if_index, + labels=[VppMplsLabel(43)])], + is_multicast=1) mpls_tun.add_vpp_config() mpls_tun.admin_up() @@ -1042,9 +1164,9 @@ class TestMPLS(VppTestCase): self.pg_start() rx = self.pg2.get_capture(257) - self.verify_capture_tunneled_ip4(self.pg0, rx, tx, [42]) + self.verify_capture_tunneled_ip4(self.pg0, rx, tx, [VppMplsLabel(42)]) rx = self.pg3.get_capture(257) - self.verify_capture_tunneled_ip4(self.pg0, rx, tx, [43]) + self.verify_capture_tunneled_ip4(self.pg0, rx, tx, [VppMplsLabel(43)]) # # An an IP multicast route via the tunnel @@ -1070,9 +1192,9 @@ class TestMPLS(VppTestCase): self.pg_start() rx = self.pg2.get_capture(257) - self.verify_capture_tunneled_ip4(self.pg0, rx, tx, [42]) + self.verify_capture_tunneled_ip4(self.pg0, rx, tx, [VppMplsLabel(42)]) rx = self.pg3.get_capture(257) - self.verify_capture_tunneled_ip4(self.pg0, rx, tx, [43]) + self.verify_capture_tunneled_ip4(self.pg0, rx, tx, [VppMplsLabel(43)]) def test_mcast_ip4_tail(self): """ MPLS IPv4 Multicast Tail """ @@ -1112,7 +1234,7 @@ class TestMPLS(VppTestCase): # Drop due to interface lookup miss # self.vapi.cli("clear trace") - tx = self.create_stream_labelled_ip4(self.pg0, [34], + tx = self.create_stream_labelled_ip4(self.pg0, [VppMplsLabel(34)], dst_ip="232.1.1.1", n=1) self.send_and_assert_no_replies(self.pg0, tx, "RPF-ID drop none") @@ -1121,30 +1243,24 @@ class TestMPLS(VppTestCase): # route_232_1_1_1.update_rpf_id(55) - self.vapi.cli("clear trace") - tx = self.create_stream_labelled_ip4(self.pg0, [34], - dst_ip="232.1.1.1", n=257) - self.pg0.add_stream(tx) - - self.pg_enable_capture(self.pg_interfaces) - self.pg_start() - - rx = self.pg1.get_capture(257) + tx = self.create_stream_labelled_ip4(self.pg0, [VppMplsLabel(34)], + dst_ip="232.1.1.1") + rx = self.send_and_expect(self.pg0, tx, self.pg1) self.verify_capture_ip4(self.pg1, rx, tx) # # disposed packets have an invalid IPv4 checkusm # - tx = self.create_stream_labelled_ip4(self.pg0, [34], + tx = self.create_stream_labelled_ip4(self.pg0, [VppMplsLabel(34)], dst_ip="232.1.1.1", n=65, chksum=1) self.send_and_assert_no_replies(self.pg0, tx, "Invalid Checksum") # - # set the RPF-ID of the enrtry to not match the input packet's + # set the RPF-ID of the entry to not match the input packet's # route_232_1_1_1.update_rpf_id(56) - tx = self.create_stream_labelled_ip4(self.pg0, [34], + tx = self.create_stream_labelled_ip4(self.pg0, [VppMplsLabel(34)], dst_ip="232.1.1.1") self.send_and_assert_no_replies(self.pg0, tx, "RPF-ID drop 56") @@ -1188,42 +1304,36 @@ class TestMPLS(VppTestCase): # # Drop due to interface lookup miss # - tx = self.create_stream_labelled_ip6(self.pg0, [34], 255, + tx = self.create_stream_labelled_ip6(self.pg0, [VppMplsLabel(34)], dst_ip="ff01::1") + self.send_and_assert_no_replies(self.pg0, tx, "RPF Miss") # # set the RPF-ID of the enrtry to match the input packet's # route_ff.update_rpf_id(55) - tx = self.create_stream_labelled_ip6(self.pg0, [34], 255, + tx = self.create_stream_labelled_ip6(self.pg0, [VppMplsLabel(34)], dst_ip="ff01::1") - self.pg0.add_stream(tx) - - self.pg_enable_capture(self.pg_interfaces) - self.pg_start() - - rx = self.pg1.get_capture(257) + rx = self.send_and_expect(self.pg0, tx, self.pg1) self.verify_capture_ip6(self.pg1, rx, tx) # # disposed packets have hop-limit = 1 # - tx = self.create_stream_labelled_ip6(self.pg0, [34], 255, - dst_ip="ff01::1", hlim=1) - self.pg0.add_stream(tx) - - self.pg_enable_capture(self.pg_interfaces) - self.pg_start() - - rx = self.pg0.get_capture(257) + tx = self.create_stream_labelled_ip6(self.pg0, + [VppMplsLabel(34)], + dst_ip="ff01::1", + hlim=1) + rx = self.send_and_expect(self.pg0, tx, self.pg0) self.verify_capture_ip6_icmp(self.pg0, rx, tx) # # set the RPF-ID of the enrtry to not match the input packet's # route_ff.update_rpf_id(56) - tx = self.create_stream_labelled_ip6(self.pg0, [34], 225, + tx = self.create_stream_labelled_ip6(self.pg0, + [VppMplsLabel(34)], dst_ip="ff01::1") self.send_and_assert_no_replies(self.pg0, tx, "RPF-ID drop 56") @@ -1709,11 +1819,7 @@ class TestMPLSL2(VppTestCase): self.pg0.admin_down() super(TestMPLSL2, self).tearDown() - def verify_capture_tunneled_ethernet(self, capture, sent, mpls_labels, - ttl=255, top=None): - if top is None: - top = len(mpls_labels) - 1 - + def verify_capture_tunneled_ethernet(self, capture, sent, mpls_labels): capture = verify_filter(capture, sent) self.assertEqual(len(capture), len(sent)) @@ -1723,7 +1829,7 @@ class TestMPLSL2(VppTestCase): rx = capture[i] # the MPLS TTL is 255 since it enters a new tunnel - verify_mpls_stack(self, rx, mpls_labels, ttl, top) + verify_mpls_stack(self, rx, mpls_labels) tx_eth = tx[Ether] rx_eth = Ether(str(rx[MPLS].payload)) @@ -1736,12 +1842,15 @@ class TestMPLSL2(VppTestCase): # # Create an MPLS tunnel that pushes 1 label + # For Ethernet over MPLS the uniform mode is irrelevant since ttl/cos + # information is not in the packet, but we test it works anyway # - mpls_tun_1 = VppMPLSTunnelInterface(self, - [VppRoutePath(self.pg0.remote_ip4, - self.pg0.sw_if_index, - labels=[42])], - is_l2=1) + mpls_tun_1 = VppMPLSTunnelInterface( + self, + [VppRoutePath(self.pg0.remote_ip4, + self.pg0.sw_if_index, + labels=[VppMplsLabel(42, MplsLspMode.UNIFORM)])], + is_l2=1) mpls_tun_1.add_vpp_config() mpls_tun_1.admin_up() @@ -1778,37 +1887,32 @@ class TestMPLSL2(VppTestCase): UDP(sport=1234, dport=1234) / Raw('\xa5' * 100)) - self.pg0.add_stream(pcore * 65) - self.pg_enable_capture(self.pg_interfaces) - self.pg_start() + tx0 = pcore * 65 + rx0 = self.send_and_expect(self.pg0, tx0, self.pg1) + payload = pcore[MPLS].payload - rx0 = self.pg1.get_capture(65) - tx = pcore[MPLS].payload - - self.assertEqual(rx0[0][Ether].dst, tx[Ether].dst) - self.assertEqual(rx0[0][Ether].src, tx[Ether].src) + self.assertEqual(rx0[0][Ether].dst, payload[Ether].dst) + self.assertEqual(rx0[0][Ether].src, payload[Ether].src) # # Inject a packet from the custoer/L2 side # - self.pg1.add_stream(tx * 65) - self.pg_enable_capture(self.pg_interfaces) - self.pg_start() - - rx0 = self.pg0.get_capture(65) + tx1 = pcore[MPLS].payload * 65 + rx1 = self.send_and_expect(self.pg1, tx1, self.pg0) - self.verify_capture_tunneled_ethernet(rx0, tx*65, [42]) + self.verify_capture_tunneled_ethernet(rx1, tx1, [VppMplsLabel(42)]) def test_vpls(self): """ Virtual Private LAN Service """ # # Create an L2 MPLS tunnel # - mpls_tun = VppMPLSTunnelInterface(self, - [VppRoutePath(self.pg0.remote_ip4, - self.pg0.sw_if_index, - labels=[42])], - is_l2=1) + mpls_tun = VppMPLSTunnelInterface( + self, + [VppRoutePath(self.pg0.remote_ip4, + self.pg0.sw_if_index, + labels=[VppMplsLabel(42)])], + is_l2=1) mpls_tun.add_vpp_config() mpls_tun.admin_up() @@ -1875,7 +1979,8 @@ class TestMPLSL2(VppTestCase): rx0 = self.pg0.get_capture(65) - self.verify_capture_tunneled_ethernet(rx0, p_cust*65, [42]) + self.verify_capture_tunneled_ethernet(rx0, p_cust*65, + [VppMplsLabel(42)]) # # remove interfaces from customers bridge-domain diff --git a/test/test_udp.py b/test/test_udp.py index 68b023c5e2f..322d8133b0d 100644 --- a/test/test_udp.py +++ b/test/test_udp.py @@ -2,7 +2,7 @@ from framework import VppTestCase, VppTestRunner from vpp_udp_encap import * -from vpp_ip_route import VppIpRoute, VppRoutePath, VppIpTable +from vpp_ip_route import VppIpRoute, VppRoutePath, VppIpTable, VppMplsLabel from scapy.packet import Raw from scapy.layers.l2 import Ether, ARP @@ -67,12 +67,12 @@ class TestUdpEncap(VppTestCase): self.assertEqual(rx[UDP].dport, encap_obj.dst_port) def validate_inner4(self, rx, tx, ttl=None): - self.assertEqual(rx.src, tx[IP].src) - self.assertEqual(rx.dst, tx[IP].dst) + self.assertEqual(rx[IP].src, tx[IP].src) + self.assertEqual(rx[IP].dst, tx[IP].dst) if ttl: - self.assertEqual(rx.ttl, ttl) + self.assertEqual(rx[IP].ttl, ttl) else: - self.assertEqual(rx.ttl, tx[IP].ttl) + self.assertEqual(rx[IP].ttl, tx[IP].ttl) def validate_inner6(self, rx, tx): self.assertEqual(rx.src, tx[IPv6].src) @@ -208,7 +208,7 @@ class TestUdpEncap(VppTestCase): 0xFFFFFFFF, is_udp_encap=1, next_hop_id=1, - labels=[66])]) + labels=[VppMplsLabel(66)])]) route_4oMPLSo4.add_vpp_config() p_4omo4 = (Ether(src=self.pg0.remote_mac, diff --git a/test/vpp_bier.py b/test/vpp_bier.py index ef9a9ab75ec..7566b1f95ab 100644 --- a/test/vpp_bier.py +++ b/test/vpp_bier.py @@ -4,7 +4,7 @@ import socket from vpp_object import VppObject -from vpp_ip_route import MPLS_LABEL_INVALID, VppRoutePath +from vpp_ip_route import MPLS_LABEL_INVALID, VppRoutePath, VppMplsLabel class BIER_HDR_PAYLOAD: @@ -120,11 +120,34 @@ class VppBierRoute(VppObject): self.bp = bp self.paths = paths + def encode_paths(self): + br_paths = [] + for p in self.paths: + lstack = [] + for l in p.nh_labels: + if type(l) == VppMplsLabel: + lstack.append(l.encode()) + else: + lstack.append({'label': l, 'ttl': 255}) + n_labels = len(lstack) + while (len(lstack) < 16): + lstack.append({}) + br_paths.append({'next_hop': p.nh_addr, + 'weight': 1, + 'afi': 0, + 'preference': 0, + 'table_id': p.nh_table_id, + 'next_hop_id': p.next_hop_id, + 'is_udp_encap': p.is_udp_encap, + 'n_labels': n_labels, + 'label_stack': lstack}) + return br_paths + def add_vpp_config(self): self._test.vapi.bier_route_add_del( self.tbl_id, self.bp, - self.paths, + self.encode_paths(), is_add=1) self._test.registry.register(self, self._test.logger) @@ -132,7 +155,7 @@ class VppBierRoute(VppObject): self._test.vapi.bier_route_add_del( self.tbl_id, self.bp, - self.paths, + self.encode_paths(), is_add=0) def __str__(self): diff --git a/test/vpp_ip_route.py b/test/vpp_ip_route.py index 2d34f55efdf..ca0ae1ad47d 100644 --- a/test/vpp_ip_route.py +++ b/test/vpp_ip_route.py @@ -38,6 +38,11 @@ class DpoProto: DPO_PROTO_NSH = 5 +class MplsLspMode: + PIPE = 0 + UNIFORM = 1 + + def find_route(test, ip_addr, len, table_id=0, inet=AF_INET): if inet == AF_INET: s = 4 @@ -95,6 +100,21 @@ class VppIpTable(VppObject): self.table_id)) +class VppMplsLabel(object): + def __init__(self, value, mode=MplsLspMode.PIPE, ttl=64, exp=0): + self.value = value + self.mode = mode + self.ttl = ttl + self.exp = exp + + def encode(self): + is_uniform = 0 if self.mode is MplsLspMode.PIPE else 1 + return {'label': self.value, + 'ttl': self.ttl, + 'exp': self.exp, + 'is_uniform': is_uniform} + + class VppRoutePath(object): def __init__( @@ -138,6 +158,16 @@ class VppRoutePath(object): self.next_hop_id = next_hop_id self.is_dvr = is_dvr + def encode_labels(self): + lstack = [] + for l in self.nh_labels: + if type(l) == VppMplsLabel: + lstack.append(l.encode()) + else: + lstack.append({'label': l, + 'ttl': 255}) + return lstack + class VppMRoutePath(VppRoutePath): @@ -195,15 +225,16 @@ class VppIpRoute(VppObject): is_ipv6=self.is_ip6) else: for path in self.paths: + lstack = path.encode_labels() + self._test.vapi.ip_add_del_route( self.dest_addr, self.dest_addr_len, path.nh_addr, path.nh_itf, table_id=self.table_id, - next_hop_out_label_stack=path.nh_labels, - next_hop_n_out_labels=len( - path.nh_labels), + next_hop_out_label_stack=lstack, + next_hop_n_out_labels=len(lstack), next_hop_via_label=path.nh_via_label, next_hop_table_id=path.nh_table_id, next_hop_id=path.next_hop_id, @@ -513,6 +544,8 @@ class VppMplsRoute(VppObject): def add_vpp_config(self): is_multipath = len(self.paths) > 1 for path in self.paths: + lstack = path.encode_labels() + self._test.vapi.mpls_route_add_del( self.local_label, self.eos_bit, @@ -524,9 +557,8 @@ class VppMplsRoute(VppObject): table_id=self.table_id, is_interface_rx=path.is_interface_rx, is_rpf_id=path.is_rpf_id, - next_hop_out_label_stack=path.nh_labels, - next_hop_n_out_labels=len( - path.nh_labels), + next_hop_out_label_stack=lstack, + next_hop_n_out_labels=len(lstack), next_hop_via_label=path.nh_via_label, next_hop_table_id=path.nh_table_id) self._test.registry.register(self, self._test.logger) diff --git a/test/vpp_mpls_tunnel_interface.py b/test/vpp_mpls_tunnel_interface.py index 0542b05c05f..c789c3f1dd0 100644 --- a/test/vpp_mpls_tunnel_interface.py +++ b/test/vpp_mpls_tunnel_interface.py @@ -1,6 +1,6 @@ from vpp_interface import VppInterface -from vpp_ip_route import VppRoutePath +from vpp_ip_route import VppRoutePath, VppMplsLabel import socket @@ -21,6 +21,8 @@ class VppMPLSTunnelInterface(VppInterface): def add_vpp_config(self): self._sw_if_index = 0xffffffff for path in self.t_paths: + lstack = path.encode_labels() + reply = self.test.vapi.mpls_tunnel_add_del( self._sw_if_index, 1, # IPv4 next-hop @@ -28,8 +30,8 @@ class VppMPLSTunnelInterface(VppInterface): path.nh_itf, path.nh_table_id, path.weight, - next_hop_out_label_stack=path.nh_labels, - next_hop_n_out_labels=len(path.nh_labels), + next_hop_out_label_stack=lstack, + next_hop_n_out_labels=len(lstack), is_multicast=self.is_multicast, l2_only=self.is_l2) self._sw_if_index = reply.sw_if_index diff --git a/test/vpp_papi_provider.py b/test/vpp_papi_provider.py index 99e320bfe60..18bb1f60d40 100644 --- a/test/vpp_papi_provider.py +++ b/test/vpp_papi_provider.py @@ -1119,7 +1119,6 @@ class VppPapiProvider(object): :param next_hop_weight: (Default value = 1) """ - return self.api( self.papi.mpls_route_add_del, {'mr_label': label, @@ -2875,25 +2874,14 @@ class VppPapiProvider(object): paths, is_add=1): """ BIER Route add/del """ - br_paths = [] - for p in paths: - br_paths.append({'next_hop': p.nh_addr, - 'weight': 1, - 'afi': 0, - 'preference': 0, - 'table_id': p.nh_table_id, - 'next_hop_id': p.next_hop_id, - 'is_udp_encap': p.is_udp_encap, - 'n_labels': len(p.nh_labels), - 'label_stack': p.nh_labels}) return self.api( self.papi.bier_route_add_del, {'br_tbl_id': {"bt_set": bti.set_id, "bt_sub_domain": bti.sub_domain_id, "bt_hdr_len_id": bti.hdr_len_id}, 'br_bp': bp, - 'br_n_paths': len(br_paths), - 'br_paths': br_paths, + 'br_n_paths': len(paths), + 'br_paths': paths, 'br_is_add': is_add}) def bier_route_dump(self, bti): @@ -2950,6 +2938,9 @@ class VppPapiProvider(object): next_hop_is_ip4=1, is_add=1): """ BIER Route add/del """ + lstack = [] + while (len(lstack) < 16): + lstack.append({}) return self.api( self.papi.bier_disp_entry_add_del, {'bde_tbl_id': bdti, @@ -2961,7 +2952,7 @@ class VppPapiProvider(object): 'afi': next_hop_afi, 'rpf_id': next_hop_rpf_id, 'n_labels': 0, - 'label_stack': [0]}], + 'label_stack': lstack}], 'bde_is_add': is_add}) def bier_disp_entry_dump(self, bdti): -- cgit 1.2.3-korg