from scapy.packet import Raw
from config import config
-from bfd import VppBFDAuthKey, BFD, BFDAuthType, VppBFDUDPSession, \
- BFDDiagCode, BFDState, BFD_vpp_echo
+from bfd import (
+ VppBFDAuthKey,
+ BFD,
+ BFDAuthType,
+ VppBFDUDPSession,
+ BFDDiagCode,
+ BFDState,
+ BFD_vpp_echo,
+)
from framework import tag_fixme_vpp_workers
from framework import VppTestCase, VppTestRunner
from framework import tag_run_solo
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_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
self._conf_key_ids = {}
def create_random_key(self, test, auth_type=BFDAuthType.keyed_sha1):
- """ create a random key with unique conf key id """
+ """create a random key with unique conf key id"""
conf_key_id = randint(0, 0xFFFFFFFF)
while conf_key_id in self._conf_key_ids:
conf_key_id = randint(0, 0xFFFFFFFF)
self._conf_key_ids[conf_key_id] = 1
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)
+ 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
+ )
class BFDAPITestCase(VppTestCase):
self.factory = AuthKeyFactory()
def test_add_bfd(self):
- """ create a BFD session """
+ """create a BFD session"""
session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4)
session.add_vpp_config()
self.logger.debug("Session state is %s", session.state)
session.remove_vpp_config()
def test_double_add(self):
- """ create the same BFD session twice (negative case) """
+ """create the same BFD session twice (negative case)"""
session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4)
session.add_vpp_config()
session.remove_vpp_config()
def test_add_bfd6(self):
- """ create IPv6 BFD session """
- session = VppBFDUDPSession(
- self, self.pg0, self.pg0.remote_ip6, af=AF_INET6)
+ """create IPv6 BFD session"""
+ session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip6, af=AF_INET6)
session.add_vpp_config()
self.logger.debug("Session state is %s", session.state)
session.remove_vpp_config()
session.remove_vpp_config()
def test_mod_bfd(self):
- """ modify BFD session parameters """
- session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4,
- desired_min_tx=50000,
- required_min_rx=10000,
- detect_mult=1)
+ """modify BFD session parameters"""
+ session = VppBFDUDPSession(
+ self,
+ self.pg0,
+ self.pg0.remote_ip4,
+ desired_min_tx=50000,
+ required_min_rx=10000,
+ detect_mult=1,
+ )
session.add_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.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.modify_parameters(desired_min_tx=session.desired_min_tx * 2,
- required_min_rx=session.required_min_rx * 2,
- detect_mult=session.detect_mult * 2)
+ session.modify_parameters(
+ 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.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_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)
+ """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.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)
+ 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.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 """
+ """add SHA1 keys"""
key_count = 10
- keys = [self.factory.create_random_key(
- self) for i in range(0, key_count)]
+ keys = [self.factory.create_random_key(self) for i in range(0, key_count)]
for key in keys:
self.assertFalse(key.query_vpp_config())
for key in keys:
self.assertFalse(key.query_vpp_config())
def test_add_bfd_sha1(self):
- """ create a BFD session (SHA1) """
+ """create a BFD session (SHA1)"""
key = self.factory.create_random_key(self)
key.add_vpp_config()
- session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4,
- sha1_key=key)
+ session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4, sha1_key=key)
session.add_vpp_config()
self.logger.debug("Session state is %s", session.state)
session.remove_vpp_config()
session.remove_vpp_config()
def test_double_add_sha1(self):
- """ create the same BFD session twice (negative case) (SHA1) """
+ """create the same BFD session twice (negative case) (SHA1)"""
key = self.factory.create_random_key(self)
key.add_vpp_config()
- session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4,
- sha1_key=key)
+ session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4, sha1_key=key)
session.add_vpp_config()
with self.assertRaises(Exception):
session.add_vpp_config()
def test_add_auth_nonexistent_key(self):
- """ create BFD session using non-existent SHA1 (negative case) """
+ """create BFD session using non-existent SHA1 (negative case)"""
session = VppBFDUDPSession(
- self, self.pg0, self.pg0.remote_ip4,
- sha1_key=self.factory.create_random_key(self))
+ self,
+ self.pg0,
+ self.pg0.remote_ip4,
+ sha1_key=self.factory.create_random_key(self),
+ )
with self.assertRaises(Exception):
session.add_vpp_config()
def test_shared_sha1_key(self):
- """ single SHA1 key shared by multiple BFD sessions """
+ """single SHA1 key shared by multiple BFD sessions"""
key = self.factory.create_random_key(self)
key.add_vpp_config()
sessions = [
- VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4,
- sha1_key=key),
- VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip6,
- sha1_key=key, af=AF_INET6),
- VppBFDUDPSession(self, self.pg1, self.pg1.remote_ip4,
- sha1_key=key),
- VppBFDUDPSession(self, self.pg1, self.pg1.remote_ip6,
- sha1_key=key, af=AF_INET6)]
+ VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4, sha1_key=key),
+ VppBFDUDPSession(
+ self, self.pg0, self.pg0.remote_ip6, sha1_key=key, af=AF_INET6
+ ),
+ VppBFDUDPSession(self, self.pg1, self.pg1.remote_ip4, sha1_key=key),
+ VppBFDUDPSession(
+ self, self.pg1, self.pg1.remote_ip6, sha1_key=key, af=AF_INET6
+ ),
+ ]
for s in sessions:
s.add_vpp_config()
removed = 0
for s in sessions:
e = key.get_bfd_auth_keys_dump_entry()
- self.assert_equal(e.use_count, len(sessions) - removed,
- "Use count for shared key")
+ self.assert_equal(
+ e.use_count, len(sessions) - removed, "Use count for shared key"
+ )
s.remove_vpp_config()
removed += 1
e = key.get_bfd_auth_keys_dump_entry()
- self.assert_equal(e.use_count, len(sessions) - removed,
- "Use count for shared key")
+ self.assert_equal(
+ e.use_count, len(sessions) - removed, "Use count for shared key"
+ )
def test_activate_auth(self):
- """ activate SHA1 authentication """
+ """activate SHA1 authentication"""
key = self.factory.create_random_key(self)
key.add_vpp_config()
session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4)
session.activate_auth(key)
def test_deactivate_auth(self):
- """ deactivate SHA1 authentication """
+ """deactivate SHA1 authentication"""
key = self.factory.create_random_key(self)
key.add_vpp_config()
session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4)
session.deactivate_auth()
def test_change_key(self):
- """ change SHA1 key """
+ """change SHA1 key"""
key1 = self.factory.create_random_key(self)
key2 = self.factory.create_random_key(self)
while key2.conf_key_id == key1.conf_key_id:
key2 = self.factory.create_random_key(self)
key1.add_vpp_config()
key2.add_vpp_config()
- session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4,
- sha1_key=key1)
+ session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4, sha1_key=key1)
session.add_vpp_config()
session.activate_auth(key2)
def test_set_del_udp_echo_source(self):
- """ set/del udp echo source """
+ """set/del udp echo source"""
self.create_loopback_interfaces(1)
self.loopback0 = self.lo_interfaces[0]
self.loopback0.admin_up()
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)
+ 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_ip6)
self.loopback0.config_ip4()
- echo_ip4 = ipaddress.IPv4Address(int(ipaddress.IPv4Address(
- self.loopback0.local_ip4)) ^ 1).packed
+ 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.assertFalse(echo_source.have_usable_ip6)
self.loopback0.config_ip6()
- echo_ip6 = ipaddress.IPv6Address(int(ipaddress.IPv6Address(
- self.loopback0.local_ip6)) ^ 1).packed
+ 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)
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,
- tunnel_header=None, phy_interface=None):
+ """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,
+ tunnel_header=None,
+ phy_interface=None,
+ ):
self.test = test
self.af = af
self.sha1_key = sha1_key
self.rx_packets_echo = 0
def inc_seq_num(self):
- """ increment sequence number, wrapping if needed """
+ """increment sequence number, wrapping if needed"""
if self.our_seq_number == 0xFFFFFFFF:
self.our_seq_number = 0
else:
self.our_seq_number += 1
- def update(self, my_discriminator=None, your_discriminator=None,
- desired_min_tx=None, required_min_rx=None,
- required_min_echo_rx=None, detect_mult=None,
- diag=None, state=None, auth_type=None):
- """ update BFD parameters associated with session """
+ def update(
+ self,
+ my_discriminator=None,
+ your_discriminator=None,
+ desired_min_tx=None,
+ required_min_rx=None,
+ required_min_echo_rx=None,
+ detect_mult=None,
+ diag=None,
+ state=None,
+ auth_type=None,
+ ):
+ """update BFD parameters associated with session"""
if my_discriminator is not None:
self.my_discriminator = my_discriminator
if your_discriminator is not None:
self.auth_type = auth_type
def fill_packet_fields(self, packet):
- """ set packet fields with known values in packet """
+ """set packet fields with known values in packet"""
bfd = packet[BFD]
if self.my_discriminator:
- self.test.logger.debug("BFD: setting packet.my_discriminator=%s",
- self.my_discriminator)
+ self.test.logger.debug(
+ "BFD: setting packet.my_discriminator=%s", self.my_discriminator
+ )
bfd.my_discriminator = self.my_discriminator
if self.your_discriminator:
- self.test.logger.debug("BFD: setting packet.your_discriminator=%s",
- self.your_discriminator)
+ self.test.logger.debug(
+ "BFD: setting packet.your_discriminator=%s", self.your_discriminator
+ )
bfd.your_discriminator = self.your_discriminator
if self.required_min_rx:
self.test.logger.debug(
- "BFD: setting packet.required_min_rx_interval=%s",
- self.required_min_rx)
+ "BFD: setting packet.required_min_rx_interval=%s", self.required_min_rx
+ )
bfd.required_min_rx_interval = self.required_min_rx
if self.required_min_echo_rx:
self.test.logger.debug(
- "BFD: setting packet.required_min_echo_rx=%s",
- self.required_min_echo_rx)
+ "BFD: setting packet.required_min_echo_rx=%s", self.required_min_echo_rx
+ )
bfd.required_min_echo_rx_interval = self.required_min_echo_rx
if self.desired_min_tx:
self.test.logger.debug(
- "BFD: setting packet.desired_min_tx_interval=%s",
- self.desired_min_tx)
+ "BFD: setting packet.desired_min_tx_interval=%s", self.desired_min_tx
+ )
bfd.desired_min_tx_interval = self.desired_min_tx
if self.detect_mult:
self.test.logger.debug(
- "BFD: setting packet.detect_mult=%s", self.detect_mult)
+ "BFD: setting packet.detect_mult=%s", self.detect_mult
+ )
bfd.detect_mult = self.detect_mult
if self.diag:
self.test.logger.debug("BFD: setting packet.diag=%s", self.diag)
bfd.state = self.state
if self.auth_type:
# this is used by a negative test-case
- self.test.logger.debug("BFD: setting packet.auth_type=%s",
- self.auth_type)
+ self.test.logger.debug("BFD: setting packet.auth_type=%s", self.auth_type)
bfd.auth_type = self.auth_type
def create_packet(self):
- """ create a BFD packet, reflecting the current state of session """
+ """create a BFD packet, reflecting the current state of session"""
if self.sha1_key:
bfd = BFD(flags="A")
bfd.auth_type = self.sha1_key.auth_type
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)
+ 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 = (packet /
- IPv6(src=self.interface.remote_ip6,
- dst=self.interface.local_ip6,
- hlim=255) /
- UDP(sport=self.udp_sport, dport=BFD.udp_dport) /
- bfd)
+ 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 = (packet /
- IP(src=self.interface.remote_ip4,
- dst=self.interface.local_ip4,
- ttl=255) /
- UDP(sport=self.udp_sport, dport=BFD.udp_dport) /
- bfd)
+ packet = (
+ packet
+ / 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")
self.fill_packet_fields(packet)
if self.sha1_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())
+ 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()
return packet
def send_packet(self, packet=None, interface=None):
- """ send packet on interface, creating the packet if needed """
+ """send packet on interface, creating the packet if needed"""
if packet is None:
packet = self.create_packet()
if interface is None:
self.test.pg_start()
def verify_sha1_auth(self, packet):
- """ Verify correctness of authentication in BFD layer. """
+ """Verify correctness of authentication in BFD layer."""
bfd = packet[BFD]
self.test.assert_equal(bfd.auth_len, 28, "Auth section length")
- self.test.assert_equal(bfd.auth_type, self.sha1_key.auth_type,
- BFDAuthType)
+ self.test.assert_equal(bfd.auth_type, self.sha1_key.auth_type, BFDAuthType)
self.test.assert_equal(bfd.auth_key_id, self.bfd_key_id, "Key ID")
self.test.assert_equal(bfd.auth_reserved, 0, "Reserved")
if self.vpp_seq_number is None:
self.vpp_seq_number = bfd.auth_seq_num
- self.test.logger.debug("Received initial sequence number: %s" %
- self.vpp_seq_number)
+ self.test.logger.debug(
+ "Received initial sequence number: %s" % self.vpp_seq_number
+ )
else:
recvd_seq_num = bfd.auth_seq_num
- self.test.logger.debug("Received followup sequence number: %s" %
- recvd_seq_num)
- if self.vpp_seq_number < 0xffffffff:
- if self.sha1_key.auth_type == \
- BFDAuthType.meticulous_keyed_sha1:
- self.test.assert_equal(recvd_seq_num,
- self.vpp_seq_number + 1,
- "BFD sequence number")
+ self.test.logger.debug(
+ "Received followup sequence number: %s" % recvd_seq_num
+ )
+ if self.vpp_seq_number < 0xFFFFFFFF:
+ if self.sha1_key.auth_type == BFDAuthType.meticulous_keyed_sha1:
+ self.test.assert_equal(
+ recvd_seq_num, self.vpp_seq_number + 1, "BFD sequence number"
+ )
else:
- self.test.assert_in_range(recvd_seq_num,
- self.vpp_seq_number,
- self.vpp_seq_number + 1,
- "BFD sequence number")
+ self.test.assert_in_range(
+ recvd_seq_num,
+ self.vpp_seq_number,
+ self.vpp_seq_number + 1,
+ "BFD sequence number",
+ )
else:
- if self.sha1_key.auth_type == \
- BFDAuthType.meticulous_keyed_sha1:
- self.test.assert_equal(recvd_seq_num, 0,
- "BFD sequence number")
+ if self.sha1_key.auth_type == BFDAuthType.meticulous_keyed_sha1:
+ self.test.assert_equal(recvd_seq_num, 0, "BFD sequence number")
else:
- self.test.assertIn(recvd_seq_num, (self.vpp_seq_number, 0),
- "BFD sequence number not one of "
- "(%s, 0)" % self.vpp_seq_number)
+ self.test.assertIn(
+ recvd_seq_num,
+ (self.vpp_seq_number, 0),
+ "BFD sequence number not one of "
+ "(%s, 0)" % self.vpp_seq_number,
+ )
self.vpp_seq_number = recvd_seq_num
# 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 + \
- b"\0" * (20 - len(self.sha1_key.key))
+ hash_material = (
+ bfd.original[:-20]
+ + 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.encode(), "Auth key hash")
+ self.test.assert_equal(
+ binascii.hexlify(bfd.auth_key_hash), expected_hash.encode(), "Auth key hash"
+ )
def verify_bfd(self, packet):
- """ Verify correctness of BFD layer. """
+ """Verify correctness of BFD layer."""
bfd = packet[BFD]
self.test.assert_equal(bfd.version, 1, "BFD version")
- self.test.assert_equal(bfd.your_discriminator,
- self.my_discriminator,
- "BFD - your discriminator")
+ self.test.assert_equal(
+ bfd.your_discriminator, self.my_discriminator, "BFD - your discriminator"
+ )
if self.sha1_key:
self.verify_sha1_auth(packet)
def bfd_session_up(test):
- """ Bring BFD session up """
+ """Bring BFD session up"""
test.logger.info("BFD: Waiting for slow hello")
p = wait_for_bfd_packet(test, 2, is_tunnel=test.vpp_session.is_tunnel)
old_offset = None
- if hasattr(test, 'vpp_clock_offset'):
+ if hasattr(test, "vpp_clock_offset"):
old_offset = test.vpp_clock_offset
test.vpp_clock_offset = time.time() - float(p.time)
- test.logger.debug("BFD: Calculated vpp clock offset: %s",
- test.vpp_clock_offset)
+ test.logger.debug("BFD: Calculated vpp clock offset: %s", test.vpp_clock_offset)
if old_offset:
test.assertAlmostEqual(
- old_offset, test.vpp_clock_offset, delta=0.5,
- msg="vpp clock offset not stable (new: %s, old: %s)" %
- (test.vpp_clock_offset, old_offset))
+ old_offset,
+ test.vpp_clock_offset,
+ delta=0.5,
+ msg="vpp clock offset not stable (new: %s, old: %s)"
+ % (test.vpp_clock_offset, old_offset),
+ )
test.logger.info("BFD: Sending Init")
- test.test_session.update(my_discriminator=randint(0, 40000000),
- your_discriminator=p[BFD].my_discriminator,
- state=BFDState.init)
- if test.test_session.sha1_key and test.test_session.sha1_key.auth_type == \
- BFDAuthType.meticulous_keyed_sha1:
+ test.test_session.update(
+ my_discriminator=randint(0, 40000000),
+ your_discriminator=p[BFD].my_discriminator,
+ state=BFDState.init,
+ )
+ if (
+ test.test_session.sha1_key
+ and test.test_session.sha1_key.auth_type == BFDAuthType.meticulous_keyed_sha1
+ ):
test.test_session.inc_seq_num()
test.test_session.send_packet()
test.logger.info("BFD: Waiting for event")
verify_event(test, e, expected_state=BFDState.up)
test.logger.info("BFD: Session is Up")
test.test_session.update(state=BFDState.up)
- if test.test_session.sha1_key and test.test_session.sha1_key.auth_type == \
- BFDAuthType.meticulous_keyed_sha1:
+ if (
+ test.test_session.sha1_key
+ and test.test_session.sha1_key.auth_type == BFDAuthType.meticulous_keyed_sha1
+ ):
test.test_session.inc_seq_num()
test.test_session.send_packet()
test.assert_equal(test.vpp_session.state, BFDState.up, BFDState)
def bfd_session_down(test):
- """ Bring BFD session down """
+ """Bring BFD session down"""
test.assert_equal(test.vpp_session.state, BFDState.up, BFDState)
test.test_session.update(state=BFDState.down)
- if test.test_session.sha1_key and test.test_session.sha1_key.auth_type == \
- BFDAuthType.meticulous_keyed_sha1:
+ if (
+ test.test_session.sha1_key
+ and test.test_session.sha1_key.auth_type == BFDAuthType.meticulous_keyed_sha1
+ ):
test.test_session.inc_seq_num()
test.test_session.send_packet()
test.logger.info("BFD: Waiting for event")
# are valid (in get_bfd_udp_session_dump_entry)
if state:
test.assert_equal(dump.state, state, "session state")
- test.assert_equal(dump.required_min_rx, session.required_min_rx,
- "required min rx interval")
- test.assert_equal(dump.desired_min_tx, session.desired_min_tx,
- "desired min tx interval")
- test.assert_equal(dump.detect_mult, session.detect_mult,
- "detect multiplier")
+ test.assert_equal(
+ dump.required_min_rx, session.required_min_rx, "required min rx interval"
+ )
+ test.assert_equal(
+ dump.desired_min_tx, session.desired_min_tx, "desired min tx interval"
+ )
+ test.assert_equal(dump.detect_mult, session.detect_mult, "detect multiplier")
if session.sha1_key is None:
test.assert_equal(dump.is_authenticated, 0, "is_authenticated flag")
else:
test.assert_equal(dump.is_authenticated, 1, "is_authenticated flag")
- test.assert_equal(dump.bfd_key_id, session.bfd_key_id,
- "bfd key id")
- test.assert_equal(dump.conf_key_id,
- session.sha1_key.conf_key_id,
- "config key id")
+ test.assert_equal(dump.bfd_key_id, session.bfd_key_id, "bfd key id")
+ test.assert_equal(
+ dump.conf_key_id, session.sha1_key.conf_key_id, "config key id"
+ )
def verify_ip(test, packet):
- """ Verify correctness of IP layer. """
+ """Verify correctness of IP layer."""
if test.vpp_session.af == AF_INET6:
ip = packet[IPv6]
local_ip = test.vpp_session.interface.local_ip6
def verify_udp(test, packet):
- """ Verify correctness of UDP layer. """
+ """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")
+ test.assert_in_range(
+ udp.sport, BFD.udp_sport_min, BFD.udp_sport_max, "UDP source port"
+ )
def verify_event(test, event, expected_state):
- """ Verify correctness of event values. """
+ """Verify correctness of event values."""
e = event
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")
-
- 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.sw_if_index, test.vpp_session.interface.sw_if_index, "BFD interface index"
+ )
+
+ 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, is_tunnel=False):
- """ wait for BFD packet and verify its correctness
+ """wait for BFD packet and verify its correctness
:param timeout: how long to wait
:param pcap_time_min: ignore packets with pcap timestamp lower than this
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 < "
- "pcap time min %s):" %
- (p.time, pcap_time_min), p))
+ test.logger.debug(
+ ppp(
+ "BFD: ignoring packet (pcap time %s < "
+ "pcap time min %s):" % (p.time, pcap_time_min),
+ p,
+ )
+ )
else:
break
if is_tunnel:
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()
+ 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()
+ 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)
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.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)
super(BFD4TestCase, self).tearDown()
def test_session_up(self):
- """ bring BFD session up """
+ """bring BFD session up"""
bfd_session_up(self)
- bfd_udp4_sessions = self.statistics['/bfd/udp4/sessions']
- bfd_udp6_sessions = self.statistics['/bfd/udp6/sessions']
+ 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 """
+ """bring BFD session up - first frame looked up by address pair"""
self.logger.info("BFD: Sending Slow control frame")
self.test_session.update(my_discriminator=randint(0, 40000000))
self.test_session.send_packet()
self.pg0.enable_capture()
p = self.pg0.wait_for_packet(1)
- self.assert_equal(p[BFD].your_discriminator,
- self.test_session.my_discriminator,
- "BFD - your discriminator")
+ self.assert_equal(
+ p[BFD].your_discriminator,
+ self.test_session.my_discriminator,
+ "BFD - your discriminator",
+ )
self.assert_equal(p[BFD].state, BFDState.init, BFDState)
- self.test_session.update(your_discriminator=p[BFD].my_discriminator,
- state=BFDState.up)
+ 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_event")
verify_event(self, e, expected_state=BFDState.init)
self.assert_equal(self.vpp_session.state, BFDState.up, BFDState)
def test_session_down(self):
- """ bring BFD session down """
+ """bring BFD session down"""
bfd_session_up(self)
bfd_session_down(self)
def test_hold_up(self):
- """ hold BFD session up """
+ """hold BFD session up"""
bfd_session_up(self)
for dummy in range(self.test_session.detect_mult * 2):
wait_for_bfd_packet(self)
self.test_session.send_packet()
- self.assert_equal(len(self.vapi.collect_events()), 0,
- "number of bfd events")
+ self.assert_equal(len(self.vapi.collect_events()), 0, "number of bfd events")
def test_slow_timer(self):
- """ verify slow periodic control frames while session down """
+ """verify slow periodic control frames while session down"""
packet_count = 3
self.logger.info("BFD: Waiting for %d BFD packets", packet_count)
prev_packet = wait_for_bfd_packet(self, 2)
time_diff = next_packet.time - prev_packet.time
# spec says the range should be <0.75, 1>, allow extra 0.05 margin
# to work around timing issues
- self.assert_in_range(
- time_diff, 0.70, 1.05, "time between slow packets")
+ self.assert_in_range(time_diff, 0.70, 1.05, "time between slow packets")
prev_packet = next_packet
def test_zero_remote_min_rx(self):
- """ no packets when zero remote required min rx interval """
+ """no packets when zero remote required min rx interval"""
bfd_session_up(self)
self.test_session.update(required_min_rx=0)
self.test_session.send_packet()
for dummy in range(self.test_session.detect_mult):
- self.sleep(self.vpp_session.required_min_rx / USEC_IN_SEC,
- "sleep before transmitting bfd packet")
+ self.sleep(
+ self.vpp_session.required_min_rx / USEC_IN_SEC,
+ "sleep before transmitting bfd packet",
+ )
self.test_session.send_packet()
try:
p = wait_for_bfd_packet(self, timeout=0)
self.logger.error(ppp("Received unexpected packet:", p))
except CaptureTimeoutError:
pass
- self.assert_equal(
- len(self.vapi.collect_events()), 0, "number of bfd events")
+ self.assert_equal(len(self.vapi.collect_events()), 0, "number of bfd events")
self.test_session.update(required_min_rx=300000)
for dummy in range(3):
self.test_session.send_packet()
wait_for_bfd_packet(
- self, timeout=self.test_session.required_min_rx / USEC_IN_SEC)
- self.assert_equal(
- len(self.vapi.collect_events()), 0, "number of bfd events")
+ self, timeout=self.test_session.required_min_rx / USEC_IN_SEC
+ )
+ self.assert_equal(len(self.vapi.collect_events()), 0, "number of bfd events")
def test_conn_down(self):
- """ verify session goes down after inactivity """
+ """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
+ 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_event")
verify_event(self, e, expected_state=BFDState.down)
def test_peer_discr_reset_sess_down(self):
- """ peer discriminator reset after session goes down """
+ """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
+ 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)
+ 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 """
+ """large remote required min rx interval"""
bfd_session_up(self)
p = wait_for_bfd_packet(self)
interval = 3000000
self.assert_equal(count, 0, "number of packets received")
def test_immediate_remote_min_rx_reduction(self):
- """ immediately honor remote required min rx reduction """
+ """immediately honor remote required 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, self.pg0, self.pg0.remote_ip4, desired_min_tx=10000
+ )
self.pg0.enable_capture()
self.vpp_session.add_vpp_config()
- self.test_session.update(desired_min_tx=1000000,
- required_min_rx=1000000)
+ self.test_session.update(desired_min_tx=1000000, required_min_rx=1000000)
bfd_session_up(self)
reference_packet = wait_for_bfd_packet(self)
time_mark = time.time()
p = wait_for_bfd_packet(self)
# first packet is allowed to be late by time we spent doing the update
# calculated in extra_time
- self.assert_in_range(p.time - reference_packet.time,
- .95 * 0.75 * interval / USEC_IN_SEC,
- 1.05 * interval / USEC_IN_SEC + extra_time,
- "time between BFD packets")
+ self.assert_in_range(
+ p.time - reference_packet.time,
+ 0.95 * 0.75 * interval / USEC_IN_SEC,
+ 1.05 * interval / USEC_IN_SEC + extra_time,
+ "time between BFD packets",
+ )
reference_packet = p
for dummy in range(3):
p = wait_for_bfd_packet(self)
diff = p.time - reference_packet.time
- self.assert_in_range(diff, .95 * .75 * interval / USEC_IN_SEC,
- 1.05 * interval / USEC_IN_SEC,
- "time between BFD packets")
+ self.assert_in_range(
+ diff,
+ 0.95 * 0.75 * interval / USEC_IN_SEC,
+ 1.05 * interval / USEC_IN_SEC,
+ "time between BFD packets",
+ )
reference_packet = p
def test_modify_req_min_rx_double(self):
- """ modify session - double required min rx """
+ """modify session - double required min rx"""
bfd_session_up(self)
p = wait_for_bfd_packet(self)
- self.test_session.update(desired_min_tx=10000,
- required_min_rx=10000)
+ self.test_session.update(desired_min_tx=10000, required_min_rx=10000)
self.test_session.send_packet()
# double required min rx
self.vpp_session.modify_parameters(
- required_min_rx=2 * self.vpp_session.required_min_rx)
- p = wait_for_bfd_packet(
- self, pcap_time_min=time.time() - self.vpp_clock_offset)
+ required_min_rx=2 * self.vpp_session.required_min_rx
+ )
+ p = wait_for_bfd_packet(self, pcap_time_min=time.time() - self.vpp_clock_offset)
# poll bit needs to be set
- self.assertIn("P", p.sprintf("%BFD.flags%"),
- "Poll bit not set in BFD packet")
+ self.assertIn("P", p.sprintf("%BFD.flags%"), "Poll bit not set in BFD packet")
# finish poll sequence with final packet
final = self.test_session.create_packet()
final[BFD].flags = "F"
- timeout = self.test_session.detect_mult * \
- max(self.test_session.desired_min_tx,
- self.vpp_session.required_min_rx) / USEC_IN_SEC
+ timeout = (
+ self.test_session.detect_mult
+ * max(self.test_session.desired_min_tx, 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_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")
+ self.assert_in_range(
+ time_to_event, 0.9 * timeout, 1.1 * timeout, "session timeout"
+ )
def test_modify_req_min_rx_halve(self):
- """ modify session - halve required min rx """
+ """modify session - halve required min rx"""
self.vpp_session.modify_parameters(
- required_min_rx=2 * self.vpp_session.required_min_rx)
+ required_min_rx=2 * self.vpp_session.required_min_rx
+ )
bfd_session_up(self)
p = wait_for_bfd_packet(self)
- self.test_session.update(desired_min_tx=10000,
- required_min_rx=10000)
+ self.test_session.update(desired_min_tx=10000, required_min_rx=10000)
self.test_session.send_packet()
- p = wait_for_bfd_packet(
- self, pcap_time_min=time.time() - self.vpp_clock_offset)
+ p = wait_for_bfd_packet(self, pcap_time_min=time.time() - self.vpp_clock_offset)
# halve required min rx
old_required_min_rx = self.vpp_session.required_min_rx
self.vpp_session.modify_parameters(
- required_min_rx=self.vpp_session.required_min_rx // 2)
+ 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,
- "wait before finishing poll sequence")
- self.assert_equal(len(self.vapi.collect_events()), 0,
- "number of bfd events")
+ self.sleep(
+ 0.8 * self.vpp_session.detect_mult * old_required_min_rx / USEC_IN_SEC,
+ "wait before finishing poll sequence",
+ )
+ self.assert_equal(len(self.vapi.collect_events()), 0, "number of bfd events")
p = wait_for_bfd_packet(self)
# poll bit needs to be set
- self.assertIn("P", p.sprintf("%BFD.flags%"),
- "Poll bit not set in BFD packet")
+ self.assertIn("P", p.sprintf("%BFD.flags%"), "Poll bit not set in BFD packet")
# finish poll sequence with final packet
final = self.test_session.create_packet()
final[BFD].flags = "F"
self.test_session.send_packet(final)
# now the session should time out under new conditions
- detection_time = self.test_session.detect_mult *\
- self.vpp_session.required_min_rx / USEC_IN_SEC
+ detection_time = (
+ self.test_session.detect_mult
+ * self.vpp_session.required_min_rx
+ / USEC_IN_SEC
+ )
before = time.time()
- e = self.vapi.wait_for_event(
- 2 * detection_time, "bfd_udp_session_event")
+ e = self.vapi.wait_for_event(2 * detection_time, "bfd_udp_session_event")
after = time.time()
- self.assert_in_range(after - before,
- 0.9 * detection_time,
- 1.1 * detection_time,
- "time before bfd session goes down")
+ self.assert_in_range(
+ after - before,
+ 0.9 * detection_time,
+ 1.1 * detection_time,
+ "time before bfd session goes down",
+ )
verify_event(self, e, expected_state=BFDState.down)
def test_modify_detect_mult(self):
- """ modify detect multiplier """
+ """modify detect multiplier"""
bfd_session_up(self)
p = wait_for_bfd_packet(self)
self.vpp_session.modify_parameters(detect_mult=1)
- p = wait_for_bfd_packet(
- self, pcap_time_min=time.time() - self.vpp_clock_offset)
- self.assert_equal(self.vpp_session.detect_mult,
- p[BFD].detect_mult,
- "detect mult")
+ p = wait_for_bfd_packet(self, pcap_time_min=time.time() - self.vpp_clock_offset)
+ self.assert_equal(
+ self.vpp_session.detect_mult, p[BFD].detect_mult, "detect mult"
+ )
# poll bit must not be set
- self.assertNotIn("P", p.sprintf("%BFD.flags%"),
- "Poll bit not set in BFD packet")
+ self.assertNotIn(
+ "P", p.sprintf("%BFD.flags%"), "Poll bit not set in BFD packet"
+ )
self.vpp_session.modify_parameters(detect_mult=10)
- p = wait_for_bfd_packet(
- self, pcap_time_min=time.time() - self.vpp_clock_offset)
- self.assert_equal(self.vpp_session.detect_mult,
- p[BFD].detect_mult,
- "detect mult")
+ p = wait_for_bfd_packet(self, pcap_time_min=time.time() - self.vpp_clock_offset)
+ self.assert_equal(
+ self.vpp_session.detect_mult, p[BFD].detect_mult, "detect mult"
+ )
# poll bit must not be set
- self.assertNotIn("P", p.sprintf("%BFD.flags%"),
- "Poll bit not set in BFD packet")
+ self.assertNotIn(
+ "P", p.sprintf("%BFD.flags%"), "Poll bit not set in BFD packet"
+ )
def test_queued_poll(self):
- """ test poll sequence queueing """
+ """test poll sequence queueing"""
bfd_session_up(self)
p = wait_for_bfd_packet(self)
self.vpp_session.modify_parameters(
- required_min_rx=2 * self.vpp_session.required_min_rx)
+ required_min_rx=2 * self.vpp_session.required_min_rx
+ )
p = wait_for_bfd_packet(self)
poll_sequence_start = time.time()
poll_sequence_length_min = 0.5
send_final_after = time.time() + poll_sequence_length_min
# poll bit needs to be set
- self.assertIn("P", p.sprintf("%BFD.flags%"),
- "Poll bit not set in BFD packet")
- self.assert_equal(p[BFD].required_min_rx_interval,
- self.vpp_session.required_min_rx,
- "BFD required min rx interval")
+ self.assertIn("P", p.sprintf("%BFD.flags%"), "Poll bit not set in BFD packet")
+ self.assert_equal(
+ p[BFD].required_min_rx_interval,
+ self.vpp_session.required_min_rx,
+ "BFD required min rx interval",
+ )
self.vpp_session.modify_parameters(
- required_min_rx=2 * self.vpp_session.required_min_rx)
+ required_min_rx=2 * self.vpp_session.required_min_rx
+ )
# 2nd poll sequence should be queued now
# don't send the reply back yet, wait for some time to emulate
# longer round-trip time
while time.time() < send_final_after:
self.test_session.send_packet()
p = wait_for_bfd_packet(self)
- self.assert_equal(len(self.vapi.collect_events()), 0,
- "number of bfd events")
- self.assert_equal(p[BFD].required_min_rx_interval,
- self.vpp_session.required_min_rx,
- "BFD required min rx interval")
+ self.assert_equal(
+ len(self.vapi.collect_events()), 0, "number of bfd events"
+ )
+ self.assert_equal(
+ p[BFD].required_min_rx_interval,
+ self.vpp_session.required_min_rx,
+ "BFD required min rx interval",
+ )
packet_count += 1
# poll bit must be set
- self.assertIn("P", p.sprintf("%BFD.flags%"),
- "Poll bit not set in BFD packet")
+ self.assertIn(
+ "P", p.sprintf("%BFD.flags%"), "Poll bit not set in BFD packet"
+ )
final = self.test_session.create_packet()
final[BFD].flags = "F"
self.test_session.send_packet(final)
poll_no_2_started = False
for dummy in range(2 * packet_count):
p = wait_for_bfd_packet(self)
- self.assert_equal(len(self.vapi.collect_events()), 0,
- "number of bfd events")
+ self.assert_equal(
+ len(self.vapi.collect_events()), 0, "number of bfd events"
+ )
if "P" in p.sprintf("%BFD.flags%"):
poll_no_2_started = True
if time.time() < poll_sequence_start + poll_sequence_length:
self.test_session.send_packet(final)
p = wait_for_bfd_packet(self)
# poll bit must not be set
- self.assertNotIn("P", p.sprintf("%BFD.flags%"),
- "Poll bit set in BFD packet")
+ self.assertNotIn("P", p.sprintf("%BFD.flags%"), "Poll bit set in BFD packet")
# returning inconsistent results requiring retries in per-patch tests
@unittest.skipUnless(config.extended, "part of extended tests")
def test_poll_response(self):
- """ test correct response to control frame with poll bit set """
+ """test correct response to control frame with poll bit set"""
bfd_session_up(self)
poll = self.test_session.create_packet()
poll[BFD].flags = "P"
self.test_session.send_packet(poll)
final = wait_for_bfd_packet(
- self, pcap_time_min=time.time() - self.vpp_clock_offset)
+ self, pcap_time_min=time.time() - self.vpp_clock_offset
+ )
self.assertIn("F", final.sprintf("%BFD.flags%"))
def test_no_periodic_if_remote_demand(self):
- """ no periodic frames outside poll sequence if remote demand set """
+ """no periodic frames outside poll sequence if remote demand set"""
bfd_session_up(self)
demand = self.test_session.create_packet()
demand[BFD].flags = "D"
self.test_session.send_packet(demand)
- transmit_time = 0.9 \
- * max(self.vpp_session.required_min_rx,
- self.test_session.desired_min_tx) \
+ transmit_time = (
+ 0.9
+ * max(self.vpp_session.required_min_rx, self.test_session.desired_min_tx)
/ USEC_IN_SEC
+ )
count = 0
for dummy in range(self.test_session.detect_mult * 2):
self.sleep(transmit_time)
self.assert_equal(len(events), 0, "number of events received")
def test_echo_looped_back(self):
- """ echo packets looped back """
+ """echo packets looped back"""
bfd_session_up(self)
stats_before = bfd_grab_stats_snapshot(self)
self.pg0.enable_capture()
# random source port low enough to increment a few times..
udp_sport_tx = randint(1, 50000)
udp_sport_rx = udp_sport_tx
- echo_packet = (Ether(src=self.pg0.remote_mac,
- dst=self.pg0.local_mac) /
- IP(src=self.pg0.remote_ip4,
- dst=self.pg0.remote_ip4) /
- UDP(dport=BFD.udp_dport_echo) /
- Raw("this should be looped back"))
+ echo_packet = (
+ Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac)
+ / IP(src=self.pg0.remote_ip4, dst=self.pg0.remote_ip4)
+ / UDP(dport=BFD.udp_dport_echo)
+ / Raw("this should be looped back")
+ )
for dummy in range(echo_packet_count):
- self.sleep(.01, "delay between echo packets")
+ self.sleep(0.01, "delay between echo packets")
echo_packet[UDP].sport = udp_sport_tx
udp_sport_tx += 1
self.logger.debug(ppp("Sending packet:", echo_packet))
p = self.pg0.wait_for_packet(1)
self.logger.debug(ppp("Got packet:", p))
ether = p[Ether]
- self.assert_equal(self.pg0.remote_mac,
- ether.dst, "Destination MAC")
+ self.assert_equal(self.pg0.remote_mac, ether.dst, "Destination MAC")
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")
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.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(scapy.compat.raw(p[UDP].payload),
- scapy.compat.raw(echo_packet[UDP].payload),
- "Received packet is not the echo packet sent")
+ 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, "RX counter bumped but no BFD packets sent")
+ 0, diff.rx_echo, "RX echo counter bumped but no BFD session exists"
+ )
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")
+ 0, diff.tx_echo, "TX echo counter bumped but no BFD session exists"
+ )
def test_echo(self):
- """ echo function """
+ """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()
- detection_time = self.test_session.detect_mult *\
- self.vpp_session.required_min_rx / USEC_IN_SEC
+ detection_time = (
+ self.test_session.detect_mult
+ * self.vpp_session.required_min_rx
+ / USEC_IN_SEC
+ )
# echo shouldn't work without echo source set
for dummy in range(10):
sleep = self.vpp_session.required_min_rx / USEC_IN_SEC
self.sleep(sleep, "delay before sending bfd packet")
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].required_min_rx_interval,
- self.vpp_session.required_min_rx,
- "BFD required min rx interval")
+ p = wait_for_bfd_packet(self, pcap_time_min=time.time() - self.vpp_clock_offset)
+ self.assert_equal(
+ p[BFD].required_min_rx_interval,
+ self.vpp_session.required_min_rx,
+ "BFD required min rx interval",
+ )
self.test_session.send_packet()
- self.vapi.bfd_udp_set_echo_source(
- sw_if_index=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):
p = self.pg0.wait_for_packet(1)
self.logger.debug(ppp("Got packet:", p))
if p[UDP].dport == BFD.udp_dport_echo:
- self.assert_equal(
- p[IP].dst, self.pg0.local_ip4, "BFD ECHO dst IP")
- self.assertNotEqual(p[IP].src, self.loopback0.local_ip4,
- "BFD ECHO src IP equal to loopback IP")
+ self.assert_equal(p[IP].dst, self.pg0.local_ip4, "BFD ECHO dst IP")
+ self.assertNotEqual(
+ p[IP].src,
+ self.loopback0.local_ip4,
+ "BFD ECHO src IP equal to loopback IP",
+ )
self.logger.debug(ppp("Looping back packet:", p))
- self.assert_equal(p[Ether].dst, self.pg0.remote_mac,
- "ECHO packet destination MAC address")
+ self.assert_equal(
+ p[Ether].dst,
+ self.pg0.remote_mac,
+ "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.rx_packets += 1
if echo_seen:
self.assertGreaterEqual(
- p[BFD].required_min_rx_interval,
- 1000000)
+ p[BFD].required_min_rx_interval, 1000000
+ )
if "P" in p.sprintf("%BFD.flags%"):
final = self.test_session.create_packet()
final[BFD].flags = "F"
else:
raise Exception(ppp("Received unknown packet:", p))
- self.assert_equal(len(self.vapi.collect_events()), 0,
- "number of bfd events")
+ self.assert_equal(
+ len(self.vapi.collect_events()), 0, "number of bfd events"
+ )
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")
+ 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 """
+ """session goes down if echo function fails"""
bfd_session_up(self)
self.test_session.update(required_min_echo_rx=150000)
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(
- sw_if_index=self.loopback0.sw_if_index)
+ detection_time = (
+ self.test_session.detect_mult
+ * self.vpp_session.required_min_rx
+ / USEC_IN_SEC
+ )
+ 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):
elif p.haslayer(BFD):
if "P" in p.sprintf("%BFD.flags%"):
self.assertGreaterEqual(
- p[BFD].required_min_rx_interval,
- 1000000)
+ p[BFD].required_min_rx_interval, 1000000
+ )
final = self.test_session.create_packet()
final[BFD].flags = "F"
self.test_session.send_packet(final)
if p[BFD].state == BFDState.down:
- self.assert_equal(p[BFD].diag,
- BFDDiagCode.echo_function_failed,
- BFDDiagCode)
+ self.assert_equal(
+ p[BFD].diag, BFDDiagCode.echo_function_failed, BFDDiagCode
+ )
verified_diag = True
else:
raise Exception(ppp("Received unknown packet:", p))
self.assertTrue(verified_diag, "Incorrect diagnostics code received")
def test_echo_stop(self):
- """ echo function stops if peer sets required min echo rx zero """
+ """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(
- sw_if_index=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)
self.test_session.send_packet()
# echo packets shouldn't arrive anymore
for dummy in range(5):
- wait_for_bfd_packet(
- self, pcap_time_min=time.time() - self.vpp_clock_offset)
+ wait_for_bfd_packet(self, pcap_time_min=time.time() - self.vpp_clock_offset)
self.test_session.send_packet()
events = self.vapi.collect_events()
self.assert_equal(len(events), 0, "number of bfd events")
def test_echo_source_removed(self):
- """ echo function stops if echo source is removed """
+ """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(
- sw_if_index=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)
self.test_session.send_packet()
# echo packets shouldn't arrive anymore
for dummy in range(5):
- wait_for_bfd_packet(
- self, pcap_time_min=time.time() - self.vpp_clock_offset)
+ wait_for_bfd_packet(self, pcap_time_min=time.time() - self.vpp_clock_offset)
self.test_session.send_packet()
events = self.vapi.collect_events()
self.assert_equal(len(events), 0, "number of bfd events")
def test_stale_echo(self):
- """ stale echo packets don't keep a session up """
+ """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(
- sw_if_index=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
if echo_packet is None:
self.logger.debug(ppp("Got first echo packet:", p))
echo_packet = p
- timeout_at = time.time() + self.vpp_session.detect_mult * \
- self.test_session.required_min_echo_rx / USEC_IN_SEC
+ timeout_at = (
+ time.time()
+ + self.vpp_session.detect_mult
+ * self.test_session.required_min_echo_rx
+ / USEC_IN_SEC
+ )
else:
self.logger.debug(ppp("Got followup echo packet:", p))
self.logger.debug(ppp("Looping back first echo packet:", p))
if p[BFD].state == BFDState.down:
self.assertIsNotNone(
timeout_at,
- "Session went down before first echo packet received")
+ "Session went down before first echo packet received",
+ )
now = time.time()
self.assertGreaterEqual(
- now, timeout_at,
- "Session timeout at %s, but is expected at %s" %
- (now, timeout_at))
- self.assert_equal(p[BFD].diag,
- BFDDiagCode.echo_function_failed,
- BFDDiagCode)
+ now,
+ timeout_at,
+ "Session timeout at %s, but is expected at %s"
+ % (now, timeout_at),
+ )
+ self.assert_equal(
+ p[BFD].diag, BFDDiagCode.echo_function_failed, BFDDiagCode
+ )
events = self.vapi.collect_events()
self.assert_equal(len(events), 1, "number of bfd events")
self.assert_equal(events[0].state, BFDState.down, BFDState)
self.assertTrue(timeout_ok, "Expected timeout event didn't occur")
def test_invalid_echo_checksum(self):
- """ echo packets with invalid checksum don't keep a session up """
+ """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(
- sw_if_index=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
if p[UDP].dport == BFD.udp_dport_echo:
self.logger.debug(ppp("Got echo packet:", p))
if timeout_at is None:
- timeout_at = time.time() + self.vpp_session.detect_mult * \
- self.test_session.required_min_echo_rx / USEC_IN_SEC
+ timeout_at = (
+ time.time()
+ + self.vpp_session.detect_mult
+ * self.test_session.required_min_echo_rx
+ / USEC_IN_SEC
+ )
p[BFD_vpp_echo].checksum = getrandbits(64)
p[Ether].dst = self.pg0.local_mac
self.logger.debug(ppp("Looping back modified echo packet:", p))
if p[BFD].state == BFDState.down:
self.assertIsNotNone(
timeout_at,
- "Session went down before first echo packet received")
+ "Session went down before first echo packet received",
+ )
now = time.time()
self.assertGreaterEqual(
- now, timeout_at,
- "Session timeout at %s, but is expected at %s" %
- (now, timeout_at))
- self.assert_equal(p[BFD].diag,
- BFDDiagCode.echo_function_failed,
- BFDDiagCode)
+ now,
+ timeout_at,
+ "Session timeout at %s, but is expected at %s"
+ % (now, timeout_at),
+ )
+ self.assert_equal(
+ p[BFD].diag, BFDDiagCode.echo_function_failed, BFDDiagCode
+ )
events = self.vapi.collect_events()
self.assert_equal(len(events), 1, "number of bfd events")
self.assert_equal(events[0].state, BFDState.down, BFDState)
self.assertTrue(timeout_ok, "Expected timeout event didn't occur")
def test_admin_up_down(self):
- """ put session admin-up and admin-down """
+ """put session admin-up and admin-down"""
bfd_session_up(self)
self.vpp_session.admin_down()
self.pg0.enable_capture()
self.test_session.update(state=BFDState.down)
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)
+ p = wait_for_bfd_packet(self, pcap_time_min=time.time() - self.vpp_clock_offset)
self.assert_equal(p[BFD].state, BFDState.down, BFDState)
self.test_session.send_packet()
- p = wait_for_bfd_packet(
- self, pcap_time_min=time.time() - self.vpp_clock_offset)
+ 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_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)
+ 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_event")
verify_event(self, e, expected_state=BFDState.up)
def test_config_change_remote_demand(self):
- """ configuration change while peer in demand mode """
+ """configuration change while peer in demand mode"""
bfd_session_up(self)
demand = self.test_session.create_packet()
demand[BFD].flags = "D"
self.test_session.send_packet(demand)
self.vpp_session.modify_parameters(
- required_min_rx=2 * self.vpp_session.required_min_rx)
- p = wait_for_bfd_packet(
- self, pcap_time_min=time.time() - self.vpp_clock_offset)
+ required_min_rx=2 * self.vpp_session.required_min_rx
+ )
+ p = wait_for_bfd_packet(self, pcap_time_min=time.time() - self.vpp_clock_offset)
# poll bit must be set
self.assertIn("P", p.sprintf("%BFD.flags%"), "Poll bit not set")
# terminate poll sequence
final[BFD].flags = "D+F"
self.test_session.send_packet(final)
# vpp should be quiet now again
- transmit_time = 0.9 \
- * max(self.vpp_session.required_min_rx,
- self.test_session.desired_min_tx) \
+ transmit_time = (
+ 0.9
+ * max(self.vpp_session.required_min_rx, self.test_session.desired_min_tx)
/ USEC_IN_SEC
+ )
count = 0
for dummy in range(self.test_session.detect_mult * 2):
self.sleep(transmit_time)
self.assert_equal(len(events), 0, "number of events received")
def test_intf_deleted(self):
- """ interface with bfd session deleted """
+ """interface with bfd session deleted"""
intf = VppLoInterface(self)
intf.config_ip4()
intf.admin_up()
@tag_run_solo
@tag_fixme_vpp_workers
class BFD6TestCase(VppTestCase):
- """Bidirectional Forwarding Detection (BFD) (IPv6) """
+ """Bidirectional Forwarding Detection (BFD) (IPv6)"""
pg0 = None
vpp_clock_offset = None
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)
+ 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
+ )
self.vpp_session.add_vpp_config()
self.vpp_session.admin_up()
self.test_session = BFDTestSession(self, self.pg0, AF_INET6)
super(BFD6TestCase, self).tearDown()
def test_session_up(self):
- """ bring BFD session up """
+ """bring BFD session up"""
bfd_session_up(self)
- bfd_udp4_sessions = self.statistics['/bfd/udp4/sessions']
- bfd_udp6_sessions = self.statistics['/bfd/udp6/sessions']
+ 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 """
+ """bring BFD session up - first frame looked up by address pair"""
self.logger.info("BFD: Sending Slow control frame")
self.test_session.update(my_discriminator=randint(0, 40000000))
self.test_session.send_packet()
self.pg0.enable_capture()
p = self.pg0.wait_for_packet(1)
- self.assert_equal(p[BFD].your_discriminator,
- self.test_session.my_discriminator,
- "BFD - your discriminator")
+ self.assert_equal(
+ p[BFD].your_discriminator,
+ self.test_session.my_discriminator,
+ "BFD - your discriminator",
+ )
self.assert_equal(p[BFD].state, BFDState.init, BFDState)
- self.test_session.update(your_discriminator=p[BFD].my_discriminator,
- state=BFDState.up)
+ 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_event")
verify_event(self, e, expected_state=BFDState.init)
self.assert_equal(self.vpp_session.state, BFDState.up, BFDState)
def test_hold_up(self):
- """ hold BFD session up """
+ """hold BFD session up"""
bfd_session_up(self)
for dummy in range(self.test_session.detect_mult * 2):
wait_for_bfd_packet(self)
self.test_session.send_packet()
- self.assert_equal(len(self.vapi.collect_events()), 0,
- "number of bfd events")
+ self.assert_equal(len(self.vapi.collect_events()), 0, "number of bfd events")
self.assert_equal(self.vpp_session.state, BFDState.up, BFDState)
def test_echo_looped_back(self):
- """ echo packets looped back """
+ """echo packets looped back"""
bfd_session_up(self)
stats_before = bfd_grab_stats_snapshot(self)
self.pg0.enable_capture()
# random source port low enough to increment a few times..
udp_sport_tx = randint(1, 50000)
udp_sport_rx = udp_sport_tx
- echo_packet = (Ether(src=self.pg0.remote_mac,
- dst=self.pg0.local_mac) /
- IPv6(src=self.pg0.remote_ip6,
- dst=self.pg0.remote_ip6) /
- UDP(dport=BFD.udp_dport_echo) /
- Raw("this should be looped back"))
+ echo_packet = (
+ Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac)
+ / IPv6(src=self.pg0.remote_ip6, dst=self.pg0.remote_ip6)
+ / UDP(dport=BFD.udp_dport_echo)
+ / Raw("this should be looped back")
+ )
for dummy in range(echo_packet_count):
- self.sleep(.01, "delay between echo packets")
+ self.sleep(0.01, "delay between echo packets")
echo_packet[UDP].sport = udp_sport_tx
udp_sport_tx += 1
self.logger.debug(ppp("Sending packet:", echo_packet))
p = self.pg0.wait_for_packet(1)
self.logger.debug(ppp("Got packet:", p))
ether = p[Ether]
- self.assert_equal(self.pg0.remote_mac,
- ether.dst, "Destination MAC")
+ self.assert_equal(self.pg0.remote_mac, ether.dst, "Destination MAC")
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")
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.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(scapy.compat.raw(p[UDP].payload),
- scapy.compat.raw(echo_packet[UDP].payload),
- "Received packet is not the echo packet sent")
+ 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, "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")
+ 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 """
+ """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()
- detection_time = self.test_session.detect_mult *\
- self.vpp_session.required_min_rx / USEC_IN_SEC
+ detection_time = (
+ self.test_session.detect_mult
+ * self.vpp_session.required_min_rx
+ / USEC_IN_SEC
+ )
# echo shouldn't work without echo source set
for dummy in range(10):
sleep = self.vpp_session.required_min_rx / USEC_IN_SEC
self.sleep(sleep, "delay before sending bfd packet")
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].required_min_rx_interval,
- self.vpp_session.required_min_rx,
- "BFD required min rx interval")
+ p = wait_for_bfd_packet(self, pcap_time_min=time.time() - self.vpp_clock_offset)
+ self.assert_equal(
+ p[BFD].required_min_rx_interval,
+ self.vpp_session.required_min_rx,
+ "BFD required min rx interval",
+ )
self.test_session.send_packet()
- self.vapi.bfd_udp_set_echo_source(
- sw_if_index=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):
self.logger.debug(ppp("Got packet:", p))
if p[UDP].dport == BFD.udp_dport_echo:
self.assert_equal(
- p[IPv6].dst, self.pg0.local_ip6, "BFD ECHO dst IP")
- self.assertNotEqual(p[IPv6].src, self.loopback0.local_ip6,
- "BFD ECHO src IP equal to loopback IP")
+ p[IPv6].dst, self.pg0.local_ip6, "BFD ECHO dst IP"
+ )
+ self.assertNotEqual(
+ p[IPv6].src,
+ self.loopback0.local_ip6,
+ "BFD ECHO src IP equal to loopback IP",
+ )
self.logger.debug(ppp("Looping back packet:", p))
- self.assert_equal(p[Ether].dst, self.pg0.remote_mac,
- "ECHO packet destination MAC address")
+ 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.test_session.rx_packets += 1
if echo_seen:
self.assertGreaterEqual(
- p[BFD].required_min_rx_interval,
- 1000000)
+ p[BFD].required_min_rx_interval, 1000000
+ )
if "P" in p.sprintf("%BFD.flags%"):
final = self.test_session.create_packet()
final[BFD].flags = "F"
else:
raise Exception(ppp("Received unknown packet:", p))
- self.assert_equal(len(self.vapi.collect_events()), 0,
- "number of bfd events")
+ self.assert_equal(
+ len(self.vapi.collect_events()), 0, "number of bfd events"
+ )
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")
+ 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 """
+ """interface with bfd session deleted"""
intf = VppLoInterface(self)
intf.config_ip6()
intf.admin_up()
sw_if_index = intf.sw_if_index
- vpp_session = VppBFDUDPSession(
- self, intf, intf.remote_ip6, af=AF_INET6)
+ vpp_session = VppBFDUDPSession(self, intf, intf.remote_ip6, af=AF_INET6)
vpp_session.add_vpp_config()
vpp_session.admin_up()
intf.remove_vpp_config()
@tag_run_solo
class BFDFIBTestCase(VppTestCase):
- """ BFD-FIB interactions (IPv6) """
+ """BFD-FIB interactions (IPv6)"""
vpp_session = None
test_session = None
@staticmethod
def pkt_is_not_data_traffic(p):
- """ not data traffic implies BFD or the usual IPv6 ND/RA"""
+ """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_session_with_fib(self):
- """ BFD-FIB interactions """
+ """BFD-FIB interactions"""
# packets to match against both of the routes
- 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(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(b'\xa5' * 100))]
+ 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(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(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)])
- ip_2002_s_64 = VppIpRoute(self, "2002::", 64,
- [VppRoutePath(self.pg0.remote_ip6,
- 0xffffffff)])
+ ip_2001_s_64 = VppIpRoute(
+ self,
+ "2001::",
+ 64,
+ [VppRoutePath(self.pg0.remote_ip6, self.pg0.sw_if_index)],
+ )
+ ip_2002_s_64 = VppIpRoute(
+ self, "2002::", 64, [VppRoutePath(self.pg0.remote_ip6, 0xFFFFFFFF)]
+ )
ip_2001_s_64.add_vpp_config()
ip_2002_s_64.add_vpp_config()
# bring the session up now the routes are present
- self.vpp_session = VppBFDUDPSession(self,
- self.pg0,
- self.pg0.remote_ip6,
- af=AF_INET6)
+ 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.pg_start()
for packet in p:
captured = self.pg0.wait_for_packet(
- 1,
- filter_out_fn=self.pkt_is_not_data_traffic)
- self.assertEqual(captured[IPv6].dst,
- packet[IPv6].dst)
+ 1, filter_out_fn=self.pkt_is_not_data_traffic
+ )
+ self.assertEqual(captured[IPv6].dst, packet[IPv6].dst)
# session is up - traffic is dropped
bfd_session_down(self)
self.pg_start()
for packet in p:
captured = self.pg0.wait_for_packet(
- 1,
- filter_out_fn=self.pkt_is_not_data_traffic)
- self.assertEqual(captured[IPv6].dst,
- packet[IPv6].dst)
+ 1, filter_out_fn=self.pkt_is_not_data_traffic
+ )
+ self.assertEqual(captured[IPv6].dst, packet[IPv6].dst)
@unittest.skipUnless(config.extended, "part of extended tests")
class BFDTunTestCase(VppTestCase):
- """ BFD over GRE tunnel """
+ """BFD over GRE tunnel"""
vpp_session = None
test_session = None
@staticmethod
def pkt_is_not_data_traffic(p):
- """ not data traffic implies BFD or the usual IPv6 ND/RA"""
+ """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 """
+ """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 = 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 = 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)
+ 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))]
+ 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)
@tag_run_solo
class BFDSHA1TestCase(VppTestCase):
- """Bidirectional Forwarding Detection (BFD) (SHA1 auth) """
+ """Bidirectional Forwarding Detection (BFD) (SHA1 auth)"""
pg0 = None
vpp_clock_offset = None
super(BFDSHA1TestCase, self).tearDown()
def test_session_up(self):
- """ bring BFD session up """
+ """bring BFD session up"""
key = self.factory.create_random_key(self)
key.add_vpp_config()
- self.vpp_session = VppBFDUDPSession(self, self.pg0,
- self.pg0.remote_ip4,
- sha1_key=key)
+ self.vpp_session = VppBFDUDPSession(
+ self, self.pg0, self.pg0.remote_ip4, sha1_key=key
+ )
self.vpp_session.add_vpp_config()
self.vpp_session.admin_up()
self.test_session = BFDTestSession(
- self, self.pg0, AF_INET, sha1_key=key,
- bfd_key_id=self.vpp_session.bfd_key_id)
+ self,
+ self.pg0,
+ AF_INET,
+ sha1_key=key,
+ bfd_key_id=self.vpp_session.bfd_key_id,
+ )
bfd_session_up(self)
def test_hold_up(self):
- """ hold BFD session up """
+ """hold BFD session up"""
key = self.factory.create_random_key(self)
key.add_vpp_config()
- self.vpp_session = VppBFDUDPSession(self, self.pg0,
- self.pg0.remote_ip4,
- sha1_key=key)
+ self.vpp_session = VppBFDUDPSession(
+ self, self.pg0, self.pg0.remote_ip4, sha1_key=key
+ )
self.vpp_session.add_vpp_config()
self.vpp_session.admin_up()
self.test_session = BFDTestSession(
- self, self.pg0, AF_INET, sha1_key=key,
- bfd_key_id=self.vpp_session.bfd_key_id)
+ self,
+ self.pg0,
+ AF_INET,
+ sha1_key=key,
+ bfd_key_id=self.vpp_session.bfd_key_id,
+ )
bfd_session_up(self)
for dummy in range(self.test_session.detect_mult * 2):
wait_for_bfd_packet(self)
self.assert_equal(self.vpp_session.state, BFDState.up, BFDState)
def test_hold_up_meticulous(self):
- """ hold BFD session up - meticulous auth """
- key = self.factory.create_random_key(
- self, BFDAuthType.meticulous_keyed_sha1)
+ """hold BFD session up - meticulous auth"""
+ key = self.factory.create_random_key(self, BFDAuthType.meticulous_keyed_sha1)
key.add_vpp_config()
- self.vpp_session = VppBFDUDPSession(self, self.pg0,
- self.pg0.remote_ip4, sha1_key=key)
+ self.vpp_session = VppBFDUDPSession(
+ self, self.pg0, self.pg0.remote_ip4, sha1_key=key
+ )
self.vpp_session.add_vpp_config()
self.vpp_session.admin_up()
# specify sequence number so that it wraps
self.test_session = BFDTestSession(
- self, self.pg0, AF_INET, sha1_key=key,
+ self,
+ self.pg0,
+ AF_INET,
+ sha1_key=key,
bfd_key_id=self.vpp_session.bfd_key_id,
- our_seq_number=0xFFFFFFFF - 4)
+ our_seq_number=0xFFFFFFFF - 4,
+ )
bfd_session_up(self)
for dummy in range(30):
wait_for_bfd_packet(self)
self.assert_equal(self.vpp_session.state, BFDState.up, BFDState)
def test_send_bad_seq_number(self):
- """ session is not kept alive by msgs with bad sequence numbers"""
- key = self.factory.create_random_key(
- self, BFDAuthType.meticulous_keyed_sha1)
+ """session is not kept alive by msgs with bad sequence numbers"""
+ key = self.factory.create_random_key(self, BFDAuthType.meticulous_keyed_sha1)
key.add_vpp_config()
- self.vpp_session = VppBFDUDPSession(self, self.pg0,
- self.pg0.remote_ip4, sha1_key=key)
+ self.vpp_session = VppBFDUDPSession(
+ self, self.pg0, self.pg0.remote_ip4, sha1_key=key
+ )
self.vpp_session.add_vpp_config()
self.test_session = BFDTestSession(
- self, self.pg0, AF_INET, sha1_key=key,
- bfd_key_id=self.vpp_session.bfd_key_id)
+ self,
+ self.pg0,
+ AF_INET,
+ sha1_key=key,
+ bfd_key_id=self.vpp_session.bfd_key_id,
+ )
bfd_session_up(self)
- detection_time = self.test_session.detect_mult *\
- self.vpp_session.required_min_rx / USEC_IN_SEC
+ detection_time = (
+ self.test_session.detect_mult
+ * self.vpp_session.required_min_rx
+ / USEC_IN_SEC
+ )
send_until = time.time() + 2 * detection_time
while time.time() < send_until:
self.test_session.send_packet()
- self.sleep(0.7 * self.vpp_session.required_min_rx / USEC_IN_SEC,
- "time between bfd packets")
+ self.sleep(
+ 0.7 * self.vpp_session.required_min_rx / USEC_IN_SEC,
+ "time between bfd packets",
+ )
e = self.vapi.collect_events()
# session should be down now, because the sequence numbers weren't
# updated
self.assert_equal(len(e), 1, "number of bfd events")
verify_event(self, e[0], expected_state=BFDState.down)
- def execute_rogue_session_scenario(self, vpp_bfd_udp_session,
- legitimate_test_session,
- rogue_test_session,
- rogue_bfd_values=None):
- """ execute a rogue session interaction scenario
+ def execute_rogue_session_scenario(
+ self,
+ vpp_bfd_udp_session,
+ legitimate_test_session,
+ rogue_test_session,
+ rogue_bfd_values=None,
+ ):
+ """execute a rogue session interaction scenario
1. create vpp session, add config
2. bring the legitimate session up
detect_mult=self.test_session.detect_mult,
diag=self.test_session.diag,
state=self.test_session.state,
- auth_type=self.test_session.auth_type)
+ auth_type=self.test_session.auth_type,
+ )
if rogue_bfd_values:
rogue_test_session.update(**rogue_bfd_values)
rogue_test_session.update(state=BFDState.down)
self.assert_equal(self.vpp_session.state, BFDState.up, BFDState)
def test_mismatch_auth(self):
- """ session is not brought down by unauthenticated msg """
+ """session is not brought down by unauthenticated msg"""
key = self.factory.create_random_key(self)
key.add_vpp_config()
vpp_session = VppBFDUDPSession(
- self, self.pg0, self.pg0.remote_ip4, sha1_key=key)
+ self, self.pg0, self.pg0.remote_ip4, sha1_key=key
+ )
legitimate_test_session = BFDTestSession(
- self, self.pg0, AF_INET, sha1_key=key,
- bfd_key_id=vpp_session.bfd_key_id)
+ self, self.pg0, AF_INET, sha1_key=key, bfd_key_id=vpp_session.bfd_key_id
+ )
rogue_test_session = BFDTestSession(self, self.pg0, AF_INET)
- self.execute_rogue_session_scenario(vpp_session,
- legitimate_test_session,
- rogue_test_session)
+ self.execute_rogue_session_scenario(
+ vpp_session, legitimate_test_session, rogue_test_session
+ )
def test_mismatch_bfd_key_id(self):
- """ session is not brought down by msg with non-existent key-id """
+ """session is not brought down by msg with non-existent key-id"""
key = self.factory.create_random_key(self)
key.add_vpp_config()
vpp_session = VppBFDUDPSession(
- self, self.pg0, self.pg0.remote_ip4, sha1_key=key)
+ self, self.pg0, self.pg0.remote_ip4, sha1_key=key
+ )
# pick a different random bfd key id
x = randint(0, 255)
while x == vpp_session.bfd_key_id:
x = randint(0, 255)
legitimate_test_session = BFDTestSession(
- self, self.pg0, AF_INET, sha1_key=key,
- bfd_key_id=vpp_session.bfd_key_id)
+ self, self.pg0, AF_INET, sha1_key=key, bfd_key_id=vpp_session.bfd_key_id
+ )
rogue_test_session = BFDTestSession(
- self, self.pg0, AF_INET, sha1_key=key, bfd_key_id=x)
- self.execute_rogue_session_scenario(vpp_session,
- legitimate_test_session,
- rogue_test_session)
+ self, self.pg0, AF_INET, sha1_key=key, bfd_key_id=x
+ )
+ self.execute_rogue_session_scenario(
+ vpp_session, legitimate_test_session, rogue_test_session
+ )
def test_mismatched_auth_type(self):
- """ session is not brought down by msg with wrong auth type """
+ """session is not brought down by msg with wrong auth type"""
key = self.factory.create_random_key(self)
key.add_vpp_config()
vpp_session = VppBFDUDPSession(
- self, self.pg0, self.pg0.remote_ip4, sha1_key=key)
+ self, self.pg0, self.pg0.remote_ip4, sha1_key=key
+ )
legitimate_test_session = BFDTestSession(
- self, self.pg0, AF_INET, sha1_key=key,
- bfd_key_id=vpp_session.bfd_key_id)
+ self, self.pg0, AF_INET, sha1_key=key, bfd_key_id=vpp_session.bfd_key_id
+ )
rogue_test_session = BFDTestSession(
- self, self.pg0, AF_INET, sha1_key=key,
- bfd_key_id=vpp_session.bfd_key_id)
+ self, self.pg0, AF_INET, sha1_key=key, bfd_key_id=vpp_session.bfd_key_id
+ )
self.execute_rogue_session_scenario(
- vpp_session, legitimate_test_session, rogue_test_session,
- {'auth_type': BFDAuthType.keyed_md5})
+ vpp_session,
+ legitimate_test_session,
+ rogue_test_session,
+ {"auth_type": BFDAuthType.keyed_md5},
+ )
def test_restart(self):
- """ simulate remote peer restart and resynchronization """
- key = self.factory.create_random_key(
- self, BFDAuthType.meticulous_keyed_sha1)
+ """simulate remote peer restart and resynchronization"""
+ key = self.factory.create_random_key(self, BFDAuthType.meticulous_keyed_sha1)
key.add_vpp_config()
- self.vpp_session = VppBFDUDPSession(self, self.pg0,
- self.pg0.remote_ip4, sha1_key=key)
+ self.vpp_session = VppBFDUDPSession(
+ self, self.pg0, self.pg0.remote_ip4, sha1_key=key
+ )
self.vpp_session.add_vpp_config()
self.test_session = BFDTestSession(
- self, self.pg0, AF_INET, sha1_key=key,
- bfd_key_id=self.vpp_session.bfd_key_id, our_seq_number=0)
+ self,
+ self.pg0,
+ AF_INET,
+ sha1_key=key,
+ bfd_key_id=self.vpp_session.bfd_key_id,
+ our_seq_number=0,
+ )
bfd_session_up(self)
# don't send any packets for 2*detection_time
- detection_time = self.test_session.detect_mult *\
- self.vpp_session.required_min_rx / USEC_IN_SEC
+ detection_time = (
+ self.test_session.detect_mult
+ * self.vpp_session.required_min_rx
+ / USEC_IN_SEC
+ )
self.sleep(2 * detection_time, "simulating peer restart")
events = self.vapi.collect_events()
self.assert_equal(len(events), 1, "number of bfd events")
@tag_run_solo
class BFDAuthOnOffTestCase(VppTestCase):
- """Bidirectional Forwarding Detection (BFD) (changing auth) """
+ """Bidirectional Forwarding Detection (BFD) (changing auth)"""
pg0 = None
vpp_session = None
super(BFDAuthOnOffTestCase, self).tearDown()
def test_auth_on_immediate(self):
- """ turn auth on without disturbing session state (immediate) """
+ """turn auth on without disturbing session state (immediate)"""
key = self.factory.create_random_key(self)
key.add_vpp_config()
- self.vpp_session = VppBFDUDPSession(self, self.pg0,
- self.pg0.remote_ip4)
+ self.vpp_session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4)
self.vpp_session.add_vpp_config()
self.test_session = BFDTestSession(self, self.pg0, AF_INET)
bfd_session_up(self)
self.assert_equal(p[BFD].state, BFDState.up, BFDState)
self.test_session.send_packet()
self.assert_equal(self.vpp_session.state, BFDState.up, BFDState)
- self.assert_equal(len(self.vapi.collect_events()), 0,
- "number of bfd events")
+ self.assert_equal(len(self.vapi.collect_events()), 0, "number of bfd events")
def test_auth_off_immediate(self):
- """ turn auth off without disturbing session state (immediate) """
+ """turn auth off without disturbing session state (immediate)"""
key = self.factory.create_random_key(self)
key.add_vpp_config()
- self.vpp_session = VppBFDUDPSession(self, self.pg0,
- self.pg0.remote_ip4, sha1_key=key)
+ self.vpp_session = VppBFDUDPSession(
+ self, self.pg0, self.pg0.remote_ip4, sha1_key=key
+ )
self.vpp_session.add_vpp_config()
self.test_session = BFDTestSession(
- self, self.pg0, AF_INET, sha1_key=key,
- bfd_key_id=self.vpp_session.bfd_key_id)
+ self,
+ self.pg0,
+ AF_INET,
+ sha1_key=key,
+ bfd_key_id=self.vpp_session.bfd_key_id,
+ )
bfd_session_up(self)
# self.vapi.want_bfd_events(enable_disable=0)
for dummy in range(self.test_session.detect_mult * 2):
self.test_session.inc_seq_num()
self.test_session.send_packet()
self.assert_equal(self.vpp_session.state, BFDState.up, BFDState)
- self.assert_equal(len(self.vapi.collect_events()), 0,
- "number of bfd events")
+ self.assert_equal(len(self.vapi.collect_events()), 0, "number of bfd events")
def test_auth_change_key_immediate(self):
- """ change auth key without disturbing session state (immediate) """
+ """change auth key without disturbing session state (immediate)"""
key1 = self.factory.create_random_key(self)
key1.add_vpp_config()
key2 = self.factory.create_random_key(self)
key2.add_vpp_config()
- self.vpp_session = VppBFDUDPSession(self, self.pg0,
- self.pg0.remote_ip4, sha1_key=key1)
+ self.vpp_session = VppBFDUDPSession(
+ self, self.pg0, self.pg0.remote_ip4, sha1_key=key1
+ )
self.vpp_session.add_vpp_config()
self.test_session = BFDTestSession(
- self, self.pg0, AF_INET, sha1_key=key1,
- bfd_key_id=self.vpp_session.bfd_key_id)
+ self,
+ self.pg0,
+ AF_INET,
+ sha1_key=key1,
+ bfd_key_id=self.vpp_session.bfd_key_id,
+ )
bfd_session_up(self)
for dummy in range(self.test_session.detect_mult * 2):
p = wait_for_bfd_packet(self)
self.assert_equal(p[BFD].state, BFDState.up, BFDState)
self.test_session.send_packet()
self.assert_equal(self.vpp_session.state, BFDState.up, BFDState)
- self.assert_equal(len(self.vapi.collect_events()), 0,
- "number of bfd events")
+ self.assert_equal(len(self.vapi.collect_events()), 0, "number of bfd events")
def test_auth_on_delayed(self):
- """ turn auth on without disturbing session state (delayed) """
+ """turn auth on without disturbing session state (delayed)"""
key = self.factory.create_random_key(self)
key.add_vpp_config()
- self.vpp_session = VppBFDUDPSession(self, self.pg0,
- self.pg0.remote_ip4)
+ self.vpp_session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4)
self.vpp_session.add_vpp_config()
self.test_session = BFDTestSession(self, self.pg0, AF_INET)
bfd_session_up(self)
self.assert_equal(p[BFD].state, BFDState.up, BFDState)
self.test_session.send_packet()
self.assert_equal(self.vpp_session.state, BFDState.up, BFDState)
- self.assert_equal(len(self.vapi.collect_events()), 0,
- "number of bfd events")
+ self.assert_equal(len(self.vapi.collect_events()), 0, "number of bfd events")
def test_auth_off_delayed(self):
- """ turn auth off without disturbing session state (delayed) """
+ """turn auth off without disturbing session state (delayed)"""
key = self.factory.create_random_key(self)
key.add_vpp_config()
- self.vpp_session = VppBFDUDPSession(self, self.pg0,
- self.pg0.remote_ip4, sha1_key=key)
+ self.vpp_session = VppBFDUDPSession(
+ self, self.pg0, self.pg0.remote_ip4, sha1_key=key
+ )
self.vpp_session.add_vpp_config()
self.test_session = BFDTestSession(
- self, self.pg0, AF_INET, sha1_key=key,
- bfd_key_id=self.vpp_session.bfd_key_id)
+ self,
+ self.pg0,
+ AF_INET,
+ sha1_key=key,
+ bfd_key_id=self.vpp_session.bfd_key_id,
+ )
bfd_session_up(self)
for dummy in range(self.test_session.detect_mult * 2):
p = wait_for_bfd_packet(self)
self.assert_equal(p[BFD].state, BFDState.up, BFDState)
self.test_session.send_packet()
self.assert_equal(self.vpp_session.state, BFDState.up, BFDState)
- self.assert_equal(len(self.vapi.collect_events()), 0,
- "number of bfd events")
+ self.assert_equal(len(self.vapi.collect_events()), 0, "number of bfd events")
def test_auth_change_key_delayed(self):
- """ change auth key without disturbing session state (delayed) """
+ """change auth key without disturbing session state (delayed)"""
key1 = self.factory.create_random_key(self)
key1.add_vpp_config()
key2 = self.factory.create_random_key(self)
key2.add_vpp_config()
- self.vpp_session = VppBFDUDPSession(self, self.pg0,
- self.pg0.remote_ip4, sha1_key=key1)
+ self.vpp_session = VppBFDUDPSession(
+ self, self.pg0, self.pg0.remote_ip4, sha1_key=key1
+ )
self.vpp_session.add_vpp_config()
self.vpp_session.admin_up()
self.test_session = BFDTestSession(
- self, self.pg0, AF_INET, sha1_key=key1,
- bfd_key_id=self.vpp_session.bfd_key_id)
+ self,
+ self.pg0,
+ AF_INET,
+ sha1_key=key1,
+ bfd_key_id=self.vpp_session.bfd_key_id,
+ )
bfd_session_up(self)
for dummy in range(self.test_session.detect_mult * 2):
p = wait_for_bfd_packet(self)
self.assert_equal(p[BFD].state, BFDState.up, BFDState)
self.test_session.send_packet()
self.assert_equal(self.vpp_session.state, BFDState.up, BFDState)
- self.assert_equal(len(self.vapi.collect_events()), 0,
- "number of bfd events")
+ self.assert_equal(len(self.vapi.collect_events()), 0, "number of bfd events")
@tag_run_solo
class BFDCLITestCase(VppTestCase):
- """Bidirectional Forwarding Detection (BFD) (CLI) """
+ """Bidirectional Forwarding Detection (BFD) (CLI)"""
+
pg0 = None
@classmethod
super(BFDCLITestCase, self).tearDown()
def cli_verify_no_response(self, cli):
- """ execute a CLI, asserting that the response is empty """
- self.assert_equal(self.vapi.cli(cli),
- "",
- "CLI command response")
+ """execute a CLI, asserting that the response is empty"""
+ self.assert_equal(self.vapi.cli(cli), "", "CLI command response")
def cli_verify_response(self, cli, expected):
- """ execute a CLI, asserting that the response matches expectation """
+ """execute a CLI, asserting that the response matches expectation"""
try:
reply = self.vapi.cli(cli)
except CliFailedCommandError as cli_error:
reply = str(cli_error)
- self.assert_equal(reply.strip(),
- expected,
- "CLI command response")
+ self.assert_equal(reply.strip(), expected, "CLI command response")
def test_show(self):
- """ show commands """
+ """show commands"""
k1 = self.factory.create_random_key(self)
k1.add_vpp_config()
k2 = self.factory.create_random_key(
- self, auth_type=BFDAuthType.meticulous_keyed_sha1)
+ self, auth_type=BFDAuthType.meticulous_keyed_sha1
+ )
k2.add_vpp_config()
s1 = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4)
s1.add_vpp_config()
- s2 = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip6, af=AF_INET6,
- sha1_key=k2)
+ s2 = VppBFDUDPSession(
+ self, self.pg0, self.pg0.remote_ip6, af=AF_INET6, sha1_key=k2
+ )
s2.add_vpp_config()
self.logger.info(self.vapi.ppcli("show bfd keys"))
self.logger.info(self.vapi.ppcli("show bfd sessions"))
self.logger.info(self.vapi.ppcli("show bfd"))
def test_set_del_sha1_key(self):
- """ set/delete SHA1 auth key """
+ """set/delete SHA1 auth key"""
k = self.factory.create_random_key(self)
self.registry.register(k, self.logger)
self.cli_verify_no_response(
- "bfd key set conf-key-id %s type keyed-sha1 secret %s" %
- (k.conf_key_id,
- "".join("{:02x}".format(scapy.compat.orb(c)) for c in k.key)))
+ "bfd key set conf-key-id %s type keyed-sha1 secret %s"
+ % (
+ k.conf_key_id,
+ "".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)
+ self, self.pg0, self.pg0.remote_ip4, sha1_key=k
+ )
self.vpp_session.add_vpp_config()
- self.test_session = \
- BFDTestSession(self, self.pg0, AF_INET, sha1_key=k,
- bfd_key_id=self.vpp_session.bfd_key_id)
+ self.test_session = BFDTestSession(
+ self, self.pg0, AF_INET, sha1_key=k, bfd_key_id=self.vpp_session.bfd_key_id
+ )
self.vapi.want_bfd_events()
bfd_session_up(self)
bfd_session_down(self)
# is in-use
k2 = self.factory.create_random_key(self)
self.cli_verify_response(
- "bfd key set conf-key-id %s type keyed-sha1 secret %s" %
- (k.conf_key_id,
- "".join("{:02x}".format(scapy.compat.orb(c)) for c in k2.key)),
+ "bfd key set conf-key-id %s type keyed-sha1 secret %s"
+ % (
+ k.conf_key_id,
+ "".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")
+ "rv=-103:BFD object in use",
+ )
# manipulating the session using old secret should still work
bfd_session_up(self)
bfd_session_down(self)
self.vpp_session.remove_vpp_config()
- self.cli_verify_no_response(
- "bfd key del conf-key-id %s" % k.conf_key_id)
+ self.cli_verify_no_response("bfd key del conf-key-id %s" % k.conf_key_id)
self.assertFalse(k.query_vpp_config())
def test_set_del_meticulous_sha1_key(self):
- """ set/delete meticulous SHA1 auth key """
+ """set/delete meticulous SHA1 auth key"""
k = self.factory.create_random_key(
- self, auth_type=BFDAuthType.meticulous_keyed_sha1)
+ self, auth_type=BFDAuthType.meticulous_keyed_sha1
+ )
self.registry.register(k, self.logger)
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(scapy.compat.orb(c)) for c in k.key)))
+ "bfd key set conf-key-id %s type meticulous-keyed-sha1 secret %s"
+ % (
+ k.conf_key_id,
+ "".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,
- sha1_key=k)
+ self.vpp_session = VppBFDUDPSession(
+ self, self.pg0, self.pg0.remote_ip6, af=AF_INET6, sha1_key=k
+ )
self.vpp_session.add_vpp_config()
self.vpp_session.admin_up()
- self.test_session = \
- BFDTestSession(self, self.pg0, AF_INET6, sha1_key=k,
- bfd_key_id=self.vpp_session.bfd_key_id)
+ self.test_session = BFDTestSession(
+ self, self.pg0, AF_INET6, sha1_key=k, bfd_key_id=self.vpp_session.bfd_key_id
+ )
self.vapi.want_bfd_events()
bfd_session_up(self)
bfd_session_down(self)
# is in-use
k2 = self.factory.create_random_key(self)
self.cli_verify_response(
- "bfd key set conf-key-id %s type keyed-sha1 secret %s" %
- (k.conf_key_id,
- "".join("{:02x}".format(scapy.compat.orb(c)) for c in k2.key)),
+ "bfd key set conf-key-id %s type keyed-sha1 secret %s"
+ % (
+ k.conf_key_id,
+ "".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")
+ "rv=-103:BFD object in use",
+ )
# manipulating the session using old secret should still work
bfd_session_up(self)
bfd_session_down(self)
self.vpp_session.remove_vpp_config()
- self.cli_verify_no_response(
- "bfd key del conf-key-id %s" % k.conf_key_id)
+ self.cli_verify_no_response("bfd key del conf-key-id %s" % k.conf_key_id)
self.assertFalse(k.query_vpp_config())
def test_add_mod_del_bfd_udp(self):
- """ create/modify/delete IPv4 BFD UDP session """
- vpp_session = VppBFDUDPSession(
- self, self.pg0, self.pg0.remote_ip4)
+ """create/modify/delete IPv4 BFD UDP session"""
+ vpp_session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4)
self.registry.register(vpp_session, self.logger)
- cli_add_cmd = "bfd udp session add interface %s local-addr %s " \
- "peer-addr %s desired-min-tx %s required-min-rx %s "\
- "detect-mult %s" % (self.pg0.name, self.pg0.local_ip4,
- self.pg0.remote_ip4,
- vpp_session.desired_min_tx,
- vpp_session.required_min_rx,
- vpp_session.detect_mult)
+ cli_add_cmd = (
+ "bfd udp session add interface %s local-addr %s "
+ "peer-addr %s desired-min-tx %s required-min-rx %s "
+ "detect-mult %s"
+ % (
+ self.pg0.name,
+ self.pg0.local_ip4,
+ self.pg0.remote_ip4,
+ vpp_session.desired_min_tx,
+ vpp_session.required_min_rx,
+ vpp_session.detect_mult,
+ )
+ )
self.cli_verify_no_response(cli_add_cmd)
# 2nd add should fail
self.cli_verify_response(
cli_add_cmd,
"bfd udp session add: `bfd_add_add_session' API call"
- " failed, rv=-101:Duplicate BFD object")
+ " failed, rv=-101:Duplicate BFD object",
+ )
verify_bfd_session_config(self, vpp_session)
mod_session = VppBFDUDPSession(
- self, self.pg0, self.pg0.remote_ip4,
+ self,
+ self.pg0,
+ self.pg0.remote_ip4,
required_min_rx=2 * vpp_session.required_min_rx,
desired_min_tx=3 * vpp_session.desired_min_tx,
- detect_mult=4 * vpp_session.detect_mult)
+ detect_mult=4 * vpp_session.detect_mult,
+ )
self.cli_verify_no_response(
"bfd udp session mod interface %s local-addr %s peer-addr %s "
- "desired-min-tx %s required-min-rx %s detect-mult %s" %
- (self.pg0.name, self.pg0.local_ip4, self.pg0.remote_ip4,
- mod_session.desired_min_tx, mod_session.required_min_rx,
- mod_session.detect_mult))
+ "desired-min-tx %s required-min-rx %s detect-mult %s"
+ % (
+ self.pg0.name,
+ self.pg0.local_ip4,
+ self.pg0.remote_ip4,
+ mod_session.desired_min_tx,
+ mod_session.required_min_rx,
+ mod_session.detect_mult,
+ )
+ )
verify_bfd_session_config(self, mod_session)
- cli_del_cmd = "bfd udp session del interface %s local-addr %s "\
- "peer-addr %s" % (self.pg0.name,
- self.pg0.local_ip4, self.pg0.remote_ip4)
+ cli_del_cmd = (
+ "bfd udp session del interface %s local-addr %s "
+ "peer-addr %s" % (self.pg0.name, self.pg0.local_ip4, self.pg0.remote_ip4)
+ )
self.cli_verify_no_response(cli_del_cmd)
# 2nd del is expected to fail
self.cli_verify_response(
- cli_del_cmd, "bfd udp session del: `bfd_udp_del_session' API call"
- " failed, rv=-102:No such BFD object")
+ cli_del_cmd,
+ "bfd udp session del: `bfd_udp_del_session' API call"
+ " failed, rv=-102:No such BFD object",
+ )
self.assertFalse(vpp_session.query_vpp_config())
def test_add_mod_del_bfd_udp6(self):
- """ create/modify/delete IPv6 BFD UDP session """
- vpp_session = VppBFDUDPSession(
- self, self.pg0, self.pg0.remote_ip6, af=AF_INET6)
+ """create/modify/delete IPv6 BFD UDP session"""
+ vpp_session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip6, af=AF_INET6)
self.registry.register(vpp_session, self.logger)
- cli_add_cmd = "bfd udp session add interface %s local-addr %s " \
- "peer-addr %s desired-min-tx %s required-min-rx %s "\
- "detect-mult %s" % (self.pg0.name, self.pg0.local_ip6,
- self.pg0.remote_ip6,
- vpp_session.desired_min_tx,
- vpp_session.required_min_rx,
- vpp_session.detect_mult)
+ cli_add_cmd = (
+ "bfd udp session add interface %s local-addr %s "
+ "peer-addr %s desired-min-tx %s required-min-rx %s "
+ "detect-mult %s"
+ % (
+ self.pg0.name,
+ self.pg0.local_ip6,
+ self.pg0.remote_ip6,
+ vpp_session.desired_min_tx,
+ vpp_session.required_min_rx,
+ vpp_session.detect_mult,
+ )
+ )
self.cli_verify_no_response(cli_add_cmd)
# 2nd add should fail
self.cli_verify_response(
cli_add_cmd,
"bfd udp session add: `bfd_add_add_session' API call"
- " failed, rv=-101:Duplicate BFD object")
+ " failed, rv=-101:Duplicate BFD object",
+ )
verify_bfd_session_config(self, vpp_session)
mod_session = VppBFDUDPSession(
- self, self.pg0, self.pg0.remote_ip6, af=AF_INET6,
+ self,
+ self.pg0,
+ self.pg0.remote_ip6,
+ af=AF_INET6,
required_min_rx=2 * vpp_session.required_min_rx,
desired_min_tx=3 * vpp_session.desired_min_tx,
- detect_mult=4 * vpp_session.detect_mult)
+ detect_mult=4 * vpp_session.detect_mult,
+ )
self.cli_verify_no_response(
"bfd udp session mod interface %s local-addr %s peer-addr %s "
- "desired-min-tx %s required-min-rx %s detect-mult %s" %
- (self.pg0.name, self.pg0.local_ip6, self.pg0.remote_ip6,
- mod_session.desired_min_tx,
- mod_session.required_min_rx, mod_session.detect_mult))
+ "desired-min-tx %s required-min-rx %s detect-mult %s"
+ % (
+ self.pg0.name,
+ self.pg0.local_ip6,
+ self.pg0.remote_ip6,
+ mod_session.desired_min_tx,
+ mod_session.required_min_rx,
+ mod_session.detect_mult,
+ )
+ )
verify_bfd_session_config(self, mod_session)
- cli_del_cmd = "bfd udp session del interface %s local-addr %s "\
- "peer-addr %s" % (self.pg0.name,
- self.pg0.local_ip6, self.pg0.remote_ip6)
+ cli_del_cmd = (
+ "bfd udp session del interface %s local-addr %s "
+ "peer-addr %s" % (self.pg0.name, self.pg0.local_ip6, self.pg0.remote_ip6)
+ )
self.cli_verify_no_response(cli_del_cmd)
# 2nd del is expected to fail
self.cli_verify_response(
cli_del_cmd,
"bfd udp session del: `bfd_udp_del_session' API call"
- " failed, rv=-102:No such BFD object")
+ " failed, rv=-102:No such BFD object",
+ )
self.assertFalse(vpp_session.query_vpp_config())
def test_add_mod_del_bfd_udp_auth(self):
- """ create/modify/delete IPv4 BFD UDP session (authenticated) """
+ """create/modify/delete IPv4 BFD UDP session (authenticated)"""
key = self.factory.create_random_key(self)
key.add_vpp_config()
vpp_session = VppBFDUDPSession(
- self, self.pg0, self.pg0.remote_ip4, sha1_key=key)
+ self, self.pg0, self.pg0.remote_ip4, sha1_key=key
+ )
self.registry.register(vpp_session, self.logger)
- cli_add_cmd = "bfd udp session add interface %s local-addr %s " \
- "peer-addr %s desired-min-tx %s required-min-rx %s "\
- "detect-mult %s conf-key-id %s bfd-key-id %s"\
- % (self.pg0.name, self.pg0.local_ip4, self.pg0.remote_ip4,
- vpp_session.desired_min_tx, vpp_session.required_min_rx,
- vpp_session.detect_mult, key.conf_key_id,
- vpp_session.bfd_key_id)
+ cli_add_cmd = (
+ "bfd udp session add interface %s local-addr %s "
+ "peer-addr %s desired-min-tx %s required-min-rx %s "
+ "detect-mult %s conf-key-id %s bfd-key-id %s"
+ % (
+ self.pg0.name,
+ self.pg0.local_ip4,
+ self.pg0.remote_ip4,
+ vpp_session.desired_min_tx,
+ vpp_session.required_min_rx,
+ vpp_session.detect_mult,
+ key.conf_key_id,
+ vpp_session.bfd_key_id,
+ )
+ )
self.cli_verify_no_response(cli_add_cmd)
# 2nd add should fail
self.cli_verify_response(
cli_add_cmd,
"bfd udp session add: `bfd_add_add_session' API call"
- " failed, rv=-101:Duplicate BFD object")
+ " failed, rv=-101:Duplicate BFD object",
+ )
verify_bfd_session_config(self, vpp_session)
mod_session = VppBFDUDPSession(
- self, self.pg0, self.pg0.remote_ip4, sha1_key=key,
+ self,
+ self.pg0,
+ self.pg0.remote_ip4,
+ sha1_key=key,
bfd_key_id=vpp_session.bfd_key_id,
required_min_rx=2 * vpp_session.required_min_rx,
desired_min_tx=3 * vpp_session.desired_min_tx,
- detect_mult=4 * vpp_session.detect_mult)
+ detect_mult=4 * vpp_session.detect_mult,
+ )
self.cli_verify_no_response(
"bfd udp session mod interface %s local-addr %s peer-addr %s "
- "desired-min-tx %s required-min-rx %s detect-mult %s" %
- (self.pg0.name, self.pg0.local_ip4, self.pg0.remote_ip4,
- mod_session.desired_min_tx,
- mod_session.required_min_rx, mod_session.detect_mult))
+ "desired-min-tx %s required-min-rx %s detect-mult %s"
+ % (
+ self.pg0.name,
+ self.pg0.local_ip4,
+ self.pg0.remote_ip4,
+ mod_session.desired_min_tx,
+ mod_session.required_min_rx,
+ mod_session.detect_mult,
+ )
+ )
verify_bfd_session_config(self, mod_session)
- cli_del_cmd = "bfd udp session del interface %s local-addr %s "\
- "peer-addr %s" % (self.pg0.name,
- self.pg0.local_ip4, self.pg0.remote_ip4)
+ cli_del_cmd = (
+ "bfd udp session del interface %s local-addr %s "
+ "peer-addr %s" % (self.pg0.name, self.pg0.local_ip4, self.pg0.remote_ip4)
+ )
self.cli_verify_no_response(cli_del_cmd)
# 2nd del is expected to fail
self.cli_verify_response(
cli_del_cmd,
"bfd udp session del: `bfd_udp_del_session' API call"
- " failed, rv=-102:No such BFD object")
+ " failed, rv=-102:No such BFD object",
+ )
self.assertFalse(vpp_session.query_vpp_config())
def test_add_mod_del_bfd_udp6_auth(self):
- """ create/modify/delete IPv6 BFD UDP session (authenticated) """
+ """create/modify/delete IPv6 BFD UDP session (authenticated)"""
key = self.factory.create_random_key(
- self, auth_type=BFDAuthType.meticulous_keyed_sha1)
+ self, auth_type=BFDAuthType.meticulous_keyed_sha1
+ )
key.add_vpp_config()
vpp_session = VppBFDUDPSession(
- self, self.pg0, self.pg0.remote_ip6, af=AF_INET6, sha1_key=key)
+ self, self.pg0, self.pg0.remote_ip6, af=AF_INET6, sha1_key=key
+ )
self.registry.register(vpp_session, self.logger)
- cli_add_cmd = "bfd udp session add interface %s local-addr %s " \
- "peer-addr %s desired-min-tx %s required-min-rx %s "\
- "detect-mult %s conf-key-id %s bfd-key-id %s" \
- % (self.pg0.name, self.pg0.local_ip6, self.pg0.remote_ip6,
- vpp_session.desired_min_tx, vpp_session.required_min_rx,
- vpp_session.detect_mult, key.conf_key_id,
- vpp_session.bfd_key_id)
+ cli_add_cmd = (
+ "bfd udp session add interface %s local-addr %s "
+ "peer-addr %s desired-min-tx %s required-min-rx %s "
+ "detect-mult %s conf-key-id %s bfd-key-id %s"
+ % (
+ self.pg0.name,
+ self.pg0.local_ip6,
+ self.pg0.remote_ip6,
+ vpp_session.desired_min_tx,
+ vpp_session.required_min_rx,
+ vpp_session.detect_mult,
+ key.conf_key_id,
+ vpp_session.bfd_key_id,
+ )
+ )
self.cli_verify_no_response(cli_add_cmd)
# 2nd add should fail
self.cli_verify_response(
cli_add_cmd,
"bfd udp session add: `bfd_add_add_session' API call"
- " failed, rv=-101:Duplicate BFD object")
+ " failed, rv=-101:Duplicate BFD object",
+ )
verify_bfd_session_config(self, vpp_session)
mod_session = VppBFDUDPSession(
- self, self.pg0, self.pg0.remote_ip6, af=AF_INET6, sha1_key=key,
+ self,
+ self.pg0,
+ self.pg0.remote_ip6,
+ af=AF_INET6,
+ sha1_key=key,
bfd_key_id=vpp_session.bfd_key_id,
required_min_rx=2 * vpp_session.required_min_rx,
desired_min_tx=3 * vpp_session.desired_min_tx,
- detect_mult=4 * vpp_session.detect_mult)
+ detect_mult=4 * vpp_session.detect_mult,
+ )
self.cli_verify_no_response(
"bfd udp session mod interface %s local-addr %s peer-addr %s "
- "desired-min-tx %s required-min-rx %s detect-mult %s" %
- (self.pg0.name, self.pg0.local_ip6, self.pg0.remote_ip6,
- mod_session.desired_min_tx,
- mod_session.required_min_rx, mod_session.detect_mult))
+ "desired-min-tx %s required-min-rx %s detect-mult %s"
+ % (
+ self.pg0.name,
+ self.pg0.local_ip6,
+ self.pg0.remote_ip6,
+ mod_session.desired_min_tx,
+ mod_session.required_min_rx,
+ mod_session.detect_mult,
+ )
+ )
verify_bfd_session_config(self, mod_session)
- cli_del_cmd = "bfd udp session del interface %s local-addr %s "\
- "peer-addr %s" % (self.pg0.name,
- self.pg0.local_ip6, self.pg0.remote_ip6)
+ cli_del_cmd = (
+ "bfd udp session del interface %s local-addr %s "
+ "peer-addr %s" % (self.pg0.name, self.pg0.local_ip6, self.pg0.remote_ip6)
+ )
self.cli_verify_no_response(cli_del_cmd)
# 2nd del is expected to fail
self.cli_verify_response(
cli_del_cmd,
"bfd udp session del: `bfd_udp_del_session' API call"
- " failed, rv=-102:No such BFD object")
+ " failed, rv=-102:No such BFD object",
+ )
self.assertFalse(vpp_session.query_vpp_config())
def test_auth_on_off(self):
- """ turn authentication on and off """
+ """turn authentication on and off"""
key = self.factory.create_random_key(
- self, auth_type=BFDAuthType.meticulous_keyed_sha1)
+ self, auth_type=BFDAuthType.meticulous_keyed_sha1
+ )
key.add_vpp_config()
session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4)
- auth_session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4,
- sha1_key=key)
+ auth_session = VppBFDUDPSession(
+ self, self.pg0, self.pg0.remote_ip4, sha1_key=key
+ )
session.add_vpp_config()
- cli_activate = \
- "bfd udp session auth activate interface %s local-addr %s "\
- "peer-addr %s conf-key-id %s bfd-key-id %s"\
- % (self.pg0.name, self.pg0.local_ip4, self.pg0.remote_ip4,
- key.conf_key_id, auth_session.bfd_key_id)
+ cli_activate = (
+ "bfd udp session auth activate interface %s local-addr %s "
+ "peer-addr %s conf-key-id %s bfd-key-id %s"
+ % (
+ self.pg0.name,
+ self.pg0.local_ip4,
+ self.pg0.remote_ip4,
+ key.conf_key_id,
+ auth_session.bfd_key_id,
+ )
+ )
self.cli_verify_no_response(cli_activate)
verify_bfd_session_config(self, auth_session)
self.cli_verify_no_response(cli_activate)
verify_bfd_session_config(self, auth_session)
- cli_deactivate = \
- "bfd udp session auth deactivate interface %s local-addr %s "\
- "peer-addr %s "\
- % (self.pg0.name, self.pg0.local_ip4, self.pg0.remote_ip4)
+ cli_deactivate = (
+ "bfd udp session auth deactivate interface %s local-addr %s "
+ "peer-addr %s " % (self.pg0.name, self.pg0.local_ip4, self.pg0.remote_ip4)
+ )
self.cli_verify_no_response(cli_deactivate)
verify_bfd_session_config(self, session)
self.cli_verify_no_response(cli_deactivate)
verify_bfd_session_config(self, session)
def test_auth_on_off_delayed(self):
- """ turn authentication on and off (delayed) """
+ """turn authentication on and off (delayed)"""
key = self.factory.create_random_key(
- self, auth_type=BFDAuthType.meticulous_keyed_sha1)
+ self, auth_type=BFDAuthType.meticulous_keyed_sha1
+ )
key.add_vpp_config()
session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4)
- auth_session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4,
- sha1_key=key)
+ auth_session = VppBFDUDPSession(
+ self, self.pg0, self.pg0.remote_ip4, sha1_key=key
+ )
session.add_vpp_config()
- cli_activate = \
- "bfd udp session auth activate interface %s local-addr %s "\
- "peer-addr %s conf-key-id %s bfd-key-id %s delayed yes"\
- % (self.pg0.name, self.pg0.local_ip4, self.pg0.remote_ip4,
- key.conf_key_id, auth_session.bfd_key_id)
+ cli_activate = (
+ "bfd udp session auth activate interface %s local-addr %s "
+ "peer-addr %s conf-key-id %s bfd-key-id %s delayed yes"
+ % (
+ self.pg0.name,
+ self.pg0.local_ip4,
+ self.pg0.remote_ip4,
+ key.conf_key_id,
+ auth_session.bfd_key_id,
+ )
+ )
self.cli_verify_no_response(cli_activate)
verify_bfd_session_config(self, auth_session)
self.cli_verify_no_response(cli_activate)
verify_bfd_session_config(self, auth_session)
- cli_deactivate = \
- "bfd udp session auth deactivate interface %s local-addr %s "\
- "peer-addr %s delayed yes"\
+ cli_deactivate = (
+ "bfd udp session auth deactivate interface %s local-addr %s "
+ "peer-addr %s delayed yes"
% (self.pg0.name, self.pg0.local_ip4, self.pg0.remote_ip4)
+ )
self.cli_verify_no_response(cli_deactivate)
verify_bfd_session_config(self, session)
self.cli_verify_no_response(cli_deactivate)
verify_bfd_session_config(self, session)
def test_admin_up_down(self):
- """ put session admin-up and admin-down """
+ """put session admin-up and admin-down"""
session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4)
session.add_vpp_config()
- cli_down = \
- "bfd udp session set-flags admin down interface %s local-addr %s "\
- "peer-addr %s "\
- % (self.pg0.name, self.pg0.local_ip4, self.pg0.remote_ip4)
- cli_up = \
- "bfd udp session set-flags admin up interface %s local-addr %s "\
- "peer-addr %s "\
- % (self.pg0.name, self.pg0.local_ip4, self.pg0.remote_ip4)
+ cli_down = (
+ "bfd udp session set-flags admin down interface %s local-addr %s "
+ "peer-addr %s " % (self.pg0.name, self.pg0.local_ip4, self.pg0.remote_ip4)
+ )
+ cli_up = (
+ "bfd udp session set-flags admin up interface %s local-addr %s "
+ "peer-addr %s " % (self.pg0.name, self.pg0.local_ip4, self.pg0.remote_ip4)
+ )
self.cli_verify_no_response(cli_down)
verify_bfd_session_config(self, session, state=BFDState.admin_down)
self.cli_verify_no_response(cli_up)
verify_bfd_session_config(self, session, state=BFDState.down)
def test_set_del_udp_echo_source(self):
- """ set/del udp echo source """
+ """set/del udp echo source"""
self.create_loopback_interfaces(1)
self.loopback0 = self.lo_interfaces[0]
self.loopback0.admin_up()
- self.cli_verify_response("show bfd echo-source",
- "UDP echo source is not set.")
+ self.cli_verify_response("show bfd echo-source", "UDP echo source is not set.")
cli_set = "bfd udp echo-source set interface %s" % self.loopback0.name
self.cli_verify_no_response(cli_set)
- self.cli_verify_response("show bfd echo-source",
- "UDP echo source is: %s\n"
- "IPv4 address usable as echo source: none\n"
- "IPv6 address usable as echo source: none" %
- self.loopback0.name)
+ self.cli_verify_response(
+ "show bfd echo-source",
+ "UDP echo source is: %s\n"
+ "IPv4 address usable as echo source: none\n"
+ "IPv6 address usable as echo source: none" % self.loopback0.name,
+ )
self.loopback0.config_ip4()
- 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))
- echo_ip6 = str(ipaddress.IPv6Address(int(ipaddress.IPv6Address(
- self.loopback0.local_ip6)) ^ 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),
+ )
+ 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"
- "IPv4 address usable as echo source: %s\n"
- "IPv6 address usable as echo source: %s" %
- (self.loopback0.name, echo_ip4, echo_ip6))
+ 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: %s"
+ % (self.loopback0.name, echo_ip4, echo_ip6),
+ )
cli_del = "bfd udp echo-source del"
self.cli_verify_no_response(cli_del)
- self.cli_verify_response("show bfd echo-source",
- "UDP echo source is not set.")
+ self.cli_verify_response("show bfd echo-source", "UDP echo source is not set.")
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main(testRunner=VppTestRunner)
Code Review / vpp.git / blobdiff