10 files changed, 257 insertions, 132 deletions

diff --git a/tools/pkt_gen/dummy/dummy.py b/tools/pkt_gen/dummy/dummy.py
index 3dc5448e..ef4b37d9 100755
--- a/tools/pkt_gen/dummy/dummy.py
+++ b/tools/pkt_gen/dummy/dummy.py
@@ -25,6 +25,7 @@ own.
 
 import json
 
+from collections import OrderedDict
 from conf import settings
 from conf import merge_spec
 from tools.pkt_gen import trafficgen
@@ -108,41 +109,41 @@ class Dummy(trafficgen.ITrafficGenerator):
         """
         pass
 
-    def send_burst_traffic(self, traffic=None, numpkts=100, duration=20):
+    def send_burst_traffic(self, traffic=None, duration=20):
         """
         Send a burst of traffic.
         """
         traffic_ = self.traffic_defaults.copy()
-        result = {}
+        result = OrderedDict()
 
         if traffic:
             traffic_ = merge_spec(traffic_, traffic)
 
         results = get_user_traffic(
             'burst',
-            '%dpkts, %dmS' % (numpkts, duration),
+            '%dpkts, %dmS' % (traffic['burst_size'], duration),
             traffic_,
             ('frames rx', 'payload errors', 'sequence errors'))
 
         # builds results by using user-supplied values where possible
         # and guessing remainder using available info
-        result[ResultsConstants.TX_FRAMES] = numpkts
+        result[ResultsConstants.TX_FRAMES] = traffic['burst_size']
         result[ResultsConstants.RX_FRAMES] = results[0]
         result[ResultsConstants.TX_BYTES] = traffic_['l2']['framesize'] \
-                                            * numpkts
+                                            * traffic['burst_size']
         result[ResultsConstants.RX_BYTES] = traffic_['l2']['framesize'] \
                                             * results[0]
         result[ResultsConstants.PAYLOAD_ERR] = results[1]
         result[ResultsConstants.SEQ_ERR] = results[2]
 
-        return results
+        return result
 
     def send_cont_traffic(self, traffic=None, duration=30):
         """
         Send a continuous flow of traffic.
         """
         traffic_ = self.traffic_defaults.copy()
-        result = {}
+        result = OrderedDict()
 
         if traffic:
             traffic_ = merge_spec(traffic_, traffic)
@@ -179,7 +180,7 @@ class Dummy(trafficgen.ITrafficGenerator):
         Send traffic per RFC2544 throughput test specifications.
         """
         traffic_ = self.traffic_defaults.copy()
-        result = {}
+        result = OrderedDict()
 
         if traffic:
             traffic_ = merge_spec(traffic_, traffic)
@@ -216,7 +217,7 @@ class Dummy(trafficgen.ITrafficGenerator):
         Send traffic per RFC2544 back2back test specifications.
         """
         traffic_ = self.traffic_defaults.copy()
-        result = {}
+        result = OrderedDict()
 
         if traffic:
             traffic_ = merge_spec(traffic_, traffic)
@@ -273,4 +274,5 @@ if __name__ == '__main__':
         print(dev.send_cont_traffic(traffic=TRAFFIC))
         print(dev.send_rfc2544_throughput(traffic=TRAFFIC))
         print(dev.send_rfc2544_back2back(traffic=TRAFFIC))
+        # pylint: disable=no-member
         print(dev.send_rfc(traffic=TRAFFIC))
diff --git a/tools/pkt_gen/ixia/ixia.py b/tools/pkt_gen/ixia/ixia.py
index d4ca56f2..31f51246 100755
--- a/tools/pkt_gen/ixia/ixia.py
+++ b/tools/pkt_gen/ixia/ixia.py
@@ -157,8 +157,8 @@ class Ixia(trafficgen.ITrafficGenerator):
         return NotImplementedError(
             'Ixia start back2back traffic not implemented')
 
-    def send_rfc2544_back2back(self, traffic=None, duration=60,
-                               lossrate=0.0, tests=1):
+    def send_rfc2544_back2back(self, traffic=None, tests=1, duration=60,
+                               lossrate=0.0):
         return NotImplementedError(
             'Ixia send back2back traffic not implemented')
 
@@ -242,11 +242,11 @@ class Ixia(trafficgen.ITrafficGenerator):
 
         return result
 
-    def send_burst_traffic(self, traffic=None, numpkts=100, duration=20):
+    def send_burst_traffic(self, traffic=None, duration=20):
         """See ITrafficGenerator for description
         """
         flow = {
-            'numpkts': numpkts,
+            'numpkts': traffic['burst_size'],
             'duration': duration,
             'type': 'stopStream',
             'framerate': traffic['frame_rate'],
@@ -254,9 +254,9 @@ class Ixia(trafficgen.ITrafficGenerator):
 
         result = self._send_traffic(flow, traffic)
 
-        assert len(result) == 6  # fail-fast if underlying Tcl code changes
+        assert len(result) == 10  # fail-fast if underlying Tcl code changes
 
-        #NOTE - implement Burst results setting via TrafficgenResults.
+        return Ixia._create_result(result)
 
     def send_cont_traffic(self, traffic=None, duration=30):
         """See ITrafficGenerator for description
