VXLAN:validate mcast encapsulation ip/mac

[vpp.git] / test / test_vxlan.py

diff --git a/test/test_vxlan.py b/test/test_vxlan.py
index 845b817..ee829a3 100644 (file)
--- a/test/test_vxlan.py
+++ b/test/test_vxlan.py
@@ -1,6 +1,7 @@
 #!/usr/bin/env python
 
 import socket
 #!/usr/bin/env python
 
 import socket

+from util import ip4n_range

 import unittest
 from framework import VppTestCase, VppTestRunner
 from template_bd import BridgeDomain
 import unittest
 from framework import VppTestCase, VppTestRunner
 from template_bd import BridgeDomain


@@ -34,7 +35,7 @@ class TestVxlan(BridgeDomain, VppTestCase):
         Encapsulate the original payload frame by adding VXLAN header with its
         UDP, IP and Ethernet fields
         """
         Encapsulate the original payload frame by adding VXLAN header with its
         UDP, IP and Ethernet fields
         """

-        return (Ether(src=src_mac, dst=self.mcast_mac4) /
+        return (Ether(src=src_mac, dst=self.mcast_mac) /

                 IP(src=src_ip, dst=self.mcast_ip4) /
                 UDP(sport=self.dport, dport=self.dport, chksum=0) /
                 VXLAN(vni=vni, flags=self.flags) /
                 IP(src=src_ip, dst=self.mcast_ip4) /
                 UDP(sport=self.dport, dport=self.dport, chksum=0) /
                 VXLAN(vni=vni, flags=self.flags) /


@@ -50,17 +51,23 @@ class TestVxlan(BridgeDomain, VppTestCase):
 
     # Method for checking VXLAN encapsulation.
     #
 
     # Method for checking VXLAN encapsulation.
     #

-    def check_encapsulation(self, pkt, vni, local_only=False):
+    def check_encapsulation(self, pkt, vni, local_only=False, mcast_pkt=False):

         # TODO: add error messages
         # Verify source MAC is VPP_MAC and destination MAC is MY_MAC resolved
         #  by VPP using ARP.
         self.assertEqual(pkt[Ether].src, self.pg0.local_mac)
         if not local_only:
         # TODO: add error messages
         # Verify source MAC is VPP_MAC and destination MAC is MY_MAC resolved
         #  by VPP using ARP.
         self.assertEqual(pkt[Ether].src, self.pg0.local_mac)
         if not local_only:

-            self.assertEqual(pkt[Ether].dst, self.pg0.remote_mac)
+            if not mcast_pkt:
+                self.assertEqual(pkt[Ether].dst, self.pg0.remote_mac)
+            else:
+                self.assertEqual(pkt[Ether].dst, type(self).mcast_mac)

         # Verify VXLAN tunnel source IP is VPP_IP and destination IP is MY_IP.
         self.assertEqual(pkt[IP].src, self.pg0.local_ip4)
         if not local_only:
         # Verify VXLAN tunnel source IP is VPP_IP and destination IP is MY_IP.
         self.assertEqual(pkt[IP].src, self.pg0.local_ip4)
         if not local_only:

-            self.assertEqual(pkt[IP].dst, self.pg0.remote_ip4)
+            if not mcast_pkt:
+                self.assertEqual(pkt[IP].dst, self.pg0.remote_ip4)
+            else:
+                self.assertEqual(pkt[IP].dst, type(self).mcast_ip4)

         # Verify UDP destination port is VXLAN 4789, source UDP port could be
         #  arbitrary.
         self.assertEqual(pkt[UDP].dport, type(self).dport)
         # Verify UDP destination port is VXLAN 4789, source UDP port could be
         #  arbitrary.
         self.assertEqual(pkt[UDP].dport, type(self).dport)


@@ -68,48 +75,72 @@ class TestVxlan(BridgeDomain, VppTestCase):
         # Verify VNI
         self.assertEqual(pkt[VXLAN].vni, vni)
 
         # Verify VNI
         self.assertEqual(pkt[VXLAN].vni, vni)
 

-    @staticmethod
-    def ip4_range(ip4n, s=10, e=20):
-        base = str(bytearray(ip4n)[:3])
-        return ((base + ip) for ip in str(bytearray(range(s, e))))
-

     @classmethod
     @classmethod

-    def create_vxlan_flood_test_bd(cls, vni):
+    def create_vxlan_flood_test_bd(cls, vni, n_ucast_tunnels):

         # Create 10 ucast vxlan tunnels under bd
         ip_range_start = 10
         # Create 10 ucast vxlan tunnels under bd
         ip_range_start = 10

-        ip_range_end = 20
+        ip_range_end = ip_range_start + n_ucast_tunnels

         next_hop_address = cls.pg0.remote_ip4n
         next_hop_address = cls.pg0.remote_ip4n

-        for dest_addr in cls.ip4_range(next_hop_address, ip_range_start,
-                                       ip_range_end):
-            # add host route so dest_addr will not be resolved
-            cls.vapi.ip_add_del_route(dest_addr, 32, next_hop_address)
+        for dest_ip4n in ip4n_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_add_del_tunnel(
                 src_addr=cls.pg0.local_ip4n,
             r = cls.vapi.vxlan_add_del_tunnel(
                 src_addr=cls.pg0.local_ip4n,

-                dst_addr=dest_addr,
+                dst_addr=dest_ip4n,

                 vni=vni)
             cls.vapi.sw_interface_set_l2_bridge(r.sw_if_index, bd_id=vni)
 
     @classmethod
                 vni=vni)
             cls.vapi.sw_interface_set_l2_bridge(r.sw_if_index, bd_id=vni)
 
     @classmethod

-    def add_del_mcast_load(cls, is_add):
+    def add_del_shared_mcast_dst_load(cls, is_add):
+        """
+        add or del tunnels sharing the same mcast dst
+        to test vxlan ref_count mechanism
+        """
+        n_shared_dst_tunnels = 2000
+        vni_start = 10000
+        vni_end = vni_start + n_shared_dst_tunnels
+        for vni in range(vni_start, vni_end):
+            cls.vapi.vxlan_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)
+
+    @classmethod
+    def add_shared_mcast_dst_load(cls):
+        cls.add_del_shared_mcast_dst_load(is_add=1)
+
+    @classmethod
+    def del_shared_mcast_dst_load(cls):
+        cls.add_del_shared_mcast_dst_load(is_add=0)
+
+    @classmethod
+    def add_del_mcast_tunnels_load(cls, is_add):
+        """
+        add or del tunnels to test vxlan stability
+        """
+        n_distinct_dst_tunnels = 200

         ip_range_start = 10
         ip_range_start = 10

-        ip_range_end = 210
-        for dest_addr in cls.ip4_range(cls.mcast_ip4n, ip_range_start,
-                                       ip_range_end):
-            vni = bytearray(dest_addr)[3]
+        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_add_del_tunnel(
                 src_addr=cls.pg0.local_ip4n,
             cls.vapi.vxlan_add_del_tunnel(
                 src_addr=cls.pg0.local_ip4n,

-                dst_addr=dest_addr,
+                dst_addr=dest_ip4n,

                 mcast_sw_if_index=1,
                 vni=vni,
                 is_add=is_add)
 
     @classmethod
                 mcast_sw_if_index=1,
                 vni=vni,
                 is_add=is_add)
 
     @classmethod

-    def add_mcast_load(cls):
-        cls.add_del_mcast_load(is_add=1)
+    def add_mcast_tunnels_load(cls):
+        cls.add_del_mcast_tunnels_load(is_add=1)

 
     @classmethod
 
     @classmethod

-    def del_mcast_load(cls):
-        cls.add_del_mcast_load(is_add=0)
+    def del_mcast_tunnels_load(cls):
+        cls.add_del_mcast_tunnels_load(is_add=0)

 
     # Class method to start the VXLAN test case.
     #  Overrides setUpClass method in VppTestCase class.
 
     # Class method to start the VXLAN test case.
     #  Overrides setUpClass method in VppTestCase class.


@@ -139,7 +170,7 @@ class TestVxlan(BridgeDomain, VppTestCase):
             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_ip4 = '239.1.1.1'
             cls.mcast_ip4n = socket.inet_pton(socket.AF_INET, cls.mcast_ip4)
             iplong = atol(cls.mcast_ip4)

-            cls.mcast_mac4 = "01:00:5e:%02x:%02x:%02x" % (
+            cls.mcast_mac = "01:00:5e:%02x:%02x:%02x" % (

                 (iplong >> 16) & 0x7F, (iplong >> 8) & 0xFF, iplong & 0xFF)
 
             # Create VXLAN VTEP on VPP pg0, and put vxlan_tunnel0 and pg1
                 (iplong >> 16) & 0x7F, (iplong >> 8) & 0xFF, iplong & 0xFF)
 
             # Create VXLAN VTEP on VPP pg0, and put vxlan_tunnel0 and pg1


@@ -155,8 +186,10 @@ class TestVxlan(BridgeDomain, VppTestCase):
                                                 bd_id=cls.single_tunnel_bd)
 
             # Setup vni 2 to test multicast flooding
                                                 bd_id=cls.single_tunnel_bd)
 
             # Setup vni 2 to test multicast flooding

