X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=test%2Ftest_bfd.py;h=174db3ed54a2c95ec83f2ddbd084de90979176e4;hb=cdaf0d8c884ae0f337ef94b0ceb7449c991a3e6c;hp=be42cdadd461d313680f208480c46554ed02626a;hpb=f3bcdbf071c98ed676591bd22c3d3f8601009fa8;p=vpp.git diff --git a/test/test_bfd.py b/test/test_bfd.py index be42cdadd46..174db3ed54a 100644 --- a/test/test_bfd.py +++ b/test/test_bfd.py @@ -1,26 +1,39 @@ -#!/usr/bin/env python +#!/usr/bin/env python3 """ BFD tests """ from __future__ import division -import unittest -import hashlib + import binascii +from collections import namedtuple +import hashlib +import ipaddress +import reprlib import time -from struct import pack, unpack +import unittest from random import randint, shuffle, getrandbits from socket import AF_INET, AF_INET6, inet_ntop -from scapy.packet import Raw -from scapy.layers.l2 import Ether +from struct import pack, unpack + +import scapy.compat from scapy.layers.inet import UDP, IP from scapy.layers.inet6 import IPv6 +from scapy.layers.l2 import Ether, GRE +from scapy.packet import Raw + from bfd import VppBFDAuthKey, BFD, BFDAuthType, VppBFDUDPSession, \ BFDDiagCode, BFDState, BFD_vpp_echo +from framework import tag_fixme_vpp_workers from framework import VppTestCase, VppTestRunner, running_extended_tests -from vpp_pg_interface import CaptureTimeoutError, is_ipv6_misc -from vpp_lo_interface import VppLoInterface +from framework import tag_run_solo from util import ppp -from vpp_papi_provider import UnexpectedApiReturnValueError +from vpp_ip import DpoProto from vpp_ip_route import VppIpRoute, VppRoutePath +from vpp_lo_interface import VppLoInterface +from vpp_papi_provider import UnexpectedApiReturnValueError, \ + CliFailedCommandError +from vpp_pg_interface import CaptureTimeoutError, is_ipv6_misc +from vpp_gre_interface import VppGreInterface +from vpp_papi import VppEnum USEC_IN_SEC = 1000000 @@ -37,12 +50,12 @@ class AuthKeyFactory(object): while conf_key_id in self._conf_key_ids: conf_key_id = randint(0, 0xFFFFFFFF) self._conf_key_ids[conf_key_id] = 1 - key = str(bytearray([randint(0, 255) for _ in range(randint(1, 20))])) + key = scapy.compat.raw( + bytearray([randint(0, 255) for _ in range(randint(1, 20))])) return VppBFDAuthKey(test=test, auth_type=auth_type, conf_key_id=conf_key_id, key=key) -@unittest.skipUnless(running_extended_tests(), "part of extended tests") class BFDAPITestCase(VppTestCase): """Bidirectional Forwarding Detection (BFD) - API""" @@ -52,7 +65,7 @@ class BFDAPITestCase(VppTestCase): @classmethod def setUpClass(cls): super(BFDAPITestCase, cls).setUpClass() - + cls.vapi.cli("set log class bfd level debug") try: cls.create_pg_interfaces(range(2)) for i in cls.pg_interfaces: @@ -64,6 +77,10 @@ class BFDAPITestCase(VppTestCase): super(BFDAPITestCase, cls).tearDownClass() raise + @classmethod + def tearDownClass(cls): + super(BFDAPITestCase, cls).tearDownClass() + def setUp(self): super(BFDAPITestCase, self).setUp() self.factory = AuthKeyFactory() @@ -83,7 +100,7 @@ class BFDAPITestCase(VppTestCase): session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4) session.add_vpp_config() - with self.vapi.expect_negative_api_retval(): + with self.vapi.assert_negative_api_retval(): session.add_vpp_config() session.remove_vpp_config() @@ -126,6 +143,34 @@ class BFDAPITestCase(VppTestCase): "required min receive interval") self.assert_equal(session.detect_mult, s.detect_mult, "detect mult") + def test_upd_bfd(self): + """ Create/Modify w/ Update BFD session parameters """ + session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4, + desired_min_tx=50000, + required_min_rx=10000, + detect_mult=1) + session.upd_vpp_config() + s = session.get_bfd_udp_session_dump_entry() + self.assert_equal(session.desired_min_tx, + s.desired_min_tx, + "desired min transmit interval") + self.assert_equal(session.required_min_rx, + s.required_min_rx, + "required min receive interval") + + self.assert_equal(session.detect_mult, s.detect_mult, "detect mult") + session.upd_vpp_config(desired_min_tx=session.desired_min_tx * 2, + required_min_rx=session.required_min_rx * 2, + detect_mult=session.detect_mult * 2) + s = session.get_bfd_udp_session_dump_entry() + self.assert_equal(session.desired_min_tx, + s.desired_min_tx, + "desired min transmit interval") + self.assert_equal(session.required_min_rx, + s.required_min_rx, + "required min receive interval") + self.assert_equal(session.detect_mult, s.detect_mult, "detect mult") + def test_add_sha1_keys(self): """ add SHA1 keys """ key_count = 10 @@ -138,7 +183,7 @@ class BFDAPITestCase(VppTestCase): for key in keys: self.assertTrue(key.query_vpp_config()) # remove randomly - indexes = range(key_count) + indexes = list(range(key_count)) shuffle(indexes) removed = [] for i in indexes: @@ -196,7 +241,7 @@ class BFDAPITestCase(VppTestCase): session.add_vpp_config() def test_shared_sha1_key(self): - """ share single SHA1 key between multiple BFD sessions """ + """ single SHA1 key shared by multiple BFD sessions """ key = self.factory.create_random_key(self) key.add_vpp_config() sessions = [ @@ -251,18 +296,68 @@ class BFDAPITestCase(VppTestCase): session.add_vpp_config() session.activate_auth(key2) + def test_set_del_udp_echo_source(self): + """ set/del udp echo source """ + self.create_loopback_interfaces(1) + self.loopback0 = self.lo_interfaces[0] + self.loopback0.admin_up() + echo_source = self.vapi.bfd_udp_get_echo_source() + self.assertFalse(echo_source.is_set) + self.assertFalse(echo_source.have_usable_ip4) + self.assertFalse(echo_source.have_usable_ip6) + + self.vapi.bfd_udp_set_echo_source( + sw_if_index=self.loopback0.sw_if_index) + echo_source = self.vapi.bfd_udp_get_echo_source() + self.assertTrue(echo_source.is_set) + self.assertEqual(echo_source.sw_if_index, self.loopback0.sw_if_index) + self.assertFalse(echo_source.have_usable_ip4) + self.assertFalse(echo_source.have_usable_ip6) + + self.loopback0.config_ip4() + echo_ip4 = ipaddress.IPv4Address(int(ipaddress.IPv4Address( + self.loopback0.local_ip4)) ^ 1).packed + echo_source = self.vapi.bfd_udp_get_echo_source() + self.assertTrue(echo_source.is_set) + self.assertEqual(echo_source.sw_if_index, self.loopback0.sw_if_index) + self.assertTrue(echo_source.have_usable_ip4) + self.assertEqual(echo_source.ip4_addr.packed, echo_ip4) + self.assertFalse(echo_source.have_usable_ip6) + + self.loopback0.config_ip6() + echo_ip6 = ipaddress.IPv6Address(int(ipaddress.IPv6Address( + self.loopback0.local_ip6)) ^ 1).packed + + echo_source = self.vapi.bfd_udp_get_echo_source() + self.assertTrue(echo_source.is_set) + self.assertEqual(echo_source.sw_if_index, self.loopback0.sw_if_index) + self.assertTrue(echo_source.have_usable_ip4) + self.assertEqual(echo_source.ip4_addr.packed, echo_ip4) + self.assertTrue(echo_source.have_usable_ip6) + self.assertEqual(echo_source.ip6_addr.packed, echo_ip6) + + self.vapi.bfd_udp_del_echo_source() + echo_source = self.vapi.bfd_udp_get_echo_source() + self.assertFalse(echo_source.is_set) + self.assertFalse(echo_source.have_usable_ip4) + self.assertFalse(echo_source.have_usable_ip6) + -@unittest.skipUnless(running_extended_tests(), "part of extended tests") class BFDTestSession(object): """ BFD session as seen from test framework side """ def __init__(self, test, interface, af, detect_mult=3, sha1_key=None, - bfd_key_id=None, our_seq_number=None): + bfd_key_id=None, our_seq_number=None, + tunnel_header=None, phy_interface=None): self.test = test self.af = af self.sha1_key = sha1_key self.bfd_key_id = bfd_key_id self.interface = interface + if phy_interface: + self.phy_interface = phy_interface + else: + self.phy_interface = self.interface self.udp_sport = randint(49152, 65535) if our_seq_number is None: self.our_seq_number = randint(0, 40000000) @@ -278,6 +373,11 @@ class BFDTestSession(object): self.your_discriminator = None self.state = BFDState.down self.auth_type = BFDAuthType.no_auth + self.tunnel_header = tunnel_header + self.tx_packets = 0 + self.rx_packets = 0 + self.tx_packets_echo = 0 + self.rx_packets_echo = 0 def inc_seq_num(self): """ increment sequence number, wrapping if needed """ @@ -363,17 +463,19 @@ class BFDTestSession(object): bfd.length = BFD.sha1_auth_len + BFD.bfd_pkt_len else: bfd = BFD() + packet = Ether(src=self.phy_interface.remote_mac, + dst=self.phy_interface.local_mac) + if self.tunnel_header: + packet = packet / self.tunnel_header if self.af == AF_INET6: - packet = (Ether(src=self.interface.remote_mac, - dst=self.interface.local_mac) / + packet = (packet / IPv6(src=self.interface.remote_ip6, dst=self.interface.local_ip6, hlim=255) / UDP(sport=self.udp_sport, dport=BFD.udp_dport) / bfd) else: - packet = (Ether(src=self.interface.remote_mac, - dst=self.interface.local_mac) / + packet = (packet / IP(src=self.interface.remote_ip4, dst=self.interface.local_ip4, ttl=255) / @@ -382,8 +484,9 @@ class BFDTestSession(object): self.test.logger.debug("BFD: Creating packet") self.fill_packet_fields(packet) if self.sha1_key: - hash_material = str(packet[BFD])[:32] + self.sha1_key.key + \ - "\0" * (20 - len(self.sha1_key.key)) + hash_material = scapy.compat.raw( + packet[BFD])[:32] + self.sha1_key.key + \ + b"\0" * (20 - len(self.sha1_key.key)) self.test.logger.debug("BFD: Calculated SHA1 hash: %s" % hashlib.sha1(hash_material).hexdigest()) packet[BFD].auth_key_hash = hashlib.sha1(hash_material).digest() @@ -394,9 +497,10 @@ class BFDTestSession(object): if packet is None: packet = self.create_packet() if interface is None: - interface = self.test.pg0 + interface = self.phy_interface self.test.logger.debug(ppp("Sending packet:", packet)) interface.add_stream(packet) + self.tx_packets += 1 self.test.pg_start() def verify_sha1_auth(self, packet): @@ -439,10 +543,10 @@ class BFDTestSession(object): # last 20 bytes represent the hash - so replace them with the key, # pad the result with zeros and hash the result hash_material = bfd.original[:-20] + self.sha1_key.key + \ - "\0" * (20 - len(self.sha1_key.key)) + b"\0" * (20 - len(self.sha1_key.key)) expected_hash = hashlib.sha1(hash_material).hexdigest() self.test.assert_equal(binascii.hexlify(bfd.auth_key_hash), - expected_hash, "Auth key hash") + expected_hash.encode(), "Auth key hash") def verify_bfd(self, packet): """ Verify correctness of BFD layer. """ @@ -458,11 +562,11 @@ class BFDTestSession(object): def bfd_session_up(test): """ Bring BFD session up """ test.logger.info("BFD: Waiting for slow hello") - p = wait_for_bfd_packet(test, 2) + p = wait_for_bfd_packet(test, 2, is_tunnel=test.vpp_session.is_tunnel) old_offset = None if hasattr(test, 'vpp_clock_offset'): old_offset = test.vpp_clock_offset - test.vpp_clock_offset = time.time() - p.time + test.vpp_clock_offset = time.time() - float(p.time) test.logger.debug("BFD: Calculated vpp clock offset: %s", test.vpp_clock_offset) if old_offset: @@ -479,7 +583,7 @@ def bfd_session_up(test): test.test_session.inc_seq_num() test.test_session.send_packet() test.logger.info("BFD: Waiting for event") - e = test.vapi.wait_for_event(1, "bfd_udp_session_details") + e = test.vapi.wait_for_event(1, "bfd_udp_session_event") verify_event(test, e, expected_state=BFDState.up) test.logger.info("BFD: Session is Up") test.test_session.update(state=BFDState.up) @@ -499,7 +603,7 @@ def bfd_session_down(test): test.test_session.inc_seq_num() test.test_session.send_packet() test.logger.info("BFD: Waiting for event") - e = test.vapi.wait_for_event(1, "bfd_udp_session_details") + e = test.vapi.wait_for_event(1, "bfd_udp_session_event") verify_event(test, e, expected_state=BFDState.down) test.logger.info("BFD: Session is Down") test.assert_equal(test.vpp_session.state, BFDState.down, BFDState) @@ -533,13 +637,13 @@ def verify_ip(test, packet): """ Verify correctness of IP layer. """ if test.vpp_session.af == AF_INET6: ip = packet[IPv6] - local_ip = test.pg0.local_ip6 - remote_ip = test.pg0.remote_ip6 + local_ip = test.vpp_session.interface.local_ip6 + remote_ip = test.vpp_session.interface.remote_ip6 test.assert_equal(ip.hlim, 255, "IPv6 hop limit") else: ip = packet[IP] - local_ip = test.pg0.local_ip4 - remote_ip = test.pg0.remote_ip4 + local_ip = test.vpp_session.interface.local_ip4 + remote_ip = test.vpp_session.interface.remote_ip4 test.assert_equal(ip.ttl, 255, "IPv4 TTL") test.assert_equal(ip.src, local_ip, "IP source address") test.assert_equal(ip.dst, remote_ip, "IP destination address") @@ -556,28 +660,19 @@ def verify_udp(test, packet): def verify_event(test, event, expected_state): """ Verify correctness of event values. """ e = event - test.logger.debug("BFD: Event: %s" % repr(e)) + test.logger.debug("BFD: Event: %s" % reprlib.repr(e)) test.assert_equal(e.sw_if_index, test.vpp_session.interface.sw_if_index, "BFD interface index") - is_ipv6 = 0 - if test.vpp_session.af == AF_INET6: - is_ipv6 = 1 - test.assert_equal(e.is_ipv6, is_ipv6, "is_ipv6") - if test.vpp_session.af == AF_INET: - test.assert_equal(e.local_addr[:4], test.vpp_session.local_addr_n, - "Local IPv4 address") - test.assert_equal(e.peer_addr[:4], test.vpp_session.peer_addr_n, - "Peer IPv4 address") - else: - test.assert_equal(e.local_addr, test.vpp_session.local_addr_n, - "Local IPv6 address") - test.assert_equal(e.peer_addr, test.vpp_session.peer_addr_n, - "Peer IPv6 address") + + test.assert_equal(str(e.local_addr), test.vpp_session.local_addr, + "Local IPv6 address") + test.assert_equal(str(e.peer_addr), test.vpp_session.peer_addr, + "Peer IPv6 address") test.assert_equal(e.state, expected_state, BFDState) -def wait_for_bfd_packet(test, timeout=1, pcap_time_min=None): +def wait_for_bfd_packet(test, timeout=1, pcap_time_min=None, is_tunnel=False): """ wait for BFD packet and verify its correctness :param timeout: how long to wait @@ -596,6 +691,7 @@ def wait_for_bfd_packet(test, timeout=1, pcap_time_min=None): if time_left < 0: raise CaptureTimeoutError("Packet did not arrive within timeout") p = test.pg0.wait_for_packet(timeout=time_left) + test.test_session.rx_packets += 1 test.logger.debug(ppp("BFD: Got packet:", p)) if pcap_time_min is not None and p.time < pcap_time_min: test.logger.debug(ppp("BFD: ignoring packet (pcap time %s < " @@ -603,6 +699,10 @@ def wait_for_bfd_packet(test, timeout=1, pcap_time_min=None): (p.time, pcap_time_min), p)) else: break + if is_tunnel: + # strip an IP layer and move to the next + p = p[IP].payload + bfd = p[BFD] if bfd is None: raise Exception(ppp("Unexpected or invalid BFD packet:", p)) @@ -614,7 +714,34 @@ def wait_for_bfd_packet(test, timeout=1, pcap_time_min=None): return p -@unittest.skipUnless(running_extended_tests(), "part of extended tests") +BFDStats = namedtuple("BFDStats", "rx rx_echo tx tx_echo") + + +def bfd_grab_stats_snapshot(test, bs_idx=0, thread_index=None): + s = test.statistics + ti = thread_index + if ti is None: + rx = s['/bfd/rx-session-counters'][:, bs_idx].sum_packets() + rx_echo = s['/bfd/rx-session-echo-counters'][:, bs_idx].sum_packets() + tx = s['/bfd/tx-session-counters'][:, bs_idx].sum_packets() + tx_echo = s['/bfd/tx-session-echo-counters'][:, bs_idx].sum_packets() + else: + rx = s['/bfd/rx-session-counters'][ti, bs_idx].sum_packets() + rx_echo = s['/bfd/rx-session-echo-counters'][ti, bs_idx].sum_packets() + tx = s['/bfd/tx-session-counters'][ti, bs_idx].sum_packets() + tx_echo = s['/bfd/tx-session-echo-counters'][ti, bs_idx].sum_packets() + return BFDStats(rx, rx_echo, tx, tx_echo) + + +def bfd_stats_diff(stats_before, stats_after): + rx = stats_after.rx - stats_before.rx + rx_echo = stats_after.rx_echo - stats_before.rx_echo + tx = stats_after.tx - stats_before.tx + tx_echo = stats_after.tx_echo - stats_before.tx_echo + return BFDStats(rx, rx_echo, tx, tx_echo) + + +@tag_run_solo class BFD4TestCase(VppTestCase): """Bidirectional Forwarding Detection (BFD)""" @@ -626,9 +753,10 @@ class BFD4TestCase(VppTestCase): @classmethod def setUpClass(cls): super(BFD4TestCase, cls).setUpClass() + cls.vapi.cli("set log class bfd level debug") try: cls.create_pg_interfaces([0]) - cls.create_loopback_interfaces([0]) + cls.create_loopback_interfaces(1) cls.loopback0 = cls.lo_interfaces[0] cls.loopback0.config_ip4() cls.loopback0.admin_up() @@ -641,18 +769,24 @@ class BFD4TestCase(VppTestCase): super(BFD4TestCase, cls).tearDownClass() raise + @classmethod + def tearDownClass(cls): + super(BFD4TestCase, cls).tearDownClass() + def setUp(self): super(BFD4TestCase, self).setUp() self.factory = AuthKeyFactory() self.vapi.want_bfd_events() self.pg0.enable_capture() try: + self.bfd_udp4_sessions = self.statistics['/bfd/udp4/sessions'] + self.bfd_udp6_sessions = self.statistics['/bfd/udp6/sessions'] self.vpp_session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4) self.vpp_session.add_vpp_config() self.vpp_session.admin_up() self.test_session = BFDTestSession(self, self.pg0, AF_INET) - except: + except BaseException: self.vapi.want_bfd_events(enable_disable=0) raise @@ -665,6 +799,10 @@ class BFD4TestCase(VppTestCase): def test_session_up(self): """ bring BFD session up """ bfd_session_up(self) + bfd_udp4_sessions = self.statistics['/bfd/udp4/sessions'] + bfd_udp6_sessions = self.statistics['/bfd/udp6/sessions'] + self.assert_equal(bfd_udp4_sessions - self.bfd_udp4_sessions, 1) + self.assert_equal(bfd_udp6_sessions, self.bfd_udp6_sessions) def test_session_up_by_ip(self): """ bring BFD session up - first frame looked up by address pair """ @@ -680,12 +818,12 @@ class BFD4TestCase(VppTestCase): self.test_session.update(your_discriminator=p[BFD].my_discriminator, state=BFDState.up) self.logger.info("BFD: Waiting for event") - e = self.vapi.wait_for_event(1, "bfd_udp_session_details") + e = self.vapi.wait_for_event(1, "bfd_udp_session_event") verify_event(self, e, expected_state=BFDState.init) self.logger.info("BFD: Sending Up") self.test_session.send_packet() self.logger.info("BFD: Waiting for event") - e = self.vapi.wait_for_event(1, "bfd_udp_session_details") + e = self.vapi.wait_for_event(1, "bfd_udp_session_event") verify_event(self, e, expected_state=BFDState.up) self.logger.info("BFD: Session is Up") self.test_session.update(state=BFDState.up) @@ -697,7 +835,6 @@ class BFD4TestCase(VppTestCase): bfd_session_up(self) bfd_session_down(self) - @unittest.skipUnless(running_extended_tests(), "part of extended tests") def test_hold_up(self): """ hold BFD session up """ bfd_session_up(self) @@ -707,7 +844,6 @@ class BFD4TestCase(VppTestCase): self.assert_equal(len(self.vapi.collect_events()), 0, "number of bfd events") - @unittest.skipUnless(running_extended_tests(), "part of extended tests") def test_slow_timer(self): """ verify slow periodic control frames while session down """ packet_count = 3 @@ -722,7 +858,6 @@ class BFD4TestCase(VppTestCase): time_diff, 0.70, 1.05, "time between slow packets") prev_packet = next_packet - @unittest.skipUnless(running_extended_tests(), "part of extended tests") def test_zero_remote_min_rx(self): """ no packets when zero remote required min rx interval """ bfd_session_up(self) @@ -747,17 +882,25 @@ class BFD4TestCase(VppTestCase): self.assert_equal( len(self.vapi.collect_events()), 0, "number of bfd events") - @unittest.skipUnless(running_extended_tests(), "part of extended tests") def test_conn_down(self): """ verify session goes down after inactivity """ bfd_session_up(self) detection_time = self.test_session.detect_mult *\ self.vpp_session.required_min_rx / USEC_IN_SEC self.sleep(detection_time, "waiting for BFD session time-out") - e = self.vapi.wait_for_event(1, "bfd_udp_session_details") + e = self.vapi.wait_for_event(1, "bfd_udp_session_event") verify_event(self, e, expected_state=BFDState.down) - @unittest.skipUnless(running_extended_tests(), "part of extended tests") + def test_peer_discr_reset_sess_down(self): + """ peer discriminator reset after session goes down """ + bfd_session_up(self) + detection_time = self.test_session.detect_mult *\ + self.vpp_session.required_min_rx / USEC_IN_SEC + self.sleep(detection_time, "waiting for BFD session time-out") + self.test_session.my_discriminator = 0 + wait_for_bfd_packet(self, + pcap_time_min=time.time() - self.vpp_clock_offset) + def test_large_required_min_rx(self): """ large remote required min rx interval """ bfd_session_up(self) @@ -787,7 +930,6 @@ class BFD4TestCase(VppTestCase): break self.assert_equal(count, 0, "number of packets received") - @unittest.skipUnless(running_extended_tests(), "part of extended tests") def test_immediate_remote_min_rx_reduction(self): """ immediately honor remote required min rx reduction """ self.vpp_session.remove_vpp_config() @@ -820,7 +962,6 @@ class BFD4TestCase(VppTestCase): "time between BFD packets") reference_packet = p - @unittest.skipUnless(running_extended_tests(), "part of extended tests") def test_modify_req_min_rx_double(self): """ modify session - double required min rx """ bfd_session_up(self) @@ -844,13 +985,12 @@ class BFD4TestCase(VppTestCase): self.vpp_session.required_min_rx) / USEC_IN_SEC self.test_session.send_packet(final) time_mark = time.time() - e = self.vapi.wait_for_event(2 * timeout, "bfd_udp_session_details") + e = self.vapi.wait_for_event(2 * timeout, "bfd_udp_session_event") verify_event(self, e, expected_state=BFDState.down) time_to_event = time.time() - time_mark self.assert_in_range(time_to_event, .9 * timeout, 1.1 * timeout, "session timeout") - @unittest.skipUnless(running_extended_tests(), "part of extended tests") def test_modify_req_min_rx_halve(self): """ modify session - halve required min rx """ self.vpp_session.modify_parameters( @@ -865,7 +1005,7 @@ class BFD4TestCase(VppTestCase): # halve required min rx old_required_min_rx = self.vpp_session.required_min_rx self.vpp_session.modify_parameters( - required_min_rx=0.5 * self.vpp_session.required_min_rx) + required_min_rx=self.vpp_session.required_min_rx // 2) # now we wait 0.8*3*old-req-min-rx and the session should still be up self.sleep(0.8 * self.vpp_session.detect_mult * old_required_min_rx / USEC_IN_SEC, @@ -885,7 +1025,7 @@ class BFD4TestCase(VppTestCase): self.vpp_session.required_min_rx / USEC_IN_SEC before = time.time() e = self.vapi.wait_for_event( - 2 * detection_time, "bfd_udp_session_details") + 2 * detection_time, "bfd_udp_session_event") after = time.time() self.assert_in_range(after - before, 0.9 * detection_time, @@ -893,7 +1033,6 @@ class BFD4TestCase(VppTestCase): "time before bfd session goes down") verify_event(self, e, expected_state=BFDState.down) - @unittest.skipUnless(running_extended_tests(), "part of extended tests") def test_modify_detect_mult(self): """ modify detect multiplier """ bfd_session_up(self) @@ -917,7 +1056,6 @@ class BFD4TestCase(VppTestCase): self.assertNotIn("P", p.sprintf("%BFD.flags%"), "Poll bit not set in BFD packet") - @unittest.skipUnless(running_extended_tests(), "part of extended tests") def test_queued_poll(self): """ test poll sequence queueing """ bfd_session_up(self) @@ -983,7 +1121,8 @@ class BFD4TestCase(VppTestCase): self.assertNotIn("P", p.sprintf("%BFD.flags%"), "Poll bit set in BFD packet") - @unittest.skipUnless(running_extended_tests(), "part of extended tests") + # returning inconsistent results requiring retries in per-patch tests + @unittest.skipUnless(running_extended_tests, "part of extended tests") def test_poll_response(self): """ test correct response to control frame with poll bit set """ bfd_session_up(self) @@ -994,7 +1133,6 @@ class BFD4TestCase(VppTestCase): self, pcap_time_min=time.time() - self.vpp_clock_offset) self.assertIn("F", final.sprintf("%BFD.flags%")) - @unittest.skipUnless(running_extended_tests(), "part of extended tests") def test_no_periodic_if_remote_demand(self): """ no periodic frames outside poll sequence if remote demand set """ bfd_session_up(self) @@ -1007,7 +1145,7 @@ class BFD4TestCase(VppTestCase): / USEC_IN_SEC count = 0 for dummy in range(self.test_session.detect_mult * 2): - time.sleep(transmit_time) + self.sleep(transmit_time) self.test_session.send_packet(demand) try: p = wait_for_bfd_packet(self, timeout=0) @@ -1023,8 +1161,8 @@ class BFD4TestCase(VppTestCase): def test_echo_looped_back(self): """ echo packets looped back """ - # don't need a session in this case.. - self.vpp_session.remove_vpp_config() + bfd_session_up(self) + stats_before = bfd_grab_stats_snapshot(self) self.pg0.enable_capture() echo_packet_count = 10 # random source port low enough to increment a few times.. @@ -1043,7 +1181,10 @@ class BFD4TestCase(VppTestCase): self.logger.debug(ppp("Sending packet:", echo_packet)) self.pg0.add_stream(echo_packet) self.pg_start() - for dummy in range(echo_packet_count): + self.logger.debug(self.vapi.ppcli("show trace")) + counter = 0 + bfd_control_packets_rx = 0 + while counter < echo_packet_count: p = self.pg0.wait_for_packet(1) self.logger.debug(ppp("Got packet:", p)) ether = p[Ether] @@ -1052,22 +1193,37 @@ class BFD4TestCase(VppTestCase): self.assert_equal(self.pg0.local_mac, ether.src, "Source MAC") ip = p[IP] self.assert_equal(self.pg0.remote_ip4, ip.dst, "Destination IP") - self.assert_equal(self.pg0.remote_ip4, ip.src, "Destination IP") udp = p[UDP] + if udp.dport == BFD.udp_dport: + bfd_control_packets_rx += 1 + continue + self.assert_equal(self.pg0.remote_ip4, ip.src, "Source IP") self.assert_equal(udp.dport, BFD.udp_dport_echo, "UDP destination port") self.assert_equal(udp.sport, udp_sport_rx, "UDP source port") udp_sport_rx += 1 # need to compare the hex payload here, otherwise BFD_vpp_echo # gets in way - self.assertEqual(str(p[UDP].payload), - str(echo_packet[UDP].payload), + self.assertEqual(scapy.compat.raw(p[UDP].payload), + scapy.compat.raw(echo_packet[UDP].payload), "Received packet is not the echo packet sent") + counter += 1 self.assert_equal(udp_sport_tx, udp_sport_rx, "UDP source port (== " "ECHO packet identifier for test purposes)") + stats_after = bfd_grab_stats_snapshot(self) + diff = bfd_stats_diff(stats_before, stats_after) + self.assertEqual( + 0, diff.rx, "RX counter bumped but no BFD packets sent") + self.assertEqual( + bfd_control_packets_rx, diff.tx, "TX counter incorrect") + self.assertEqual(0, diff.rx_echo, + "RX echo counter bumped but no BFD session exists") + self.assertEqual(0, diff.tx_echo, + "TX echo counter bumped but no BFD session exists") def test_echo(self): """ echo function """ + stats_before = bfd_grab_stats_snapshot(self) bfd_session_up(self) self.test_session.update(required_min_echo_rx=150000) self.test_session.send_packet() @@ -1084,7 +1240,8 @@ class BFD4TestCase(VppTestCase): self.vpp_session.required_min_rx, "BFD required min rx interval") self.test_session.send_packet() - self.vapi.bfd_udp_set_echo_source(self.loopback0.sw_if_index) + self.vapi.bfd_udp_set_echo_source( + sw_if_index=self.loopback0.sw_if_index) echo_seen = False # should be turned on - loopback echo packets for dummy in range(3): @@ -1102,9 +1259,12 @@ class BFD4TestCase(VppTestCase): "ECHO packet destination MAC address") p[Ether].dst = self.pg0.local_mac self.pg0.add_stream(p) + self.test_session.rx_packets_echo += 1 + self.test_session.tx_packets_echo += 1 self.pg_start() echo_seen = True elif p.haslayer(BFD): + self.test_session.rx_packets += 1 if echo_seen: self.assertGreaterEqual( p[BFD].required_min_rx_interval, @@ -1121,7 +1281,20 @@ class BFD4TestCase(VppTestCase): self.test_session.send_packet() self.assertTrue(echo_seen, "No echo packets received") - @unittest.skipUnless(running_extended_tests(), "part of extended tests") + stats_after = bfd_grab_stats_snapshot(self) + diff = bfd_stats_diff(stats_before, stats_after) + # our rx is vpp tx and vice versa, also tolerate one packet off + self.assert_in_range(self.test_session.tx_packets, + diff.rx - 1, diff.rx + 1, "RX counter") + self.assert_in_range(self.test_session.rx_packets, + diff.tx - 1, diff.tx + 1, "TX counter") + self.assert_in_range(self.test_session.tx_packets_echo, + diff.rx_echo - 1, diff.rx_echo + 1, + "RX echo counter") + self.assert_in_range(self.test_session.rx_packets_echo, + diff.tx_echo - 1, diff.tx_echo + 1, + "TX echo counter") + def test_echo_fail(self): """ session goes down if echo function fails """ bfd_session_up(self) @@ -1129,7 +1302,8 @@ class BFD4TestCase(VppTestCase): self.test_session.send_packet() detection_time = self.test_session.detect_mult *\ self.vpp_session.required_min_rx / USEC_IN_SEC - self.vapi.bfd_udp_set_echo_source(self.loopback0.sw_if_index) + self.vapi.bfd_udp_set_echo_source( + sw_if_index=self.loopback0.sw_if_index) # echo function should be used now, but we will drop the echo packets verified_diag = False for dummy in range(3): @@ -1161,13 +1335,13 @@ class BFD4TestCase(VppTestCase): self.assert_equal(events[0].state, BFDState.down, BFDState) self.assertTrue(verified_diag, "Incorrect diagnostics code received") - @unittest.skipUnless(running_extended_tests(), "part of extended tests") def test_echo_stop(self): """ echo function stops if peer sets required min echo rx zero """ bfd_session_up(self) self.test_session.update(required_min_echo_rx=150000) self.test_session.send_packet() - self.vapi.bfd_udp_set_echo_source(self.loopback0.sw_if_index) + self.vapi.bfd_udp_set_echo_source( + sw_if_index=self.loopback0.sw_if_index) # wait for first echo packet while True: p = self.pg0.wait_for_packet(1) @@ -1193,13 +1367,13 @@ class BFD4TestCase(VppTestCase): events = self.vapi.collect_events() self.assert_equal(len(events), 0, "number of bfd events") - @unittest.skipUnless(running_extended_tests(), "part of extended tests") def test_echo_source_removed(self): """ echo function stops if echo source is removed """ bfd_session_up(self) self.test_session.update(required_min_echo_rx=150000) self.test_session.send_packet() - self.vapi.bfd_udp_set_echo_source(self.loopback0.sw_if_index) + self.vapi.bfd_udp_set_echo_source( + sw_if_index=self.loopback0.sw_if_index) # wait for first echo packet while True: p = self.pg0.wait_for_packet(1) @@ -1225,12 +1399,12 @@ class BFD4TestCase(VppTestCase): events = self.vapi.collect_events() self.assert_equal(len(events), 0, "number of bfd events") - @unittest.skipUnless(running_extended_tests(), "part of extended tests") def test_stale_echo(self): """ stale echo packets don't keep a session up """ bfd_session_up(self) self.test_session.update(required_min_echo_rx=150000) - self.vapi.bfd_udp_set_echo_source(self.loopback0.sw_if_index) + self.vapi.bfd_udp_set_echo_source( + sw_if_index=self.loopback0.sw_if_index) self.test_session.send_packet() # should be turned on - loopback echo packets echo_packet = None @@ -1278,12 +1452,12 @@ class BFD4TestCase(VppTestCase): self.test_session.send_packet() self.assertTrue(timeout_ok, "Expected timeout event didn't occur") - @unittest.skipUnless(running_extended_tests(), "part of extended tests") def test_invalid_echo_checksum(self): """ echo packets with invalid checksum don't keep a session up """ bfd_session_up(self) self.test_session.update(required_min_echo_rx=150000) - self.vapi.bfd_udp_set_echo_source(self.loopback0.sw_if_index) + self.vapi.bfd_udp_set_echo_source( + sw_if_index=self.loopback0.sw_if_index) self.test_session.send_packet() # should be turned on - loopback echo packets timeout_at = None @@ -1328,13 +1502,12 @@ class BFD4TestCase(VppTestCase): self.test_session.send_packet() self.assertTrue(timeout_ok, "Expected timeout event didn't occur") - @unittest.skipUnless(running_extended_tests(), "part of extended tests") def test_admin_up_down(self): """ put session admin-up and admin-down """ bfd_session_up(self) self.vpp_session.admin_down() self.pg0.enable_capture() - e = self.vapi.wait_for_event(1, "bfd_udp_session_details") + e = self.vapi.wait_for_event(1, "bfd_udp_session_event") verify_event(self, e, expected_state=BFDState.admin_down) for dummy in range(2): p = wait_for_bfd_packet(self) @@ -1347,7 +1520,7 @@ class BFD4TestCase(VppTestCase): self.assert_equal(p[BFD].state, BFDState.admin_down, BFDState) self.vpp_session.admin_up() self.test_session.update(state=BFDState.down) - e = self.vapi.wait_for_event(1, "bfd_udp_session_details") + e = self.vapi.wait_for_event(1, "bfd_udp_session_event") verify_event(self, e, expected_state=BFDState.down) p = wait_for_bfd_packet( self, pcap_time_min=time.time() - self.vpp_clock_offset) @@ -1356,17 +1529,16 @@ class BFD4TestCase(VppTestCase): p = wait_for_bfd_packet( self, pcap_time_min=time.time() - self.vpp_clock_offset) self.assert_equal(p[BFD].state, BFDState.init, BFDState) - e = self.vapi.wait_for_event(1, "bfd_udp_session_details") + e = self.vapi.wait_for_event(1, "bfd_udp_session_event") verify_event(self, e, expected_state=BFDState.init) self.test_session.update(state=BFDState.up) self.test_session.send_packet() p = wait_for_bfd_packet( self, pcap_time_min=time.time() - self.vpp_clock_offset) self.assert_equal(p[BFD].state, BFDState.up, BFDState) - e = self.vapi.wait_for_event(1, "bfd_udp_session_details") + e = self.vapi.wait_for_event(1, "bfd_udp_session_event") verify_event(self, e, expected_state=BFDState.up) - @unittest.skipUnless(running_extended_tests(), "part of extended tests") def test_config_change_remote_demand(self): """ configuration change while peer in demand mode """ bfd_session_up(self) @@ -1390,7 +1562,7 @@ class BFD4TestCase(VppTestCase): / USEC_IN_SEC count = 0 for dummy in range(self.test_session.detect_mult * 2): - time.sleep(transmit_time) + self.sleep(transmit_time) self.test_session.send_packet(demand) try: p = wait_for_bfd_packet(self, timeout=0) @@ -1406,7 +1578,7 @@ class BFD4TestCase(VppTestCase): def test_intf_deleted(self): """ interface with bfd session deleted """ - intf = VppLoInterface(self, 0) + intf = VppLoInterface(self) intf.config_ip4() intf.admin_up() sw_if_index = intf.sw_if_index @@ -1414,12 +1586,13 @@ class BFD4TestCase(VppTestCase): vpp_session.add_vpp_config() vpp_session.admin_up() intf.remove_vpp_config() - e = self.vapi.wait_for_event(1, "bfd_udp_session_details") + e = self.vapi.wait_for_event(1, "bfd_udp_session_event") self.assert_equal(e.sw_if_index, sw_if_index, "sw_if_index") self.assertFalse(vpp_session.query_vpp_config()) -@unittest.skipUnless(running_extended_tests(), "part of extended tests") +@tag_run_solo +@tag_fixme_vpp_workers class BFD6TestCase(VppTestCase): """Bidirectional Forwarding Detection (BFD) (IPv6) """ @@ -1431,13 +1604,14 @@ class BFD6TestCase(VppTestCase): @classmethod def setUpClass(cls): super(BFD6TestCase, cls).setUpClass() + cls.vapi.cli("set log class bfd level debug") try: cls.create_pg_interfaces([0]) cls.pg0.config_ip6() cls.pg0.configure_ipv6_neighbors() cls.pg0.admin_up() cls.pg0.resolve_ndp() - cls.create_loopback_interfaces([0]) + cls.create_loopback_interfaces(1) cls.loopback0 = cls.lo_interfaces[0] cls.loopback0.config_ip6() cls.loopback0.admin_up() @@ -1446,12 +1620,18 @@ class BFD6TestCase(VppTestCase): super(BFD6TestCase, cls).tearDownClass() raise + @classmethod + def tearDownClass(cls): + super(BFD6TestCase, cls).tearDownClass() + def setUp(self): super(BFD6TestCase, self).setUp() self.factory = AuthKeyFactory() self.vapi.want_bfd_events() self.pg0.enable_capture() try: + self.bfd_udp4_sessions = self.statistics['/bfd/udp4/sessions'] + self.bfd_udp6_sessions = self.statistics['/bfd/udp6/sessions'] self.vpp_session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip6, af=AF_INET6) @@ -1459,7 +1639,7 @@ class BFD6TestCase(VppTestCase): self.vpp_session.admin_up() self.test_session = BFDTestSession(self, self.pg0, AF_INET6) self.logger.debug(self.vapi.cli("show adj nbr")) - except: + except BaseException: self.vapi.want_bfd_events(enable_disable=0) raise @@ -1472,6 +1652,10 @@ class BFD6TestCase(VppTestCase): def test_session_up(self): """ bring BFD session up """ bfd_session_up(self) + bfd_udp4_sessions = self.statistics['/bfd/udp4/sessions'] + bfd_udp6_sessions = self.statistics['/bfd/udp6/sessions'] + self.assert_equal(bfd_udp4_sessions, self.bfd_udp4_sessions) + self.assert_equal(bfd_udp6_sessions - self.bfd_udp6_sessions, 1) def test_session_up_by_ip(self): """ bring BFD session up - first frame looked up by address pair """ @@ -1487,19 +1671,18 @@ class BFD6TestCase(VppTestCase): self.test_session.update(your_discriminator=p[BFD].my_discriminator, state=BFDState.up) self.logger.info("BFD: Waiting for event") - e = self.vapi.wait_for_event(1, "bfd_udp_session_details") + e = self.vapi.wait_for_event(1, "bfd_udp_session_event") verify_event(self, e, expected_state=BFDState.init) self.logger.info("BFD: Sending Up") self.test_session.send_packet() self.logger.info("BFD: Waiting for event") - e = self.vapi.wait_for_event(1, "bfd_udp_session_details") + e = self.vapi.wait_for_event(1, "bfd_udp_session_event") verify_event(self, e, expected_state=BFDState.up) self.logger.info("BFD: Session is Up") self.test_session.update(state=BFDState.up) self.test_session.send_packet() self.assert_equal(self.vpp_session.state, BFDState.up, BFDState) - @unittest.skipUnless(running_extended_tests(), "part of extended tests") def test_hold_up(self): """ hold BFD session up """ bfd_session_up(self) @@ -1512,8 +1695,8 @@ class BFD6TestCase(VppTestCase): def test_echo_looped_back(self): """ echo packets looped back """ - # don't need a session in this case.. - self.vpp_session.remove_vpp_config() + bfd_session_up(self) + stats_before = bfd_grab_stats_snapshot(self) self.pg0.enable_capture() echo_packet_count = 10 # random source port low enough to increment a few times.. @@ -1532,7 +1715,9 @@ class BFD6TestCase(VppTestCase): self.logger.debug(ppp("Sending packet:", echo_packet)) self.pg0.add_stream(echo_packet) self.pg_start() - for dummy in range(echo_packet_count): + counter = 0 + bfd_control_packets_rx = 0 + while counter < echo_packet_count: p = self.pg0.wait_for_packet(1) self.logger.debug(ppp("Got packet:", p)) ether = p[Ether] @@ -1541,24 +1726,37 @@ class BFD6TestCase(VppTestCase): self.assert_equal(self.pg0.local_mac, ether.src, "Source MAC") ip = p[IPv6] self.assert_equal(self.pg0.remote_ip6, ip.dst, "Destination IP") - self.assert_equal(self.pg0.remote_ip6, ip.src, "Destination IP") udp = p[UDP] + if udp.dport == BFD.udp_dport: + bfd_control_packets_rx += 1 + continue + self.assert_equal(self.pg0.remote_ip6, ip.src, "Source IP") self.assert_equal(udp.dport, BFD.udp_dport_echo, "UDP destination port") self.assert_equal(udp.sport, udp_sport_rx, "UDP source port") udp_sport_rx += 1 # need to compare the hex payload here, otherwise BFD_vpp_echo # gets in way - self.assertEqual(str(p[UDP].payload), - str(echo_packet[UDP].payload), + self.assertEqual(scapy.compat.raw(p[UDP].payload), + scapy.compat.raw(echo_packet[UDP].payload), "Received packet is not the echo packet sent") + counter += 1 self.assert_equal(udp_sport_tx, udp_sport_rx, "UDP source port (== " "ECHO packet identifier for test purposes)") - self.assert_equal(udp_sport_tx, udp_sport_rx, "UDP source port (== " - "ECHO packet identifier for test purposes)") + stats_after = bfd_grab_stats_snapshot(self) + diff = bfd_stats_diff(stats_before, stats_after) + self.assertEqual( + 0, diff.rx, "RX counter bumped but no BFD packets sent") + self.assertEqual(bfd_control_packets_rx, + diff.tx, "TX counter incorrect") + self.assertEqual(0, diff.rx_echo, + "RX echo counter bumped but no BFD session exists") + self.assertEqual(0, diff.tx_echo, + "TX echo counter bumped but no BFD session exists") def test_echo(self): """ echo function """ + stats_before = bfd_grab_stats_snapshot(self) bfd_session_up(self) self.test_session.update(required_min_echo_rx=150000) self.test_session.send_packet() @@ -1575,7 +1773,8 @@ class BFD6TestCase(VppTestCase): self.vpp_session.required_min_rx, "BFD required min rx interval") self.test_session.send_packet() - self.vapi.bfd_udp_set_echo_source(self.loopback0.sw_if_index) + self.vapi.bfd_udp_set_echo_source( + sw_if_index=self.loopback0.sw_if_index) echo_seen = False # should be turned on - loopback echo packets for dummy in range(3): @@ -1591,11 +1790,14 @@ class BFD6TestCase(VppTestCase): self.logger.debug(ppp("Looping back packet:", p)) self.assert_equal(p[Ether].dst, self.pg0.remote_mac, "ECHO packet destination MAC address") + self.test_session.rx_packets_echo += 1 + self.test_session.tx_packets_echo += 1 p[Ether].dst = self.pg0.local_mac self.pg0.add_stream(p) self.pg_start() echo_seen = True elif p.haslayer(BFD): + self.test_session.rx_packets += 1 if echo_seen: self.assertGreaterEqual( p[BFD].required_min_rx_interval, @@ -1612,9 +1814,23 @@ class BFD6TestCase(VppTestCase): self.test_session.send_packet() self.assertTrue(echo_seen, "No echo packets received") + stats_after = bfd_grab_stats_snapshot(self) + diff = bfd_stats_diff(stats_before, stats_after) + # our rx is vpp tx and vice versa, also tolerate one packet off + self.assert_in_range(self.test_session.tx_packets, + diff.rx - 1, diff.rx + 1, "RX counter") + self.assert_in_range(self.test_session.rx_packets, + diff.tx - 1, diff.tx + 1, "TX counter") + self.assert_in_range(self.test_session.tx_packets_echo, + diff.rx_echo - 1, diff.rx_echo + 1, + "RX echo counter") + self.assert_in_range(self.test_session.rx_packets_echo, + diff.tx_echo - 1, diff.tx_echo + 1, + "TX echo counter") + def test_intf_deleted(self): """ interface with bfd session deleted """ - intf = VppLoInterface(self, 0) + intf = VppLoInterface(self) intf.config_ip6() intf.admin_up() sw_if_index = intf.sw_if_index @@ -1623,18 +1839,26 @@ class BFD6TestCase(VppTestCase): vpp_session.add_vpp_config() vpp_session.admin_up() intf.remove_vpp_config() - e = self.vapi.wait_for_event(1, "bfd_udp_session_details") + e = self.vapi.wait_for_event(1, "bfd_udp_session_event") self.assert_equal(e.sw_if_index, sw_if_index, "sw_if_index") self.assertFalse(vpp_session.query_vpp_config()) -@unittest.skipUnless(running_extended_tests(), "part of extended tests") +@tag_run_solo class BFDFIBTestCase(VppTestCase): """ BFD-FIB interactions (IPv6) """ vpp_session = None test_session = None + @classmethod + def setUpClass(cls): + super(BFDFIBTestCase, cls).setUpClass() + + @classmethod + def tearDownClass(cls): + super(BFDFIBTestCase, cls).tearDownClass() + def setUp(self): super(BFDFIBTestCase, self).setUp() self.create_pg_interfaces(range(1)) @@ -1649,7 +1873,7 @@ class BFDFIBTestCase(VppTestCase): def tearDown(self): if not self.vpp_dead: - self.vapi.want_bfd_events(enable_disable=0) + self.vapi.want_bfd_events(enable_disable=False) super(BFDFIBTestCase, self).tearDown() @@ -1667,24 +1891,20 @@ class BFDFIBTestCase(VppTestCase): p = [(Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) / IPv6(src="3001::1", dst="2001::1") / UDP(sport=1234, dport=1234) / - Raw('\xa5' * 100)), + Raw(b'\xa5' * 100)), (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) / IPv6(src="3001::1", dst="2002::1") / UDP(sport=1234, dport=1234) / - Raw('\xa5' * 100))] + Raw(b'\xa5' * 100))] # A recursive and a non-recursive route via a next-hop that # will have a BFD session ip_2001_s_64 = VppIpRoute(self, "2001::", 64, [VppRoutePath(self.pg0.remote_ip6, - self.pg0.sw_if_index, - is_ip6=1)], - is_ip6=1) + self.pg0.sw_if_index)]) ip_2002_s_64 = VppIpRoute(self, "2002::", 64, [VppRoutePath(self.pg0.remote_ip6, - 0xffffffff, - is_ip6=1)], - is_ip6=1) + 0xffffffff)]) ip_2001_s_64.add_vpp_config() ip_2002_s_64.add_vpp_config() @@ -1730,7 +1950,88 @@ class BFDFIBTestCase(VppTestCase): packet[IPv6].dst) -@unittest.skipUnless(running_extended_tests(), "part of extended tests") +@unittest.skipUnless(running_extended_tests, "part of extended tests") +class BFDTunTestCase(VppTestCase): + """ BFD over GRE tunnel """ + + vpp_session = None + test_session = None + + @classmethod + def setUpClass(cls): + super(BFDTunTestCase, cls).setUpClass() + + @classmethod + def tearDownClass(cls): + super(BFDTunTestCase, cls).tearDownClass() + + def setUp(self): + super(BFDTunTestCase, self).setUp() + self.create_pg_interfaces(range(1)) + + self.vapi.want_bfd_events() + self.pg0.enable_capture() + + for i in self.pg_interfaces: + i.admin_up() + i.config_ip4() + i.resolve_arp() + + def tearDown(self): + if not self.vpp_dead: + self.vapi.want_bfd_events(enable_disable=0) + + super(BFDTunTestCase, self).tearDown() + + @staticmethod + def pkt_is_not_data_traffic(p): + """ not data traffic implies BFD or the usual IPv6 ND/RA""" + if p.haslayer(BFD) or is_ipv6_misc(p): + return True + return False + + def test_bfd_o_gre(self): + """ BFD-o-GRE """ + + # A GRE interface over which to run a BFD session + gre_if = VppGreInterface(self, + self.pg0.local_ip4, + self.pg0.remote_ip4) + gre_if.add_vpp_config() + gre_if.admin_up() + gre_if.config_ip4() + + # bring the session up now the routes are present + self.vpp_session = VppBFDUDPSession(self, + gre_if, + gre_if.remote_ip4, + is_tunnel=True) + self.vpp_session.add_vpp_config() + self.vpp_session.admin_up() + + self.test_session = BFDTestSession( + self, gre_if, AF_INET, + tunnel_header=(IP(src=self.pg0.remote_ip4, + dst=self.pg0.local_ip4) / + GRE()), + phy_interface=self.pg0) + + # packets to match against both of the routes + p = [(Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) / + IP(src=self.pg0.remote_ip4, dst=gre_if.remote_ip4) / + UDP(sport=1234, dport=1234) / + Raw(b'\xa5' * 100))] + + # session is up - traffic passes + bfd_session_up(self) + + self.send_and_expect(self.pg0, p, self.pg0) + + # bring session down + bfd_session_down(self) + + +@tag_run_solo class BFDSHA1TestCase(VppTestCase): """Bidirectional Forwarding Detection (BFD) (SHA1 auth) """ @@ -1742,6 +2043,7 @@ class BFDSHA1TestCase(VppTestCase): @classmethod def setUpClass(cls): super(BFDSHA1TestCase, cls).setUpClass() + cls.vapi.cli("set log class bfd level debug") try: cls.create_pg_interfaces([0]) cls.pg0.config_ip4() @@ -1752,6 +2054,10 @@ class BFDSHA1TestCase(VppTestCase): super(BFDSHA1TestCase, cls).tearDownClass() raise + @classmethod + def tearDownClass(cls): + super(BFDSHA1TestCase, cls).tearDownClass() + def setUp(self): super(BFDSHA1TestCase, self).setUp() self.factory = AuthKeyFactory() @@ -1760,7 +2066,7 @@ class BFDSHA1TestCase(VppTestCase): def tearDown(self): if not self.vpp_dead: - self.vapi.want_bfd_events(enable_disable=0) + self.vapi.want_bfd_events(enable_disable=False) self.vapi.collect_events() # clear the event queue super(BFDSHA1TestCase, self).tearDown() @@ -1778,7 +2084,6 @@ class BFDSHA1TestCase(VppTestCase): bfd_key_id=self.vpp_session.bfd_key_id) bfd_session_up(self) - @unittest.skipUnless(running_extended_tests(), "part of extended tests") def test_hold_up(self): """ hold BFD session up """ key = self.factory.create_random_key(self) @@ -1797,7 +2102,6 @@ class BFDSHA1TestCase(VppTestCase): self.test_session.send_packet() self.assert_equal(self.vpp_session.state, BFDState.up, BFDState) - @unittest.skipUnless(running_extended_tests(), "part of extended tests") def test_hold_up_meticulous(self): """ hold BFD session up - meticulous auth """ key = self.factory.create_random_key( @@ -1819,7 +2123,6 @@ class BFDSHA1TestCase(VppTestCase): self.test_session.send_packet() self.assert_equal(self.vpp_session.state, BFDState.up, BFDState) - @unittest.skipUnless(running_extended_tests(), "part of extended tests") def test_send_bad_seq_number(self): """ session is not kept alive by msgs with bad sequence numbers""" key = self.factory.create_random_key( @@ -1882,7 +2185,6 @@ class BFDSHA1TestCase(VppTestCase): wait_for_bfd_packet(self) self.assert_equal(self.vpp_session.state, BFDState.up, BFDState) - @unittest.skipUnless(running_extended_tests(), "part of extended tests") def test_mismatch_auth(self): """ session is not brought down by unauthenticated msg """ key = self.factory.create_random_key(self) @@ -1897,7 +2199,6 @@ class BFDSHA1TestCase(VppTestCase): legitimate_test_session, rogue_test_session) - @unittest.skipUnless(running_extended_tests(), "part of extended tests") def test_mismatch_bfd_key_id(self): """ session is not brought down by msg with non-existent key-id """ key = self.factory.create_random_key(self) @@ -1917,7 +2218,6 @@ class BFDSHA1TestCase(VppTestCase): legitimate_test_session, rogue_test_session) - @unittest.skipUnless(running_extended_tests(), "part of extended tests") def test_mismatched_auth_type(self): """ session is not brought down by msg with wrong auth type """ key = self.factory.create_random_key(self) @@ -1934,7 +2234,6 @@ class BFDSHA1TestCase(VppTestCase): vpp_session, legitimate_test_session, rogue_test_session, {'auth_type': BFDAuthType.keyed_md5}) - @unittest.skipUnless(running_extended_tests(), "part of extended tests") def test_restart(self): """ simulate remote peer restart and resynchronization """ key = self.factory.create_random_key( @@ -1960,10 +2259,11 @@ class BFDSHA1TestCase(VppTestCase): self.test_session.vpp_seq_number = None # now throw away any pending packets self.pg0.enable_capture() + self.test_session.my_discriminator = 0 bfd_session_up(self) -@unittest.skipUnless(running_extended_tests(), "part of extended tests") +@tag_run_solo class BFDAuthOnOffTestCase(VppTestCase): """Bidirectional Forwarding Detection (BFD) (changing auth) """ @@ -1974,6 +2274,7 @@ class BFDAuthOnOffTestCase(VppTestCase): @classmethod def setUpClass(cls): super(BFDAuthOnOffTestCase, cls).setUpClass() + cls.vapi.cli("set log class bfd level debug") try: cls.create_pg_interfaces([0]) cls.pg0.config_ip4() @@ -1984,6 +2285,10 @@ class BFDAuthOnOffTestCase(VppTestCase): super(BFDAuthOnOffTestCase, cls).tearDownClass() raise + @classmethod + def tearDownClass(cls): + super(BFDAuthOnOffTestCase, cls).tearDownClass() + def setUp(self): super(BFDAuthOnOffTestCase, self).setUp() self.factory = AuthKeyFactory() @@ -1992,7 +2297,7 @@ class BFDAuthOnOffTestCase(VppTestCase): def tearDown(self): if not self.vpp_dead: - self.vapi.want_bfd_events(enable_disable=0) + self.vapi.want_bfd_events(enable_disable=False) self.vapi.collect_events() # clear the event queue super(BFDAuthOnOffTestCase, self).tearDown() @@ -2171,7 +2476,7 @@ class BFDAuthOnOffTestCase(VppTestCase): "number of bfd events") -@unittest.skipUnless(running_extended_tests(), "part of extended tests") +@tag_run_solo class BFDCLITestCase(VppTestCase): """Bidirectional Forwarding Detection (BFD) (CLI) """ pg0 = None @@ -2179,7 +2484,7 @@ class BFDCLITestCase(VppTestCase): @classmethod def setUpClass(cls): super(BFDCLITestCase, cls).setUpClass() - + cls.vapi.cli("set log class bfd level debug") try: cls.create_pg_interfaces((0,)) cls.pg0.config_ip4() @@ -2191,6 +2496,10 @@ class BFDCLITestCase(VppTestCase): super(BFDCLITestCase, cls).tearDownClass() raise + @classmethod + def tearDownClass(cls): + super(BFDCLITestCase, cls).tearDownClass() + def setUp(self): super(BFDCLITestCase, self).setUp() self.factory = AuthKeyFactory() @@ -2198,7 +2507,7 @@ class BFDCLITestCase(VppTestCase): def tearDown(self): try: - self.vapi.want_bfd_events(enable_disable=0) + self.vapi.want_bfd_events(enable_disable=False) except UnexpectedApiReturnValueError: # some tests aren't subscribed, so this is not an issue pass @@ -2213,7 +2522,11 @@ class BFDCLITestCase(VppTestCase): def cli_verify_response(self, cli, expected): """ execute a CLI, asserting that the response matches expectation """ - self.assert_equal(self.vapi.cli(cli).strip(), + try: + reply = self.vapi.cli(cli) + except CliFailedCommandError as cli_error: + reply = str(cli_error) + self.assert_equal(reply.strip(), expected, "CLI command response") @@ -2240,7 +2553,7 @@ class BFDCLITestCase(VppTestCase): self.cli_verify_no_response( "bfd key set conf-key-id %s type keyed-sha1 secret %s" % (k.conf_key_id, - "".join("{:02x}".format(ord(c)) for c in k.key))) + "".join("{:02x}".format(scapy.compat.orb(c)) for c in k.key))) self.assertTrue(k.query_vpp_config()) self.vpp_session = VppBFDUDPSession( self, self.pg0, self.pg0.remote_ip4, sha1_key=k) @@ -2257,7 +2570,7 @@ class BFDCLITestCase(VppTestCase): self.cli_verify_response( "bfd key set conf-key-id %s type keyed-sha1 secret %s" % (k.conf_key_id, - "".join("{:02x}".format(ord(c)) for c in k2.key)), + "".join("{:02x}".format(scapy.compat.orb(c)) for c in k2.key)), "bfd key set: `bfd_auth_set_key' API call failed, " "rv=-103:BFD object in use") # manipulating the session using old secret should still work @@ -2276,7 +2589,7 @@ class BFDCLITestCase(VppTestCase): self.cli_verify_no_response( "bfd key set conf-key-id %s type meticulous-keyed-sha1 secret %s" % (k.conf_key_id, - "".join("{:02x}".format(ord(c)) for c in k.key))) + "".join("{:02x}".format(scapy.compat.orb(c)) for c in k.key))) self.assertTrue(k.query_vpp_config()) self.vpp_session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip6, af=AF_INET6, @@ -2295,7 +2608,7 @@ class BFDCLITestCase(VppTestCase): self.cli_verify_response( "bfd key set conf-key-id %s type keyed-sha1 secret %s" % (k.conf_key_id, - "".join("{:02x}".format(ord(c)) for c in k2.key)), + "".join("{:02x}".format(scapy.compat.orb(c)) for c in k2.key)), "bfd key set: `bfd_auth_set_key' API call failed, " "rv=-103:BFD object in use") # manipulating the session using old secret should still work @@ -2553,7 +2866,7 @@ class BFDCLITestCase(VppTestCase): def test_set_del_udp_echo_source(self): """ set/del udp echo source """ - self.create_loopback_interfaces([0]) + self.create_loopback_interfaces(1) self.loopback0 = self.lo_interfaces[0] self.loopback0.admin_up() self.cli_verify_response("show bfd echo-source", @@ -2566,16 +2879,15 @@ class BFDCLITestCase(VppTestCase): "IPv6 address usable as echo source: none" % self.loopback0.name) self.loopback0.config_ip4() - unpacked = unpack("!L", self.loopback0.local_ip4n) - echo_ip4 = inet_ntop(AF_INET, pack("!L", unpacked[0] ^ 1)) + echo_ip4 = str(ipaddress.IPv4Address(int(ipaddress.IPv4Address( + self.loopback0.local_ip4)) ^ 1)) self.cli_verify_response("show bfd echo-source", "UDP echo source is: %s\n" "IPv4 address usable as echo source: %s\n" "IPv6 address usable as echo source: none" % (self.loopback0.name, echo_ip4)) - unpacked = unpack("!LLLL", self.loopback0.local_ip6n) - echo_ip6 = inet_ntop(AF_INET6, pack("!LLLL", unpacked[0], unpacked[1], - unpacked[2], unpacked[3] ^ 1)) + echo_ip6 = str(ipaddress.IPv6Address(int(ipaddress.IPv6Address( + self.loopback0.local_ip6)) ^ 1)) self.loopback0.config_ip6() self.cli_verify_response("show bfd echo-source", "UDP echo source is: %s\n" @@ -2587,5 +2899,6 @@ class BFDCLITestCase(VppTestCase): self.cli_verify_response("show bfd echo-source", "UDP echo source is not set.") + if __name__ == '__main__': unittest.main(testRunner=VppTestRunner)