@@ -317,20 +317,25 @@ class Ixia(trafficgen.ITrafficGenerator):
         :returns: dictionary strings representing results from
                     traffic generator.
         """
-        assert len(result) == 8  # fail-fast if underlying Tcl code changes
+        assert len(result) == 8 or len(result) == 10  # fail-fast if underlying Tcl code changes
+
+        # content of result common for all tests
+        # [framesSent, framesRecv, bytesSent, bytesRecv, sendRate, recvRate, sendRateBytes, recvRateBytes]
+        # burst test has additional two values at the end: payError, seqError
 
         if float(result[0]) == 0:
             loss_rate = 100
         else:
-            loss_rate = (float(result[0]) - float(result[1])) / float(result[0]) * 100
+            loss_rate = round((float(result[0]) - float(result[1])) / float(result[0]) * 100, 5)
         result_dict = OrderedDict()
-        # drop the first 4 elements as we don't use/need them. In
-        # addition, IxExplorer does not support latency or % line rate
+        # IxExplorer does not support latency or % line rate
         # metrics so we have to return dummy values for these metrics
-        result_dict[ResultsConstants.THROUGHPUT_RX_FPS] = result[4]
-        result_dict[ResultsConstants.TX_RATE_FPS] = result[5]
-        result_dict[ResultsConstants.THROUGHPUT_RX_MBPS] = str(round(int(result[6]) / 1000000, 3))
-        result_dict[ResultsConstants.TX_RATE_MBPS] = str(round(int(result[7]) / 1000000, 3))
+        result_dict[ResultsConstants.TX_FRAMES] = result[0]
+        result_dict[ResultsConstants.RX_FRAMES] = result[1]
+        result_dict[ResultsConstants.TX_RATE_FPS] = result[4]
+        result_dict[ResultsConstants.THROUGHPUT_RX_FPS] = result[5]
+        result_dict[ResultsConstants.TX_RATE_MBPS] = str(round(int(result[6]) * 8 / 1e6, 3))
+        result_dict[ResultsConstants.THROUGHPUT_RX_MBPS] = str(round(int(result[7]) * 8 / 1e6, 3))
         result_dict[ResultsConstants.FRAME_LOSS_PERCENT] = loss_rate
         result_dict[ResultsConstants.TX_RATE_PERCENT] = \
                                             ResultsConstants.UNKNOWN_VALUE
diff --git a/tools/pkt_gen/ixnet/ixnet.py b/tools/pkt_gen/ixnet/ixnet.py
index d1ba9096..87fb2c65 100755
--- a/tools/pkt_gen/ixnet/ixnet.py
+++ b/tools/pkt_gen/ixnet/ixnet.py
@@ -370,7 +370,7 @@ class IxNet(trafficgen.ITrafficGenerator):
                 next(reader)
                 for row in reader:
                     #Replace null entries added by Ixia with 0s.
-                    row = [entry if len(entry) > 0 else '0' for entry in row]
+                    row = [entry if entry else '0' for entry in row]
 
                     # tx_fps and tx_mps cannot be reliably calculated
                     # as the DUT may be modifying the frame size
@@ -528,7 +528,7 @@ class IxNet(trafficgen.ITrafficGenerator):
 
         return parse_ixnet_rfc_results(parse_result_string(output[0]))
 
-    def send_burst_traffic(self, traffic=None, numpkts=100, duration=20):
+    def send_burst_traffic(self, traffic=None, duration=20):
         return NotImplementedError('IxNet does not implement send_burst_traffic')
 
 if __name__ == '__main__':
diff --git a/tools/pkt_gen/moongen/moongen.py b/tools/pkt_gen/moongen/moongen.py
index 570720e8..b7d55c4d 100644
--- a/tools/pkt_gen/moongen/moongen.py
+++ b/tools/pkt_gen/moongen/moongen.py
@@ -64,46 +64,46 @@ class Moongen(ITrafficGenerator):
         :param one_shot: No RFC 2544 binary search,
                         just packet flow at traffic specifics
         """
