Improve IXIA IxNetwork library and traffic profile (4)

This patch implements an active wait for the traffic injection. Once the
traffic is started, the traffic generator class will poll periodically the
IXIA traffic generator chassis to retrieve the status of the traffic
("started", "stopped").

Now the latency statistics are retrieved and reported for each injection
period.

JIRA: YARDSTICK-1116

Change-Id: I4422e2c88b4fc97b7cac3de8a82b2d75467c4117
Signed-off-by: Rodolfo Alonso Hernandez <rodolfo.alonso.hernandez@intel.com>
Signed-off-by: Emma Foley <emma.l.foley@intel.com>

4 files changed, 86 insertions, 102 deletions

diff --git a/yardstick/network_services/libs/ixia_libs/ixnet/ixnet_api.py b/yardstick/network_services/libs/ixia_libs/ixnet/ixnet_api.py
index a8464e936..393f60f7c 100644
--- a/yardstick/network_services/libs/ixia_libs/ixnet/ixnet_api.py
+++ b/yardstick/network_services/libs/ixia_libs/ixnet/ixnet_api.py
@@ -17,6 +17,7 @@ import logging
 import IxNetwork
 
 from yardstick.common import exceptions
+from yardstick.common import utils
 
 
 log = logging.getLogger(__name__)
@@ -34,6 +35,9 @@ PROTO_VLAN = 'vlan'
 IP_VERSION_4_MASK = '0.0.0.255'
 IP_VERSION_6_MASK = '0:0:0:0:0:0:0:ff'
 
+TRAFFIC_STATUS_STARTED = 'started'
+TRAFFIC_STATUS_STOPPED = 'stopped'
+
 
 # NOTE(ralonsoh): this pragma will be removed in the last patch of this series
 class IxNextgen(object):  # pragma: no cover
@@ -141,6 +145,19 @@ class IxNextgen(object):  # pragma: no cover
         raise exceptions.IxNetworkFieldNotPresentInStackItem(
             field_name=field_name, stack_item=stack_item)
 
+    def _get_traffic_state(self):
+        """Get traffic state"""
+        return self.ixnet.getAttribute(self.ixnet.getRoot() + 'traffic',
+                                       '-state')
+
+    def is_traffic_running(self):
+        """Returns true if traffic state == TRAFFIC_STATUS_STARTED"""
+        return self._get_traffic_state() == TRAFFIC_STATUS_STARTED
+
+    def is_traffic_stopped(self):
+        """Returns true if traffic state == TRAFFIC_STATUS_STOPPED"""
+        return self._get_traffic_state() == TRAFFIC_STATUS_STOPPED
+
     @staticmethod
     def _parse_framesize(framesize):
         """Parse "framesize" config param. to return a list of weighted pairs
@@ -435,15 +452,19 @@ class IxNextgen(object):  # pragma: no cover
         return stats
 
     def start_traffic(self):
-        tis = self.ixnet.getList('/traffic', 'trafficItem')
-        for ti in tis:
-            self.ixnet.execute('generate', [ti])
-            self.ixnet.execute('apply', '/traffic')
-            self.ixnet.execute('start', '/traffic')
-
-    # NOTE(ralonsoh): to be updated in next patchset
-    # pragma: no cover
-    def ix_stop_traffic(self):
-        tis = self.ixnet.getList('/traffic', 'trafficItem')
-        for _ in tis:
+        """Start the traffic injection in the traffic item
+
+        By configuration, there is only one traffic item. This function returns
+        when the traffic state is TRAFFIC_STATUS_STARTED.
+        """
+        traffic_items = self.ixnet.getList('/traffic', 'trafficItem')
+        if self.is_traffic_running():
             self.ixnet.execute('stop', '/traffic')
+            # pylint: disable=unnecessary-lambda
+            utils.wait_until_true(lambda: self.is_traffic_stopped())
+
+        self.ixnet.execute('generate', traffic_items)
+        self.ixnet.execute('apply', '/traffic')
+        self.ixnet.execute('start', '/traffic')
+        # pylint: disable=unnecessary-lambda
+        utils.wait_until_true(lambda: self.is_traffic_running())
diff --git a/yardstick/network_services/traffic_profile/base.py b/yardstick/network_services/traffic_profile/base.py
index 162bab2bc..9eba550aa 100644
--- a/yardstick/network_services/traffic_profile/base.py
+++ b/yardstick/network_services/traffic_profile/base.py
@@ -44,7 +44,7 @@ class TrafficProfile(object):
         # IMIX = {"10K": 0.1, "100M": 0.5}
         self.params = tp_config
 
-    def execute_traffic(self, traffic_generator):
+    def execute_traffic(self, traffic_generator, **kawrgs):
         """ This methods defines the behavior of the traffic generator.
         It will be called in a loop until the traffic generator exits.
 
