ligang/vpp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added basic tests for multicast vxlan tunnels

Browse Source 
unicast flood test - test headend replication
multicast flood test - test flooding when a multicast vxlan tunnel is present in BD
multicast receive test - verify that multicast packet are received on their
   corresponding unicast tunnels and that unmatched packets are dropped

all tests run after adding and removing 200 mcast tunnels to test stability

Change-Id: Ia05108c39ac35096a5b633cf52480a9ba87c14df
Signed-off-by: Eyal Bari <ebari@cisco.com>
(cherry picked from commit c4aaee1146)
This commit is contained in:
Eyal Bari
2016-12-20 18:36:46 +02:00
committed by John Lo
parent b95a916dc3
commit ee85bfabc9
2 changed files with 206 additions and 40 deletions
Download Patch File Download Diff File Expand all files Collapse all files

125
test/template_bd.py
View File

@ -11,23 +11,28 @@ class BridgeDomain(object):
__metaclass__ = ABCMeta
@property
def frame_pg0_to_pg1(self):
""" Ethernet frame sent from pg0 and expected to arrive at pg1 """
def frame_request(self):
""" Ethernet frame modeling a generic request """
return (Ether(src='00:00:00:00:00:01', dst='00:00:00:00:00:02') /
IP(src='1.2.3.4', dst='4.3.2.1') /
UDP(sport=10000, dport=20000) /
Raw('\xa5' * 100))
@property
def frame_pg1_to_pg0(self):
""" Ethernet frame sent from pg1 and expected to arrive at pg0 """
def frame_reply(self):
""" Ethernet frame modeling a generic reply """
return (Ether(src='00:00:00:00:00:02', dst='00:00:00:00:00:01') /
IP(src='4.3.2.1', dst='1.2.3.4') /
UDP(sport=20000, dport=10000) /
Raw('\xa5' * 100))
@abstractmethod
def encapsulate(self, pkt):
def encap_mcast(self, pkt, src_ip, src_mac, vni):
""" Encapsulate mcast packet """
pass
@abstractmethod
def encapsulate(self, pkt, vni):
""" Encapsulate packet """
pass
@ -37,17 +42,30 @@ class BridgeDomain(object):
pass
@abstractmethod
def check_encapsulation(self, pkt):
def check_encapsulation(self, pkt, vni, local_only=False):
""" Verify the encapsulation """
pass
def assert_eq_pkts(self, pkt1, pkt2):
""" Verify the Ether, IP, UDP, payload are equal in both
packets
"""
self.assertEqual(pkt1[Ether].src, pkt2[Ether].src)
self.assertEqual(pkt1[Ether].dst, pkt2[Ether].dst)
self.assertEqual(pkt1[IP].src, pkt2[IP].src)
self.assertEqual(pkt1[IP].dst, pkt2[IP].dst)
self.assertEqual(pkt1[UDP].sport, pkt2[UDP].sport)
self.assertEqual(pkt1[UDP].dport, pkt2[UDP].dport)
self.assertEqual(pkt1[Raw], pkt2[Raw])
def test_decap(self):
""" Decapsulation test
Send encapsulated frames from pg0
Verify receipt of decapsulated frames on pg1
"""
encapsulated_pkt = self.encapsulate(self.frame_pg0_to_pg1)
encapsulated_pkt = self.encapsulate(self.frame_request,
self.single_tunnel_bd)
self.pg0.add_stream([encapsulated_pkt, ])
@ -61,22 +79,14 @@ class BridgeDomain(object):
'Invalid number of packets on '
'output: {}'.format(len(out)))
pkt = out[0]
# TODO: add error messages
self.assertEqual(pkt[Ether].src, self.frame_pg0_to_pg1[Ether].src)
self.assertEqual(pkt[Ether].dst, self.frame_pg0_to_pg1[Ether].dst)
self.assertEqual(pkt[IP].src, self.frame_pg0_to_pg1[IP].src)
self.assertEqual(pkt[IP].dst, self.frame_pg0_to_pg1[IP].dst)
self.assertEqual(pkt[UDP].sport, self.frame_pg0_to_pg1[UDP].sport)
self.assertEqual(pkt[UDP].dport, self.frame_pg0_to_pg1[UDP].dport)
self.assertEqual(pkt[Raw], self.frame_pg0_to_pg1[Raw])
self.assert_eq_pkts(pkt, self.frame_request)
def test_encap(self):
""" Encapsulation test
Send frames from pg1
Verify receipt of encapsulated frames on pg0
"""
self.pg1.add_stream([self.frame_pg1_to_pg0])
self.pg1.add_stream([self.frame_reply])
self.pg0.enable_capture()
@ -88,14 +98,77 @@ class BridgeDomain(object):
'Invalid number of packets on '
'output: {}'.format(len(out)))
pkt = out[0]
self.check_encapsulation(pkt)
self.check_encapsulation(pkt, self.single_tunnel_bd)
payload = self.decapsulate(pkt)
# TODO: add error messages
self.assertEqual(payload[Ether].src, self.frame_pg1_to_pg0[Ether].src)
self.assertEqual(payload[Ether].dst, self.frame_pg1_to_pg0[Ether].dst)
self.assertEqual(payload[IP].src, self.frame_pg1_to_pg0[IP].src)
self.assertEqual(payload[IP].dst, self.frame_pg1_to_pg0[IP].dst)
self.assertEqual(payload[UDP].sport, self.frame_pg1_to_pg0[UDP].sport)
self.assertEqual(payload[UDP].dport, self.frame_pg1_to_pg0[UDP].dport)
self.assertEqual(payload[Raw], self.frame_pg1_to_pg0[Raw])
self.assert_eq_pkts(payload, self.frame_reply)
def test_ucast_flood(self):
""" Unicast flood test
Send frames from pg3
Verify receipt of encapsulated frames on pg0
"""
self.pg3.add_stream([self.frame_reply])
self.pg0.enable_capture()
self.pg_start()
# Get packet from each tunnel and assert it's corectly encapsulated.
out = self.pg0.get_capture()
self.assertEqual(len(out), 10,
'Invalid number of packets on '
'output: {}'.format(len(out)))
for pkt in out:
self.check_encapsulation(pkt, self.ucast_flood_bd, True)
payload = self.decapsulate(pkt)
self.assert_eq_pkts(payload, self.frame_reply)
def test_mcast_flood(self):
""" Multicast flood test
Send frames from pg2
Verify receipt of encapsulated frames on pg0
"""
self.pg2.add_stream([self.frame_reply])
self.pg0.enable_capture()
self.pg_start()
# Pick first received frame and check if it's corectly encapsulated.
out = self.pg0.get_capture()
self.assertEqual(len(out), 1,
'Invalid number of packets on '
'output: {}'.format(len(out)))
pkt = out[0]
self.check_encapsulation(pkt, self.mcast_flood_bd, True)
payload = self.decapsulate(pkt)
self.assert_eq_pkts(payload, self.frame_reply)
@staticmethod
def ipn_to_ip(ipn):
return '.'.join(str(i) for i in bytearray(ipn))
def test_mcast_rcv(self):
""" Multicast receive test
Send 20 encapsulated frames from pg0 only 10 match unicast tunnels
Verify receipt of 10 decap frames on pg2
"""
mac = self.pg0.remote_mac
ip_range_start = 10
ip_range_end = 30
mcast_stream = [
self.encap_mcast(self.frame_request, self.ipn_to_ip(ip), mac,
self.mcast_flood_bd)
for ip in self.ip4_range(self.pg0.remote_ip4n,
ip_range_start, ip_range_end)]
self.pg0.add_stream(mcast_stream)
self.pg2.enable_capture()
self.pg_start()
out = self.pg2.get_capture()
self.assertEqual(len(out), 10,
'Invalid number of packets on '
'output: {}'.format(len(out)))
for pkt in out:
self.assert_eq_pkts(pkt, self.frame_request)