+            cls.n_ucast_tunnels = 10

             cls.mcast_flood_bd = 2
             cls.mcast_flood_bd = 2

-            cls.create_vxlan_flood_test_bd(cls.mcast_flood_bd)
+            cls.create_vxlan_flood_test_bd(cls.mcast_flood_bd,
+                                           cls.n_ucast_tunnels)

             r = cls.vapi.vxlan_add_del_tunnel(
                 src_addr=cls.pg0.local_ip4n,
                 dst_addr=cls.mcast_ip4n,
             r = cls.vapi.vxlan_add_del_tunnel(
                 src_addr=cls.pg0.local_ip4n,
                 dst_addr=cls.mcast_ip4n,


@@ -168,12 +201,15 @@ class TestVxlan(BridgeDomain, VppTestCase):
                                                 bd_id=cls.mcast_flood_bd)
 
             # Add and delete mcast tunnels to check stability
                                                 bd_id=cls.mcast_flood_bd)
 
             # Add and delete mcast tunnels to check stability

-            cls.add_mcast_load()
-            cls.del_mcast_load()
+            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 = 3
 
             # Setup vni 3 to test unicast flooding
             cls.ucast_flood_bd = 3

-            cls.create_vxlan_flood_test_bd(cls.ucast_flood_bd)
+            cls.create_vxlan_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)
         except Exception:
             cls.vapi.sw_interface_set_l2_bridge(cls.pg3.sw_if_index,
                                                 bd_id=cls.ucast_flood_bd)
         except Exception: