X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=resources%2Ftools%2Ftrex%2Ftrex_stateless_profile.py;h=edb0b8d8cfc84be44840cb94277d677a8734193f;hb=eb774c3e205a538262aef928bfbed17cd5be7b25;hp=311c85f5d87f81e7121980ceb578d84f22c1f128;hpb=ab94abd6fea7e4015c3fdc3130beb35b59582d58;p=csit.git

diff --git a/resources/tools/trex/trex_stateless_profile.py b/resources/tools/trex/trex_stateless_profile.py
index 311c85f5d8..edb0b8d8cf 100755
--- a/resources/tools/trex/trex_stateless_profile.py
+++ b/resources/tools/trex/trex_stateless_profile.py
@@ -1,6 +1,6 @@
-#!/usr/bin/python
+#!/usr/bin/python3
 
-# Copyright (c) 2017 Cisco and/or its affiliates.
+# Copyright (c) 2019 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -18,29 +18,31 @@ the profile and sends the traffic. At the end, it measures the packet loss and
 latency.
 """
 
-import sys
 import argparse
 import json
+import sys
+import time
 
-sys.path.insert(0, "/opt/trex-core-2.34/scripts/automation/"
-                   "trex_control_plane/stl/")
-
-from trex_stl_lib.api import *
+sys.path.insert(
+    0, u"/opt/trex-core-2.73/scripts/automation/trex_control_plane/interactive/"
+)
+from trex.stl.api import *
 
 
-def fmt_latency(lat_min, lat_avg, lat_max):
+def fmt_latency(lat_min, lat_avg, lat_max, hdrh):
     """Return formatted, rounded latency.
 
     :param lat_min: Min latency
     :param lat_avg: Average latency
     :param lat_max: Max latency
-    :type lat_min: string
-    :type lat_avg: string
-    :type lat_max: string
-    :return: Formatted and rounded output "min/avg/max"
-    :rtype: string
+    :param hdrh: Base64 encoded compressed HDRHistogram object.
+    :type lat_min: str
+    :type lat_avg: str
+    :type lat_max: str
+    :type hdrh: str
+    :return: Formatted and rounded output (hdrh unchanged) "min/avg/max/hdrh".
+    :rtype: str
     """
-
     try:
         t_min = int(round(float(lat_min)))
     except ValueError:
@@ -54,12 +56,13 @@ def fmt_latency(lat_min, lat_avg, lat_max):
     except ValueError:
         t_max = int(-1)
 
-    return "/".join(str(tmp) for tmp in (t_min, t_avg, t_max))
+    return u"/".join(str(tmp) for tmp in (t_min, t_avg, t_max, hdrh))
 
 
-def simple_burst(profile_file, duration, framesize, rate, warmup_time, port_0,
-                 port_1, latency, async_start=False):
-    """Send the traffic and measure packet loss and latency.
+def simple_burst(
+        profile_file, duration, framesize, rate, warmup_time, port_0, port_1,
+        latency, async_start=False, traffic_directions=2, force=False):
+    """Send traffic and measure packet loss and latency.
 
     Procedure:
      - reads the given traffic profile with streams,
@@ -85,76 +88,87 @@ def simple_burst(profile_file, duration, framesize, rate, warmup_time, port_0,
     :param port_1: Port 1 on the traffic generator.
     :param latency: With latency stats.
     :param async_start: Start the traffic and exit.
+    :param traffic_directions: Bidirectional (2) or unidirectional (1) traffic.
+    :param force: Force start regardless of ports state.
     :type profile_file: str
     :type framesize: int or str
-    :type duration: int
+    :type duration: float
     :type rate: str
-    :type warmup_time: int
+    :type warmup_time: float
     :type port_0: int
     :type port_1: int
-    :type latency: boo;
+    :type latency: bool
     :type async_start: bool
+    :type traffic_directions: int
+    :type force: bool
     """
-
     client = None
     total_rcvd = 0
     total_sent = 0
     lost_a = 0
     lost_b = 0
-    lat_a = "-1/-1/-1"
-    lat_b = "-1/-1/-1"
+    lat_a = u"-1/-1/-1/"
+    lat_b = u"-1/-1/-1/"
 
     # Read the profile:
     try:
