Bfd test multihop (sonic-net#6032)

Cherry pick of PR sonic-net#6032 for 202012

Author: siqbal1986

ansible/roles/test/files/helpers/bfd_responder.py

@@ -0,0 +1,182 @@
+import binascii
+import socket
+import struct
+import select
+import json
+import argparse
+import os.path
+from fcntl import ioctl
+import logging
+logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
+import scapy.all as scapy2
+scapy2.conf.use_pcap=True
+from  scapy.contrib.bfd import BFD
+
+def get_if(iff, cmd):
+    s = socket.socket()
+    ifreq = ioctl(s, cmd, struct.pack("16s16x",iff))
+    s.close()
+
+    return ifreq
+
+def get_mac(iff):
+    SIOCGIFHWADDR = 0x8927          # Get hardware address
+    return get_if(iff, SIOCGIFHWADDR)[18:24]
+
+
+class Interface(object):
+
+    def __init__(self, iface):
+        self.iface = iface
+        self.socket = None
+        self.mac_address = get_mac(iface)
+
+    def __del__(self):
+        if self.socket:
+            self.socket.close()
+
+    def bind(self):
+        self.socket = scapy2.conf.L2listen(iface=self.iface, filter="udp port 4784")
+
+    def handler(self):
+        return self.socket
+
+    def recv(self):
+        sniffed = self.socket.recv()
+        pkt = sniffed[0]
+        str_pkt = str(pkt).encode("HEX")
+        binpkt = binascii.unhexlify(str_pkt)
+        return binpkt
+
+    def send(self, data):
+        scapy2.sendp(data, iface=self.iface)
+
+    def mac(self):
+        return self.mac_address
+
+    def name(self):
+        return self.iface
+
+
+class Poller(object):
+    def __init__(self, interfaces, responder):
+        self.responder = responder
+        self.mapping = {}
+        for interface in interfaces:
+            self.mapping[interface.handler()] = interface
+
+    def poll(self):
+        handlers = self.mapping.keys()
+        while True:
+            (rdlist, _, _) = select.select(handlers, [], [])
+            for handler in rdlist:
+                self.responder.action(self.mapping[handler])
+
+
+class BFDResponder(object):
+    def __init__(self, sessions):
+        self.sessions = sessions
+        return
+
+    def action(self, interface):
+        data = interface.recv()
+        mac_src, mac_dst, ip_src, ip_dst,  bfd_remote_disc, bfd_state = self.extract_bfd_info(data)
+        if ip_dst not in self.sessions:
+            return
+        session = self.sessions[ip_dst]
+
+        if bfd_state== 3L:
+            interface.send(session["pkt"])
+            return
+
+        if bfd_state == 2L:
+            return
+        session = self.sessions[ip_dst]
+        session["other_disc"] = bfd_remote_disc
+        bfd_pkt_init = self.craft_bfd_packet( session, data, mac_src, mac_dst, ip_src, ip_dst, bfd_remote_disc, 2L )
+        print("sending INIT", bfd_pkt_init)
+        interface.send(bfd_pkt_init)
+        bfd_pkt_init.payload.payload.payload.load.sta =3L
+        session["pkt"] = bfd_pkt_init
+        return
+
+    def extract_bfd_info(self, data):
+        # remote_mac, remote_ip, request_ip, op_type
+        ether = scapy2.Ether(data)
+        mac_src= ether.src
+        mac_dst = ether.dst
+        ip_src = ether.payload.src
+        ip_dst = ether.payload.dst
+        bfdpkt = BFD(ether.payload.payload.payload.load)
+        bfd_remote_disc =bfdpkt.my_discriminator
+        bfd_state = bfdpkt.sta
+        return mac_src, mac_dst, ip_src, ip_dst, bfd_remote_disc, bfd_state
+
+    def craft_bfd_packet(self, session, data, mac_src, mac_dst, ip_src, ip_dst, bfd_remote_disc, bfd_state):
+        ethpart = scapy2.Ether(data)
+        bfdpart = BFD(ethpart.payload.payload.payload.load)
+        bfdpart.my_discriminator = session["my_disc"]
+        bfdpart.your_discriminator = bfd_remote_disc
+        bfdpart.sta = bfd_state
+
+        ethpart.payload.payload.payload.load = bfdpart
+        ethpart.src = mac_dst
+        ethpart.dst = mac_src
+        ethpart.payload.src= ip_dst
+        ethpart.payload.dst= ip_src
+        return ethpart
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='ARP autoresponder')
+    parser.add_argument('--conf', '-c', type=str, dest='conf', default='/tmp/from_t1.json', help='path to json file with configuration')
+    args = parser.parse_args()
+
+    return args
+
+def main():
+    args = parse_args()
+
+    if not os.path.exists(args.conf):
+        print("Can't find file %s" % args.conf)
+        return
+
+    with open(args.conf) as fp:
+        data = json.load(fp)
+
+    # generate ip_sets. every ip address will have it's own uniq mac address
+    sessions = {}
+    local_disc_base = 0xcdba0000
+    local_src_port = 14000
+    ifaces = {}
+    for bfd in data:
+        curr_session = {}
+        curr_session["local"] = bfd["local_addr"]
+        curr_session["remote"] = bfd["neighbor_addr"]
+        curr_session["intf"] = bfd["ptf_intf"]
+        curr_session["multihop"] = bfd["multihop"]
+        curr_session["my_disc"] =  local_disc_base
+        curr_session["other_disc"] = 0x00
+        curr_session["mac"] = get_mac( str( bfd["ptf_intf"]))
+        curr_session["src_port"] = local_src_port
+        curr_session["pkt"] = ""
+        if bfd["ptf_intf"] not in ifaces:
+            ifaces[curr_session["intf"]] = curr_session["mac"]
+
+        local_disc_base +=1
+        local_src_port +=1
+        sessions[curr_session["local"]] = curr_session
+    ifaceobjs =[]
+    for iface_name in ifaces.keys():
+        iface = Interface(str(iface_name))
+        iface.bind()
+        ifaceobjs.append(iface)
+
+    resp = BFDResponder(sessions)
+
+    p = Poller(ifaceobjs, resp)
+    p.poll()
+
+    return
+
+if __name__ == '__main__':
+    main()