diff --git a/yardstick/network_services/traffic_profile/ixia_rfc2544.py b/yardstick/network_services/traffic_profile/ixia_rfc2544.py
index 453c58622..73806f958 100644
--- a/yardstick/network_services/traffic_profile/ixia_rfc2544.py
+++ b/yardstick/network_services/traffic_profile/ixia_rfc2544.py
@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from __future__ import absolute_import
 import logging
 
 from yardstick.network_services.traffic_profile.trex_traffic_profile import \
@@ -82,12 +81,10 @@ class IXIARFC2544Profile(TrexProfile):
     def _ixia_traffic_generate(self, traffic, ixia_obj):
         for key, value in traffic.items():
             if key.startswith((self.UPLINK, self.DOWNLINK)):
-                value["iload"] = str(self.rate)
+                value['iload'] = str(self.rate)
         ixia_obj.update_frame(traffic)
         ixia_obj.update_ip_packet(traffic)
         ixia_obj.start_traffic()
-        self.tmp_drop = 0
-        self.tmp_throughput = 0
 
     def update_traffic_profile(self, traffic_generator):
         def port_generator():
@@ -105,78 +102,59 @@ class IXIARFC2544Profile(TrexProfile):
 
         self.ports = [port for port in port_generator()]
 
-    def execute_traffic(self, traffic_generator, ixia_obj, mac=None):
-        if mac is None:
-            mac = {}
+    def execute_traffic(self, traffic_generator, ixia_obj=None, mac=None):
+        mac = {} if mac is None else mac
+        first_run = self.first_run
         if self.first_run:
+            self.first_run = False
             self.full_profile = {}
             self.pg_id = 0
             self.update_traffic_profile(traffic_generator)
-            traffic = \
-                self._get_ixia_traffic_profile(self.full_profile, mac)
             self.max_rate = self.rate
             self.min_rate = 0
-            self.get_multiplier()
-            self._ixia_traffic_generate(traffic, ixia_obj)
-
-    def get_multiplier(self):
-        self.rate = round((self.max_rate + self.min_rate) / 2.0, 2)
-        multiplier = round(self.rate / self.pps, 2)
-        return str(multiplier)
+        else:
+            self.rate = round(float(self.max_rate + self.min_rate) / 2.0, 2)
 
-    def start_ixia_latency(self, traffic_generator, ixia_obj, mac=None):
-        if mac is None:
-            mac = {}
-        self.update_traffic_profile(traffic_generator)
-        traffic = \
-            self._get_ixia_traffic_profile(self.full_profile, mac)
+        traffic = self._get_ixia_traffic_profile(self.full_profile, mac)
         self._ixia_traffic_generate(traffic, ixia_obj)
+        return first_run
 
-    def get_drop_percentage(self, samples, tol_min, tolerance, ixia_obj,
-                            mac=None):
-        if mac is None:
-            mac = {}
-        status = 'Running'
+    def get_drop_percentage(self, samples, tol_min, tolerance, duration=30.0,
+                            first_run=False):
+        completed = False
         drop_percent = 100
-        in_packets = sum([samples[iface]['in_packets'] for iface in samples])
-        out_packets = sum([samples[iface]['out_packets'] for iface in samples])
-        rx_throughput = \
-            sum([samples[iface]['RxThroughput'] for iface in samples])
-        tx_throughput = \
-            sum([samples[iface]['TxThroughput'] for iface in samples])
-        packet_drop = abs(out_packets - in_packets)
+        num_ifaces = len(samples)
+        in_packets_sum = sum(
+            [samples[iface]['in_packets'] for iface in samples])
+        out_packets_sum = sum(
+            [samples[iface]['out_packets'] for iface in samples])
+        rx_throughput = sum(
+            [samples[iface]['RxThroughput'] for iface in samples])
+        rx_throughput = round(float(rx_throughput), 2)
+        tx_throughput = sum(
+            [samples[iface]['TxThroughput'] for iface in samples])
+        tx_throughput = round(float(tx_throughput), 2)
+        packet_drop = abs(out_packets_sum - in_packets_sum)
+
         try:
-            drop_percent = round((packet_drop / float(out_packets)) * 100, 2)
+            drop_percent = round(
+                (packet_drop / float(out_packets_sum)) * 100, 2)
         except ZeroDivisionError:
             LOG.info('No traffic is flowing')
