nsb_installation: updates

[yardstick.git] / yardstick / network_services / traffic_profile / rfc2544.py

diff --git a/yardstick/network_services/traffic_profile/rfc2544.py b/yardstick/network_services/traffic_profile/rfc2544.py
index b07bc9d..16e809b 100644 (file)
--- a/yardstick/network_services/traffic_profile/rfc2544.py
+++ b/yardstick/network_services/traffic_profile/rfc2544.py
@@ -17,9 +17,9 @@ from __future__ import absolute_import
 from __future__ import division
 import logging
 
-from stl.trex_stl_lib.trex_stl_client import STLStream
-from stl.trex_stl_lib.trex_stl_streams import STLFlowLatencyStats
-from stl.trex_stl_lib.trex_stl_streams import STLTXCont
+from trex_stl_lib.trex_stl_client import STLStream
+from trex_stl_lib.trex_stl_streams import STLFlowLatencyStats
+from trex_stl_lib.trex_stl_streams import STLTXCont
 
 from yardstick.network_services.traffic_profile.traffic_profile \
     import TrexProfile
@@ -43,7 +43,7 @@ class RFC2544Profile(TrexProfile):
     def register_generator(self, generator):
         self.generator = generator
 
-    def execute(self, traffic_generator=None):
+    def execute_traffic(self, traffic_generator=None):
         """ Generate the stream and run traffic on the given ports """
         if traffic_generator is not None and self.generator is None:
             self.generator = traffic_generator
@@ -52,21 +52,19 @@ class RFC2544Profile(TrexProfile):
             return
 
         self.ports = []
-        priv_ports = self.generator.priv_ports
-        pub_ports = self.generator.pub_ports
-        # start from 1 for private_1, public_1, etc.
-        for index, (priv_port, pub_port) in enumerate(zip(priv_ports, pub_ports), 1):
-            profile_data = self.params.get('private_{}'.format(index), '')
-            self.ports.append(priv_port)
-            # pass profile_data directly, don't use self.profile_data
-            self.generator.client.add_streams(self.get_streams(profile_data), ports=priv_port)
-            profile_data = self.params.get('public_{}'.format(index), '')
+        for vld_id, intfs in sorted(self.generator.networks.items()):
+            profile_data = self.params.get(vld_id)
+            # no profile for this port
+            if not profile_data:
+                continue
             # correlated traffic doesn't use public traffic?
-            if not profile_data or self.generator.rfc2544_helper.correlated_traffic:
+            if vld_id.startswith(self.DOWNLINK) and \
+                self.generator.rfc2544_helper.correlated_traffic:
                 continue
-            # just get the pub_port
-            self.ports.append(pub_port)
-            self.generator.client.add_streams(self.get_streams(profile_data), ports=pub_port)
+            for intf in intfs:
+                port = self.generator.vnfd_helper.port_num(intf)
+                self.ports.append(port)
+                self.generator.client.add_streams(self.get_streams(profile_data), ports=port)
 
         self.max_rate = self.rate
         self.min_rate = 0
@@ -86,7 +84,7 @@ class RFC2544Profile(TrexProfile):
         if generator is None:
             generator = self.generator
         run_duration = self.generator.RUN_DURATION
-        samples = self.generator.generate_samples()
+        samples = self.generator.generate_samples(self.ports)
 
         in_packets = sum([value['in_packets'] for value in samples.values()])
         out_packets = sum([value['out_packets'] for value in samples.values()])
@@ -135,8 +133,8 @@ class RFC2544Profile(TrexProfile):
             # TODO(esm): why don't we discard results that are out of tolerance?
             self.min_rate = self.rate
 
-        generator.clear_client_stats()
-        generator.start_client(mult=self.get_multiplier(),
+        generator.clear_client_stats(self.ports)
+        generator.start_client(self.ports, mult=self.get_multiplier(),
                                duration=run_duration, force=True)
 
         # if correlated traffic update the Throughput
@@ -154,34 +152,30 @@ class RFC2544Profile(TrexProfile):
         return samples
 
     def execute_latency(self, generator=None, samples=None):
-        if generator is None:
-            generator = self.generator
+        if generator is not None and self.generator is None:
+            self.generator = generator
 
         if samples is None:
-            samples = generator.generate_samples()
+            samples = self.generator.generate_samples()
 
         self.pps, multiplier = self.calculate_pps(samples)
         self.ports = []
         self.pg_id = self.params['traffic_profile'].get('pg_id', 1)
-        priv_ports = generator.priv_ports
-        pub_ports = generator.pub_ports
-        for index, (priv_port, pub_port) in enumerate(zip(priv_ports, pub_ports), 1):
-            profile_data = self.params.get('private_{}'.format(index), '')
-            self.ports.append(priv_port)
-            generator.client.add_streams(self.get_streams(profile_data),
-                                         ports=priv_port)
-
-            profile_data = self.params.get('public_{}'.format(index), '')
-            if not profile_data or generator.correlated_traffic:
+        for vld_id, intfs in sorted(self.generator.networks.items()):
+            profile_data = self.params.get(vld_id)
+            if not profile_data:
                 continue
+            # correlated traffic doesn't use public traffic?
+            if vld_id.startswith(self.DOWNLINK) and \
+                self.generator.rfc2544_helper.correlated_traffic:
+                continue
+            for intf in intfs:
+                port = self.generator.vnfd_helper.port_num(intf)
+                self.ports.append(port)
+                self.generator.client.add_streams(self.get_streams(profile_data), ports=port)
 
-            pub_port = generator.pub_ports[index]
-            self.ports.append(pub_port)
-            generator.client.add_streams(self.get_streams(profile_data),
-                                         ports=pub_port)
-
-        generator.start_client(ports=self.ports, mult=str(multiplier),
-                               duration=120, force=True)
+        self.generator.start_client(ports=self.ports, mult=str(multiplier),
+                                    duration=120, force=True)
         self.first_run = False
 
     def calculate_pps(self, samples):