tests/bfd/test_bfd.py

@@ -14,15 +14,11 @@
 from tests.common import constants
 
 pytestmark = [
-    pytest.mark.topology('t0', 't1', 't1-lag')
+   pytest.mark.topology('t1')
 ]
 
-def skip_201911_and_older(duthost):
-    """ Skip the current test if the DUT version is 201911 or older.
-    """
-    if parse_version(duthost.kernel_version) <= parse_version('4.9.0'):
-        pytest.skip("Test not supported for 201911 images or older. Skipping the test")
-
+BFD_RESPONDER_SCRIPT_SRC_PATH = '../ansible/roles/test/files/helpers/bfd_responder.py'
+BFD_RESPONDER_SCRIPT_DEST_PATH = '/opt/bfd_responder.py'
 
 def is_dualtor(tbinfo):
     """Check if the testbed is dualtor."""
@@ -96,6 +92,47 @@ def get_neighbors(duthost, tbinfo, ipv6=False, count=1):
             return [t1_ipv4_pattern.format(idx * 2) for idx in indices], 31, [t1_ipv4_pattern.format(idx * 2 + 1) for idx in indices], [t0_intfs[_] for _ in indices], [ptf_ports[_] for _ in indices]
 
 
+def get_loopback_intf(mg_facts, ipv6):
+    ipv6idx = 0 if mg_facts['minigraph_lo_interfaces'][0]['prefixlen'] == 128 else 1
+    if ipv6:
+        return mg_facts['minigraph_lo_interfaces'][ipv6idx]['addr']
+    else:
+         return mg_facts['minigraph_lo_interfaces'][(ipv6idx+1) %2]['addr']
+
+def get_neighbors_multihop(duthost, tbinfo, ipv6=False, count=1):
+    mg_facts = duthost.get_extended_minigraph_facts(tbinfo)
+    t0_ipv4_pattern = '4.{}.{}.1'
+    t0_ipv6_pattern = '3000:3000:{:x}::3000'
+    t0_intfs = get_t0_intfs(mg_facts)
+    ptf_ports = [mg_facts['minigraph_ptf_indices'][port] for port in t0_intfs]
+    loopback_addr = get_loopback_intf( mg_facts, ipv6 )
+
+    index = random.sample(list(range(len(t0_intfs))), k=1)[0]
+    port_intf = t0_intfs[index]
+    ptf_intf = ptf_ports[index]
+    nexthop_ip = ""
+    neighbour_dev_name = mg_facts['minigraph_neighbors'][port_intf]['name']
+    for bgpinfo in  mg_facts['minigraph_bgp']:
+        if bgpinfo['name'] == neighbour_dev_name:
+            nexthop_ip =  bgpinfo['addr']
+            if  ipv6 and ":" not in nexthop_ip :
+                nexthop_ip = ""
+                continue
+            break
+    if nexthop_ip =="":
+        assert False
+    neighbor_addrs = []
+    idx2 =0
+    for idx in range(1, count):
+        if idx %250 ==0:
+            idx2 +=1
+        if ipv6:
+            neighbor_addrs.append(t0_ipv6_pattern.format(idx))
+        else:
+            neighbor_addrs.append(t0_ipv4_pattern.format((idx%250),idx2))
+    
+    return loopback_addr, ptf_intf, nexthop_ip, neighbor_addrs
+
 def init_ptf_bfd(ptfhost):
     ptfhost.shell("bfdd-beacon")
 
