vxlan: vxlan/vxlan.api API cleanup

[vpp.git] / test / vpp_pg_interface.py

diff --git a/test/vpp_pg_interface.py b/test/vpp_pg_interface.py
index 380c1fa..b7f1881 100755 (executable)
--- a/test/vpp_pg_interface.py
+++ b/test/vpp_pg_interface.py
@@ -1,6 +1,6 @@
 import os
 import time
-import socket
+from socket import inet_pton, inet_ntop
 import struct
 from traceback import format_exc, format_stack
 
@@ -15,7 +15,6 @@ from scapy.layers.inet6 import IPv6, ICMPv6ND_NS, ICMPv6ND_NA,\
     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):
@@ -45,6 +44,18 @@ class VppPGInterface(VppInterface):
         """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"""
@@ -70,6 +81,8 @@ class VppPGInterface(VppInterface):
         """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
@@ -86,24 +99,27 @@ class VppPGInterface(VppInterface):
         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)
@@ -131,7 +147,8 @@ class VppPGInterface(VppInterface):
             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)
@@ -142,13 +159,14 @@ class VppPGInterface(VppInterface):
     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
         self._rename_previous_capture_file(self.in_path,
                                            self.in_history_counter,
@@ -276,6 +294,20 @@ class VppPGInterface(VppInterface):
                 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
@@ -284,6 +316,7 @@ class VppPGInterface(VppInterface):
 
         :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, "