import os
import time
-import socket
+from socket import inet_pton, inet_ntop
import struct
from traceback import format_exc, format_stack
IPv6ExtHdrHopByHop
from util import ppp, ppc
from scapy.utils6 import in6_getnsma, in6_getnsmac, in6_ismaddr
-from scapy.utils import inet_pton, inet_ntop
class CaptureTimeoutError(Exception):
"""packet-generator interface index assigned by VPP"""
return self._pg_index
+ @property
+ def gso_enabled(self):
+ """gso enabled on packet-generator interface"""
+ if self._gso_enabled == 0:
+ return "gso-disabled"
+ return "gso-enabled"
+
+ @property
+ def gso_size(self):
+ """gso size on packet-generator interface"""
+ return self._gso_size
+
@property
def out_path(self):
"""pcap file path - captured packets"""
"""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
@property
self._out_history_counter += 1
return v
- def __init__(self, test, pg_index):
+ def __init__(self, test, pg_index, gso, gso_size):
""" Create VPP packet-generator interface """
super(VppPGInterface, self).__init__(test)
- r = test.vapi.pg_create_interface(pg_index)
+ r = test.vapi.pg_create_interface(pg_index, gso, gso_size)
self.set_sw_if_index(r.sw_if_index)
self._in_history_counter = 0
self._out_history_counter = 0
self._out_assert_counter = 0
self._pg_index = pg_index
+ self._gso_enabled = gso
+ self._gso_size = gso_size
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" % self.sw_if_index
+ 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 enable_capture(self):
- """ Enable capture on this packet-generator interface
- of at most n packets.
- If n < 0, this is no limit
- """
+ def _rename_previous_capture_file(self, path, counter, file):
+ # if a file from a previous capture exists, rename it.
try:
- if os.path.isfile(self.out_path):
+ if os.path.isfile(path):
name = "%s/history.[timestamp:%f].[%s-counter:%04d].%s" % \
(self.test.tempdir,
time.time(),
self.name,
- self.out_history_counter,
- self._out_file)
+ counter,
+ file)
self.test.logger.debug("Renaming %s->%s" %
- (self.out_path, name))
- os.rename(self.out_path, name)
- except:
- pass
+ (path, name))
+ os.rename(path, name)
+ except OSError:
+ self.test.logger.debug("OSError: Could not rename %s %s" %
+ (path, file))
+
+ def enable_capture(self):
+ """ Enable capture on this packet-generator interface
+ of at most n packets.
+ If n < 0, this is no limit
+ """
+ # 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)
# 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 add_stream(self, pkts, nb_replays=None):
+ 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
- try:
- if os.path.isfile(self.in_path):
- name = "%s/history.[timestamp:%f].[%s-counter:%04d].%s" %\
- (self.test.tempdir,
- time.time(),
- self.name,
- self.in_history_counter,
- self._in_file)
- self.test.logger.debug("Renaming %s->%s" %
- (self.in_path, name))
- os.rename(self.in_path, name)
- except:
- pass
+ 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)
# FIXME this should be an API, but no such exists atm
raise AssertionError("Capture file present for interface %s" %
self.name)
+ def wait_for_pg_stop(self):
+ # wait till packet-generator is stopped
+ # "show packet-generator" while it is still running gives this:
+ # Name Enabled Count Parameters
+ # pcap0-sw_if_inde Yes 64 limit 64, ...
+ #
+ # also have a 5-minute timeout just in case things go terribly wrong...
+ deadline = time.time() + 300
+ while self.test.vapi.cli('show packet-generator').find("Yes") != -1:
+ self._test.sleep(0.01) # yield
+ if time.time() > deadline:
+ self.test.logger.debug("Timeout waiting for pg to stop")
+ break
+
def wait_for_capture_file(self, timeout=1):
"""
Wait until pcap capture file appears
:returns: True/False if the file is present or appears within timeout
"""
+ self.wait_for_pg_stop()
deadline = time.time() + timeout
if not os.path.isfile(self.out_path):
self.test.logger.debug("Waiting for capture file %s to appear, "