import time
from traceback import format_exc, format_stack
+from config import config
import scapy.compat
from scapy.utils import wrpcap, rdpcap, PcapReader
from scapy.plist import PacketList
from vpp_interface import VppInterface
+from vpp_papi import VppEnum
from scapy.layers.l2 import Ether, ARP
from scapy.layers.inet6 import IPv6, ICMPv6ND_NS, ICMPv6ND_NA,\
ICMPv6NDOptSrcLLAddr, ICMPv6NDOptDstLLAddr, ICMPv6ND_RA, RouterAlert, \
IPv6ExtHdrHopByHop
-from util import ppp, ppc
+from util import ppp, ppc, UnexpectedPacketError
from scapy.utils6 import in6_getnsma, in6_getnsmac, in6_ismaddr
"""gso size on packet-generator interface"""
return self._gso_size
+ @property
+ def coalesce_is_enabled(self):
+ """coalesce enabled on packet-generator interface"""
+ if self._coalesce_enabled == 0:
+ return "coalesce-disabled"
+ return "coalesce-enabled"
+
@property
def out_path(self):
"""pcap file path - captured packets"""
return self._out_path
- @property
- def in_path(self):
+ def get_in_path(self, worker):
""" pcap file path - injected packets"""
- return self._in_path
+ if worker is not None:
+ return "%s/pg%u_wrk%u_in.pcap" % (self.test.tempdir, self.pg_index,
+ worker)
+ return "%s/pg%u_in.pcap" % (self.test.tempdir, self.pg_index)
@property
def capture_cli(self):
"""CLI string to start capture on this interface"""
return self._capture_cli
- @property
- def cap_name(self):
- """capture name for this interface"""
+ def get_cap_name(self, worker=None):
+ """return capture name for this interface and given worker"""
+ if worker is not None:
+ return self._cap_name + "-worker%d" % worker
return self._cap_name
- @property
- def input_cli(self):
- """CLI string to load the injected packets"""
- if self._nb_replays is not None:
- return "%s limit %d" % (self._input_cli, self._nb_replays)
- if self._worker is not None:
- return "%s worker %d" % (self._input_cli, self._worker)
- return self._input_cli
+ def get_input_cli(self, nb_replays=None, worker=None):
+ """return CLI string to load the injected packets"""
+ input_cli = "packet-generator new pcap %s source pg%u name %s" % (
+ self.get_in_path(worker), self.pg_index, self.get_cap_name(worker))
+ if nb_replays is not None:
+ return "%s limit %d" % (input_cli, nb_replays)
+ if worker is not None:
+ return "%s worker %d" % (input_cli, worker)
+ return input_cli
@property
def in_history_counter(self):
self._out_history_counter += 1
return v
- def __init__(self, test, pg_index, gso, gso_size):
+ def __init__(self, test, pg_index, gso, gso_size, mode):
""" Create VPP packet-generator interface """
- super(VppPGInterface, self).__init__(test)
+ super().__init__(test)
- r = test.vapi.pg_create_interface(pg_index, gso, gso_size)
+ r = test.vapi.pg_create_interface_v2(pg_index, gso, gso_size, mode)
self.set_sw_if_index(r.sw_if_index)
self._in_history_counter = 0
self._pg_index = pg_index
self._gso_enabled = gso
self._gso_size = gso_size
+ self._coalesce_enabled = 0
self._out_file = "pg%u_out.pcap" % self.pg_index
self._out_path = self.test.tempdir + "/" + self._out_file
- self._in_file = "pg%u_in.pcap" % self.pg_index
- self._in_path = self.test.tempdir + "/" + self._in_file
self._capture_cli = "packet-generator capture pg%u pcap %s" % (
self.pg_index, self.out_path)
self._cap_name = "pcap%u-sw_if_index-%s" % (
self.pg_index, self.sw_if_index)
- self._input_cli = \
- "packet-generator new pcap %s source pg%u name %s" % (
- self.in_path, self.pg_index, self.cap_name)
- self._nb_replays = None
- def _rename_previous_capture_file(self, path, counter, file):
- # if a file from a previous capture exists, rename it.
+ def handle_old_pcap_file(self, path, counter):
+ filename = os.path.basename(path)
+
+ if not config.keep_pcaps:
+ try:
+ self.test.logger.debug(f"Removing {path}")
+ os.remove(path)
+ except OSError:
+ self.test.logger.debug(f"OSError: Could not remove {path}")
+ return
+
+ # keep
try:
+
if os.path.isfile(path):
name = "%s/history.[timestamp:%f].[%s-counter:%04d].%s" % \
(self.test.tempdir,
time.time(),
self.name,
counter,
- file)
- self.test.logger.debug("Renaming %s->%s" %
- (path, name))
+ filename)
+ self.test.logger.debug("Renaming %s->%s" % (path, name))
os.rename(path, name)
except OSError:
self.test.logger.debug("OSError: Could not rename %s %s" %
- (path, file))
+ (path, filename))
def enable_capture(self):
""" Enable capture on this packet-generator interface
"""
# disable the capture to flush the capture
self.disable_capture()
- self._rename_previous_capture_file(self.out_path,
- self.out_history_counter,
- self._out_file)
+ self.handle_old_pcap_file(self.out_path, self.out_history_counter)
# FIXME this should be an API, but no such exists atm
self.test.vapi.cli(self.capture_cli)
self._pcap_reader = None
def disable_capture(self):
self.test.vapi.cli("%s disable" % self.capture_cli)
+ def coalesce_enable(self):
+ """ Enable packet coalesce on this packet-generator interface"""
+ self._coalesce_enabled = 1
+ self.test.vapi.pg_interface_enable_disable_coalesce(self.sw_if_index,
+ 1)
+
+ def coalesce_disable(self):
+ """ Disable packet coalesce on this packet-generator interface"""
+ self._coalesce_enabled = 0
+ self.test.vapi.pg_interface_enable_disable_coalesce(self.sw_if_index,
+ 0)
+
def add_stream(self, pkts, nb_replays=None, worker=None):
"""
Add a stream of packets to this packet-generator
:param pkts: iterable packets
"""
- self._worker = worker
- self._nb_replays = nb_replays
- self._rename_previous_capture_file(self.in_path,
- self.in_history_counter,
- self._in_file)
- wrpcap(self.in_path, pkts)
- self.test.register_capture(self.cap_name)
+ wrpcap(self.get_in_path(worker), pkts)
+ self.test.register_pcap(self, worker)
# FIXME this should be an API, but no such exists atm
- self.test.vapi.cli(self.input_cli)
+ self.test.vapi.cli(self.get_input_cli(nb_replays, worker))
def generate_debug_aid(self, kind):
""" Create a hardlink to the out file with a counter and a file
remaining_time -= elapsed_time
if capture:
self.generate_debug_aid("count-mismatch")
+ if len(capture) > 0 and 0 == expected_count:
+ rem = f"\n{remark}" if remark else ""
+ raise UnexpectedPacketError(
+ capture[0],
+ f"\n({len(capture)} packets captured in total){rem}")
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):
+ def assert_nothing_captured(self, timeout=1, remark=None,
+ filter_out_fn=is_ipv6_misc):
""" Assert that nothing unfiltered was captured on interface
:param remark: remark printed into debug logs
if os.path.isfile(self.out_path):
try:
capture = self.get_capture(
- 0, remark=remark, filter_out_fn=filter_out_fn)
+ 0, timeout=timeout, remark=remark,
+ filter_out_fn=filter_out_fn)
if not capture or len(capture.res) == 0:
# junk filtered out, we're good
return
pass
self.generate_debug_aid("empty-assert")
if remark:
- raise AssertionError(
- "Non-empty capture file present for interface %s (%s)" %
- (self.name, remark))
+ raise UnexpectedPacketError(
+ capture[0],
+ f" ({len(capture)} packets captured in total) ({remark})")
else:
- raise AssertionError("Capture file present for interface %s" %
- self.name)
+ raise UnexpectedPacketError(
+ capture[0], f" ({len(capture)} packets captured in total)")
def wait_for_pg_stop(self):
# wait till packet-generator is stopped
ARP(op=ARP.who_has, pdst=self.local_ip4,
psrc=self.remote_ip4, hwsrc=self.remote_mac))
- def create_ndp_req(self):
+ def create_ndp_req(self, addr=None):
"""Create NDP - NS applicable for this interface"""
- nsma = in6_getnsma(inet_pton(socket.AF_INET6, self.local_ip6))
+ if not addr:
+ addr = self.local_ip6
+ nsma = in6_getnsma(inet_pton(socket.AF_INET6, addr))
d = inet_ntop(socket.AF_INET6, nsma)
return (Ether(dst=in6_getnsmac(nsma)) /
IPv6(dst=d, src=self.remote_ip6) /
- ICMPv6ND_NS(tgt=self.local_ip6) /
+ ICMPv6ND_NS(tgt=addr) /
ICMPv6NDOptSrcLLAddr(lladdr=self.remote_mac))
def resolve_arp(self, pg_interface=None):
ppp("Unexpected response to ARP request:", captured_packet))
raise
- def resolve_ndp(self, pg_interface=None, timeout=1):
+ def resolve_ndp(self, pg_interface=None, timeout=1, link_layer=False):
"""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
+ :param link_layer: resolve for global address if False (default)
+ or for link-layer address if True
"""
if pg_interface is None:
pg_interface = self
+ addr = self.local_ip6_ll if link_layer else self.local_ip6
self.test.logger.info("Sending NDP request for %s on port %s" %
- (self.local_ip6, pg_interface.name))
- ndp_req = self.create_ndp_req()
+ (addr, pg_interface.name))
+ ndp_req = self.create_ndp_req(addr)
pg_interface.add_stream(ndp_req)
pg_interface.enable_capture()
self.test.pg_start()
Code Review / vpp.git / blobdiff