@@ -117,7 +154,13 @@ def del_ipaddr(ptfhost, neighbor_addrs, prefix_len, neighbor_interfaces, ipv6=Fa
         if ipv6:
             ptfhost.shell("ip -6 addr del {}/{} dev eth{}".format(neighbor_addrs[idx], prefix_len, neighbor_interfaces[idx]), module_ignore_errors=True)
         else:
-            ptfhost.shell("ip addr del {}/{} dev eth{}".format(neighbor_addrs[idx], prefix_len, neighbor_interfaces[idx]), module_ignore_errors=True)
+            cmd_buffer += "ip addr del {}/{} dev eth{} ;".format(neighbor_addrs[idx], prefix_len,
+                                                                 neighbor_interfaces[idx])
+        if idx % 50 == 0:
+            ptfhost.shell(cmd_buffer, module_ignore_errors=True)
+            cmd_buffer = ""
+    if cmd_buffer != "":
+        ptfhost.shell(cmd_buffer, module_ignore_errors=True)
 
 
 def check_ptf_bfd_status(ptfhost, neighbor_addr, local_addr, expected_state):
@@ -157,8 +200,51 @@ def create_bfd_sessions(ptfhost, duthost, local_addrs, neighbor_addrs):
     if result['rc'] != 0:
         pytest.fail('Failed to apply BFD session configuration file: {}'.format(result['stderr']))
 
+def create_bfd_sessions_multihop(ptfhost, duthost, loopback_addr, ptf_intf, neighbor_addrs):
+    # Create a tempfile for BFD sessions
+    bfd_file_dir = duthost.shell('mktemp')['stdout']
+    ptf_file_dir = ptfhost.shell('mktemp')['stdout']
+    bfd_config = []
+    ptf_config = []
+    for neighbor_addr in neighbor_addrs:
+        bfd_config.append({
+            "BFD_SESSION_TABLE:default:default:{}".format(neighbor_addr): {
+                "local_addr": loopback_addr,
+                "multihop" : "true"
+            },
+            "OP": "SET"
+        })
+        ptf_config.append(
+            {
+                "neighbor_addr": loopback_addr,
+                "local_addr" : neighbor_addr,
+                "multihop" : "true",
+                "ptf_intf" : "eth{}".format(ptf_intf)
+            }
+        )
+
+    # Copy json file to DUT
+    duthost.copy(content=json.dumps(bfd_config, indent=4), dest=bfd_file_dir, verbose=False)
+
+    # Apply BFD sessions with swssconfig
+    result = duthost.shell('docker exec -i swss swssconfig /dev/stdin < {}'.format(bfd_file_dir),
+                           module_ignore_errors=True)
+    if result['rc'] != 0:
+        pytest.fail('Failed to apply BFD session configuration file: {}'.format(result['stderr']))
+    # Copy json file to PTF
+    ptfhost.copy(content=json.dumps(ptf_config, indent=4), dest=ptf_file_dir, verbose=False)
 
-def remove_bfd_sessions(duthost, local_addrs, neighbor_addrs):
+    ptfhost.copy(src=BFD_RESPONDER_SCRIPT_SRC_PATH, dest=BFD_RESPONDER_SCRIPT_DEST_PATH)
+
+    extra_vars = {"bfd_responder_args" : "-c {}".format(ptf_file_dir)}
+    ptfhost.host.options["variable_manager"].extra_vars.update(extra_vars)
+
+    ptfhost.template(src='templates/bfd_responder.conf.j2', dest='/etc/supervisor/conf.d/bfd_responder.conf')
+    ptfhost.command('supervisorctl reread')
+    ptfhost.command('supervisorctl update')
+    ptfhost.command('supervisorctl start bfd_responder')
+
+def remove_bfd_sessions(duthost, neighbor_addrs):
     # Create a tempfile for BFD sessions
     bfd_file_dir = duthost.shell('mktemp')['stdout']
     bfd_config = []
@@ -167,7 +253,6 @@ def remove_bfd_sessions(duthost, local_addrs, neighbor_addrs):
         duthost.shell("sonic-db-cli APPL_DB hmset 'BFD_SESSION_TABLE:default:default:{}' local_addr {}".format(neighbor_addr, local_addrs[idx]))
         bfd_config.append({
             "BFD_SESSION_TABLE:default:default:{}".format(neighbor_addr): {
-                "local_addr": local_addrs[idx]
             },
             "OP": "DEL"
         })
@@ -218,10 +303,9 @@ def test_bfd(rand_selected_dut, ptfhost, tbinfo, toggle_all_simulator_ports_to_r
                 check_ptf_bfd_status(ptfhost, neighbor_addr, local_addrs[idx], "Up")
     finally:
         stop_ptf_bfd(ptfhost)
-        del_ipaddr(ptfhost, neighbor_addrs, prefix_len, neighbor_interfaces, ipv6=False)
-        remove_bfd_sessions(duthost, local_addrs, neighbor_addrs)
-        if 't1' in tbinfo['topo']['name']:
-            remove_dut_ip(duthost, neighbor_devs, local_addrs, prefix_len)
+        del_ipaddr(ptfhost, neighbor_addrs, prefix_len, neighbor_interfaces, ipv6)
+        remove_bfd_sessions(duthost, neighbor_addrs)
+        remove_dut_ip(duthost, neighbor_devs, local_addrs, prefix_len)
 
 
 @pytest.mark.skip(reason="Test may currently fail due to lack of hardware support")
@@ -238,11 +322,12 @@ def test_bfd_ipv6(rand_selected_dut, ptfhost, tbinfo, toggle_all_simulator_ports
         add_ipaddr(ptfhost, neighbor_addrs, prefix_len, neighbor_interfaces, ipv6=True)
         create_bfd_sessions(ptfhost, duthost, local_addrs, neighbor_addrs)
 
-        time.sleep(1)
-
-        for idx, neighbor_addr in enumerate(neighbor_addrs):
-            check_dut_bfd_status(duthost, neighbor_addr, "Up")
-            check_ptf_bfd_status(ptfhost, neighbor_addr, local_addrs[idx], "Up")
+       time.sleep(10)
+        bfd_state = ptfhost.shell("bfdd-control status")
+        dut_state = duthost.shell("show bfd summary")
+        for itr in local_addrs:
+            assert itr in bfd_state['stdout']
+            assert itr in dut_state['stdout']
 
         update_idx = random.choice(range(bfd_session_cnt))
         update_bfd_session_state(ptfhost, neighbor_addrs[update_idx], local_addrs[idx], "down")
@@ -256,7 +341,34 @@ def test_bfd_ipv6(rand_selected_dut, ptfhost, tbinfo, toggle_all_simulator_ports
                 check_ptf_bfd_status(ptfhost, neighbor_addr, local_addrs[idx], "Up")
     finally:
         stop_ptf_bfd(ptfhost)
-        del_ipaddr(ptfhost, neighbor_addrs, prefix_len, neighbor_interfaces, ipv6=True)
-        remove_bfd_sessions(duthost, local_addrs, neighbor_addrs)
-        if 't1' in tbinfo['topo']['name']:
-            remove_dut_ip(duthost, neighbor_devs, local_addrs, prefix_len)
+        del_ipaddr(ptfhost, neighbor_addrs, prefix_len, neighbor_interfaces, ipv6)
+        remove_bfd_sessions(duthost, neighbor_addrs)
+        remove_dut_ip(duthost, neighbor_devs, local_addrs, prefix_len)
+
+
+@pytest.mark.parametrize('ipv6', [False, True], ids=['ipv4', 'ipv6'])
+def test_bfd_multihop(request, rand_selected_dut, ptfhost, tbinfo, toggle_all_simulator_ports_to_rand_selected_tor_m, ipv6):
+    duthost = rand_selected_dut
+
+    bfd_session_cnt = int(request.config.getoption('--num_sessions'))
+    loopback_addr, ptf_intf, nexthop_ip, neighbor_addrs = get_neighbors_multihop(duthost, tbinfo, ipv6, count = bfd_session_cnt)
+    try:
+        cmd_buffer = ""
+        for neighbor in neighbor_addrs:
+            cmd_buffer += 'sudo ip route add {} via {} ;'.format(neighbor, nexthop_ip)
+        duthost.shell(cmd_buffer)
+
+        create_bfd_sessions_multihop(ptfhost, duthost, loopback_addr, ptf_intf, neighbor_addrs)
+
+        time.sleep(1)
+        for neighbor_addr in neighbor_addrs:
+            check_dut_bfd_status(duthost, neighbor_addr, "Up")
+
+    finally:
+        remove_bfd_sessions(duthost, neighbor_addrs)
+        cmd_buffer = ""
+        for neighbor in neighbor_addrs:
+            cmd_buffer += 'sudo ip route delete {} via {} ;'.format(neighbor, nexthop_ip)
+        duthost.shell(cmd_buffer)
+        ptfhost.command('supervisorctl stop bfd_responder')
+        ptfhost.file(path=BFD_RESPONDER_SCRIPT_DEST_PATH, state="absent")