-        logging.debug("traffic['frame_rate'] = " + \
+        logging.debug("traffic['frame_rate'] = %s", \
             str(traffic['frame_rate']))
 
-        logging.debug("traffic['multistream'] = " + \
+        logging.debug("traffic['multistream'] = %s", \
             str(traffic['multistream']))
 
-        logging.debug("traffic['stream_type'] = " + \
+        logging.debug("traffic['stream_type'] = %s", \
             str(traffic['stream_type']))
 
-        logging.debug("traffic['l2']['srcmac'] = " + \
+        logging.debug("traffic['l2']['srcmac'] = %s", \
             str(traffic['l2']['srcmac']))
 
-        logging.debug("traffic['l2']['dstmac'] = " + \
+        logging.debug("traffic['l2']['dstmac'] = %s", \
             str(traffic['l2']['dstmac']))
 
-        logging.debug("traffic['l3']['proto'] = " + \
+        logging.debug("traffic['l3']['proto'] = %s", \
             str(traffic['l3']['proto']))
 
-        logging.debug("traffic['l3']['srcip'] = " + \
+        logging.debug("traffic['l3']['srcip'] = %s", \
             str(traffic['l3']['srcip']))
 
-        logging.debug("traffic['l3']['dstip'] = " + \
+        logging.debug("traffic['l3']['dstip'] = %s", \
             str(traffic['l3']['dstip']))
 
-        logging.debug("traffic['l4']['srcport'] = " + \
+        logging.debug("traffic['l4']['srcport'] = %s", \
             str(traffic['l4']['srcport']))
 
-        logging.debug("traffic['l4']['dstport'] = " + \
+        logging.debug("traffic['l4']['dstport'] = %s", \
             str(traffic['l4']['dstport']))
 
-        logging.debug("traffic['vlan']['enabled'] = " + \
+        logging.debug("traffic['vlan']['enabled'] = %s", \
             str(traffic['vlan']['enabled']))
 
-        logging.debug("traffic['vlan']['id'] = " + \
+        logging.debug("traffic['vlan']['id'] = %s", \
             str(traffic['vlan']['id']))
 
-        logging.debug("traffic['vlan']['priority'] = " + \
+        logging.debug("traffic['vlan']['priority'] = %s", \
             str(traffic['vlan']['priority']))
 
-        logging.debug("traffic['vlan']['cfi'] = " + \
+        logging.debug("traffic['vlan']['cfi'] = %s", \
             str(traffic['vlan']['cfi']))
 
         logging.debug(traffic['l2']['framesize'])
@@ -160,9 +160,9 @@ class Moongen(ITrafficGenerator):
             (traffic['frame_rate'] / 100) * (self._moongen_line_speed / \
             (8 * (traffic['l2']['framesize'] + 20)) / math.pow(10, 6)))
 
-        logging.debug("startRate = " + start_rate)
+        logging.debug("startRate = %s", start_rate)
 
-        out_file.write("startRate = " + \
+        out_file.write("startRate = %s" % \
             start_rate + "\n")
 
         out_file.write("}" + "\n")
@@ -240,14 +240,13 @@ class Moongen(ITrafficGenerator):
         """
         self._logger.info("MOONGEN: In moongen disconnect method")
 
-    def send_burst_traffic(self, traffic=None, numpkts=100, duration=20):
+    def send_burst_traffic(self, traffic=None, duration=20):
         """Send a burst of traffic.
 
-        Send a ``numpkts`` packets of traffic, using ``traffic``
+        Send a ``traffic['burst_traffic']`` packets of traffic, using ``traffic``
         configuration, with a timeout of ``time``.
 
         :param traffic: Detailed "traffic" spec, i.e. IP address, VLAN tags
-        :param numpkts: Number of packets to send
         :param duration: Time to wait to receive packets
 
         :returns: dictionary of strings with following data:
@@ -508,8 +507,8 @@ class Moongen(ITrafficGenerator):
 
         return moongen_results
 
-    def send_rfc2544_throughput(self, traffic=None, duration=20,
-                                lossrate=0.0, tests=1):
+    def send_rfc2544_throughput(self, traffic=None, tests=1, duration=20,
+                                lossrate=0.0):
         #
         # Send traffic per RFC2544 throughput test specifications.
         #
@@ -631,8 +630,8 @@ class Moongen(ITrafficGenerator):
         """
         self._logger.info('In moongen wait_rfc2544_throughput')
 
-    def send_rfc2544_back2back(self, traffic=None, duration=60,
-                               lossrate=0.0, tests=1):
+    def send_rfc2544_back2back(self, traffic=None, tests=1, duration=60,
+                               lossrate=0.0):
         """Send traffic per RFC2544 back2back test specifications.
 
         Send packets at a fixed rate, using ``traffic``
diff --git a/tools/pkt_gen/testcenter/testcenter.py b/tools/pkt_gen/testcenter/testcenter.py
index 9980ae7c..487566bf 100644
--- a/tools/pkt_gen/testcenter/testcenter.py
+++ b/tools/pkt_gen/testcenter/testcenter.py
@@ -182,7 +182,7 @@ class TestCenter(trafficgen.ITrafficGenerator):
         """
         pass
 
-    def send_burst_traffic(self, traffic=None, numpkts=100, duration=20):
+    def send_burst_traffic(self, traffic=None, duration=20):
         """
         Do nothing.
         """
@@ -246,8 +246,7 @@ class TestCenter(trafficgen.ITrafficGenerator):
                     row["ForwardingRate(fps)"])
         return result
 
-    # pylint: disable=unused-argument
-    def send_rfc2889_forwarding(self, traffic=None, tests=1, duration=20):
+    def send_rfc2889_forwarding(self, traffic=None, tests=1, _duration=20):
         """
         Send traffic per RFC2889 Forwarding test specifications.
         """
@@ -257,7 +256,7 @@ class TestCenter(trafficgen.ITrafficGenerator):
                 framesize = traffic['l2']['framesize']
         args = get_rfc2889_common_settings(framesize, tests,
                                            traffic['traffic_type'])
-        if settings.getValue("TRAFFICGEN_STC_VERBOSE") is "True":
+        if settings.getValue("TRAFFICGEN_STC_VERBOSE") == "True":
             args.append("--verbose")
             verbose = True
             self._logger.debug("Arguments used to call test: %s", args)
@@ -273,7 +272,7 @@ class TestCenter(trafficgen.ITrafficGenerator):
 
         return self.get_rfc2889_forwarding_results(filec)
 
-    def send_rfc2889_caching(self, traffic=None, tests=1, duration=20):
+    def send_rfc2889_caching(self, traffic=None, tests=1, _duration=20):
         """
         Send as per RFC2889 Addr-Caching test specifications.
         """
@@ -286,7 +285,7 @@ class TestCenter(trafficgen.ITrafficGenerator):
         custom_args = get_rfc2889_custom_settings()
         args = common_args + custom_args
 
-        if settings.getValue("TRAFFICGEN_STC_VERBOSE") is "True":
+        if settings.getValue("TRAFFICGEN_STC_VERBOSE") == "True":
             args.append("--verbose")
             verbose = True
             self._logger.debug("Arguments used to call test: %s", args)
@@ -302,7 +301,7 @@ class TestCenter(trafficgen.ITrafficGenerator):
 
         return self.get_rfc2889_addr_caching_results(filec)
 
-    def send_rfc2889_learning(self, traffic=None, tests=1, duration=20):
+    def send_rfc2889_learning(self, traffic=None, tests=1, _duration=20):
         """
         Send traffic per RFC2889 Addr-Learning test specifications.
         """
@@ -315,7 +314,7 @@ class TestCenter(trafficgen.ITrafficGenerator):
         custom_args = get_rfc2889_custom_settings()
         args = common_args + custom_args
 
-        if settings.getValue("TRAFFICGEN_STC_VERBOSE") is "True":
+        if settings.getValue("TRAFFICGEN_STC_VERBOSE") == "True":
             args.append("--verbose")
             verbose = True
             self._logger.debug("Arguments used to call test: %s", args)
@@ -387,7 +386,7 @@ class TestCenter(trafficgen.ITrafficGenerator):
                                                           custom, 1)
         args = rfc2544_common_args + stc_common_args + rfc2544_custom_args
 
-        if settings.getValue("TRAFFICGEN_STC_VERBOSE") is "True":
+        if settings.getValue("TRAFFICGEN_STC_VERBOSE") == "True":
             args.append("--verbose")
             verbose = True
             self._logger.debug("Arguments used to call test: %s", args)
@@ -420,7 +419,7 @@ class TestCenter(trafficgen.ITrafficGenerator):
                                                           tests)
         args = rfc2544_common_args + stc_common_args + rfc2544_custom_args
 
-        if settings.getValue("TRAFFICGEN_STC_VERBOSE") is "True":
+        if settings.getValue("TRAFFICGEN_STC_VERBOSE") == "True":
             args.append("--verbose")
             verbose = True
             self._logger.debug("Arguments used to call test: %s", args)
@@ -453,7 +452,7 @@ class TestCenter(trafficgen.ITrafficGenerator):
                                                           tests)
         args = rfc2544_common_args + stc_common_args + rfc2544_custom_args
 
-        if settings.getValue("TRAFFICGEN_STC_VERBOSE") is "True":
+        if settings.getValue("TRAFFICGEN_STC_VERBOSE") == "True":
             args.append("--verbose")
             verbose = True
             self._logger.info("Arguments used to call test: %s", args)
@@ -498,4 +497,5 @@ if __name__ == '__main__':
     }
     with TestCenter() as dev:
         print(dev.send_rfc2544_throughput(traffic=TRAFFIC))
+        # pylint: disable=no-member
         print(dev.send_rfc2544_backtoback(traffic=TRAFFIC))
diff --git a/tools/pkt_gen/trafficgen/trafficgen.py b/tools/pkt_gen/trafficgen/trafficgen.py
index 262df71d..a6f7edcc 100755
--- a/tools/pkt_gen/trafficgen/trafficgen.py
+++ b/tools/pkt_gen/trafficgen/trafficgen.py
@@ -81,15 +81,14 @@ class ITrafficGenerator(object):
         """
         raise NotImplementedError('Please call an implementation.')
 
-    def send_burst_traffic(self, traffic=None, numpkts=100, duration=20):
+    def send_burst_traffic(self, traffic=None, duration=20):
         """Send a burst of traffic.
 
-        Send a ``numpkts`` packets of traffic, using ``traffic``
+        Send a ``traffic['burst_size']`` packets of traffic, using ``traffic``
         configuration, for ``duration`` seconds.
 
         Attributes:
         :param traffic: Detailed "traffic" spec, see design docs for details
-        :param numpkts: Number of packets to send
         :param duration: Time to wait to receive packets
 
         :returns: dictionary of strings with following data:
diff --git a/tools/pkt_gen/trex/trex.py b/tools/pkt_gen/trex/trex.py
index e0ce4c48..94b793d6 100644
--- a/tools/pkt_gen/trex/trex.py
+++ b/tools/pkt_gen/trex/trex.py
@@ -15,12 +15,14 @@
 """
 Trex Traffic Generator Model
 """
+
 # pylint: disable=undefined-variable
 import logging
 import subprocess
 import sys
 import time
 import os
+import re
 from collections import OrderedDict
 # pylint: disable=unused-import
 import netaddr
@@ -69,6 +71,20 @@ _EMPTY_STATS = {
               'tx_pps': 0.0,
               'tx_util': 0.0,}}
 
+# Default frame definition, which can be overridden by TRAFFIC['scapy'].
+# The content of the frame and its network layers are driven by TRAFFIC
+# dictionary, i.e. 'l2', 'l3, 'l4' and 'vlan' parts.
+_SCAPY_FRAME = {
+    '0' : 'Ether(src={Ether_src}, dst={Ether_dst})/'
+          'Dot1Q(prio={Dot1Q_prio}, id={Dot1Q_id}, vlan={Dot1Q_vlan})/'
+          'IP(proto={IP_proto}, src={IP_src}, dst={IP_dst})/'
+          '{IP_PROTO}(sport={IP_PROTO_sport}, dport={IP_PROTO_dport})',
+    '1' : 'Ether(src={Ether_dst}, dst={Ether_src})/'
+          'Dot1Q(prio={Dot1Q_prio}, id={Dot1Q_id}, vlan={Dot1Q_vlan})/'
+          'IP(proto={IP_proto}, src={IP_dst}, dst={IP_src})/'
+          '{IP_PROTO}(sport={IP_PROTO_dport}, dport={IP_PROTO_sport})',
+}
+
 
 class Trex(ITrafficGenerator):
     """Trex Traffic generator wrapper."""
@@ -165,35 +181,77 @@ class Trex(ITrafficGenerator):
         self._logger.info("T-Rex: In trex disconnect method")
         self._stlclient.disconnect(stop_traffic=True, release_ports=True)
 
-    @staticmethod
-    def create_packets(traffic, ports_info):
+    def create_packets(self, traffic, ports_info):
         """Create base packet according to traffic specification.
            If traffic haven't specified srcmac and dstmac fields
-           packet will be create with mac address of trex server.
+           packet will be created with mac address of trex server.
         """
-        mac_add = [li['hw_mac'] for li in ports_info]
-
-        if traffic and traffic['l2']['framesize'] > 0:
-            if traffic['l2']['dstmac'] == '00:00:00:00:00:00' and \
-               traffic['l2']['srcmac'] == '00:00:00:00:00:00':
-                base_pkt_a = Ether(src=mac_add[0], dst=mac_add[1])/ \
-                             IP(proto=traffic['l3']['proto'], src=traffic['l3']['srcip'],
-                                dst=traffic['l3']['dstip'])/ \
-                             UDP(dport=traffic['l4']['dstport'], sport=traffic['l4']['srcport'])
-                base_pkt_b = Ether(src=mac_add[1], dst=mac_add[0])/ \
-                             IP(proto=traffic['l3']['proto'], src=traffic['l3']['dstip'],
-                                dst=traffic['l3']['srcip'])/ \
-                             UDP(dport=traffic['l4']['srcport'], sport=traffic['l4']['dstport'])
-            else:
-                base_pkt_a = Ether(src=traffic['l2']['srcmac'], dst=traffic['l2']['dstmac'])/ \
-                             IP(proto=traffic['l3']['proto'], src=traffic['l3']['dstip'],
-                                dst=traffic['l3']['srcip'])/ \
-                             UDP(dport=traffic['l4']['dstport'], sport=traffic['l4']['srcport'])
+        if not traffic or traffic['l2']['framesize'] <= 0:
+            return (None, None)
 
-                base_pkt_b = Ether(src=traffic['l2']['dstmac'], dst=traffic['l2']['srcmac'])/ \
-                             IP(proto=traffic['l3']['proto'], src=traffic['l3']['dstip'],
-                                dst=traffic['l3']['srcip'])/ \
-                             UDP(dport=traffic['l4']['srcport'], sport=traffic['l4']['dstport'])
+        if traffic['l2']['dstmac'] == '00:00:00:00:00:00' and \
+           traffic['l2']['srcmac'] == '00:00:00:00:00:00':
+
+            mac_add = [li['hw_mac'] for li in ports_info]
+            src_mac = mac_add[0]
+            dst_mac = mac_add[1]
+        else:
+            src_mac = traffic['l2']['srcmac']
+            dst_mac = traffic['l2']['dstmac']
+
+        if traffic['scapy']['enabled']:
+            base_pkt_a = traffic['scapy']['0']
+            base_pkt_b = traffic['scapy']['1']
+        else:
+            base_pkt_a = _SCAPY_FRAME['0']
+            base_pkt_b = _SCAPY_FRAME['1']
+
+        # check and remove network layers disabled by TRAFFIC dictionary
+        # Note: In general, it is possible to remove layers from scapy object by
+        # e.g. del base_pkt_a['IP']. However it doesn't work for all layers
+        # (e.g. Dot1Q). Thus it is safer to modify string with scapy frame definition
+        # directly, before it is converted to the real scapy object.
+        if not traffic['vlan']['enabled']:
+            self._logger.info('VLAN headers are disabled by TRAFFIC')
+            base_pkt_a = re.sub(r'(^|\/)Dot1Q?\([^\)]*\)', '', base_pkt_a)
+            base_pkt_b = re.sub(r'(^|\/)Dot1Q?\([^\)]*\)', '', base_pkt_b)
+        if not traffic['l3']['enabled']:
+            self._logger.info('IP headers are disabled by TRAFFIC')
+            base_pkt_a = re.sub(r'(^|\/)IP(v6)?\([^\)]*\)', '', base_pkt_a)
+            base_pkt_b = re.sub(r'(^|\/)IP(v6)?\([^\)]*\)', '', base_pkt_b)
+        if not traffic['l4']['enabled']:
+            self._logger.info('%s headers are disabled by TRAFFIC',
+                              traffic['l3']['proto'].upper())
+            base_pkt_a = re.sub(r'(^|\/)(UDP|TCP|SCTP|{{IP_PROTO}}|{})\([^\)]*\)'.format(
+                traffic['l3']['proto'].upper()), '', base_pkt_a)
+            base_pkt_b = re.sub(r'(^|\/)(UDP|TCP|SCTP|{{IP_PROTO}}|{})\([^\)]*\)'.format(
+                traffic['l3']['proto'].upper()), '', base_pkt_b)
+
+        # pylint: disable=eval-used
+        base_pkt_a = eval(base_pkt_a.format(
+            Ether_src=repr(src_mac),
+            Ether_dst=repr(dst_mac),
+            Dot1Q_prio=traffic['vlan']['priority'],
+            Dot1Q_id=traffic['vlan']['cfi'],
+            Dot1Q_vlan=traffic['vlan']['id'],
+            IP_proto=repr(traffic['l3']['proto']),
+            IP_PROTO=traffic['l3']['proto'].upper(),
+            IP_src=repr(traffic['l3']['srcip']),
+            IP_dst=repr(traffic['l3']['dstip']),
+            IP_PROTO_sport=traffic['l4']['srcport'],
+            IP_PROTO_dport=traffic['l4']['dstport']))
+        base_pkt_b = eval(base_pkt_b.format(
+            Ether_src=repr(src_mac),
+            Ether_dst=repr(dst_mac),
+            Dot1Q_prio=traffic['vlan']['priority'],
+            Dot1Q_id=traffic['vlan']['cfi'],
+            Dot1Q_vlan=traffic['vlan']['id'],
+            IP_proto=repr(traffic['l3']['proto']),
+            IP_PROTO=traffic['l3']['proto'].upper(),
+            IP_src=repr(traffic['l3']['srcip']),
+            IP_dst=repr(traffic['l3']['dstip']),
+            IP_PROTO_sport=traffic['l4']['srcport'],
+            IP_PROTO_dport=traffic['l4']['dstport']))
 
         return (base_pkt_a, base_pkt_b)
 
@@ -248,22 +306,48 @@ class Trex(ITrafficGenerator):
             pkt_a = STLPktBuilder(pkt=base_pkt_a / payload_a)
             pkt_b = STLPktBuilder(pkt=base_pkt_b / payload_b)
 
-        stream_1 = STLStream(packet=pkt_a,
-                             name='stream_1',
-                             mode=STLTXCont(percentage=traffic['frame_rate']))
-        stream_2 = STLStream(packet=pkt_b,
-                             name='stream_2',
-                             mode=STLTXCont(percentage=traffic['frame_rate']))
         lat_pps = settings.getValue('TRAFFICGEN_TREX_LATENCY_PPS')
-        if lat_pps > 0:
-            stream_1_lat = STLStream(packet=pkt_a,
+        if traffic['traffic_type'] == 'burst':
+            if lat_pps > 0:
+                # latency statistics are requested; in case of frame burst we can enable
+                # statistics for all frames
+                stream_1 = STLStream(packet=pkt_a,
                                      flow_stats=STLFlowLatencyStats(pg_id=0),
-                                     name='stream_1_lat',
-                                     mode=STLTXCont(pps=lat_pps))
-            stream_2_lat = STLStream(packet=pkt_b,
+                                     name='stream_1',
+                                     mode=STLTXSingleBurst(percentage=traffic['frame_rate'],
+                                                           total_pkts=traffic['burst_size']))
+                stream_2 = STLStream(packet=pkt_b,
                                      flow_stats=STLFlowLatencyStats(pg_id=1),
-                                     name='stream_2_lat',
-                                     mode=STLTXCont(pps=lat_pps))
+                                     name='stream_2',
+                                     mode=STLTXSingleBurst(percentage=traffic['frame_rate'],
+                                                           total_pkts=traffic['burst_size']))
+            else:
+                stream_1 = STLStream(packet=pkt_a,
+                                     name='stream_1',
+                                     mode=STLTXSingleBurst(percentage=traffic['frame_rate'],
+                                                           total_pkts=traffic['burst_size']))
+                stream_2 = STLStream(packet=pkt_b,
+                                     name='stream_2',
+                                     mode=STLTXSingleBurst(percentage=traffic['frame_rate'],
+                                                           total_pkts=traffic['burst_size']))
+        else:
+            stream_1 = STLStream(packet=pkt_a,
+                                 name='stream_1',
+                                 mode=STLTXCont(percentage=traffic['frame_rate']))
+            stream_2 = STLStream(packet=pkt_b,
+                                 name='stream_2',
+                                 mode=STLTXCont(percentage=traffic['frame_rate']))
+            # workaround for latency statistics, which can't be enabled for streams
+            # with high framerate due to the huge performance impact
+            if lat_pps > 0:
+                stream_1_lat = STLStream(packet=pkt_a,
+                                         flow_stats=STLFlowLatencyStats(pg_id=0),
+                                         name='stream_1_lat',
+                                         mode=STLTXCont(pps=lat_pps))
+                stream_2_lat = STLStream(packet=pkt_b,
+                                         flow_stats=STLFlowLatencyStats(pg_id=1),
+                                         name='stream_2_lat',
+                                         mode=STLTXCont(pps=lat_pps))
 
         return (stream_1, stream_2, stream_1_lat, stream_2_lat)
 
@@ -293,13 +377,13 @@ class Trex(ITrafficGenerator):
             # since we can only control both ports at once take the lower of the two
             max_speed = min(max_speed_1, max_speed_2)
         gbps_speed = (max_speed / 1000) * (float(traffic['frame_rate']) / 100.0)
-        self._logger.debug('Starting traffic at %s Gpbs speed', gbps_speed)
+        self._logger.debug('Starting traffic at %s Gbps speed', gbps_speed)
 
         # for SR-IOV
         if settings.getValue('TRAFFICGEN_TREX_PROMISCUOUS'):
             self._stlclient.set_port_attr(my_ports, promiscuous=True)
 
-        packet_1, packet_2 = Trex.create_packets(traffic, ports_info)
+        packet_1, packet_2 = self.create_packets(traffic, ports_info)
         self.show_packet_info(packet_1, packet_2)
         stream_1, stream_2, stream_1_lat, stream_2_lat = Trex.create_streams(packet_1, packet_2, traffic)
         self._stlclient.add_streams(stream_1, ports=[0])
@@ -382,20 +466,29 @@ class Trex(ITrafficGenerator):
             result[ResultsConstants.FRAME_LOSS_PERCENT] = 100
 
         if settings.getValue('TRAFFICGEN_TREX_LATENCY_PPS') > 0 and stats['latency']:
-            result[ResultsConstants.MIN_LATENCY_NS] = (
-                '{:.3f}'.format(
-                    (float(min(stats["latency"][0]["latency"]["total_min"],
-                               stats["latency"][1]["latency"]["total_min"])))))
-
-            result[ResultsConstants.MAX_LATENCY_NS] = (
-                '{:.3f}'.format(
-                    (float(max(stats["latency"][0]["latency"]["total_max"],
-                               stats["latency"][1]["latency"]["total_max"])))))
-
-            result[ResultsConstants.AVG_LATENCY_NS] = (
-                '{:.3f}'.format(
-                    float((stats["latency"][0]["latency"]["average"]+
-                           stats["latency"][1]["latency"]["average"])/2)))
+            try:
+                result[ResultsConstants.MIN_LATENCY_NS] = (
+                    '{:.3f}'.format(
+                        (float(min(stats["latency"][0]["latency"]["total_min"],
+                                   stats["latency"][1]["latency"]["total_min"])))))
+            except TypeError:
+                result[ResultsConstants.MIN_LATENCY_NS] = 'Unknown'
+
+            try:
+                result[ResultsConstants.MAX_LATENCY_NS] = (
+                    '{:.3f}'.format(
+                        (float(max(stats["latency"][0]["latency"]["total_max"],
+                                   stats["latency"][1]["latency"]["total_max"])))))
+            except TypeError:
+                result[ResultsConstants.MAX_LATENCY_NS] = 'Unknown'
+
+            try:
+                result[ResultsConstants.AVG_LATENCY_NS] = (
+                    '{:.3f}'.format(
+                        float((stats["latency"][0]["latency"]["average"]+
+                               stats["latency"][1]["latency"]["average"])/2)))
+            except TypeError:
+                result[ResultsConstants.AVG_LATENCY_NS] = 'Unknown'
 
         else:
             result[ResultsConstants.MIN_LATENCY_NS] = 'Unknown'
@@ -568,9 +661,25 @@ class Trex(ITrafficGenerator):
         raise NotImplementedError(
             'Trex wait rfc2544 throughput not implemented')
 
-    def send_burst_traffic(self, traffic=None, numpkts=100, duration=5):
-        raise NotImplementedError(
-            'Trex send burst traffic not implemented')
+    def send_burst_traffic(self, traffic=None, duration=20):
+        """See ITrafficGenerator for description
+        """
+        self._logger.info("In Trex send_burst_traffic method")
+        self._params.clear()
+
+        self._params['traffic'] = self.traffic_defaults.copy()
+        if traffic:
+            self._params['traffic'] = merge_spec(
+                self._params['traffic'], traffic)
+
+        if settings.getValue('TRAFFICGEN_TREX_LEARNING_MODE'):
+            self.learning_packets(traffic)
+        self._logger.info("T-Rex sending traffic")
+        stats = self.generate_traffic(traffic, duration)
+
+        time.sleep(3)  # allow packets to complete before reading stats
+
+        return self.calculate_results(stats)
 
     def send_rfc2544_back2back(self, traffic=None, tests=1, duration=30,
                                lossrate=0.0):
diff --git a/tools/pkt_gen/xena/XenaDriver.py b/tools/pkt_gen/xena/XenaDriver.py
index 6e39e47a..cdc82838 100644
--- a/tools/pkt_gen/xena/XenaDriver.py
+++ b/tools/pkt_gen/xena/XenaDriver.py
@@ -170,8 +170,7 @@ class KeepAliveThread(threading.Thread):
         self.finished = threading.Event()
         self.setDaemon(True)
         _LOGGER.debug(
-            'Xena Socket keep alive thread initiated, interval ' +
-            '{} seconds'.format(self.interval))
+            'Xena Socket keep alive thread initiated, interval %s seconds', self.interval)
 
     def stop(self):
         """ Thread stop. See python thread docs for more info
@@ -904,7 +903,7 @@ class XenaRXStats(object):
                 statdict[entry_id] = self._pack_stats(param, 3)
             elif param[1] == 'PR_TPLDS':
                 tid_list = self._pack_tplds_stats(param, 2)
-                if len(tid_list):
+                if tid_list:
                     statdict['pr_tplds'] = tid_list
             elif param[1] == 'PR_TPLDTRAFFIC':
                 if 'pr_tpldstraffic' in statdict:
diff --git a/tools/pkt_gen/xena/json/xena_json.py b/tools/pkt_gen/xena/json/xena_json.py
index b1eed720..df2aa55f 100644
--- a/tools/pkt_gen/xena/json/xena_json.py
+++ b/tools/pkt_gen/xena/json/xena_json.py
@@ -28,8 +28,6 @@ import locale
 import logging
 import os
 
-import scapy.layers.inet as inet
-
 from tools.pkt_gen.xena.json import json_utilities
 
 _LOGGER = logging.getLogger(__name__)
@@ -279,6 +277,10 @@ class XenaJSON(object):
         :param kwargs: Extra params per scapy usage.
         :return: None
         """
+        # import can't be performed at module level, because it conflicts with import
+        # of customized scapy version by T-Rex
+        import scapy.layers.inet as inet
+
         self.packet_data['layer2'] = [
             inet.Ether(dst=dst_mac, src=src_mac, **kwargs),
             inet.Ether(dst=src_mac, src=dst_mac, **kwargs)]
@@ -293,6 +295,10 @@ class XenaJSON(object):
         :param kwargs: Extra params per scapy usage
         :return: None
         """
+        # import can't be performed at module level, because it conflicts with import
+        # of customized scapy version by T-Rex
+        import scapy.layers.inet as inet
+
         self.packet_data['layer3'] = [
             inet.IP(src=src_ip, dst=dst_ip, proto=protocol.lower(), **kwargs),
             inet.IP(src=dst_ip, dst=src_ip, proto=protocol.lower(), **kwargs)]
@@ -305,6 +311,10 @@ class XenaJSON(object):
         :param kwargs: Extra params per scapy usage
         :return: None
         """
+        # import can't be performed at module level, because it conflicts with import
+        # of customized scapy version by T-Rex
+        import scapy.layers.inet as inet
+
         self.packet_data['layer4'] = [
             inet.UDP(sport=source_port, dport=destination_port, **kwargs),
             inet.UDP(sport=source_port, dport=destination_port, **kwargs)]
@@ -316,6 +326,10 @@ class XenaJSON(object):
         :param kwargs: Extra params per scapy usage
         :return: None
         """
+        # import can't be performed at module level, because it conflicts with import
+        # of customized scapy version by T-Rex
+        import scapy.layers.inet as inet
+
         self.packet_data['vlan'] = [
             inet.Dot1Q(vlan=vlan_id, **kwargs),
             inet.Dot1Q(vlan=vlan_id, **kwargs)]
diff --git a/tools/pkt_gen/xena/xena.py b/tools/pkt_gen/xena/xena.py
index 19b44f0b..33864079 100755
--- a/tools/pkt_gen/xena/xena.py
+++ b/tools/pkt_gen/xena/xena.py
@@ -32,8 +32,6 @@ import xml.etree.ElementTree as ET
 from collections import OrderedDict
 from time import sleep
 
-import scapy.layers.inet as inet
-
 from conf import merge_spec
 from conf import settings
 from core.results.results_constants import ResultsConstants
@@ -149,6 +147,10 @@ class Xena(ITrafficGenerator):
         :param reverse: Swap source and destination info when building header
         :return: packet header in hex
         """
+        # import can't be performed at module level, because it conflicts with import
+        # of customized scapy version by T-Rex
+        import scapy.layers.inet as inet
+
         srcmac = self._params['traffic']['l2'][
             'srcmac'] if not reverse else self._params['traffic']['l2'][
                 'dstmac']
@@ -274,10 +276,6 @@ class Xena(ITrafficGenerator):
         enable the pairs topology
         :return: None
         """
-        # set duplex mode, this code is valid, pylint complaining with a
-        # warning that many have complained about online.
-        # pylint: disable=redefined-variable-type
-
         try:
             if self._params['traffic']['bidir'] == "True":
                 j_file = XenaJSONMesh()
@@ -568,7 +566,7 @@ class Xena(ITrafficGenerator):
             self._xsocket.disconnect()
             self._xsocket = None
 
-    def send_burst_traffic(self, traffic=None, numpkts=100, duration=20):
+    def send_burst_traffic(self, traffic=None, duration=20):
         """Send a burst of traffic.
 
         See ITrafficGenerator for description
@@ -579,7 +577,7 @@ class Xena(ITrafficGenerator):
         if traffic:
             self._params['traffic'] = merge_spec(self._params['traffic'],
                                                  traffic)
-        self._start_traffic_api(numpkts)
+        self._start_traffic_api(traffic['burst_size'])
         return self._stop_api_traffic()
 
     def send_cont_traffic(self, traffic=None, duration=20):