121
test/test_vxlan.py
View File

@ -1,5 +1,6 @@
#!/usr/bin/env python
import socket
import unittest
from framework import VppTestCase, VppTestRunner
from template_bd import BridgeDomain
@ -7,6 +8,7 @@ from template_bd import BridgeDomain
from scapy.layers.l2 import Ether
from scapy.layers.inet import IP, UDP
from scapy.layers.vxlan import VXLAN
from scapy.utils import atol
class TestVxlan(BridgeDomain, VppTestCase):
@ -16,7 +18,7 @@ class TestVxlan(BridgeDomain, VppTestCase):
BridgeDomain.__init__(self)
VppTestCase.__init__(self, *args)
def encapsulate(self, pkt):
def encapsulate(self, pkt, vni):
"""
Encapsulate the original payload frame by adding VXLAN header with its
UDP, IP and Ethernet fields
@ -24,7 +26,18 @@ class TestVxlan(BridgeDomain, VppTestCase):
return (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
IP(src=self.pg0.remote_ip4, dst=self.pg0.local_ip4) /
UDP(sport=self.dport, dport=self.dport, chksum=0) /
VXLAN(vni=self.vni, flags=self.flags) /
VXLAN(vni=vni, flags=self.flags) /
pkt)
def encap_mcast(self, pkt, src_ip, src_mac, vni):
"""
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) /
IP(src=src_ip, dst=self.mcast_ip4) /
UDP(sport=self.dport, dport=self.dport, chksum=0) /
VXLAN(vni=vni, flags=self.flags) /
pkt)
def decapsulate(self, pkt):
@ -37,21 +50,66 @@ class TestVxlan(BridgeDomain, VppTestCase):
# Method for checking VXLAN encapsulation.
#
def check_encapsulation(self, pkt):
def check_encapsulation(self, pkt, vni, local_only=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)
self.assertEqual(pkt[Ether].dst, self.pg0.remote_mac)
if not local_only:
self.assertEqual(pkt[Ether].dst, self.pg0.remote_mac)
# Verify VXLAN tunnel source IP is VPP_IP and destination IP is MY_IP.
self.assertEqual(pkt[IP].src, self.pg0.local_ip4)
self.assertEqual(pkt[IP].dst, self.pg0.remote_ip4)
if not local_only:
self.assertEqual(pkt[IP].dst, self.pg0.remote_ip4)
# Verify UDP destination port is VXLAN 4789, source UDP port could be
# arbitrary.
self.assertEqual(pkt[UDP].dport, type(self).dport)
# TODO: checksum check
# Verify VNI, based on configuration it must be 1.
self.assertEqual(pkt[VXLAN].vni, type(self).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
def create_vxlan_flood_test_bd(cls, vni):
# Create 10 ucast vxlan tunnels under bd
ip_range_start = 10
ip_range_end = 20
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)
r = cls.vapi.vxlan_add_del_tunnel(
src_addr=cls.pg0.local_ip4n,
dst_addr=dest_addr,
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):
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]
cls.vapi.vxlan_add_del_tunnel(
src_addr=cls.pg0.local_ip4n,
dst_addr=dest_addr,
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)
@classmethod
def del_mcast_load(cls):
cls.add_del_mcast_load(is_add=0)
# Class method to start the VXLAN test case.
# Overrides setUpClass method in VppTestCase class.
@ -65,12 +123,11 @@ class TestVxlan(BridgeDomain, VppTestCase):
try:
cls.dport = 4789
cls.flags = 0x8
cls.vni = 1
# Create 2 pg interfaces.
cls.create_pg_interfaces(range(2))
cls.pg0.admin_up()
cls.pg1.admin_up()
cls.create_pg_interfaces(range(4))
for pg in cls.pg_interfaces:
pg.admin_up()
# Configure IPv4 addresses on VPP pg0.
cls.pg0.config_ip4()
@ -78,14 +135,47 @@ class TestVxlan(BridgeDomain, VppTestCase):
# Resolve MAC address for VPP's IP address on pg0.
cls.pg0.resolve_arp()
# 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_mac4 = "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
# into BD.
cls.single_tunnel_bd = 1
r = cls.vapi.vxlan_add_del_tunnel(
src_addr=cls.pg0.local_ip4n,
dst_addr=cls.pg0.remote_ip4n,
vni=cls.vni)
cls.vapi.sw_interface_set_l2_bridge(r.sw_if_index, bd_id=1)
cls.vapi.sw_interface_set_l2_bridge(cls.pg1.sw_if_index, bd_id=1)
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.mcast_flood_bd = 2
cls.create_vxlan_flood_test_bd(cls.mcast_flood_bd)
r = cls.vapi.vxlan_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_mcast_load()
cls.del_mcast_load()
# Setup vni 3 to test unicast flooding
cls.ucast_flood_bd = 3
cls.create_vxlan_flood_test_bd(cls.ucast_flood_bd)
cls.vapi.sw_interface_set_l2_bridge(cls.pg3.sw_if_index,
bd_id=cls.ucast_flood_bd)
except Exception:
super(TestVxlan, cls).tearDownClass()
raise
@ -97,6 +187,9 @@ class TestVxlan(BridgeDomain, VppTestCase):
super(TestVxlan, self).tearDown()
if not self.vpp_dead:
self.logger.info(self.vapi.cli("show bridge-domain 1 detail"))
self.logger.info(self.vapi.cli("show bridge-domain 2 detail"))
self.logger.info(self.vapi.cli("show bridge-domain 3 detail"))
self.logger.info(self.vapi.cli("show vxlan tunnel"))
if __name__ == '__main__':