Merge "Prox standalone test case changes:"

[yardstick.git] / yardstick / benchmark / scenarios / networking / vnf_generic.py

diff --git a/yardstick/benchmark/scenarios/networking/vnf_generic.py b/yardstick/benchmark/scenarios/networking/vnf_generic.py
index 3bb168c..5ac51cd 100644 (file)
--- a/yardstick/benchmark/scenarios/networking/vnf_generic.py
+++ b/yardstick/benchmark/scenarios/networking/vnf_generic.py
@@ -63,38 +63,40 @@ class NetworkServiceTestCase(scenario_base.Scenario):
         self.bin_path = get_nsb_option('bin_path', '')
         self._mq_ids = []
 
+    def is_ended(self):
+        return self.traffic_profile is not None and self.traffic_profile.is_ended()
+
     def _get_ip_flow_range(self, ip_start_range):
+        """Retrieve a CIDR first and last viable IPs
 
-        # IP range is specified as 'x.x.x.x-y.y.y.y'
+        :param ip_start_range: could be the IP range itself or a dictionary
+               with the host name and the port.
+        :return: (str) IP range (min, max) with this format "x.x.x.x-y.y.y.y"
+        """
         if isinstance(ip_start_range, six.string_types):
             return ip_start_range
 
-        node_name, range_or_interface = next(iter(ip_start_range.items()), (None, '0.0.0.0'))
+        node_name, range_or_interface = next(iter(ip_start_range.items()),
+                                             (None, '0.0.0.0'))
         if node_name is None:
-            # we are manually specifying the range
-            ip_addr_range = range_or_interface
+            return range_or_interface
+
+        node = self.context_cfg['nodes'].get(node_name, {})
+        interface = node.get('interfaces', {}).get(range_or_interface)
+        if interface:
+            ip = interface['local_ip']
+            mask = interface['netmask']
         else:
-            node = self.context_cfg["nodes"].get(node_name, {})
-            try:
-                # the ip_range is the interface name
-                interface = node.get("interfaces", {})[range_or_interface]
-            except KeyError:
-                ip = "0.0.0.0"
-                mask = "255.255.255.0"
-            else:
-                ip = interface["local_ip"]
-                # we can't default these values, they must both exist to be valid
-                mask = interface["netmask"]
-
-            ipaddr = ipaddress.ip_network(six.text_type('{}/{}'.format(ip, mask)), strict=False)
-            hosts = list(ipaddr.hosts())
-            if len(hosts) > 2:
-                # skip the first host in case of gateway
-                ip_addr_range = "{}-{}".format(hosts[1], hosts[-1])
-            else:
-                LOG.warning("Only single IP in range %s", ipaddr)
-                # fall back to single IP range
-                ip_addr_range = ip
+            ip = '0.0.0.0'
+            mask = '255.255.255.0'
+
+        ipaddr = ipaddress.ip_network(
+            six.text_type('{}/{}'.format(ip, mask)), strict=False)
+        if ipaddr.prefixlen + 2 < ipaddr.max_prefixlen:
+            ip_addr_range = '{}-{}'.format(ipaddr[2], ipaddr[-2])
+        else:
+            LOG.warning('Only single IP in range %s', ipaddr)
+            ip_addr_range = ip
         return ip_addr_range
 
     def _get_traffic_flow(self):
@@ -118,7 +120,15 @@ class NetworkServiceTestCase(scenario_base.Scenario):
             for index, dst_port in enumerate(fflow.get("dst_port", [])):
                 flow["dst_port_{}".format(index)] = dst_port
 
-            flow["count"] = fflow["count"]
+            if "count" in fflow:
+                flow["count"] = fflow["count"]
+
+            if "srcseed" in fflow:
+                flow["srcseed"] = fflow["srcseed"]
+
+            if "dstseed" in fflow:
+                flow["dstseed"] = fflow["dstseed"]
+
         except KeyError:
             flow = {}
         return {"flow": flow}
@@ -141,6 +151,26 @@ class NetworkServiceTestCase(scenario_base.Scenario):
         return options.get('duration',
                            tprofile_base.TrafficProfileConfig.DEFAULT_DURATION)
 
+    def _key_list_to_dict(self, key, value_list):
+        value_dict = {}
+        try:
+            for index, count in enumerate(value_list[key]):
+                value_dict["{}_{}".format(key, index)] = count
+        except KeyError:
+            value_dict = {}
+
+        return value_dict
+
+    def _get_simulated_users(self):
+        users = self.scenario_cfg.get("options", {}).get("simulated_users", {})
+        simulated_users = self._key_list_to_dict("uplink", users)
+        return {"simulated_users": simulated_users}
+
+    def _get_page_object(self):
+        objects = self.scenario_cfg.get("options", {}).get("page_object", {})
+        page_object = self._key_list_to_dict("uplink", objects)
+        return {"page_object": page_object}
+
     def _fill_traffic_profile(self):
         tprofile = self._get_traffic_profile()
         extra_args = self.scenario_cfg.get('extra_args', {})
@@ -150,9 +180,19 @@ class NetworkServiceTestCase(scenario_base.Scenario):
             tprofile_base.TrafficProfile.UPLINK: {},
             tprofile_base.TrafficProfile.DOWNLINK: {},
             'extra_args': extra_args,
-            'duration': self._get_duration()}
+            'duration': self._get_duration(),
+            'page_object': self._get_page_object(),
+            'simulated_users': self._get_simulated_users()}
         traffic_vnfd = vnfdgen.generate_vnfd(tprofile, tprofile_data)
-        self.traffic_profile = tprofile_base.TrafficProfile.get(traffic_vnfd)
+
+        traffic_config = \
+            self.scenario_cfg.get("options", {}).get("traffic_config", {})
+
+        traffic_vnfd.setdefault("traffic_profile", {})
+        traffic_vnfd["traffic_profile"].update(traffic_config)
+
+        self.traffic_profile = \
+            tprofile_base.TrafficProfile.get(traffic_vnfd)
 
     def _get_topology(self):
         topology = self.scenario_cfg["topology"]
@@ -406,7 +446,7 @@ class NetworkServiceTestCase(scenario_base.Scenario):
                 pass
             self.create_interfaces_from_node(vnfd, node)
             vnf_impl = self.get_vnf_impl(vnfd['id'])
-            vnf_instance = vnf_impl(node_name, vnfd)
+            vnf_instance = vnf_impl(node_name, vnfd, scenario_cfg['task_id'])
             vnfs.append(vnf_instance)
 
         self.vnfs = vnfs