from framework import *
from util import ppp
+us_in_sec = 1000000
-class BFDCLITestCase(VppTestCase):
- """Bidirectional Forwarding Detection (BFD) - CLI"""
+
+class BFDAPITestCase(VppTestCase):
+ """Bidirectional Forwarding Detection (BFD) - API"""
@classmethod
def setUpClass(cls):
- super(BFDCLITestCase, cls).setUpClass()
+ super(BFDAPITestCase, cls).setUpClass()
try:
- cls.create_pg_interfaces([0])
- cls.pg0.config_ip4()
- cls.pg0.resolve_arp()
+ cls.create_pg_interfaces(range(2))
+ for i in cls.pg_interfaces:
+ i.config_ip4()
+ i.resolve_arp()
except Exception:
- super(BFDCLITestCase, cls).tearDownClass()
+ super(BFDAPITestCase, cls).tearDownClass()
raise
def test_add_bfd(self):
""" create the same BFD session twice (negative case) """
session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4)
session.add_vpp_config()
- try:
- session.add_vpp_config()
- except:
- session.remove_vpp_config()
- return
- session.remove_vpp_config()
- raise Exception("Expected failure while adding duplicate "
- "configuration")
-
-
-def create_packet(interface, ttl=255, src_port=50000, **kwargs):
- p = (Ether(src=interface.remote_mac, dst=interface.local_mac) /
- IP(src=interface.remote_ip4, dst=interface.local_ip4, ttl=ttl) /
- UDP(sport=src_port, dport=BFD.udp_dport) /
- BFD(*kwargs))
- return p
-
-def verify_ip(test, packet, local_ip, remote_ip):
- """ Verify correctness of IP layer. """
- ip = packet[IP]
- test.assert_equal(ip.src, local_ip, "IP source address")
- test.assert_equal(ip.dst, remote_ip, "IP destination address")
- test.assert_equal(ip.ttl, 255, "IP TTL")
+ with self.vapi.expect_negative_api_retval():
+ session.add_vpp_config()
+ session.remove_vpp_config()
-def verify_udp(test, packet):
- """ Verify correctness of UDP layer. """
- udp = packet[UDP]
- test.assert_equal(udp.dport, BFD.udp_dport, "UDP destination port")
- test.assert_in_range(udp.sport, BFD.udp_sport_min, BFD.udp_sport_max,
- "UDP source port")
+ def test_add_two(self):
+ """ create two BFD sessions """
+ session1 = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4)
+ session1.add_vpp_config()
+ session2 = VppBFDUDPSession(self, self.pg1, self.pg1.remote_ip4)
+ session2.add_vpp_config()
+ self.assertNotEqual(session1.bs_index, session2.bs_index,
+ "Different BFD sessions share bs_index (%s)" %
+ session1.bs_index)
class BFDTestSession(object):
+ """ BFD session as seen from test framework side """
- def __init__(self, test, interface, detect_mult=3):
+ def __init__(self, test, interface, af, detect_mult=3):
self.test = test
+ self.af = af
self.interface = interface
+ self.udp_sport = 50000
self.bfd_values = {
'my_discriminator': 0,
- 'desired_min_tx_interval': 500000,
+ 'desired_min_tx_interval': 100000,
'detect_mult': detect_mult,
'diag': BFDDiagCode.no_diagnostic,
}
self.bfd_values.update(kwargs)
def create_packet(self):
- packet = create_packet(self.interface)
+ if self.af == AF_INET6:
+ packet = (Ether(src=self.interface.remote_mac,
+ dst=self.interface.local_mac) /
+ 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) /
+ IP(src=self.interface.remote_ip4,
+ dst=self.interface.local_ip4,
+ ttl=255) /
+ UDP(sport=self.udp_sport, dport=BFD.udp_dport) /
+ BFD())
+ self.test.logger.debug("BFD: Creating packet")
for name, value in self.bfd_values.iteritems():
+ self.test.logger.debug("BFD: setting packet.%s=%s", name, value)
packet[BFD].setfieldval(name, value)
return packet
"BFD - your discriminator")
-class BFDTestCase(VppTestCase):
- """Bidirectional Forwarding Detection (BFD)"""
-
- @classmethod
- def setUpClass(cls):
- super(BFDTestCase, cls).setUpClass()
- try:
- cls.create_pg_interfaces([0, 1])
- cls.pg0.config_ip4()
- cls.pg0.generate_remote_hosts()
- cls.pg0.configure_ipv4_neighbors()
- cls.pg0.admin_up()
- cls.pg0.resolve_arp()
-
- except Exception:
- super(BFDTestCase, cls).tearDownClass()
- raise
-
- def setUp(self):
- self.vapi.want_bfd_events()
- 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)
+class BFDCommonCode:
+ """Common code used by both IPv4 and IPv6 Test Cases"""
def tearDown(self):
- self.vapi.want_bfd_events(enable_disable=0)
+ self.vapi.collect_events() # clear the event queue
if not self.vpp_dead:
+ self.vapi.want_bfd_events(enable_disable=0)
self.vpp_session.remove_vpp_config()
- super(BFDTestCase, self).tearDown()
+
+ def bfd_session_up(self):
+ self.pg_enable_capture([self.pg0])
+ self.logger.info("BFD: Waiting for slow hello")
+ p, timeout = self.wait_for_bfd_packet(2)
+ self.logger.info("BFD: Sending Init")
+ self.test_session.update(my_discriminator=randint(0, 40000000),
+ your_discriminator=p[BFD].my_discriminator,
+ state=BFDState.init,
+ required_min_rx_interval=100000)
+ self.test_session.send_packet()
+ self.logger.info("BFD: Waiting for event")
+ e = self.vapi.wait_for_event(1, "bfd_udp_session_details")
+ self.verify_event(e, expected_state=BFDState.up)
+ self.logger.info("BFD: Session is Up")
+ self.test_session.update(state=BFDState.up)
+
+ def verify_ip(self, packet):
+ """ Verify correctness of IP layer. """
+ if self.vpp_session.af == AF_INET6:
+ ip = packet[IPv6]
+ local_ip = self.pg0.local_ip6
+ remote_ip = self.pg0.remote_ip6
+ self.assert_equal(ip.hlim, 255, "IPv6 hop limit")
+ else:
+ ip = packet[IP]
+ local_ip = self.pg0.local_ip4
+ remote_ip = self.pg0.remote_ip4
+ self.assert_equal(ip.ttl, 255, "IPv4 TTL")
+ self.assert_equal(ip.src, local_ip, "IP source address")
+ self.assert_equal(ip.dst, remote_ip, "IP destination address")
+
+ def verify_udp(self, packet):
+ """ Verify correctness of UDP layer. """
+ udp = packet[UDP]
+ self.assert_equal(udp.dport, BFD.udp_dport, "UDP destination port")
+ self.assert_in_range(udp.sport, BFD.udp_sport_min, BFD.udp_sport_max,
+ "UDP source port")
def verify_event(self, event, expected_state):
""" Verify correctness of event values. """
e = event
- self.logger.debug("Event: %s" % repr(e))
+ self.logger.debug("BFD: Event: %s" % repr(e))
self.assert_equal(e.bs_index, self.vpp_session.bs_index,
"BFD session index")
- self.assert_equal(e.sw_if_index, self.vpp_session.interface.sw_if_index,
- "BFD interface index")
+ self.assert_equal(
+ e.sw_if_index,
+ self.vpp_session.interface.sw_if_index,
+ "BFD interface index")
is_ipv6 = 0
if self.vpp_session.af == AF_INET6:
is_ipv6 = 1
self.assert_equal(e.state, expected_state, BFDState)
def wait_for_bfd_packet(self, timeout=1):
+ """ wait for BFD packet
+
+ :param timeout: how long to wait max
+
+ :returns: tuple (packet, time spent waiting for packet)
+ """
+ self.logger.info("BFD: Waiting for BFD packet")
+ before = time.time()
p = self.pg0.wait_for_packet(timeout=timeout)
+ after = time.time()
+ self.logger.debug(ppp("Got packet:", p))
bfd = p[BFD]
if bfd is None:
raise Exception(ppp("Unexpected or invalid BFD packet:", p))
if bfd.payload:
raise Exception(ppp("Unexpected payload in BFD packet:", bfd))
- verify_ip(self, p, self.pg0.local_ip4, self.pg0.remote_ip4)
- verify_udp(self, p)
+ self.verify_ip(p)
+ self.verify_udp(p)
self.test_session.verify_packet(p)
- return p
+ return p, after - before
- def test_slow_timer(self):
- """ Slow timer """
+ def test_session_up(self):
+ """ bring BFD session up """
+ self.bfd_session_up()
+
+ def test_hold_up(self):
+ """ hold BFD session up """
+ self.bfd_session_up()
+ for i in range(5):
+ self.wait_for_bfd_packet()
+ self.test_session.send_packet()
+
+
+class BFD4TestCase(VppTestCase, BFDCommonCode):
+ """Bidirectional Forwarding Detection (BFD)"""
+
+ @classmethod
+ def setUpClass(cls):
+ super(BFD4TestCase, cls).setUpClass()
+ try:
+ cls.create_pg_interfaces([0])
+ cls.pg0.config_ip4()
+ cls.pg0.generate_remote_hosts()
+ cls.pg0.configure_ipv4_neighbors()
+ cls.pg0.admin_up()
+ cls.pg0.resolve_arp()
+
+ except Exception:
+ super(BFD4TestCase, cls).tearDownClass()
+ raise
+
+ def setUp(self):
+ super(BFD4TestCase, self).setUp()
+ self.vapi.want_bfd_events()
+ try:
+ 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:
+ self.vapi.want_bfd_events(enable_disable=0)
+ raise
+
+ def tearDown(self):
+ BFDCommonCode.tearDown(self)
+ super(BFD4TestCase, self).tearDown()
+ def test_slow_timer(self):
+ """ verify slow periodic control frames while session down """
self.pg_enable_capture([self.pg0])
- expected_packets = 10
- self.logger.info("Waiting for %d BFD packets" % expected_packets)
- self.wait_for_bfd_packet()
+ expected_packets = 3
+ self.logger.info("BFD: Waiting for %d BFD packets" % expected_packets)
+ self.wait_for_bfd_packet(2)
for i in range(expected_packets):
before = time.time()
- self.wait_for_bfd_packet()
+ self.wait_for_bfd_packet(2)
after = time.time()
+ # spec says the range should be <0.75, 1>, allow extra 0.05 margin
+ # to work around timing issues
self.assert_in_range(
- after - before, 0.75, 1, "time between slow packets")
+ after - before, 0.70, 1.05, "time between slow packets")
before = after
def test_zero_remote_min_rx(self):
- """ Zero RemoteMinRxInterval """
+ """ no packets when zero BFD RemoteMinRxInterval """
self.pg_enable_capture([self.pg0])
- p = self.wait_for_bfd_packet()
+ p, timeout = self.wait_for_bfd_packet(2)
self.test_session.update(my_discriminator=randint(0, 40000000),
your_discriminator=p[BFD].my_discriminator,
state=BFDState.init,
return
raise Exception(ppp("Received unexpected BFD packet:", p))
- def bfd_conn_up(self):
- self.pg_enable_capture([self.pg0])
- self.logger.info("Waiting for slow hello")
- p = self.wait_for_bfd_packet()
- self.logger.info("Sending Init")
- self.test_session.update(my_discriminator=randint(0, 40000000),
- your_discriminator=p[BFD].my_discriminator,
- state=BFDState.init,
- required_min_rx_interval=500000)
- self.test_session.send_packet()
- self.logger.info("Waiting for event")
- e = self.vapi.wait_for_event(1, "bfd_udp_session_details")
- self.verify_event(e, expected_state=BFDState.up)
- self.logger.info("Session is Up")
- self.test_session.update(state=BFDState.up)
-
- def test_conn_up(self):
- """ Basic connection up """
- self.bfd_conn_up()
-
- def test_hold_up(self):
- """ Hold BFD up """
- self.bfd_conn_up()
- for i in range(5):
- self.wait_for_bfd_packet()
- self.test_session.send_packet()
-
def test_conn_down(self):
- """ Session down after inactivity """
- self.bfd_conn_up()
+ """ verify session goes down after inactivity """
+ self.bfd_session_up()
self.wait_for_bfd_packet()
- self.assert_equal(
- 0, len(self.vapi.collect_events()),
- "number of bfd events")
+ self.assert_equal(len(self.vapi.collect_events()), 0,
+ "number of bfd events")
self.wait_for_bfd_packet()
- self.assert_equal(
- 0, len(self.vapi.collect_events()),
- "number of bfd events")
+ self.assert_equal(len(self.vapi.collect_events()), 0,
+ "number of bfd events")
e = self.vapi.wait_for_event(1, "bfd_udp_session_details")
self.verify_event(e, expected_state=BFDState.down)
- @unittest.skip("this test is not working yet")
def test_large_required_min_rx(self):
- self.bfd_conn_up()
- interval = 5000000
+ """ large remote RequiredMinRxInterval """
+ self.bfd_session_up()
+ interval = 3000000
self.test_session.update(required_min_rx_interval=interval)
self.test_session.send_packet()
now = time.time()
- count = 1
- while time.time() < now + interval / 1000000:
+ count = 0
+ while time.time() < now + interval / us_in_sec:
try:
p = self.wait_for_bfd_packet()
if count > 1:
count += 1
except:
pass
- self.assert_equal(count, 1, "number of packets received")
+ self.assert_in_range(count, 0, 1, "number of packets received")
+ def test_immediate_remote_min_rx_reduce(self):
+ """ immediately honor remote min rx reduction """
+ self.vpp_session.remove_vpp_config()
+ self.vpp_session = VppBFDUDPSession(
+ self, self.pg0, self.pg0.remote_ip4, desired_min_tx=10000)
+ self.vpp_session.add_vpp_config()
+ self.test_session.update(desired_min_tx_interval=1000000,
+ required_min_rx_interval=1000000)
+ self.bfd_session_up()
+ self.wait_for_bfd_packet()
+ interval = 100000
+ self.test_session.update(required_min_rx_interval=interval)
+ self.test_session.send_packet()
+ p, ttp = self.wait_for_bfd_packet()
+ # allow extra 10% to work around timing issues, first packet is special
+ self.assert_in_range(ttp, 0, 1.10 * interval / us_in_sec,
+ "time between BFD packets")
+ p, ttp = self.wait_for_bfd_packet()
+ self.assert_in_range(ttp, .9 * .75 * interval / us_in_sec,
+ 1.10 * interval / us_in_sec,
+ "time between BFD packets")
+ p, ttp = self.wait_for_bfd_packet()
+ self.assert_in_range(ttp, .9 * .75 * interval / us_in_sec,
+ 1.10 * interval / us_in_sec,
+ "time between BFD packets")
+
+
+class BFD6TestCase(VppTestCase, BFDCommonCode):
+ """Bidirectional Forwarding Detection (BFD) (IPv6) """
+
+ @classmethod
+ def setUpClass(cls):
+ super(BFD6TestCase, cls).setUpClass()
+ try:
+ cls.create_pg_interfaces([0])
+ cls.pg0.config_ip6()
+ cls.pg0.configure_ipv6_neighbors()
+ cls.pg0.admin_up()
+ cls.pg0.resolve_ndp()
+
+ except Exception:
+ super(BFD6TestCase, cls).tearDownClass()
+ raise
+
+ def setUp(self):
+ super(BFD6TestCase, self).setUp()
+ self.vapi.want_bfd_events()
+ try:
+ self.vpp_session = VppBFDUDPSession(self, self.pg0,
+ self.pg0.remote_ip6,
+ af=AF_INET6)
+ self.vpp_session.add_vpp_config()
+ self.vpp_session.admin_up()
+ self.test_session = BFDTestSession(self, self.pg0, AF_INET6)
+ self.logger.debug(self.vapi.cli("show adj nbr"))
+ except:
+ self.vapi.want_bfd_events(enable_disable=0)
+ raise
+
+ def tearDown(self):
+ BFDCommonCode.tearDown(self)
+ super(BFD6TestCase, self).tearDown()
if __name__ == '__main__':
unittest.main(testRunner=VppTestRunner)
Code Review / vpp.git / blobdiff