X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=test%2Fvpp_pg_interface.py;h=bd4ddaff58aedf042883f6df6fece58eb4f92cb1;hb=3ffe6cadf;hp=1300f1f1f006b3d5f769482068fe985e32151cc2;hpb=31da2e30317bc1fcb4586e1dc0d560600d9b29d3;p=vpp.git

diff --git a/test/vpp_pg_interface.py b/test/vpp_pg_interface.py
old mode 100644
new mode 100755
index 1300f1f1f00..bd4ddaff58a
--- a/test/vpp_pg_interface.py
+++ b/test/vpp_pg_interface.py
@@ -3,6 +3,8 @@ import time
 import socket
 import struct
 from traceback import format_exc, format_stack
+
+import scapy.compat
 from scapy.utils import wrpcap, rdpcap, PcapReader
 from scapy.plist import PacketList
 from vpp_interface import VppInterface
@@ -66,6 +68,8 @@ class VppPGInterface(VppInterface):
     @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)
         return self._input_cli
 
     @property
@@ -99,50 +103,57 @@ class VppPGInterface(VppInterface):
         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"""
+    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
+        """
+
+        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 add_stream(self, pkts):
+    def disable_capture(self):
+        self.test.vapi.cli("%s disable" % self.capture_cli)
+
+    def add_stream(self, pkts, nb_replays=None):
         """
         Add a stream of packets to this packet-generator
 
         :param pkts: iterable packets
 
         """
-        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._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)
         # FIXME this should be an API, but no such exists atm
@@ -285,7 +296,7 @@ class VppPGInterface(VppInterface):
         while time.time() < deadline:
             if os.path.isfile(self.out_path):
                 break
-            time.sleep(0)  # yield
+            self._test.sleep(0)  # yield
         if os.path.isfile(self.out_path):
             self.test.logger.debug("Capture file appeared after %fs" %
                                    (time.time() - (deadline - timeout)))
@@ -353,7 +364,7 @@ class VppPGInterface(VppInterface):
             self.test.logger.debug("Polling for packet")
         while time.time() < deadline or poll:
             if not self.verify_enough_packet_data_in_pcap():
-                time.sleep(0)  # yield
+                self._test.sleep(0)  # yield
                 poll = False
                 continue
             p = self._pcap_reader.recv()
@@ -367,7 +378,7 @@ class VppPGInterface(VppInterface):
                         "Packet received after %fs" %
                         (time.time() - (deadline - timeout)))
                     return p
-            time.sleep(0)  # yield
+            self._test.sleep(0)  # yield
             poll = False
         self.test.logger.debug("Timeout - no packets received")
         raise CaptureTimeoutError("Packet didn't arrive within timeout")
@@ -411,10 +422,6 @@ class VppPGInterface(VppInterface):
                                   pg_interface.name)
             return
         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
-            arp_reply = Ether(str(arp_reply))
         try:
             if arp_reply[ARP].op == ARP.is_at:
                 self.test.logger.info("VPP %s MAC address is %s " %
@@ -458,10 +465,6 @@ class VppPGInterface(VppInterface):
                     "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
-                ndp_reply = Ether(str(ndp_reply))
             try:
                 ndp_na = ndp_reply[ICMPv6ND_NA]
                 opt = ndp_na[ICMPv6NDOptDstLLAddr]