X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=test%2Ftest_vxlan_gpe.py;h=28c31ccd3bb131de831a5bf71dede458c6540b9a;hb=50bd1d3e256154212198a31932896b07af5b129f;hp=61d86fe07dc08802834999ef1ce1c63ebea4ea81;hpb=7e665d64eb172f8ff42009a0d412ad05ffae7432;p=vpp.git diff --git a/test/test_vxlan_gpe.py b/test/test_vxlan_gpe.py index 61d86fe07dc..28c31ccd3bb 100644 --- a/test/test_vxlan_gpe.py +++ b/test/test_vxlan_gpe.py @@ -1,18 +1,23 @@ -#!/usr/bin/env python +#!/usr/bin/env python3 import socket -from util import ip4n_range +from util import ip4_range import unittest from framework import VppTestCase, VppTestRunner, running_extended_tests from template_bd import BridgeDomain -from scapy.layers.l2 import Ether, Raw +from scapy.layers.l2 import Ether +from scapy.packet import Raw, bind_layers from scapy.layers.inet import IP, UDP from scapy.layers.vxlan import VXLAN -from scapy.utils import atol +import util +from vpp_ip_route import VppIpRoute, VppRoutePath +from vpp_vxlan_gpe_tunnel import VppVxlanGpeTunnel +from vpp_ip import INVALID_INDEX -@unittest.skipUnless(running_extended_tests(), "part of extended tests") + +@unittest.skipUnless(running_extended_tests, "part of extended tests") class TestVxlanGpe(BridgeDomain, VppTestCase): """ VXLAN-GPE Test Case """ @@ -31,6 +36,10 @@ class TestVxlanGpe(BridgeDomain, VppTestCase): VXLAN(vni=vni, flags=self.flags) / pkt) + def ip_range(self, start, end): + """ range of remote ip's """ + return ip4_range(self.pg0.remote_ip4, start, end) + def encap_mcast(self, pkt, src_ip, src_mac, vni): """ Encapsulate the original payload frame by adding VXLAN-GPE header @@ -70,28 +79,39 @@ class TestVxlanGpe(BridgeDomain, VppTestCase): self.assertEqual(pkt[IP].dst, type(self).mcast_ip4) # Verify UDP destination port is VXLAN-GPE 4790, source UDP port # could be arbitrary. - self.assertEqual(pkt[UDP].dport, type(self).dport) + self.assertEqual(pkt[UDP].dport, self.dport) + # Verify UDP checksum + self.assert_udp_checksum_valid(pkt) # Verify VNI self.assertEqual(pkt[VXLAN].vni, vni) @classmethod - def create_vxlan_gpe_flood_test_bd(cls, vni, n_ucast_tunnels): - # Create 10 ucast vxlan_gpe tunnels under bd + def create_vxlan_gpe_flood_test_bd(cls, vni, n_ucast_tunnels, port): + # Create 10 ucast vxlan tunnels under bd ip_range_start = 10 ip_range_end = ip_range_start + n_ucast_tunnels - next_hop_address = cls.pg0.remote_ip4n - for dest_ip4n in ip4n_range(next_hop_address, ip_range_start, - ip_range_end): + next_hop_address = cls.pg0.remote_ip4 + for dest_ip4 in ip4_range(next_hop_address, ip_range_start, + ip_range_end): # add host route so dest_ip4n will not be resolved - cls.vapi.ip_add_del_route(dest_ip4n, 32, next_hop_address) - r = cls.vapi.vxlan_gpe_add_del_tunnel( - src_addr=cls.pg0.local_ip4n, - dst_addr=dest_ip4n, - vni=vni) - cls.vapi.sw_interface_set_l2_bridge(r.sw_if_index, bd_id=vni) + rip = VppIpRoute(cls, dest_ip4, 32, + [VppRoutePath(next_hop_address, + INVALID_INDEX)], + register=False) + rip.add_vpp_config() + + r = VppVxlanGpeTunnel(cls, + src_addr=cls.pg0.local_ip4, + dst_addr=dest_ip4, + src_port=port, + dst_port=port, + vni=vni) + r.add_vpp_config() + cls.vapi.sw_interface_set_l2_bridge(rx_sw_if_index=r.sw_if_index, + bd_id=vni) @classmethod - def add_del_shared_mcast_dst_load(cls, is_add): + def add_del_shared_mcast_dst_load(cls, port, is_add): """ add or del tunnels sharing the same mcast dst to test vxlan_gpe ref_count mechanism @@ -100,48 +120,58 @@ class TestVxlanGpe(BridgeDomain, VppTestCase): vni_start = 1000 vni_end = vni_start + n_shared_dst_tunnels for vni in range(vni_start, vni_end): - r = cls.vapi.vxlan_gpe_add_del_tunnel( - src_addr=cls.pg0.local_ip4n, - dst_addr=cls.mcast_ip4n, - mcast_sw_if_index=1, - vni=vni, - is_add=is_add) - if r.sw_if_index == 0xffffffff: - raise "bad sw_if_index" + r = VppVxlanGpeTunnel(cls, + src_addr=cls.pg0.local_ip4, + dst_addr=cls.mcast_ip4, + src_port=port, + dst_port=port, + mcast_sw_if_index=1, + vni=vni) + if is_add: + r.add_vpp_config() + if r.sw_if_index == 0xffffffff: + raise ValueError("bad sw_if_index: ~0") + else: + r.remove_vpp_config() @classmethod - def add_shared_mcast_dst_load(cls): - cls.add_del_shared_mcast_dst_load(is_add=1) + def add_shared_mcast_dst_load(cls, port): + cls.add_del_shared_mcast_dst_load(port=port, is_add=1) @classmethod - def del_shared_mcast_dst_load(cls): - cls.add_del_shared_mcast_dst_load(is_add=0) + def del_shared_mcast_dst_load(cls, port): + cls.add_del_shared_mcast_dst_load(port=port, is_add=0) @classmethod - def add_del_mcast_tunnels_load(cls, is_add): + def add_del_mcast_tunnels_load(cls, port, is_add): """ add or del tunnels to test vxlan_gpe stability """ n_distinct_dst_tunnels = 20 ip_range_start = 10 ip_range_end = ip_range_start + n_distinct_dst_tunnels - for dest_ip4n in ip4n_range(cls.mcast_ip4n, ip_range_start, - ip_range_end): - vni = bytearray(dest_ip4n)[3] - cls.vapi.vxlan_gpe_add_del_tunnel( - src_addr=cls.pg0.local_ip4n, - dst_addr=dest_ip4n, - mcast_sw_if_index=1, - vni=vni, - is_add=is_add) + for dest_ip4 in ip4_range(cls.mcast_ip4, ip_range_start, + ip_range_end): + vni = int(dest_ip4.split(".")[3]) + r = VppVxlanGpeTunnel(cls, + src_addr=cls.pg0.local_ip4, + dst_addr=dest_ip4, + src_port=port, + dst_port=port, + mcast_sw_if_index=1, + vni=vni) + if is_add: + r.add_vpp_config() + else: + r.remove_vpp_config() @classmethod - def add_mcast_tunnels_load(cls): - cls.add_del_mcast_tunnels_load(is_add=1) + def add_mcast_tunnels_load(cls, port): + cls.add_del_mcast_tunnels_load(port=port, is_add=1) @classmethod - def del_mcast_tunnels_load(cls): - cls.add_del_mcast_tunnels_load(is_add=0) + def del_mcast_tunnels_load(cls, port): + cls.add_del_mcast_tunnels_load(port=port, is_add=0) # Class method to start the VXLAN-GPE test case. # Overrides setUpClass method in VppTestCase class. @@ -153,7 +183,6 @@ class TestVxlanGpe(BridgeDomain, VppTestCase): super(TestVxlanGpe, cls).setUpClass() try: - cls.dport = 4790 cls.flags = 0x0c # Create 2 pg interfaces. @@ -169,54 +198,121 @@ class TestVxlanGpe(BridgeDomain, VppTestCase): # Our Multicast address cls.mcast_ip4 = '239.1.1.1' - cls.mcast_ip4n = socket.inet_pton(socket.AF_INET, cls.mcast_ip4) - iplong = atol(cls.mcast_ip4) - cls.mcast_mac = "01:00:5e:%02x:%02x:%02x" % ( - (iplong >> 16) & 0x7F, (iplong >> 8) & 0xFF, iplong & 0xFF) - - # Create VXLAN-GPE VTEP on VPP pg0, and put vxlan_gpe_tunnel0 - # and pg1 into BD. - cls.single_tunnel_bd = 11 - r = cls.vapi.vxlan_gpe_add_del_tunnel( - src_addr=cls.pg0.local_ip4n, - dst_addr=cls.pg0.remote_ip4n, - vni=cls.single_tunnel_bd) - cls.vapi.sw_interface_set_l2_bridge(r.sw_if_index, - bd_id=cls.single_tunnel_bd) - cls.vapi.sw_interface_set_l2_bridge(cls.pg1.sw_if_index, - bd_id=cls.single_tunnel_bd) - - # Setup vni 2 to test multicast flooding - cls.n_ucast_tunnels = 10 - cls.mcast_flood_bd = 12 - cls.create_vxlan_gpe_flood_test_bd(cls.mcast_flood_bd, - cls.n_ucast_tunnels) - r = cls.vapi.vxlan_gpe_add_del_tunnel( - src_addr=cls.pg0.local_ip4n, - dst_addr=cls.mcast_ip4n, - mcast_sw_if_index=1, - vni=cls.mcast_flood_bd) - cls.vapi.sw_interface_set_l2_bridge(r.sw_if_index, - bd_id=cls.mcast_flood_bd) - cls.vapi.sw_interface_set_l2_bridge(cls.pg2.sw_if_index, - bd_id=cls.mcast_flood_bd) - - # Add and delete mcast tunnels to check stability - cls.add_shared_mcast_dst_load() - cls.add_mcast_tunnels_load() - cls.del_shared_mcast_dst_load() - cls.del_mcast_tunnels_load() - - # Setup vni 3 to test unicast flooding - cls.ucast_flood_bd = 13 - cls.create_vxlan_gpe_flood_test_bd(cls.ucast_flood_bd, - cls.n_ucast_tunnels) - cls.vapi.sw_interface_set_l2_bridge(cls.pg3.sw_if_index, - bd_id=cls.ucast_flood_bd) + cls.mcast_mac = util.mcast_ip_to_mac(cls.mcast_ip4) except Exception: - super(TestVxlanGpe, cls).tearDownClass() + cls.tearDownClass() raise + @classmethod + def tearDownClass(cls): + super(TestVxlanGpe, cls).tearDownClass() + + def setUp(self): + super(TestVxlanGpe, self).setUp() + + def createVxLANInterfaces(self, port=4790): + # Create VXLAN-GPE VTEP on VPP pg0, and put vxlan_gpe_tunnel0 + # and pg1 into BD. + self.dport = port + + self.single_tunnel_vni = 0xabcde + self.single_tunnel_bd = 11 + r = VppVxlanGpeTunnel(self, + src_addr=self.pg0.local_ip4, + dst_addr=self.pg0.remote_ip4, + src_port=port, + dst_port=port, + vni=self.single_tunnel_vni) + r.add_vpp_config() + self.vapi.sw_interface_set_l2_bridge(rx_sw_if_index=r.sw_if_index, + bd_id=self.single_tunnel_bd) + self.vapi.sw_interface_set_l2_bridge( + rx_sw_if_index=self.pg1.sw_if_index, bd_id=self.single_tunnel_bd) + + # Setup vni 2 to test multicast flooding + self.n_ucast_tunnels = 10 + self.mcast_flood_bd = 12 + self.create_vxlan_gpe_flood_test_bd(self.mcast_flood_bd, + self.n_ucast_tunnels, + self.dport) + r = VppVxlanGpeTunnel(self, + src_addr=self.pg0.local_ip4, + dst_addr=self.mcast_ip4, + src_port=port, + dst_port=port, + mcast_sw_if_index=1, + vni=self.mcast_flood_bd) + r.add_vpp_config() + self.vapi.sw_interface_set_l2_bridge(rx_sw_if_index=r.sw_if_index, + bd_id=self.mcast_flood_bd) + self.vapi.sw_interface_set_l2_bridge( + rx_sw_if_index=self.pg2.sw_if_index, bd_id=self.mcast_flood_bd) + + # Add and delete mcast tunnels to check stability + self.add_shared_mcast_dst_load(self.dport) + self.add_mcast_tunnels_load(self.dport) + self.del_shared_mcast_dst_load(self.dport) + self.del_mcast_tunnels_load(self.dport) + + # Setup vni 3 to test unicast flooding + self.ucast_flood_bd = 13 + self.create_vxlan_gpe_flood_test_bd(self.ucast_flood_bd, + self.n_ucast_tunnels, + self.dport) + self.vapi.sw_interface_set_l2_bridge( + rx_sw_if_index=self.pg3.sw_if_index, bd_id=self.ucast_flood_bd) + + # Set scapy listen custom port for VxLAN + bind_layers(UDP, VXLAN, dport=self.dport) + + """ + Tests with default port (4790) + """ + def test_decap(self): + """ Decapsulation test + from BridgeDoman + """ + self.createVxLANInterfaces() + super(TestVxlanGpe, self).test_decap() + + def test_encap(self): + """ Encapsulation test + from BridgeDoman + """ + self.createVxLANInterfaces() + super(TestVxlanGpe, self).test_encap() + + def test_ucast_flood(self): + """ Unicast flood test + from BridgeDoman + """ + self.createVxLANInterfaces() + super(TestVxlanGpe, self).test_ucast_flood() + + """ + Tests with custom port (1112) + """ + def test_decap_custom_port(self): + """ Decapsulation test custom port + from BridgeDoman + """ + self.createVxLANInterfaces(1112) + super(TestVxlanGpe, self).test_decap() + + def test_encap_custom_port(self): + """ Encapsulation test custom port + from BridgeDoman + """ + self.createVxLANInterfaces(1112) + super(TestVxlanGpe, self).test_encap() + + def test_ucast_flood_custom_port(self): + """ Unicast flood test custom port + from BridgeDoman + """ + self.createVxLANInterfaces(1112) + super(TestVxlanGpe, self).test_ucast_flood() + @unittest.skip("test disabled for vxlan-gpe") def test_mcast_flood(self): """ inherited from BridgeDomain """ @@ -232,13 +328,14 @@ class TestVxlanGpe(BridgeDomain, VppTestCase): # @param self The object pointer. def tearDown(self): super(TestVxlanGpe, self).tearDown() - if not self.vpp_dead: - self.logger.info(self.vapi.cli("show bridge-domain 11 detail")) - self.logger.info(self.vapi.cli("show bridge-domain 12 detail")) - self.logger.info(self.vapi.cli("show bridge-domain 13 detail")) - self.logger.info(self.vapi.cli("show int")) - self.logger.info(self.vapi.cli("show vxlan-gpe")) - self.logger.info(self.vapi.cli("show trace")) + + def show_commands_at_teardown(self): + self.logger.info(self.vapi.cli("show bridge-domain 11 detail")) + self.logger.info(self.vapi.cli("show bridge-domain 12 detail")) + self.logger.info(self.vapi.cli("show bridge-domain 13 detail")) + self.logger.info(self.vapi.cli("show int")) + self.logger.info(self.vapi.cli("show vxlan-gpe")) + self.logger.info(self.vapi.cli("show trace")) if __name__ == '__main__':