-        print("### Profile file:\n{}".format(profile_file))
-        profile = STLProfile.load(profile_file, direction=0, port_id=0,
-                                  framesize=framesize)
+        print(f"### Profile file:\n{profile_file}")
+        profile = STLProfile.load(
+            profile_file, direction=0, port_id=0, framesize=framesize
+        )
         streams = profile.get_streams()
     except STLError as err:
-        print("Error while loading profile '{0}' {1}".format(profile_file, err))
+        print(f"Error while loading profile '{profile_file}' {err!r}")
         sys.exit(1)
 
     try:
         # Create the client:
-        client = STLClient(verbose_level=LoggerApi.VERBOSE_QUIET)
+        client = STLClient()
         # Connect to server:
         client.connect()
         # Prepare our ports (the machine has 0 <--> 1 with static route):
         client.reset(ports=[port_0, port_1])
         client.remove_all_streams(ports=[port_0, port_1])
 
-        if "macsrc" in profile_file:
-            client.set_port_attr(ports=[port_0, port_1], promiscuous=True,
-                                 resolve=False)
+        if u"macsrc" in profile_file:
+            client.set_port_attr(ports=[port_0, port_1], promiscuous=True)
         if isinstance(framesize, int):
             client.add_streams(streams[0], ports=[port_0])
-            client.add_streams(streams[1], ports=[port_1])
+            if traffic_directions > 1:
+                client.add_streams(streams[1], ports=[port_1])
         elif isinstance(framesize, str):
             client.add_streams(streams[0:3], ports=[port_0])
-            client.add_streams(streams[3:6], ports=[port_1])
+            if traffic_directions > 1:
+                client.add_streams(streams[3:6], ports=[port_1])
         if latency:
             try:
                 if isinstance(framesize, int):
                     client.add_streams(streams[2], ports=[port_0])
-                    client.add_streams(streams[3], ports=[port_1])
+                    if traffic_directions > 1:
+                        client.add_streams(streams[3], ports=[port_1])
                 elif isinstance(framesize, str):
                     latency = False
             except STLError:
                 # Disable latency if NIC does not support requested stream type
-                print("##### FAILED to add latency streams #####")
+                print(u"##### FAILED to add latency streams #####")
                 latency = False
+        ports = [port_0]
+        if traffic_directions > 1:
+            ports.append(port_1)
         # Warm-up phase:
         if warmup_time > 0:
             # Clear the stats before injecting:
             client.clear_stats()
 
             # Choose rate and start traffic:
-            client.start(ports=[port_0, port_1], mult=rate,
-                         duration=warmup_time)
+            time_start = time.time()
+            client.start(ports=ports, mult=rate, duration=warmup_time,
+                         force=force)
 
             # Block until done:
-            client.wait_on_traffic(ports=[port_0, port_1],
-                                   timeout=warmup_time+30)
+            client.wait_on_traffic(ports=ports, timeout=warmup_time+30)
+            time_stop = time.time()
+            print(f"Warmup traffic took {time_stop - time_start} seconds.")
 
             if client.get_warnings():
                 for warning in client.get_warnings():
