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

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