Perform accounting of expected packets based on created packet infos.
Use this accounting info to automatically expect (and verify) the
correct number of packets to be captured. Automatically retry the read
of the capture file if scapy raises an exception while doing so to
handle rare cases when capture file is read while only partially
written during busy wait. Don't fail assert_nothing_captured if only
junk packets arrived.
Change-Id: I16ec2e9410ef510d313ec16b7e13c57d0b2a63f5
Signed-off-by: Klement Sekera <ksekera@cisco.com>
from inspect import getdoc
from hook import StepHook, PollHook
from vpp_pg_interface import VppPGInterface
+from vpp_sub_interface import VppSubInterface
from vpp_lo_interface import VppLoInterface
from vpp_papi_provider import VppPapiProvider
from scapy.packet import Raw
"""List of packet infos"""
return self._packet_infos
- @packet_infos.setter
- def packet_infos(self, value):
- self._packet_infos = value
+ @classmethod
+ def get_packet_count_for_if_idx(cls, dst_if_index):
+ """Get the number of packet info for specified destination if index"""
+ if dst_if_index in cls._packet_count_for_dst_if_idx:
+ return cls._packet_count_for_dst_if_idx[dst_if_index]
+ else:
+ return 0
@classmethod
def instance(cls):
cls.logger.info("Temporary dir is %s, shm prefix is %s",
cls.tempdir, cls.shm_prefix)
cls.setUpConstants()
+ cls.reset_packet_infos()
cls._captures = []
cls._zombie_captures = []
- cls.packet_infos = {}
cls.verbose = 0
cls.vpp_dead = False
print(double_line_delim)
if extend > 0:
packet[Raw].load += ' ' * extend
- def add_packet_info_to_list(self, info):
- """
- Add packet info to the testcase's packet info list
-
- :param info: packet info
-
- """
- info.index = len(self.packet_infos)
- self.packet_infos[info.index] = info
+ @classmethod
+ def reset_packet_infos(cls):
+ """ Reset the list of packet info objects and packet counts to zero """
+ cls._packet_infos = {}
+ cls._packet_count_for_dst_if_idx = {}
- def create_packet_info(self, src_pg_index, dst_pg_index):
+ @classmethod
+ def create_packet_info(cls, src_if, dst_if):
"""
Create packet info object containing the source and destination indexes
and add it to the testcase's packet info list
- :param src_pg_index: source packet-generator index
- :param dst_pg_index: destination packet-generator index
+ :param VppInterface src_if: source interface
+ :param VppInterface dst_if: destination interface
:returns: _PacketInfo object
"""
info = _PacketInfo()
- self.add_packet_info_to_list(info)
- info.src = src_pg_index
- info.dst = dst_pg_index
+ info.index = len(cls._packet_infos)
+ info.src = src_if.sw_if_index
+ info.dst = dst_if.sw_if_index
+ if isinstance(dst_if, VppSubInterface):
+ dst_idx = dst_if.parent.sw_if_index
+ else:
+ dst_idx = dst_if.sw_if_index
+ if dst_idx in cls._packet_count_for_dst_if_idx:
+ cls._packet_count_for_dst_if_idx[dst_idx] += 1
+ else:
+ cls._packet_count_for_dst_if_idx[dst_idx] = 1
+ cls._packet_infos[info.index] = info
return info
@staticmethod
next_index = 0
else:
next_index = info.index + 1
- if next_index == len(self.packet_infos):
+ if next_index == len(self._packet_infos):
return None
else:
- return self.packet_infos[next_index]
+ return self._packet_infos[next_index]
def get_next_packet_info_for_interface(self, src_index, info):
"""
self.pg_start()
# Pick first received frame and check if it's the non-encapsulated frame
- out = self.pg1.get_capture()
- self.assertEqual(len(out), 1,
- 'Invalid number of packets on '
- 'output: {}'.format(len(out)))
+ out = self.pg1.get_capture(1)
pkt = out[0]
# TODO: add error messages
self.pg_start()
# Pick first received frame and check if it's corectly encapsulated.
- out = self.pg0.get_capture()
- self.assertEqual(len(out), 1,
- 'Invalid number of packets on '
- 'output: {}'.format(len(out)))
+ out = self.pg0.get_capture(1)
pkt = out[0]
self.check_encapsulation(pkt)
self.pg_enable_capture([self.pg0])
expected_packets = 3
self.logger.info("BFD: Waiting for %d BFD packets" % expected_packets)
- self.wait_for_bfd_packet()
+ self.wait_for_bfd_packet(2)
for i in range(expected_packets):
before = time.time()
- self.wait_for_bfd_packet()
+ self.wait_for_bfd_packet(2)
after = time.time()
# spec says the range should be <0.75, 1>, allow extra 0.05 margin
# to work around timing issues
def test_zero_remote_min_rx(self):
""" no packets when zero BFD RemoteMinRxInterval """
self.pg_enable_capture([self.pg0])
- p = self.wait_for_bfd_packet()
+ p = self.wait_for_bfd_packet(2)
self.test_session.update(my_discriminator=randint(0, 40000000),
your_discriminator=p[BFD].my_discriminator,
state=BFDState.init,
def bfd_session_up(self):
self.pg_enable_capture([self.pg0])
self.logger.info("BFD: Waiting for slow hello")
- p = self.wait_for_bfd_packet()
+ p = self.wait_for_bfd_packet(2)
self.logger.info("BFD: Sending Init")
self.test_session.update(my_discriminator=randint(0, 40000000),
your_discriminator=p[BFD].my_discriminator,
from scapy.layers.inet import IP, UDP
from util import ppp
+
class TestClassifier(VppTestCase):
""" Classifier Test Case """
"""
pkts = []
for size in packet_sizes:
- info = self.create_packet_info(src_if.sw_if_index,
- dst_if.sw_if_index)
+ info = self.create_packet_info(src_if, dst_if)
payload = self.info_to_payload(info)
p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
IP(src=src_if.remote_ip4, dst=dst_if.remote_ip4) /
:param str dst_port: destination port number <0-ffff>
"""
- return ('{:0>20}{:0>12}{:0>8}{:0>12}{:0>4}'.format(proto, src_ip,
- dst_ip, src_port, dst_port)).rstrip('0')
+ return ('{:0>20}{:0>12}{:0>8}{:0>12}{:0>4}'.format(
+ proto, src_ip, dst_ip, src_port, dst_port)).rstrip('0')
@staticmethod
def build_ip_match(proto='', src_ip='', dst_ip='',
:param str src_port: source port number <0-ffff>
:param str dst_port: destination port number <0-ffff>
"""
- if src_ip: src_ip = socket.inet_aton(src_ip).encode('hex')
- if dst_ip: dst_ip = socket.inet_aton(dst_ip).encode('hex')
+ if src_ip:
+ src_ip = socket.inet_aton(src_ip).encode('hex')
+ if dst_ip:
+ dst_ip = socket.inet_aton(dst_ip).encode('hex')
- return ('{:0>20}{:0>12}{:0>8}{:0>12}{:0>4}'.format(proto, src_ip,
- dst_ip, src_port, dst_port)).rstrip('0')
+ return ('{:0>20}{:0>12}{:0>8}{:0>12}{:0>4}'.format(
+ proto, src_ip, dst_ip, src_port, dst_port)).rstrip('0')
@staticmethod
def build_mac_mask(dst_mac='', src_mac='', ether_type=''):
"""
return ('{:0>12}{:0>12}{:0>4}'.format(dst_mac, src_mac,
- ether_type)).rstrip('0')
+ ether_type)).rstrip('0')
@staticmethod
def build_mac_match(dst_mac='', src_mac='', ether_type=''):
:param str src_mac: destination MAC address <x:x:x:x:x:x>
:param str ether_type: ethernet type <0-ffff>
"""
- if dst_mac: dst_mac = dst_mac.replace(':', '')
- if src_mac: src_mac = src_mac.replace(':', '')
+ if dst_mac:
+ dst_mac = dst_mac.replace(':', '')
+ if src_mac:
+ src_mac = src_mac.replace(':', '')
return ('{:0>12}{:0>12}{:0>4}'.format(dst_mac, src_mac,
- ether_type)).rstrip('0')
+ ether_type)).rstrip('0')
def create_classify_table(self, key, mask, data_offset=0, is_add=1):
"""Create Classify Table
- create(1) or delete(0)
"""
r = self.vapi.classify_add_del_table(
- is_add,
- binascii.unhexlify(mask),
- match_n_vectors=(len(mask)-1)//32 + 1,
- miss_next_index=0,
- current_data_flag=1,
- current_data_offset=data_offset)
+ is_add,
+ binascii.unhexlify(mask),
+ match_n_vectors=(len(mask) - 1) // 32 + 1,
+ miss_next_index=0,
+ current_data_flag=1,
+ current_data_offset=data_offset)
self.assertIsNotNone(r, msg='No response msg for add_del_table')
self.acl_tbl_idx[key] = r.new_table_index
- create(1) or delete(0)
"""
r = self.vapi.classify_add_del_session(
- is_add,
- table_index,
- binascii.unhexlify(match),
- opaque_index=0,
- action=pbr_option,
- metadata=vrfid)
+ is_add,
+ table_index,
+ binascii.unhexlify(match),
+ opaque_index=0,
+ action=pbr_option,
+ metadata=vrfid)
self.assertIsNotNone(r, msg='No response msg for add_del_session')
def input_acl_set_interface(self, intf, table_index, is_add=1):
- enable(1) or disable(0)
"""
r = self.vapi.input_acl_set_interface(
- is_add,
- intf.sw_if_index,
- ip4_table_index=table_index)
+ is_add,
+ intf.sw_if_index,
+ ip4_table_index=table_index)
self.assertIsNotNone(r, msg='No response msg for acl_set_interface')
def test_acl_ip(self):
self.pg0.add_stream(pkts)
self.create_classify_table('ip', self.build_ip_mask(src_ip='ffffffff'))
- self.create_classify_session(self.pg0, self.acl_tbl_idx.get('ip'),
- self.build_ip_match(src_ip=self.pg0.remote_ip4))
+ self.create_classify_session(
+ self.pg0, self.acl_tbl_idx.get('ip'),
+ self.build_ip_match(src_ip=self.pg0.remote_ip4))
self.input_acl_set_interface(self.pg0, self.acl_tbl_idx.get('ip'))
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- pkts = self.pg1.get_capture()
+ pkts = self.pg1.get_capture(len(pkts))
self.verify_capture(self.pg1, pkts)
self.input_acl_set_interface(self.pg0, self.acl_tbl_idx.get('ip'), 0)
self.pg0.assert_nothing_captured(remark="packets forwarded")
pkts = self.create_stream(self.pg0, self.pg2, self.pg_if_packet_sizes)
self.pg0.add_stream(pkts)
- self.create_classify_table('mac',
- self.build_mac_mask(src_mac='ffffffffffff'), data_offset=-14)
- self.create_classify_session(self.pg0, self.acl_tbl_idx.get('mac'),
- self.build_mac_match(src_mac=self.pg0.remote_mac))
+ self.create_classify_table(
+ 'mac', self.build_mac_mask(src_mac='ffffffffffff'), data_offset=-14)
+ self.create_classify_session(
+ self.pg0, self.acl_tbl_idx.get('mac'),
+ self.build_mac_match(src_mac=self.pg0.remote_mac))
self.input_acl_set_interface(self.pg0, self.acl_tbl_idx.get('mac'))
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- pkts = self.pg2.get_capture()
+ pkts = self.pg2.get_capture(len(pkts))
self.verify_capture(self.pg2, pkts)
self.input_acl_set_interface(self.pg0, self.acl_tbl_idx.get('mac'), 0)
self.pg0.assert_nothing_captured(remark="packets forwarded")
self.create_classify_table('pbr', self.build_ip_mask(src_ip='ffffffff'))
pbr_option = 1
- self.create_classify_session(self.pg0, self.acl_tbl_idx.get('pbr'),
- self.build_ip_match(src_ip=self.pg0.remote_ip4),
- pbr_option, self.pbr_vrfid)
+ self.create_classify_session(
+ self.pg0, self.acl_tbl_idx.get('pbr'),
+ self.build_ip_match(src_ip=self.pg0.remote_ip4),
+ pbr_option, self.pbr_vrfid)
self.config_pbr_fib_entry(self.pg3)
self.input_acl_set_interface(self.pg0, self.acl_tbl_idx.get('pbr'))
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- pkts = self.pg3.get_capture()
+ pkts = self.pg3.get_capture(len(pkts))
self.verify_capture(self.pg3, pkts)
self.input_acl_set_interface(self.pg0, self.acl_tbl_idx.get('pbr'), 0)
self.pg0.assert_nothing_captured(remark="packets forwarded")
def create_stream_ip4(self, src_if, src_ip, dst_ip):
pkts = []
for i in range(0, 257):
- info = self.create_packet_info(src_if.sw_if_index,
- src_if.sw_if_index)
+ info = self.create_packet_info(src_if, src_if)
payload = self.info_to_payload(info)
p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
IP(src=src_ip, dst=dst_ip) /
src_ip, dst_ip):
pkts = []
for i in range(0, 257):
- info = self.create_packet_info(src_if.sw_if_index,
- src_if.sw_if_index)
+ info = self.create_packet_info(src_if, src_if)
payload = self.info_to_payload(info)
p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
IP(src=tunnel_src, dst=tunnel_dst) /
src_ip, dst_ip):
pkts = []
for i in range(0, 257):
- info = self.create_packet_info(src_if.sw_if_index,
- src_if.sw_if_index)
+ info = self.create_packet_info(src_if, src_if)
payload = self.info_to_payload(info)
p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
IP(src=tunnel_src, dst=tunnel_dst) /
tunnel_src, tunnel_dst):
pkts = []
for i in range(0, 257):
- info = self.create_packet_info(src_if.sw_if_index,
- src_if.sw_if_index)
+ info = self.create_packet_info(src_if, src_if)
payload = self.info_to_payload(info)
p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
IP(src=tunnel_src, dst=tunnel_dst) /
tunnel_src, tunnel_dst, vlan):
pkts = []
for i in range(0, 257):
- info = self.create_packet_info(src_if.sw_if_index,
- src_if.sw_if_index)
+ info = self.create_packet_info(src_if, src_if)
payload = self.info_to_payload(info)
p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
IP(src=tunnel_src, dst=tunnel_dst) /
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- rx = self.pg0.get_capture()
+ rx = self.pg0.get_capture(len(tx))
self.verify_tunneled_4o4(self.pg0, rx, tx,
self.pg0.local_ip4, "1.1.1.2")
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- rx = self.pg0.get_capture()
+ rx = self.pg0.get_capture(len(tx))
self.verify_decapped_4o4(self.pg0, rx, tx)
#
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- rx = self.pg0.get_capture()
+ rx = self.pg0.get_capture(len(tx))
self.verify_decapped_6o4(self.pg0, rx, tx)
#
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- rx = self.pg1.get_capture()
+ rx = self.pg1.get_capture(len(tx))
self.verify_tunneled_4o4(self.pg1, rx, tx,
self.pg1.local_ip4, "2.2.2.2")
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- rx = self.pg0.get_capture()
+ rx = self.pg0.get_capture(len(tx))
self.verify_decapped_4o4(self.pg0, rx, tx)
#
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- rx = self.pg0.get_capture()
+ rx = self.pg0.get_capture(len(tx))
self.verify_tunneled_l2o4(self.pg0, rx, tx,
self.pg0.local_ip4,
"2.2.2.3")
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- rx = self.pg0.get_capture()
+ rx = self.pg0.get_capture(len(tx))
self.verify_tunneled_l2o4(self.pg0, rx, tx,
self.pg0.local_ip4,
"2.2.2.2")
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- rx = self.pg0.get_capture()
+ rx = self.pg0.get_capture(len(tx))
self.verify_tunneled_vlano4(self.pg0, rx, tx,
self.pg0.local_ip4,
"2.2.2.3",
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- rx = self.pg0.get_capture()
+ rx = self.pg0.get_capture(len(tx))
self.verify_tunneled_vlano4(self.pg0, rx, tx,
self.pg0.local_ip4,
"2.2.2.2",
pkts = []
for i in range(0, 257):
dst_if = self.flows[src_if][i % 2]
- info = self.create_packet_info(
- src_if.sw_if_index, dst_if.sw_if_index)
+ info = self.create_packet_info(src_if, dst_if)
payload = self.info_to_payload(info)
p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
IP(src=src_if.remote_ip4, dst=dst_if.remote_ip4) /
for _ in range(count):
dst_addr = random.choice(dst_ips)
- info = self.create_packet_info(
- src_if.sw_if_index, dst_if.sw_if_index)
+ info = self.create_packet_info(src_if, dst_if)
payload = self.info_to_payload(info)
p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
IP(src=src_if.remote_ip4, dst=dst_addr) /
UDP(sport=1234, dport=1234) /
Raw(payload))
info.data = p.copy()
- size = random.choice(self.pg_if_packet_sizes)
self.extend_packet(p, random.choice(self.pg_if_packet_sizes))
pkts.append(p)
def _find_ip_match(self, find_in, pkt):
for p in find_in:
- if self.payload_to_info(str(p[Raw])) == self.payload_to_info(str(pkt[Raw])):
+ if self.payload_to_info(str(p[Raw])) == \
+ self.payload_to_info(str(pkt[Raw])):
if p[IP].src != pkt[IP].src:
break
if p[IP].dst != pkt[IP].dst:
def setUp(self):
super(TestIPv4FibCrud, self).setUp()
- self.packet_infos = {}
+ self.reset_packet_infos()
def test_1_add_routes(self):
""" Add 1k routes
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- pkts = self.pg0.get_capture()
+ pkts = self.pg0.get_capture(len(self.stream_1) + len(self.stream_2))
self.verify_capture(self.pg0, pkts, self.stream_1 + self.stream_2)
-
def test_2_del_routes(self):
""" Delete 100 routes
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- pkts = self.pg0.get_capture()
+ pkts = self.pg0.get_capture(len(self.stream_1) + len(self.stream_2))
self.verify_capture(self.pg0, pkts, self.stream_1 + self.stream_2)
def test_3_add_new_routes(self):
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- pkts = self.pg0.get_capture()
+ pkts = self.pg0.get_capture(len(self.stream_1) + len(self.stream_2))
self.verify_capture(self.pg0, pkts, self.stream_1 + self.stream_2)
def test_4_del_routes(self):
pkts = []
for i in range(0, 257):
remote_dst_host = choice(dst_ip_if.remote_hosts)
- info = self.create_packet_info(
- src_ip_if.sw_if_index, dst_ip_if.sw_if_index)
+ info = self.create_packet_info(src_ip_if, dst_ip_if)
payload = self.info_to_payload(info)
p = (Ether(dst=src_ip_if.local_mac, src=src_ip_if.remote_mac) /
IP(src=src_ip_if.remote_ip4,
packet_sizes):
pkts = []
for i in range(0, 257):
- info = self.create_packet_info(
- src_ip_if.sw_if_index, dst_ip_if.sw_if_index)
+ info = self.create_packet_info(src_ip_if, dst_ip_if)
payload = self.info_to_payload(info)
host = choice(src_l2_if.remote_hosts)
p = (Ether(src=host.mac,
- dst = src_ip_if.local_mac) /
+ dst=src_ip_if.local_mac) /
IP(src=host.ip4,
dst=dst_ip_if.remote_ip4) /
UDP(sport=1234, dport=1234) /
ip = packet[IP]
udp = packet[IP][UDP]
payload_info = self.payload_to_info(str(packet[IP][UDP][Raw]))
- packet_index = payload_info.index
self.assertEqual(payload_info.dst, dst_ip_sw_if_index)
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- rcvd1 = self.pg0.get_capture()
- rcvd2 = self.pg1.get_capture()
+ packet_count = self.get_packet_count_for_if_idx(self.loop0.sw_if_index)
+
+ rcvd1 = self.pg0.get_capture(packet_count)
+ rcvd2 = self.pg1.get_capture(packet_count)
self.verify_capture(self.loop0, self.pg2, rcvd1)
self.verify_capture(self.loop0, self.pg2, rcvd2)
rcvd = self.pg2.get_capture()
self.verify_capture_l2_to_ip(self.pg2, self.loop0, rcvd)
- self.assertEqual(len(stream1) + len(stream2), len(rcvd.res))
-
if __name__ == '__main__':
unittest.main(testRunner=VppTestRunner)
pkts = []
for i in range(0, 257):
dst_if = self.flows[src_if][i % 2]
- info = self.create_packet_info(
- src_if.sw_if_index, dst_if.sw_if_index)
+ info = self.create_packet_info(src_if, dst_if)
payload = self.info_to_payload(info)
p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
IPv6(src=src_if.remote_ip6, dst=dst_if.remote_ip6) /
raise
def setUp(self):
- """
- Clear trace and packet infos before running each test.
- """
super(TestL2fib, self).setUp()
- self.packet_infos = {}
+ self.reset_packet_infos()
def tearDown(self):
"""
for i in range(0, n_int):
dst_host = dst_hosts[i]
src_host = random.choice(src_hosts)
- pkt_info = self.create_packet_info(
- src_if.sw_if_index, dst_if.sw_if_index)
+ pkt_info = self.create_packet_info(src_if, dst_if)
payload = self.info_to_payload(pkt_info)
p = (Ether(dst=dst_host.mac, src=src_host.mac) /
IP(src=src_host.ip4, dst=dst_host.ip4) /
# Test
# Create incoming packet streams for packet-generator interfaces for
# deleted MAC addresses
- self.packet_infos = {}
+ self.reset_packet_infos()
for i in self.pg_interfaces:
pkts = self.create_stream(i, self.pg_if_packet_sizes, deleted=True)
i.add_stream(pkts)
Clear trace and packet infos before running each test.
"""
super(TestL2bd, self).setUp()
- self.packet_infos = {}
+ self.reset_packet_infos()
def tearDown(self):
"""
dst_if = self.flows[src_if][i % 2]
dst_host = random.choice(self.hosts_by_pg_idx[dst_if.sw_if_index])
src_host = random.choice(self.hosts_by_pg_idx[src_if.sw_if_index])
- pkt_info = self.create_packet_info(
- src_if.sw_if_index, dst_if.sw_if_index)
+ pkt_info = self.create_packet_info(src_if, dst_if)
payload = self.info_to_payload(pkt_info)
p = (Ether(dst=dst_host.mac, src=src_host.mac) /
IP(src=src_host.ip4, dst=dst_host.ip4) /
Clear trace and packet infos before running each test.
"""
super(TestL2bdMultiInst, self).setUp()
- self.packet_infos = {}
def tearDown(self):
"""
for i in range(0, n_int):
dst_host = dst_hosts[i]
src_host = random.choice(src_hosts)
- pkt_info = self.create_packet_info(
- src_if.sw_if_index, dst_if.sw_if_index)
+ pkt_info = self.create_packet_info(src_if, dst_if)
payload = self.info_to_payload(pkt_info)
p = (Ether(dst=dst_host.mac, src=src_host.mac) /
IP(src=src_host.ip4, dst=dst_host.ip4) /
for pg_if in self.pg_interfaces:
capture = pg_if.get_capture()
if pg_if in self.pg_in_bd:
- if len(capture) == 0:
- raise RuntimeError("Interface %s is in BD but the capture "
- "is empty!" % pg_if.name)
self.verify_capture(pg_if, capture)
- elif pg_if in self.pg_not_in_bd:
- try:
- self.assertEqual(len(capture), 0)
- except AssertionError:
- raise RuntimeError("Interface %s is not in BD but "
- "the capture is not empty!" % pg_if.name)
- else:
+ elif pg_if not in self.pg_not_in_bd:
self.logger.error("Unknown interface: %s" % pg_if.name)
def test_l2bd_inst_01(self):
raise
def setUp(self):
- """
- Clear trace and packet infos before running each test.
- """
super(TestL2xc, self).setUp()
- self.packet_infos = {}
+ self.reset_packet_infos()
def tearDown(self):
"""
dst_if = self.flows[src_if][0]
dst_host = random.choice(self.hosts_by_pg_idx[dst_if.sw_if_index])
src_host = random.choice(self.hosts_by_pg_idx[src_if.sw_if_index])
- pkt_info = self.create_packet_info(
- src_if.sw_if_index, dst_if.sw_if_index)
+ pkt_info = self.create_packet_info(src_if, dst_if)
payload = self.info_to_payload(pkt_info)
p = (Ether(dst=dst_host.mac, src=src_host.mac) /
IP(src=src_host.ip4, dst=dst_host.ip4) /
Clear trace and packet infos before running each test.
"""
super(TestL2xcMultiInst, self).setUp()
- self.packet_infos = {}
+ self.reset_packet_infos()
def tearDown(self):
"""
for i in range(0, n_int):
dst_host = dst_hosts[i]
src_host = random.choice(src_hosts)
- pkt_info = self.create_packet_info(
- src_if.sw_if_index, dst_if.sw_if_index)
+ pkt_info = self.create_packet_info(src_if, dst_if)
payload = self.info_to_payload(pkt_info)
p = (Ether(dst=dst_host.mac, src=src_host.mac) /
IP(src=src_host.ip4, dst=dst_host.ip4) /
UDP(sport=10000 + id, dport=20000 + id))
def generatePackets(self, src_if, isv4):
- self.packet_infos = {}
+ self.reset_packet_infos()
pkts = []
for pktid in self.packets:
- info = self.create_packet_info(src_if.sw_if_index, pktid)
+ info = self.create_packet_info(src_if, self.pg1)
payload = self.info_to_payload(info)
ip = self.getIPv4Flow(pktid) if isv4 else self.getIPv6Flow(pktid)
packet = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
self.assertEqual(gre.version, 0)
inner = IPver(str(gre.payload))
payload_info = self.payload_to_info(str(inner[Raw]))
- self.info = self.get_next_packet_info_for_interface2(
- self.pg0.sw_if_index, payload_info.dst, self.info)
+ self.info = self.packet_infos[payload_info.index]
+ self.assertEqual(payload_info.src, self.pg0.sw_if_index)
self.assertEqual(str(inner), str(self.info.data[IPver]))
def checkCapture(self, gre4, isv4):
self.pg0.assert_nothing_captured()
- out = self.pg1.get_capture()
- self.assertEqual(len(out), len(self.packets))
+ out = self.pg1.get_capture(len(self.packets))
load = [0] * len(self.ass)
self.info = None
from scapy.layers.inet6 import IPv6
from scapy.contrib.mpls import MPLS
+
class TestMPLS(VppTestCase):
""" MPLS Test Case """
super(TestMPLS, self).tearDown()
# the default of 64 matches the IP packet TTL default
- def create_stream_labelled_ip4(self, src_if, mpls_labels, mpls_ttl=255, ping=0, ip_itf=None):
+ def create_stream_labelled_ip4(
+ self,
+ src_if,
+ mpls_labels,
+ mpls_ttl=255,
+ ping=0,
+ ip_itf=None):
+ self.reset_packet_infos()
pkts = []
for i in range(0, 257):
- info = self.create_packet_info(src_if.sw_if_index,
- src_if.sw_if_index)
+ info = self.create_packet_info(src_if, src_if)
payload = self.info_to_payload(info)
p = Ether(dst=src_if.local_mac, src=src_if.remote_mac)
return pkts
def create_stream_ip4(self, src_if, dst_ip):
+ self.reset_packet_infos()
pkts = []
for i in range(0, 257):
- info = self.create_packet_info(src_if.sw_if_index,
- src_if.sw_if_index)
+ info = self.create_packet_info(src_if, src_if)
payload = self.info_to_payload(info)
p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
IP(src=src_if.remote_ip4, dst=dst_ip) /
return pkts
def create_stream_labelled_ip6(self, src_if, mpls_label, mpls_ttl):
+ self.reset_packet_infos()
pkts = []
for i in range(0, 257):
- info = self.create_packet_info(src_if.sw_if_index,
- src_if.sw_if_index)
+ info = self.create_packet_info(src_if, src_if)
payload = self.info_to_payload(info)
p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
MPLS(label=mpls_label, ttl=mpls_ttl) /
labels=[44, 45])])
route_34_eos.add_vpp_config()
- self.vapi.cli("clear trace")
tx = self.create_stream_labelled_ip4(self.pg0, [34])
self.pg0.add_stream(tx)
# a stream with a non-zero MPLS TTL
# PG0 is in the default table
#
- self.vapi.cli("clear trace")
tx = self.create_stream_labelled_ip4(self.pg0, [0])
self.pg0.add_stream(tx)
# A de-agg route - next-hop lookup in default table
#
route_34_eos = MplsRoute(self, 34, 1,
- [RoutePath("0.0.0.0",
- 0xffffffff,
- nh_table_id=0)])
+ [RoutePath("0.0.0.0",
+ 0xffffffff,
+ nh_table_id=0)])
route_34_eos.add_vpp_config()
#
# A de-agg route - next-hop lookup in non-default table
#
route_35_eos = MplsRoute(self, 35, 1,
- [RoutePath("0.0.0.0",
- 0xffffffff,
- nh_table_id=1)])
+ [RoutePath("0.0.0.0",
+ 0xffffffff,
+ nh_table_id=1)])
route_35_eos.add_vpp_config()
#
# default table and egress unlabelled in the non-default
#
self.vapi.cli("clear trace")
- tx = self.create_stream_labelled_ip4(self.pg0, [35], ping=1, ip_itf=self.pg1)
+ tx = self.create_stream_labelled_ip4(
+ self.pg0, [35], ping=1, ip_itf=self.pg1)
self.pg0.add_stream(tx)
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- rx = self.pg1.get_capture()
+ packet_count = self.get_packet_count_for_if_idx(self.pg0.sw_if_index)
+ rx = self.pg1.get_capture(packet_count)
self.verify_capture_ip4(self.pg1, rx, tx, ping_resp=1)
route_35_eos.remove_vpp_config()
self.pg0.add_stream(pkts)
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- capture = self.pg1.get_capture()
+ capture = self.pg1.get_capture(len(pkts))
self.verify_capture_out(capture)
# out2in
self.pg1.add_stream(pkts)
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- capture = self.pg0.get_capture()
+ capture = self.pg0.get_capture(len(pkts))
self.verify_capture_in(capture, self.pg0)
def test_static_in(self):
self.pg0.add_stream(pkts)
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- capture = self.pg1.get_capture()
+ capture = self.pg1.get_capture(len(pkts))
self.verify_capture_out(capture, nat_ip, True)
# out2in
self.pg1.add_stream(pkts)
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- capture = self.pg0.get_capture()
+ capture = self.pg0.get_capture(len(pkts))
self.verify_capture_in(capture, self.pg0)
def test_static_out(self):
self.pg1.add_stream(pkts)
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- capture = self.pg0.get_capture()
+ capture = self.pg0.get_capture(len(pkts))
self.verify_capture_in(capture, self.pg0)
# in2out
self.pg0.add_stream(pkts)
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- capture = self.pg1.get_capture()
+ capture = self.pg1.get_capture(len(pkts))
self.verify_capture_out(capture, nat_ip, True)
def test_static_with_port_in(self):
self.pg0.add_stream(pkts)
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- capture = self.pg1.get_capture()
+ capture = self.pg1.get_capture(len(pkts))
self.verify_capture_out(capture)
# out2in
self.pg1.add_stream(pkts)
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- capture = self.pg0.get_capture()
+ capture = self.pg0.get_capture(len(pkts))
self.verify_capture_in(capture, self.pg0)
def test_static_with_port_out(self):
self.pg1.add_stream(pkts)
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- capture = self.pg0.get_capture()
+ capture = self.pg0.get_capture(len(pkts))
self.verify_capture_in(capture, self.pg0)
# in2out
self.pg0.add_stream(pkts)
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- capture = self.pg1.get_capture()
+ capture = self.pg1.get_capture(len(pkts))
self.verify_capture_out(capture)
def test_static_vrf_aware(self):
self.pg4.add_stream(pkts)
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- capture = self.pg3.get_capture()
+ capture = self.pg3.get_capture(len(pkts))
self.verify_capture_out(capture, nat_ip1, True)
# inside interface VRF don't match SNAT static mapping VRF (packets
self.pg0.add_stream(pkts)
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- capture = self.pg3.get_capture()
+ capture = self.pg3.get_capture(len(pkts))
self.verify_capture_out(capture)
# out2in 1st interface
self.pg3.add_stream(pkts)
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- capture = self.pg0.get_capture()
+ capture = self.pg0.get_capture(len(pkts))
self.verify_capture_in(capture, self.pg0)
# in2out 2nd interface
self.pg1.add_stream(pkts)
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- capture = self.pg3.get_capture()
+ capture = self.pg3.get_capture(len(pkts))
self.verify_capture_out(capture)
# out2in 2nd interface
self.pg3.add_stream(pkts)
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- capture = self.pg1.get_capture()
+ capture = self.pg1.get_capture(len(pkts))
self.verify_capture_in(capture, self.pg1)
# in2out 3rd interface
self.pg2.add_stream(pkts)
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- capture = self.pg3.get_capture()
+ capture = self.pg3.get_capture(len(pkts))
self.verify_capture_out(capture)
# out2in 3rd interface
self.pg3.add_stream(pkts)
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- capture = self.pg2.get_capture()
+ capture = self.pg2.get_capture(len(pkts))
self.verify_capture_in(capture, self.pg2)
def test_inside_overlapping_interfaces(self):
self.pg4.add_stream(pkts)
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- capture = self.pg3.get_capture()
+ capture = self.pg3.get_capture(len(pkts))
self.verify_capture_out(capture)
# out2in 1st interface
self.pg3.add_stream(pkts)
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- capture = self.pg4.get_capture()
+ capture = self.pg4.get_capture(len(pkts))
self.verify_capture_in(capture, self.pg4)
# in2out 2nd interface
self.pg5.add_stream(pkts)
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- capture = self.pg3.get_capture()
+ capture = self.pg3.get_capture(len(pkts))
self.verify_capture_out(capture)
# out2in 2nd interface
self.pg3.add_stream(pkts)
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- capture = self.pg5.get_capture()
+ capture = self.pg5.get_capture(len(pkts))
self.verify_capture_in(capture, self.pg5)
# in2out 3rd interface
self.pg6.add_stream(pkts)
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- capture = self.pg3.get_capture()
+ capture = self.pg3.get_capture(len(pkts))
self.verify_capture_out(capture)
# out2in 3rd interface
self.pg3.add_stream(pkts)
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- capture = self.pg6.get_capture()
+ capture = self.pg6.get_capture(len(pkts))
self.verify_capture_in(capture, self.pg6)
def test_hairpinning(self):
self.pg0.add_stream(p)
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- capture = self.pg0.get_capture()
- self.assertEqual(1, len(capture))
+ capture = self.pg0.get_capture(1)
p = capture[0]
try:
ip = p[IP]
self.pg0.add_stream(p)
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
- capture = self.pg0.get_capture()
- self.assertEqual(1, len(capture))
+ capture = self.pg0.get_capture(1)
p = capture[0]
try:
ip = p[IP]
self.pg_start()
# verify number of translated packet
- capture = self.pg1.get_capture()
- self.assertEqual(pkts_num, len(capture))
+ self.pg1.get_capture(pkts_num)
def tearDown(self):
super(TestSNAT, self).tearDown()
pkts = []
for i in range(0, TestSpan.pkts_per_burst):
dst_if = self.flows[src_if][0]
- pkt_info = self.create_packet_info(
- src_if.sw_if_index, dst_if.sw_if_index)
+ pkt_info = self.create_packet_info(src_if, dst_if)
payload = self.info_to_payload(pkt_info)
p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
IP(src=src_if.remote_ip4, dst=dst_if.remote_ip4) /
# Verify packets outgoing packet streams on mirrored interface (pg2)
self.logger.info("Verifying capture on interfaces %s and %s" %
(self.pg1.name, self.pg2.name))
- self.verify_capture(self.pg1,
- self.pg1.get_capture(),
- self.pg2.get_capture())
+ pg2_expected = self.get_packet_count_for_if_idx(self.pg1.sw_if_index)
+ self.verify_capture(
+ self.pg1,
+ self.pg1.get_capture(),
+ self.pg2.get_capture(pg2_expected))
if __name__ == '__main__':
"""
if not capture:
return headline
- result = headline + "\n"
- count = 1
- for p in capture:
- result.append(ppp("Packet #%s:" % count, p))
- count += 1
- if count >= limit:
- break
+ tail = ""
if limit < len(capture):
- result.append(
- "Capture contains %s packets in total, of which %s were printed" %
- (len(capture), limit))
+ tail = "\nPrint limit reached, %s out of %s packets printed" % (
+ len(capture), limit)
+ limit = len(capture)
+ body = "".join([ppp("Packet #%s:" % count, p)
+ for count, p in zip(range(0, limit), capture)])
+ return "%s\n%s%s" % (headline, body, tail)
class NumericConstant(object):
import os
import time
+from traceback import format_exc
from scapy.utils import wrpcap, rdpcap, PcapReader
from vpp_interface import VppInterface
# FIXME this should be an API, but no such exists atm
self.test.vapi.cli(self.input_cli)
- def get_capture(self, remark=None, filter_fn=is_ipv6_misc):
- """
- Get captured packets
-
- :param remark: remark printed into debug logs
- :param filter_fn: filter applied to each packet, packets for which
- the filter returns True are removed from capture
- :returns: iterable packets
- """
+ def _get_capture(self, timeout, filter_out_fn=is_ipv6_misc):
+ """ Helper method to get capture and filter it """
try:
- self.wait_for_capture_file()
+ if not self.wait_for_capture_file(timeout):
+ return None
output = rdpcap(self.out_path)
self.test.logger.debug("Capture has %s packets" % len(output.res))
- except IOError: # TODO
- self.test.logger.debug("File %s does not exist, probably because no"
- " packets arrived" % self.out_path)
- if remark:
- raise Exception("No packets captured on %s(%s)" %
- (self.name, remark))
- else:
- raise Exception("No packets captured on %s" % self.name)
+ except:
+ self.test.logger.debug("Exception in scapy.rdpcap(%s): %s" %
+ (self.out_path, format_exc()))
+ return None
before = len(output.res)
- if filter_fn:
- output.res = [p for p in output.res if not filter_fn(p)]
+ if filter_out_fn:
+ output.res = [p for p in output.res if not filter_out_fn(p)]
removed = len(output.res) - before
if removed:
self.test.logger.debug(
(removed, len(output.res)))
return output
- def assert_nothing_captured(self, remark=None):
+ def get_capture(self, expected_count=None, remark=None, timeout=1,
+ filter_out_fn=is_ipv6_misc):
+ """ Get captured packets
+
+ :param expected_count: expected number of packets to capture, if None,
+ then self.test.packet_count_for_dst_pg_idx is
+ used to lookup the expected count
+ :param remark: remark printed into debug logs
+ :param timeout: how long to wait for packets
+ :param filter_out_fn: filter applied to each packet, packets for which
+ the filter returns True are removed from capture
+ :returns: iterable packets
+ """
+ remaining_time = timeout
+ capture = None
+ name = self.name if remark is None else "%s (%s)" % (self.name, remark)
+ based_on = "based on provided argument"
+ if expected_count is None:
+ expected_count = \
+ self.test.get_packet_count_for_if_idx(self.sw_if_index)
+ based_on = "based on stored packet_infos"
+ self.test.logger.debug("Expecting to capture %s(%s) packets on %s" % (
+ expected_count, based_on, name))
+ if expected_count == 0:
+ raise Exception(
+ "Internal error, expected packet count for %s is 0!" % name)
+ while remaining_time > 0:
+ before = time.time()
+ capture = self._get_capture(remaining_time, filter_out_fn)
+ elapsed_time = time.time() - before
+ if capture:
+ if len(capture.res) == expected_count:
+ # bingo, got the packets we expected
+ return capture
+ remaining_time -= elapsed_time
+ if capture:
+ raise Exception("Captured packets mismatch, captured %s packets, "
+ "expected %s packets on %s" %
+ (len(capture.res), expected_count, name))
+ else:
+ raise Exception("No packets captured on %s" % name)
+
+ def assert_nothing_captured(self, remark=None, filter_out_fn=is_ipv6_misc):
+ """ Assert that nothing unfiltered was captured on interface
+
+ :param remark: remark printed into debug logs
+ :param filter_out_fn: filter applied to each packet, packets for which
+ the filter returns True are removed from capture
+ """
if os.path.isfile(self.out_path):
try:
- capture = self.get_capture(remark=remark)
+ capture = self.get_capture(
+ 0, remark=remark, filter_out_fn=filter_out_fn)
+ if capture:
+ if len(capture.res) == 0:
+ # junk filtered out, we're good
+ return
self.test.logger.error(
ppc("Unexpected packets captured:", capture))
except:
pass
if remark:
raise AssertionError(
- "Capture file present for interface %s(%s)" %
+ "Non-empty capture file present for interface %s(%s)" %
(self.name, remark))
else:
- raise AssertionError("Capture file present for interface %s" %
- self.name)
+ raise AssertionError(
+ "Non-empty capture file present for interface %s" %
+ self.name)
def wait_for_capture_file(self, timeout=1):
"""
:param timeout: How long to wait for the packet (default 1s)
- :raises Exception: if the capture file does not appear within timeout
+ :returns: True/False if the file is present or appears within timeout
"""
limit = time.time() + timeout
if not os.path.isfile(self.out_path):
- self.test.logger.debug(
- "Waiting for capture file to appear, timeout is %ss", timeout)
+ self.test.logger.debug("Waiting for capture file %s to appear, "
+ "timeout is %ss" % (self.out_path, timeout))
else:
- self.test.logger.debug("Capture file already exists")
- return
+ self.test.logger.debug(
+ "Capture file %s already exists" %
+ self.out_path)
+ return True
while time.time() < limit:
if os.path.isfile(self.out_path):
break
(time.time() - (limit - timeout)))
else:
self.test.logger.debug("Timeout - capture file still nowhere")
- raise Exception("Capture file did not appear within timeout")
+ return False
+ return True
- def wait_for_packet(self, timeout):
+ def wait_for_packet(self, timeout, filter_out_fn=is_ipv6_misc):
"""
Wait for next packet captured with a timeout
:returns: Captured packet if no packet arrived within timeout
:raises Exception: if no packet arrives within timeout
"""
- limit = time.time() + timeout
+ deadline = time.time() + timeout
if self._pcap_reader is None:
- self.wait_for_capture_file(timeout)
- self._pcap_reader = PcapReader(self.out_path)
+ if not self.wait_for_capture_file(timeout):
+ raise Exception("Capture file %s did not appear within "
+ "timeout" % self.out_path)
+ while time.time() < deadline:
+ try:
+ self._pcap_reader = PcapReader(self.out_path)
+ break
+ except:
+ self.test.logger.debug("Exception in scapy.PcapReader(%s): "
+ "%s" % (self.out_path, format_exc()))
+ if not self._pcap_reader:
+ raise Exception("Capture file %s did not appear within "
+ "timeout" % self.out_path)
self.test.logger.debug("Waiting for packet")
- while time.time() < limit:
+ while time.time() < deadline:
p = self._pcap_reader.recv()
if p is not None:
- self.test.logger.debug("Packet received after %fs",
- (time.time() - (limit - timeout)))
- return p
+ if filter_out_fn is not None and filter_out_fn(p):
+ self.test.logger.debug(
+ "Packet received after %ss was filtered out" %
+ (time.time() - (deadline - timeout)))
+ else:
+ self.test.logger.debug("Packet received after %fs" %
+ (time.time() - (deadline - timeout)))
+ return p
time.sleep(0) # yield
self.test.logger.debug("Timeout - no packets received")
raise Exception("Packet didn't arrive within timeout")
self.test.pg_start()
self.test.logger.info(self.test.vapi.cli("show trace"))
try:
- arp_reply = pg_interface.get_capture(filter_fn=None)
+ captured_packet = pg_interface.wait_for_packet(1)
except:
self.test.logger.info("No ARP received on port %s" %
pg_interface.name)
return
- arp_reply = arp_reply[0]
+ arp_reply = captured_packet.copy() # keep original for exception
# Make Dot1AD packet content recognizable to scapy
if arp_reply.type == 0x88a8:
arp_reply.type = 0x8100
(self.name, arp_reply[ARP].hwsrc))
self._local_mac = arp_reply[ARP].hwsrc
else:
- self.test.logger.info(
- "No ARP received on port %s" %
- pg_interface.name)
+ self.test.logger.info("No ARP received on port %s" %
+ pg_interface.name)
except:
self.test.logger.error(
- ppp("Unexpected response to ARP request:", arp_reply))
+ ppp("Unexpected response to ARP request:", captured_packet))
raise
- def resolve_ndp(self, pg_interface=None):
+ def resolve_ndp(self, pg_interface=None, timeout=1):
"""Resolve NDP using provided packet-generator interface
:param pg_interface: interface used to resolve, if None then this
interface is used
+ :param timeout: how long to wait for response before giving up
"""
if pg_interface is None:
pg_interface.add_stream(ndp_req)
pg_interface.enable_capture()
self.test.pg_start()
- self.test.logger.info(self.test.vapi.cli("show trace"))
- replies = pg_interface.get_capture(filter_fn=None)
- if replies is None or len(replies) == 0:
- self.test.logger.info(
- "No NDP received on port %s" %
- pg_interface.name)
- return
+ now = time.time()
+ deadline = now + timeout
# Enabling IPv6 on an interface can generate more than the
# ND reply we are looking for (namely MLD). So loop through
# the replies to look for want we want.
- for ndp_reply in replies:
+ while now < deadline:
+ try:
+ captured_packet = pg_interface.wait_for_packet(
+ deadline - now, filter_out_fn=None)
+ except:
+ self.test.logger.error("Timeout while waiting for NDP response")
+ raise
+ ndp_reply = captured_packet.copy() # keep original for exception
# Make Dot1AD packet content recognizable to scapy
if ndp_reply.type == 0x88a8:
ndp_reply.type = 0x8100
self.test.logger.info("VPP %s MAC address is %s " %
(self.name, opt.lladdr))
self._local_mac = opt.lladdr
+ self.test.logger.debug(self.test.vapi.cli("show trace"))
+ # we now have the MAC we've been after
+ return
except:
self.test.logger.info(
- ppp("Unexpected response to NDP request:", ndp_reply))
- # if no packets above provided the local MAC, then this failed.
- if not hasattr(self, '_local_mac'):
- raise
+ ppp("Unexpected response to NDP request:", captured_packet))
+ now = time.time()
+
+ self.test.logger.debug(self.test.vapi.cli("show trace"))
+ raise Exception("Timeout while waiting for NDP response")