@@ -163,15 +177,16 @@ def simple_burst(profile_file, duration, framesize, rate, warmup_time, port_0,
             # Read the stats after the test:
             stats = client.get_stats()
 
-            print("##### Warmup statistics #####")
-            print(json.dumps(stats, indent=4, separators=(',', ': '),
-                             sort_keys=True))
+            print(u"##### Warmup statistics #####")
+            print(json.dumps(stats, indent=4, separators=(u",", u": ")))
 
-            lost_a = stats[0]["opackets"] - stats[1]["ipackets"]
-            lost_b = stats[1]["opackets"] - stats[0]["ipackets"]
+            lost_a = stats[port_0][u"opackets"] - stats[port_1][u"ipackets"]
+            if traffic_directions > 1:
+                lost_b = stats[port_1][u"opackets"] - stats[port_0][u"ipackets"]
 
-            print("\npackets lost from 0 --> 1: {0} pkts".format(lost_a))
-            print("packets lost from 1 --> 0: {0} pkts".format(lost_b))
+            print(f"\npackets lost from {port_0} --> {port_1}: {lost_a} pkts")
+            if traffic_directions > 1:
+                print(f"packets lost from {port_1} --> {port_0}: {lost_b} pkts")
 
         # Clear the stats before injecting:
         client.clear_stats()
@@ -179,11 +194,21 @@ def simple_burst(profile_file, duration, framesize, rate, warmup_time, port_0,
         lost_b = 0
 
         # Choose rate and start traffic:
-        client.start(ports=[port_0, port_1], mult=rate, duration=duration)
+        time_start = time.time()
+        client.start(ports=ports, mult=rate, duration=duration, force=force)
 
-        if not async_start:
+        if async_start:
+            # For async stop, we need to export the current snapshot.
+            xsnap0 = client.ports[0].get_xstats().reference_stats
+            print(f"Xstats snapshot 0: {xsnap0!r}")
+            if traffic_directions > 1:
+                xsnap1 = client.ports[1].get_xstats().reference_stats
+                print(f"Xstats snapshot 1: {xsnap1!r}")
+        else:
             # Block until done:
-            client.wait_on_traffic(ports=[port_0, port_1], timeout=duration+30)
+            client.wait_on_traffic(ports=ports, timeout=duration+30)
+            time_stop = time.time()
+            print(f"Main traffic took {time_stop - time_start} seconds.")
 
             if client.get_warnings():
                 for warning in client.get_warnings():
@@ -192,31 +217,39 @@ def simple_burst(profile_file, duration, framesize, rate, warmup_time, port_0,
             # Read the stats after the test
             stats = client.get_stats()
 
-            print("##### Statistics #####")
-            print(json.dumps(stats, indent=4, separators=(',', ': '),
-                             sort_keys=True))
+            print(u"##### Statistics #####")
+            print(json.dumps(stats, indent=4, separators=(u",", u": ")))
 
-            lost_a = stats[0]["opackets"] - stats[1]["ipackets"]
-            lost_b = stats[1]["opackets"] - stats[0]["ipackets"]
+            lost_a = stats[port_0][u"opackets"] - stats[port_1][u"ipackets"]
+            if traffic_directions > 1:
+                lost_b = stats[port_1][u"opackets"] - stats[port_0][u"ipackets"]
 
+            # Stats index is not a port number, but "pgid".
+            # TODO: Find out what "pgid" means.
             if latency:
+                lat_obj = stats[u"latency"][0][u"latency"]
                 lat_a = fmt_latency(
-                    str(stats["latency"][0]["latency"]["total_min"]),
-                    str(stats["latency"][0]["latency"]["average"]),
-                    str(stats["latency"][0]["latency"]["total_max"]))
-                lat_b = fmt_latency(
-                    str(stats["latency"][1]["latency"]["total_min"]),
-                    str(stats["latency"][1]["latency"]["average"]),
-                    str(stats["latency"][1]["latency"]["total_max"]))
-
-            total_sent = stats[0]["opackets"] + stats[1]["opackets"]
-            total_rcvd = stats[0]["ipackets"] + stats[1]["ipackets"]
-
-            print("\npackets lost from 0 --> 1:   {0} pkts".format(lost_a))
-            print("packets lost from 1 --> 0:   {0} pkts".format(lost_b))
-
-    except STLError as err:
-        sys.stderr.write("{0}\n".format(err))
+                    str(lat_obj[u"total_min"]), str(lat_obj[u"average"]),
+                    str(lat_obj[u"total_max"]), str(lat_obj[u"hdrh"]))
+                if traffic_directions > 1:
+                    lat_obj = stats[u"latency"][1][u"latency"]
+                    lat_b = fmt_latency(
+                        str(lat_obj[u"total_min"]), str(lat_obj[u"average"]),
+                        str(lat_obj[u"total_max"]), str(lat_obj[u"hdrh"]))
+
+            if traffic_directions > 1:
+                total_sent = stats[0][u"opackets"] + stats[1][u"opackets"]
+                total_rcvd = stats[0][u"ipackets"] + stats[1][u"ipackets"]
+            else:
+                total_sent = stats[port_0][u"opackets"]
+                total_rcvd = stats[port_1][u"ipackets"]
+
+            print(f"\npackets lost from {port_0} --> {port_1}: {lost_a} pkts")
+            if traffic_directions > 1:
+                print(f"packets lost from {port_1} --> {port_0}: {lost_b} pkts")
+
+    except STLError as ex_error:
+        print(ex_error, file=sys.stderr)
         sys.exit(1)
 
     finally:
@@ -226,11 +259,12 @@ def simple_burst(profile_file, duration, framesize, rate, warmup_time, port_0,
         else:
             if client:
                 client.disconnect()
-            print("rate={0}, totalReceived={1}, totalSent={2}, "
-                  "frameLoss={3}, latencyStream0(usec)={4}, "
-                  "latencyStream1(usec)={5}".
-                  format(rate, total_rcvd, total_sent, lost_a + lost_b,
-                         lat_a, lat_b))
+            print(
+                f"rate={rate!r}, totalReceived={total_rcvd}, "
+                f"totalSent={total_sent}, frameLoss={lost_a + lost_b}, "
+                f"latencyStream0(usec)={lat_a}, latencyStream1(usec)={lat_b}, "
+                f"targetDuration={duration!r}"
+            )
 
 
 def main():
@@ -239,42 +273,52 @@ def main():
     It verifies the given command line arguments and runs "simple_burst"
     function.
     """
-
     parser = argparse.ArgumentParser()
-    parser.add_argument("-p", "--profile",
-                        required=True,
-                        type=str,
-                        help="Python traffic profile.")
-    parser.add_argument("-d", "--duration",
-                        required=True,
-                        type=int,
-                        help="Duration of traffic run.")
-    parser.add_argument("-s", "--frame_size",
-                        required=True,
-                        help="Size of a Frame without padding and IPG.")
-    parser.add_argument("-r", "--rate",
-                        required=True,
-                        help="Traffic rate with included units (%, pps).")
-    parser.add_argument("-w", "--warmup_time",
-                        type=int,
-                        default=5,
-                        help="Traffic warm-up time in seconds, 0 = disable.")
-    parser.add_argument("--port_0",
-                        required=True,
-                        type=int,
-                        help="Port 0 on the traffic generator.")
-    parser.add_argument("--port_1",
-                        required=True,
-                        type=int,
-                        help="Port 1 on the traffic generator.")
-    parser.add_argument("--async",
-                        action="store_true",
-                        default=False,
-                        help="Non-blocking call of the script.")
-    parser.add_argument("--latency",
-                        action="store_true",
-                        default=False,
-                        help="Add latency stream")
+    parser.add_argument(
+        u"-p", u"--profile", required=True, type=str,
+        help=u"Python traffic profile."
+    )
+    parser.add_argument(
+        u"-d", u"--duration", required=True, type=float,
+        help=u"Duration of traffic run."
+    )
+    parser.add_argument(
+        u"-s", u"--frame_size", required=True,
+        help=u"Size of a Frame without padding and IPG."
+    )
+    parser.add_argument(
+        u"-r", u"--rate", required=True,
+        help=u"Traffic rate with included units (%, pps)."
+    )
+    parser.add_argument(
+        u"-w", u"--warmup_time", type=float, default=5.0,
+        help=u"Traffic warm-up time in seconds, 0 = disable."
+    )
+    parser.add_argument(
+        u"--port_0", required=True, type=int,
+        help=u"Port 0 on the traffic generator."
+    )
+    parser.add_argument(
+        u"--port_1", required=True, type=int,
+        help=u"Port 1 on the traffic generator."
+    )
+    parser.add_argument(
+        u"--async_start", action=u"store_true", default=False,
+        help=u"Non-blocking call of the script."
+    )
+    parser.add_argument(
+        u"--latency", action=u"store_true", default=False,
+        help=u"Add latency stream."
+    )
+    parser.add_argument(
+        u"--traffic_directions", type=int, default=2,
+        help=u"Send bi- (2) or uni- (1) directional traffic."
+    )
+    parser.add_argument(
+        u"--force", action=u"store_true", default=False,
+        help=u"Force start regardless of ports state."
+    )
+
     args = parser.parse_args()
 
     try:
@@ -282,16 +326,13 @@ def main():
     except ValueError:
         framesize = args.frame_size
 
-    simple_burst(profile_file=args.profile,
-                 duration=int(args.duration),
-                 framesize=framesize,
-                 rate=args.rate,
-                 warmup_time=int(args.warmup_time),
-                 port_0=int(args.port_0),
-                 port_1=int(args.port_1),
-                 latency=args.latency,
-                 async_start=args.async)
+    simple_burst(
+        profile_file=args.profile, duration=args.duration, framesize=framesize,
+        rate=args.rate, warmup_time=args.warmup_time, port_0=args.port_0,
+        port_1=args.port_1, latency=args.latency, async_start=args.async_start,
+        traffic_directions=args.traffic_directions, force=args.force
+    )
 
 
-if __name__ == '__main__':
+if __name__ == u"__main__":
     main()