vstf/vstf/controller/reporters/report/data_factory.py

   1 #!/usr/bin/python
   2 # -*- coding: utf8 -*-
   3 # author: wly
   4 # date: 2015-07-29
   5 # see license for license details
   6 __version__ = ''' '''
   7
   8 from vstf.controller.database.dbinterface import DbManage
   9
  10
  11 class DataProvider(object):
  12     def __init__(self, taskid, dbase):
  13         self._dbase = dbase
  14         self._taskid = taskid
  15
  16
  17 class CommonData(DataProvider):
  18     def get_components(self):
  19         result = []
  20         query = self._dbase.query_exten_info(self._taskid)
  21         print "CommonData", query
  22         for item in query:
  23             if item[2]:
  24                 context = "%s:%s(%s)" % (item[0], item[1], item[2])
  25             else:
  26                 context = "%s:%s" % (item[0], item[1])
  27             result.append(context)
  28         return result
  29
  30     def get_software(self):
  31         result = [
  32             "  Host OS:  ubuntu 14.04.2",
  33             "  Guest OS: ubuntu 12.04.4"
  34         ]
  35         return result
  36
  37     def get_hardware(self):
  38         result = [
  39             "  Server: Dell R920",
  40             "  CPU: E7-8893/2P/3.4GHz/10-Cores/37.5M-L3C",
  41             "  MEM: 128G",
  42             "  NIC: Intel 82599"
  43         ]
  44         return result
  45
  46     def get_taskname(self):
  47         return self._dbase.query_taskname(self._taskid)
  48
  49     def get_gitinfo_tabledata(self):
  50         result = []
  51         return result
  52
  53     def get_profileparameters_tabledData(self):
  54         result = [
  55         ]
  56         return result
  57
  58     def get_testingoptions_tabledata(self):
  59         result = [
  60         ]
  61         return result
  62
  63     def get_systeminfo_tabledata(self):
  64         result = [
  65         ]
  66         return result
  67
  68     def get_systeminfo(self):
  69         systable = [
  70             ['host', 'Server', 'CPU', 'MEM', 'NIC', 'OS'],
  71         ]
  72         query = self._dbase.query_task_host_list(self._taskid)
  73         query = map(lambda x: list(x), query)
  74         #    rows = len(query)
  75         #    cols = len(zip(*query))
  76         #    for i in range(rows):
  77         #        for j in range(cols):
  78         #            query[i][j] = query[i][j].replace('\",','\"\n')
  79         systable += query
  80         systable = map(lambda x: list(x), zip(*systable))
  81         return systable
  82
  83     def get_introduct_tabledata(self):
  84         result = [
  85             ["Type", "Case", "Name", "Direction", "Configure"]
  86         ]
  87         query = self._dbase.query_caseinfo()
  88         result += map(lambda x: list(x), query)
  89         return result
  90
  91     def get_scenariolist(self):
  92         query = self._dbase.query_scenariolist(self._taskid)
  93         result = map(lambda x: list(x), zip(*query))
  94         if result:
  95             return result[0]
  96         else:
  97             return result
  98
  99     def is_scenario_start(self):
 100         scenarioList = self.get_scenariolist()
 101         print "scenarioList: ", scenarioList
 102         if scenarioList:
 103             return True
 104         return False
 105
 106     def get_contact(self):
 107         result = [
 108             "Name: xxx",
 109             "ID: xxxxxxxx",
 110             "Email: xxxx@xxx.com"
 111         ]
 112         return result
 113
 114     def get_casename(self, case):
 115         return self._dbase.query_casename(case)
 116
 117     def get_casefigure(self, case, tools):
 118         return self._dbase.query_casefigure(case, tools)
 119
 120
 121 class ScenarioData(DataProvider):
 122     def __init__(self, taskid, dbase, scenario):
 123         print "ScenarioData in"
 124         DataProvider.__init__(self, taskid, dbase)
 125         self._scenario = scenario
 126
 127     def get_covertitle(self):
 128         result = [
 129             "",
 130             "",
 131             "Elastic Virtual Switching Performance "
 132             "Test Report",
 133             "Scenario %s" % (self._scenario)
 134         ]
 135         return result
 136
 137     def get_test(self):
 138         result = [
 139             "Scenario: %s" % (self._scenario),
 140             "Configuration: without VLAN",
 141         ]
 142         return result
 143
 144     def get_test_tools(self, case):
 145         query = self._dbase.query_casetools(self._taskid, case)
 146         result = map(lambda x: list(x), query)
 147         if result:
 148             return result[0][0]
 149         else:
 150             return result
 151
 152     def get_caselist(self):
 153         query = self._dbase.query_caselist(self._taskid, self._scenario)
 154         result = map(lambda x: list(x), zip(*query))
 155         if result:
 156             return result[0]
 157         else:
 158             return result
 159
 160     def is_provider_start(self, case, provider):
 161         count = self._dbase.query_case_provider_count(self._taskid, case, provider)
 162         if count:
 163             return True
 164         return False
 165
 166     def is_type_provider_start(self, case, provider, ptype):
 167         count = self._dbase.query_case_type_provider_count(self._taskid, case, provider, ptype)
 168         if count:
 169             return True
 170         return False
 171
 172     def is_type_start(self, case, ptype):
 173         count = self._dbase.query_case_type_count(self._taskid, case, ptype)
 174         if count:
 175             return True
 176         return False
 177
 178     def is_throughput_start(self, case):
 179         test_type = "throughput"
 180         return self.is_type_start(case, test_type)
 181
 182     def is_frameloss_start(self, case):
 183         test_type = "frameloss"
 184         return self.is_type_start(case, test_type)
 185
 186     def is_latency_start(self, case):
 187         test_type = "latency"
 188         return self.is_type_start(case, test_type)
 189
 190     def get_summary_throughput_data(self, case, provider):
 191         test_type = "throughput"
 192         return self.get_summary_tabledata(case, provider, test_type)
 193
 194     def get_summary_frameLoss_data(self, case, provider):
 195         test_type = "frameloss"
 196         return self.get_summary_tabledata(case, provider, test_type)
 197
 198     def get_summary_tabledata(self, case, provider, test_type, table_type='pdf'):
 199         table_head = []
 200         table_body = []
 201         type_title = {
 202             "frameloss": "Load",
 203             "throughput": "Load"
 204         }
 205         tools = self.get_test_tools(case)
 206         if "spirent" in tools:
 207             table_body = self._dbase.query_summary_table(self._taskid, case, provider, test_type)
 208             if 'pdf' == table_type:
 209                 table_head = [
 210                     ["FrameSize (byte)", test_type, "", "", "", "Latency(uSec)", "", ""],
 211                     ["", "    Mpps    ", "   " + type_title[test_type] + " (%)   ", "CPU Used (%)", " Mpps/Ghz ",
 212                      " Min ", " Max ", " Avg "]
 213                 ]
 214             else:
 215                 table_head = [
 216                     ["FrameSize (byte)", "    Mpps    ", "   " + type_title[test_type] + " (%)   ", "CPU Used (%)",
 217                      " Mpps/Ghz ", "MinLatency(uSec)", "MaxLatency(uSec)", "AvgLatency(uSec)"],
 218                 ]
 219         else:
 220             table_body = self._dbase.query_summary_simpletable(self._taskid, case, provider, test_type)
 221             if 'pdf' == table_type:
 222                 table_head = [
 223                     ["FrameSize (byte)", test_type, "", "", "", "Latency(uSec)"],
 224                     ["", "    Mpps    ", "   " + type_title[test_type] + " (%)", "CPU Used (%)", " Mpps/Ghz ",
 225                      "  Avg  "]
 226                 ]
 227             else:
 228                 table_head = [
 229                     ["FrameSize (byte)", "    Mpps    ", "   " + type_title[test_type] + " (%)   ", "CPU Used (%)",
 230                      " Mpps/Ghz ", "AvgLatency(uSec)"],
 231                 ]
 232         return table_head + table_body
 233
 234     def get_tabledata(self, case, test_type, item):
 235         type_dict = {
 236             "FrameSize": "FrameSize (byte)",
 237             "fastlink": "fastlink",
 238             "l2switch": "l2switch",
 239             "rdp": "kernel rdp",
 240             "line": "line speed"
 241         }
 242         item_dict = {
 243             "Percent": "  ",
 244             "Mpps": "   ",
 245             "Avg": "   ",
 246         }
 247         provider_list = ["fastlink", "rdp", "l2switch"]
 248         table = []
 249         line_speed = 20.0 if case in ["Tn-2v", "Tn-2"] else 10.0
 250
 251         for provider in provider_list:
 252             if self.is_provider_start(case, provider):
 253                 if item == 'Percent':
 254                     query = self._dbase.query_load(self._taskid, case, provider, test_type)
 255                 elif item == 'Mpps':
 256                     query = self._dbase.query_bandwidth(self._taskid, case, provider, test_type)
 257                 else:
 258                     query = self._dbase.query_avglatency(self._taskid, case, provider, test_type)
 259                 query = map(lambda x: list(x), zip(*query))
 260                 if query:
 261                     table_head = [[type_dict["FrameSize"]] + map(lambda x: "  %4d  " % (x), query[0])]
 262                     if item == "Avg":
 263                         data = map(lambda x: item_dict[item] + "%.1f" % (x) + item_dict[item], query[1])
 264                     else:
 265                         data = map(lambda x: item_dict[item] + "%.2f" % (x) + item_dict[item], query[1])
 266                     if item == "Mpps":
 267                         line_table = map(lambda x: "%.2f" % (line_speed * 1000 / (8 * (x + 20))), query[0])
 268                     table.append([type_dict[provider]] + data)
 269         if table:
 270             if item == "Mpps":
 271                 table.append([type_dict["line"]] + line_table)
 272             table = table_head + table
 273         return table
 274
 275     def get_frameloss_tabledata(self, case, test_type):
 276         item = "Percent"
 277         table = self.get_tabledata(case, test_type, item)
 278         return table
 279
 280     def get_frameloss_chartdata(self, case, test_type):
 281         result = self.get_frameloss_tabledata(case, test_type)
 282         result = map(list, zip(*result))
 283         return result
 284
 285     def get_framerate_tabledata(self, case, test_type):
 286         item = "Mpps"
 287         table = self.get_tabledata(case, test_type, item)
 288         return table
 289
 290     def get_framerate_chartdata(self, case, test_type):
 291         result = self.get_framerate_tabledata(case, test_type)
 292         result = map(list, zip(*result))
 293         return result
 294
 295     def get_latency_tabledata(self, case):
 296         test_type = "latency"
 297         item = "Avg"
 298         table = self.get_tabledata(case, test_type, item)
 299         return table
 300
 301     def get_latency_chartdata(self, case):
 302         result = self.get_latency_tabledata(case)
 303         result = map(list, zip(*result))
 304         return result
 305
 306     def get_latency_bardata(self, case):
 307         table_data = self.get_latency_tabledata(case)
 308         result = []
 309         if table_data:
 310             ytitle = "Average Latency (uSec)"
 311             category_names = map(lambda x: "FS:%4d" % int(float(x)) + "LOAD:50", table_data[0][1:])
 312             bar_ = map(lambda x: x[0], table_data[1:])
 313             data = map(lambda x: x[1:], table_data[1:])
 314             result = [ytitle, category_names, bar_, data]
 315         return result
 316
 317     def get_bardata(self, case, provider, test_type):
 318         if test_type == "latency":
 319             query = self._dbase.query_avglatency(self._taskid, case, provider, test_type)
 320             item = "Avg"
 321         else:
 322             query = self._dbase.query_load(self._taskid, case, provider, test_type)
 323             item = "Percent"
 324
 325         title_dict = {
 326             "Avg": "Latency (uSec)",
 327             "Percent": test_type + " (%)"
 328         }
 329         name_dict = {
 330             "Avg": " LOAD:50",
 331             "Percent": " OF:100 "
 332         }
 333         color_dict = {
 334             "Avg": "latency",
 335             "Percent": "loss"
 336         }
 337         ytitle = title_dict[item]
 338         query = map(lambda x: list(x), zip(*query))
 339         result = []
 340         if query:
 341             category_names = map(lambda x: "FS:%4d" % x + name_dict[item], query[0])
 342             data = query[1:]
 343             bar_ = [color_dict[item]]
 344             result = [ytitle, category_names, bar_, data]
 345         return result
 346
 347
 348 class TaskData(object):
 349     def __init__(self, taskid, dbase):
 350         self.__common = CommonData(taskid, dbase)
 351         scenario_list = self.__common.get_scenariolist()
 352         scenario_dic = {}
 353         for scenario in scenario_list:
 354             scenario_dic[scenario] = ScenarioData(taskid, dbase, scenario)
 355         self.__dict__.update(scenario_dic)
 356
 357     @property
 358     def common(self):
 359         return self.__common
 360
 361
 362 class HistoryData(DataProvider):
 363     def get_data(self, task_list, case, provider, ttype, item):
 364         """
 365         @provider  in ["fastlink", "rdp", "l2switch"]
 366         @ttype in ["throughput", "frameloss", "latency"]
 367         @item in ["avg", "ratep", "load"]
 368         """
 369         table = []
 370         table_head = []
 371         datas = []
 372         sizes = []
 373         for taskid in task_list:
 374             if item == 'ratep':
 375                 query = self._dbase.query_bandwidth(taskid, case, provider, ttype)
 376             else:
 377                 query = self._dbase.query_avglatency(taskid, case, provider, ttype)
 378
 379             if query:
 380                 data = {}
 381                 for size, value in query:
 382                     data[size] = value
 383                 sizes.extend(data.keys())
 384                 sizes = {}.fromkeys(sizes).keys()
 385                 sizes.sort()
 386                 datas.append({taskid: data})
 387
 388         result = []
 389         for data in datas:
 390             print data
 391             taskid = data.keys()[0]
 392             data_th = self._dbase.query_taskdate(taskid)
 393             testdata = data[taskid]
 394             item = [data_th]
 395             for size in sizes:
 396                 item.append(str(testdata.get(size, '')))
 397             result.append(item)
 398
 399         if result:
 400             head_th = "FrameSize (byte)"
 401             table_head = [[head_th] + map(lambda x: "  %4d  " % (x), sizes)]
 402             table = table_head + result
 403
 404         return table
 405
 406     def get_tasklist(self, count=5):
 407         task_list = []
 408         query = self._dbase.query_tasklist()
 409         if query:
 410             for item in query:
 411                 if item.TaskID <= self._taskid:
 412                     task_list.append(item.TaskID)
 413
 414         task_list = task_list[-count:]
 415         return task_list
 416
 417     def get_history_info(self, case):
 418         providers = ["fastlink", "rdp", "l2switch"]
 419         provider_dict = {"fastlink": "Fast Link ", "l2switch": "L2Switch ", "rdp": "Kernel RDP "}
 420         ttype_dict = {
 421             "throughput": "Throughput Testing ",
 422             "frameloss": "Frame Loss Testing ",
 423             "latency": "Latency Testing "
 424         }
 425
 426         items_dict = {
 427             "ratep": "RX Frame Rate(Mpps) ",
 428             "avg": "Average Latency (uSec) "
 429         }
 430
 431         task_list = self.get_tasklist()
 432         result = []
 433
 434         ttypes = ["throughput", "frameloss", "latency"]
 435         for ttype in ttypes:
 436             content = {}
 437             if ttype == "latency":
 438                 item = "avg"
 439             else:
 440                 item = "ratep"
 441
 442             for provider in providers:
 443                 table_data = self.get_data(task_list, case, provider, ttype, item)
 444                 if table_data:
 445                     data = {
 446                         "title": provider_dict[provider] + items_dict[item],
 447                         "data": table_data
 448                     }
 449                     content["title"] = ttype_dict[ttype]
 450                     content.setdefault("data", [])
 451                     content["data"].append(data)
 452             if content:
 453                 result.append(content)
 454         print "xxxxxxxxxxxxxx"
 455         print result
 456         print "xxxxxxxxxxxxxx"
 457         return result
 458
 459
 460 def unit_test():
 461     dbase = DbManage()
 462     taskid = dbase.get_last_taskid()
 463     hdata = HistoryData(taskid, dbase)
 464     task_list = hdata.get_tasklist()
 465
 466     cdata = CommonData(taskid, dbase)
 467     scenario_list = cdata.get_scenariolist()
 468     print scenario_list
 469
 470     scenario = "Tn"
 471     sdata = ScenarioData(taskid, dbase, scenario)
 472
 473     case_list = sdata.get_caselist()
 474     print case_list
 475
 476     case = "Tn-1"
 477
 478     providers = ["fastlink", "rdp", "l2switch"]
 479     ttypes = ["throughput", "frameloss"]
 480     items = ["ratep", "load"]
 481
 482     for provider in providers:
 483         for ttype in ttypes:
 484             for item in items:
 485                 print provider
 486                 print ttype
 487                 print item
 488                 print hdata.get_data(task_list, case, provider, ttype, item)
 489
 490     hdata.get_history_info(case)
 491
 492
 493 if __name__ == '__main__':
 494     unit_test()