testsuites/posca/testcase_script/posca_factor_multistack_storage.py

   1 #!/usr/bin/env python
   2 ##############################################################################
   3 # Copyright (c) 2017 Huawei Technologies Co.,Ltd and others.
   4 #
   5 # All rights reserved. This program and the accompanying materials
   6 # are made available under the terms of the Apache License, Version 2.0
   7 # which accompanies this distribution, and is available at
   8 # http://www.apache.org/licenses/LICENSE-2.0
   9 ##############################################################################
  10 '''This file realize the function of run posca multistack storage stress test
  11 This file contain several part:
  12 First is create a script to realize several threading run'''
  13
  14 import utils.logger as log
  15 import uuid
  16 import json
  17 import os
  18 import time
  19 import threading
  20 import datetime
  21 import Queue
  22 from utils.parser import Parser as conf_parser
  23 import utils.env_prepare.quota_prepare as quota_prepare
  24 import utils.env_prepare.stack_prepare as stack_prepare
  25 import utils.infra_setup.runner.yardstick as yardstick_task
  26
  27 import utils.infra_setup.runner.docker_env as docker_env
  28
  29 # --------------------------------------------------
  30 # logging configuration
  31 # --------------------------------------------------
  32 LOG = log.Logger(__name__).getLogger()
  33
  34 test_dict = {
  35     "action": "runTestCase",
  36     "args": {
  37         "opts": {
  38             "task-args": {}
  39         },
  40         "testcase": "multistack_storage_bottlenecks"
  41     }
  42 }
  43 testfile = os.path.basename(__file__)
  44 testcase, file_format = os.path.splitext(testfile)
  45 cidr = "/home/opnfv/repos/yardstick/samples/storage_bottlenecks.yaml"
  46 runner_DEBUG = True
  47 q = Queue.Queue()
  48 final_result = Queue.Queue()
  49
  50
  51 def env_pre(test_config):
  52     test_yardstick = False
  53     if "yardstick" in test_config["contexts"].keys():
  54         test_yardstick = True
  55     stack_prepare._prepare_env_daemon(test_yardstick)
  56     quota_prepare.quota_env_prepare()
  57     LOG.info("yardstick environment prepare!")
  58     if(test_config["contexts"]['yardstick_envpre']):
  59         stdout = yardstick_task.yardstick_image_prepare()
  60         LOG.debug(stdout)
  61
  62
  63 def testcase_parser(out_file="yardstick.out", **parameter_info):
  64     cmd = yardstick_task.yardstick_command_parser(debug=runner_DEBUG,
  65                                                   cidr=cidr,
  66                                                   outfile=out_file,
  67                                                   parameter=parameter_info)
  68     return cmd
  69
  70
  71 def do_test(test_config):
  72     out_file = ("/tmp/yardstick_" + str(uuid.uuid4()) + ".out")
  73     yardstick_container = docker_env.yardstick_info['container']
  74     cmd = testcase_parser(out_file=out_file, **test_config)
  75     print(cmd)
  76     stdout = docker_env.docker_exec_cmd(yardstick_container, cmd)
  77     LOG.info(stdout)
  78     loop_value = 0
  79     while loop_value < 60:
  80         time.sleep(2)
  81         loop_value = loop_value + 1
  82         with open(out_file) as f:
  83             data = json.load(f)
  84             if data["result"]["criteria"] == "PASS":
  85                 LOG.info("yardstick run success")
  86                 LOG.info("%s" % data["result"]["testcases"])
  87                 break
  88             else:
  89                 LOG.error("yardstick error exit")
  90                 break
  91
  92     save_data = final_config_to_result(test_config, data)
  93     return save_data
  94
  95
  96 def config_to_result(num, out_num, during_date):
  97     testdata = {}
  98     test_result = {}
  99     final_data = {}
 100
 101     final_data["read_iops"] = 0
 102     final_data["read_bw"] = 0
 103     final_data["read_lat"] = 0
 104     final_data["write_iops"] = 0
 105     final_data["write_bw"] = 0
 106     final_data["write_lat"] = 0
 107
 108     test_result["number_of_stacks"] = float(num)
 109     test_result["success_times"] = out_num
 110     test_result["success_rate"] = out_num / num
 111     test_result["duration_time"] = during_date
 112     testdata["data_body"] = test_result
 113     testdata["testcase"] = testcase
 114
 115     while not final_result.empty():
 116         data = final_result.get()
 117         final_data["read_iops"] += data["read_iops"]
 118         final_data["read_bw"] += data["read_bw"]
 119         if final_data["read_lat"] is 0:
 120             final_data["read_lat"] = data["read_lat"]
 121         else:
 122             final_data["read_lat"] += data["read_lat"]
 123             final_data["read_lat"] = final_data["read_lat"]/2
 124         final_data["write_iops"] += data["write_iops"]
 125         final_data["write_bw"] += data["read_iops"]
 126         if final_data["write_lat"] is 0:
 127             final_data["write_lat"] = data["write_lat"]
 128         else:
 129             final_data["write_lat"] += data["write_lat"]
 130             final_data["write_lat"] = final_data["write_lat"]/2
 131
 132     testdata["test_value"] = final_data
 133     LOG.info("Final testdata is %s" % testdata)
 134     return testdata
 135
 136
 137 def final_config_to_result(test_config, test_result):
 138     out_data = test_result["result"]["testcases"]
 139     test_data = out_data["storage_bottlenecks"]["tc_data"]
 140     testdata = {}
 141     testdata["read_iops"] = 0
 142     testdata["read_bw"] = 0
 143     testdata["read_lat"] = 0
 144     testdata["write_iops"] = 0
 145     testdata["write_bw"] = 0
 146     testdata["write_lat"] = 0
 147     print(testdata["read_iops"])
 148     for result in test_data:
 149         testdata["read_iops"] += result["data"]["read_iops"]
 150         testdata["read_bw"] += result["data"]["read_bw"]
 151         if testdata["read_lat"] is 0:
 152             testdata["read_lat"] = result["data"]["read_lat"]
 153         else:
 154             testdata["read_lat"] += result["data"]["read_lat"]
 155             testdata["read_lat"] = testdata["read_lat"]/2
 156         testdata["write_iops"] += result["data"]["write_iops"]
 157         testdata["write_bw"] += result["data"]["write_bw"]
 158         if testdata["write_lat"] is 0:
 159             testdata["write_lat"] = result["data"]["write_lat"]
 160         else:
 161             testdata["write_lat"] += result["data"]["write_lat"]
 162             testdata["write_lat"] = testdata["write_lat"]/2
 163     final_result.put(testdata)
 164     q.put(1)
 165     return testdata
 166
 167
 168 def func_run(con_dic):
 169     test_date = do_test(con_dic)
 170     return test_date
 171
 172
 173 def run(test_config):
 174     con_dic = test_config["load_manager"]
 175     scenarios_conf = con_dic["scenarios"]
 176
 177     if test_config["contexts"]["yardstick_ip"] is None:
 178         con_dic["contexts"]["yardstick_ip"] =\
 179             conf_parser.ip_parser("yardstick_test_ip")
 180
 181     env_pre(test_config)
 182     LOG.info("yardstick environment prepare done!")
 183
 184     stack_num = scenarios_conf["num_stack"]
 185     test_num = conf_parser.str_to_list(scenarios_conf["num_thread"])
 186     rw = scenarios_conf["rw"]
 187     bs = scenarios_conf["bs"]
 188     size = scenarios_conf["size"]
 189     rwmixwrite = scenarios_conf["rwmixwrite"]
 190     numjobs = scenarios_conf["num_jobs"]
 191     direct = scenarios_conf["direct"]
 192     volume_num = scenarios_conf["volume_num"]
 193     volume_size = scenarios_conf["volume_size"]
 194
 195     for value in test_num:
 196         result = []
 197         out_num = 0
 198         num = int(value)
 199         # pool = multiprocessing.Pool(processes=num)
 200         threadings = []
 201         LOG.info("begin to run %s thread" % num)
 202
 203         starttime = datetime.datetime.now()
 204
 205         for i in xrange(0, num):
 206             case_config = {"stack_num": int(stack_num),
 207                            "volume_num": volume_num,
 208                            "rw": rw,
 209                            "bs": bs,
 210                            "size": size,
 211                            "rwmixwrite": rwmixwrite,
 212                            "numjobs": numjobs,
 213                            "direct": direct,
 214                            "volume_size": int(volume_size)}
 215             tmp_thread = threading.Thread(target=func_run, args=(case_config,))
 216             threadings.append(tmp_thread)
 217             tmp_thread.start()
 218
 219         for one_thread in threadings:
 220             one_thread.join()
 221         while not q.empty():
 222             result.append(q.get())
 223         for item in result:
 224             out_num = out_num + float(item)
 225
 226         print(result)
 227
 228         endtime = datetime.datetime.now()
 229         LOG.info("%s thread success %d times" % (num, out_num))
 230         during_date = (endtime - starttime).seconds
 231
 232         data_reply = config_to_result(num, out_num, during_date)
 233         conf_parser.result_to_file(data_reply, test_config["out_file"])
 234
 235     LOG.info('END POSCA stress multistack storage test')
 236     return data_reply