-        samples['TxThroughput'] = round(tx_throughput / 1.0, 2)
-        samples['RxThroughput'] = round(rx_throughput / 1.0, 2)
-        samples['CurrentDropPercentage'] = drop_percent
-        samples['Throughput'] = self.tmp_throughput
-        samples['DropPercentage'] = self.tmp_drop
-        if drop_percent > tolerance and self.tmp_throughput == 0:
-            samples['Throughput'] = round(rx_throughput / 1.0, 2)
-            samples['DropPercentage'] = drop_percent
-        if self.first_run:
-            max_supported_rate = out_packets / 30.0
-            self.rate = max_supported_rate
-            self.first_run = False
-            if drop_percent <= tolerance:
-                status = 'Completed'
+
+        samples['TxThroughput'] = tx_throughput
+        samples['RxThroughput'] = rx_throughput
+        samples['DropPercentage'] = drop_percent
+
+        if first_run:
+            self.rate = out_packets_sum / duration / num_ifaces
+            completed = True if drop_percent <= tolerance else False
+
         if drop_percent > tolerance:
             self.max_rate = self.rate
         elif drop_percent < tol_min:
             self.min_rate = self.rate
-            if drop_percent >= self.tmp_drop:
-                self.tmp_drop = drop_percent
-                self.tmp_throughput = round((rx_throughput / 1.0), 2)
-                samples['Throughput'] = round(rx_throughput / 1.0, 2)
-                samples['DropPercentage'] = drop_percent
         else:
-            samples['Throughput'] = round(rx_throughput / 1.0, 2)
-            samples['DropPercentage'] = drop_percent
-            return status, samples
-        self.get_multiplier()
-        traffic = self._get_ixia_traffic_profile(self.full_profile, mac)
-        self._ixia_traffic_generate(traffic, ixia_obj)
-        return status, samples
+            completed = True
+
+        return completed, samples
diff --git a/yardstick/network_services/vnf_generic/vnf/tg_rfc2544_ixia.py b/yardstick/network_services/vnf_generic/vnf/tg_rfc2544_ixia.py
index deb0a8023..2010546e7 100644
--- a/yardstick/network_services/vnf_generic/vnf/tg_rfc2544_ixia.py
+++ b/yardstick/network_services/vnf_generic/vnf/tg_rfc2544_ixia.py
@@ -12,12 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import time
 import os
 import logging
 import sys
 
 from yardstick.common import exceptions
+from yardstick.common import utils
 from yardstick.network_services.vnf_generic.vnf.sample_vnf import SampleVNFTrafficGen
 from yardstick.network_services.vnf_generic.vnf.sample_vnf import ClientResourceHelper
 from yardstick.network_services.vnf_generic.vnf.sample_vnf import Rfc2544ResourceHelper
@@ -135,43 +135,28 @@ class IxiaResourceHelper(ClientResourceHelper):
             mac["src_mac_{}".format(port_num)] = virt_intf.get("local_mac", default)
             mac["dst_mac_{}".format(port_num)] = virt_intf.get("dst_mac", default)
 
-        samples = {}
-        # Generate ixia traffic config...
         try:
             while not self._terminated.value:
-                traffic_profile.execute_traffic(self, self.client, mac)
+                first_run = traffic_profile.execute_traffic(
+                    self, self.client, mac)
                 self.client_started.value = 1
-                time.sleep(WAIT_FOR_TRAFFIC)
-                self.client.ix_stop_traffic()
+                # pylint: disable=unnecessary-lambda
+                utils.wait_until_true(lambda: self.client.is_traffic_stopped())
                 samples = self.generate_samples(traffic_profile.ports)
+
+                # NOTE(ralonsoh): the traffic injection duration is fixed to 30
+                # seconds. This parameter is configurable and must be retrieved
+                # from the traffic_profile.full_profile information.
+                # Every flow must have the same duration.
+                completed, samples = traffic_profile.get_drop_percentage(
+                    samples, min_tol, max_tol, first_run=first_run)
                 self._queue.put(samples)
-                status, samples = traffic_profile.get_drop_percentage(samples, min_tol,
-                                                                      max_tol, self.client, mac)
 
-                current = samples['CurrentDropPercentage']
-                if min_tol <= current <= max_tol or status == 'Completed':
+                if completed:
                     self._terminated.value = 1
 
-            self.client.ix_stop_traffic()
-            self._queue.put(samples)
-
-            if not self.rfc_helper.is_done():
-                self._terminated.value = 1
-                return
-
-            traffic_profile.execute_traffic(self, self.client, mac)
-            for _ in range(5):
-                time.sleep(self.LATENCY_TIME_SLEEP)
-                self.client.ix_stop_traffic()
-                samples = self.generate_samples(traffic_profile.ports, 'latency', {})
-                self._queue.put(samples)
-                traffic_profile.start_ixia_latency(self, self.client, mac)
-                if self._terminated.value:
-                    break
-
-            self.client.ix_stop_traffic()
         except Exception:  # pylint: disable=broad-except
-            LOG.exception("Run Traffic terminated")
+            LOG.exception('Run Traffic terminated')
 
         self._terminated.value = 1