Merge "Added required ubuntu packages to run IxLoad client"

[yardstick.git] / yardstick / benchmark / scenarios / storage / storperf.py

diff --git a/yardstick/benchmark/scenarios/storage/storperf.py b/yardstick/benchmark/scenarios/storage/storperf.py
index 77df6db..f0b2361 100644 (file)
--- a/yardstick/benchmark/scenarios/storage/storperf.py
+++ b/yardstick/benchmark/scenarios/storage/storperf.py
@@ -6,11 +6,15 @@
 # which accompanies this distribution, and is available at
 # http://www.apache.org/licenses/LICENSE-2.0
 ##############################################################################
+from __future__ import absolute_import
+
+import os
 import logging
-import json
-import requests
 import time
 
+import requests
+from oslo_serialization import jsonutils
+
 from yardstick.benchmark.scenarios import base
 
 LOG = logging.getLogger(__name__)
@@ -73,17 +77,19 @@ class StorPerf(base.Scenario):
         setup_query = requests.get('http://%s:5000/api/v1.0/configurations'
                                    % self.target)
 
-        setup_query_content = json.loads(setup_query.content)
+        setup_query_content = jsonutils.loads(
+            setup_query.content)
         if setup_query_content["stack_created"]:
             self.setup_done = True
-            LOG.debug("stack_created: %s"
-                      % setup_query_content["stack_created"])
+            LOG.debug("stack_created: %s",
+                      setup_query_content["stack_created"])
 
     def setup(self):
         """Set the configuration."""
         env_args = {}
-        env_args_payload_list = ["agent_count", "public_network",
-                                 "agent_image", "volume_size"]
+        env_args_payload_list = ["agent_count", "agent_flavor",
+                                 "public_network", "agent_image",
+                                 "volume_size"]
 
         for env_argument in env_args_payload_list:
             try:
@@ -91,18 +97,19 @@ class StorPerf(base.Scenario):
             except KeyError:
                 pass
 
-        LOG.info("Creating a stack on node %s with parameters %s" %
-                 (self.target, env_args))
+        LOG.info("Creating a stack on node %s with parameters %s",
+                 self.target, env_args)
         setup_res = requests.post('http://%s:5000/api/v1.0/configurations'
                                   % self.target, json=env_args)
 
-        setup_res_content = json.loads(setup_res.content)
+        setup_res_content = jsonutils.loads(
+            setup_res.content)
 
         if setup_res.status_code != 200:
             raise RuntimeError("Failed to create a stack, error message:",
                                setup_res_content["message"])
         elif setup_res.status_code == 200:
-            LOG.info("stack_id: %s" % setup_res_content["stack_id"])
+            LOG.info("stack_id: %s", setup_res_content["stack_id"])
 
             while not self.setup_done:
                 self._query_setup_state()
@@ -112,18 +119,20 @@ class StorPerf(base.Scenario):
         """Query the status of the supplied job_id and report on metrics"""
         LOG.info("Fetching report for %s...", job_id)
         report_res = requests.get('http://{}:5000/api/v1.0/jobs'.format
-                                  (self.target), params={'id': job_id})
+                                  (self.target),
+                                  params={'id': job_id, 'type': 'status'})
 
-        report_res_content = json.loads(report_res.content)
+        report_res_content = jsonutils.loads(
+            report_res.content)
 
         if report_res.status_code != 200:
             raise RuntimeError("Failed to fetch report, error message:",
                                report_res_content["message"])
         else:
-            job_status = report_res_content["status"]
+            job_status = report_res_content["Status"]
 
         LOG.debug("Job is: %s...", job_status)
-        self.job_completed = job_status == "completed"
+        self.job_completed = job_status == "Completed"
 
         # TODO: Support using StorPerf ReST API to read Job ETA.
 
@@ -140,7 +149,18 @@ class StorPerf(base.Scenario):
         if not self.setup_done:
             self.setup()
 
-        job_args = {}
+        metadata = {"build_tag": "latest", "test_case": "opnfv_yardstick_tc074"}
+        metadata_payload_dict = {"pod_name": "NODE_NAME",
+                                 "scenario_name": "DEPLOY_SCENARIO",
+                                 "version": "YARDSTICK_BRANCH"}
+
+        for key, value in metadata_payload_dict.items():
+            try:
+                metadata[key] = os.environ[value]
+            except KeyError:
+                pass
+
+        job_args = {"metadata": metadata}
         job_args_payload_list = ["block_sizes", "queue_depths", "deadline",
                                  "target", "nossd", "nowarm", "workload"]
 
@@ -150,18 +170,18 @@ class StorPerf(base.Scenario):
             except KeyError:
                 pass
 
-        LOG.info("Starting a job with parameters %s" % job_args)
+        LOG.info("Starting a job with parameters %s", job_args)
         job_res = requests.post('http://%s:5000/api/v1.0/jobs' % self.target,
                                 json=job_args)
 
-        job_res_content = json.loads(job_res.content)
+        job_res_content = jsonutils.loads(job_res.content)
 
         if job_res.status_code != 200:
             raise RuntimeError("Failed to start a job, error message:",
                                job_res_content["message"])
         elif job_res.status_code == 200:
             job_id = job_res_content["job_id"]
-            LOG.info("Started job id: %s..." % job_id)
+            LOG.info("Started job id: %s...", job_id)
 
             while not self.job_completed:
                 self._query_job_state(job_id)
@@ -171,7 +191,8 @@ class StorPerf(base.Scenario):
                                             self.target)
 
             if terminate_res.status_code != 200:
-                terminate_res_content = json.loads(terminate_res.content)
+                terminate_res_content = jsonutils.loads(
+                    terminate_res.content)
                 raise RuntimeError("Failed to start a job, error message:",
                                    terminate_res_content["message"])
 
@@ -186,11 +207,12 @@ class StorPerf(base.Scenario):
         #           terminate_res = requests.delete('http://%s:5000/api/v1.0
         #                                           /jobs' % self.target)
         #       else:
-        #           time.sleep(int(est_time)/2)
+        #           time.sleep(int(esti_time)/2)
 
             result_res = requests.get('http://%s:5000/api/v1.0/jobs?id=%s' %
                                       (self.target, job_id))
-            result_res_content = json.loads(result_res.content)
+            result_res_content = jsonutils.loads(
+                result_res.content)
 
             result.update(result_res_content)
 
@@ -200,7 +222,8 @@ class StorPerf(base.Scenario):
                                        configurations' % self.target)
 
         if teardown_res.status_code == 400:
-            teardown_res_content = json.loads(teardown_res.content)
+            teardown_res_content = jsonutils.loads(
+                teardown_res.content)
             raise RuntimeError("Failed to reset environment, error message:",
                                teardown_res_content['message'])