1 ##############################################################################
2 # Copyright (c) 2015 Huawei Technologies Co.,Ltd and others.
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 ##############################################################################
10 from vstf.controller.database.dbinterface import DbManage
11 import vstf.common.constants as cst
14 class DataProvider(object):
16 def __init__(self, taskid, dbase):
21 class CommonData(DataProvider):
23 def get_taskname(self):
24 return self._dbase.query_taskname(self._taskid)
26 def get_systeminfo(self):
28 ['Host', 'Server', 'CPU', 'MEM', 'NIC', 'OS'],
30 query = self._dbase.query_task_host_list(self._taskid)
31 query = map(lambda x: list(x), 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')
38 systable = map(lambda x: list(x), zip(*systable))
41 def get_introduct_tabledata(self):
43 ["Type", "Case", "Name", "Direction", "Configure"]
45 query = self._dbase.query_caseinfo()
46 result += map(lambda x: list(x), query)
49 def get_scenariolist(self):
50 query = self._dbase.query_scenariolist(self._taskid)
51 result = map(lambda x: list(x), zip(*query))
57 def is_scenario_start(self):
58 scenarioList = self.get_scenariolist()
59 print "scenarioList: ", scenarioList
64 def get_casename(self, case):
65 return self._dbase.query_casename(case)
67 def get_casefigure(self, case, tools):
68 return self._dbase.query_casefigure(case, tools)
71 class ScenarioData(DataProvider):
73 def __init__(self, taskid, dbase, scenario):
74 print "ScenarioData in"
75 DataProvider.__init__(self, taskid, dbase)
76 self._scenario = scenario
78 def get_test_tools(self, case):
79 query = self._dbase.query_casetools(self._taskid, case)
80 result = map(lambda x: list(x), query)
86 def get_caselist(self):
87 query = self._dbase.query_caselist(self._taskid, self._scenario)
88 result = map(lambda x: list(x), zip(*query))
94 def get_testlist(self):
95 query = self._dbase.query_testlist(self._taskid, self._scenario)
98 result.append(item.__dict__)
101 def is_provider_start(self, case, provider):
102 count = self._dbase.query_case_provider_count(
103 self._taskid, case, provider)
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)
115 def is_type_start(self, case, ptype):
116 count = self._dbase.query_case_type_count(self._taskid, case, ptype)
121 def is_throughput_start(self, case):
122 test_type = "throughput"
123 return self.is_type_start(case, test_type)
125 def is_frameloss_start(self, case):
126 test_type = "frameloss"
127 return self.is_type_start(case, test_type)
129 def is_latency_start(self, case):
130 test_type = "latency"
131 return self.is_type_start(case, test_type)
133 def get_summary_throughput_data(self, case, provider):
134 test_type = "throughput"
135 return self.get_summary_tabledata(case, provider, test_type)
137 def get_summary_frameLoss_data(self, case, provider):
138 test_type = "frameloss"
139 return self.get_summary_tabledata(case, provider, test_type)
141 def get_summary_tabledata(
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)",
168 " " + type_title[test_type] + " (%) ",
175 table_head = [["FrameSize (byte)",
177 " " + type_title[test_type] + " (%) ",
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)",
196 " " + type_title[test_type] + " (%)",
201 table_head = [["FrameSize (byte)",
203 " " + type_title[test_type] + " (%) ",
208 return table_head + table_body
210 def get_ratedata(self, testid, test_type):
211 table_head = [["FrameSize (bytes)",
218 query = self._dbase.query_testdata(testid, test_type)
221 table_body.append([item.AvgFrameSize,
226 item.AverageLatency])
229 result = table_head + table_body
232 def get_tabledata(self, case, test_type, item):
234 "FrameSize": "FrameSize (byte)",
235 "fastlink": "fastlink",
236 "l2switch": "l2switch",
247 line_speed = 20.0 if case in ["Tn-2v", "Tn-2"] else 10.0
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)
255 query = self._dbase.query_bandwidth(
256 self._taskid, case, provider, test_type)
258 query = self._dbase.query_avglatency(
259 self._taskid, case, provider, test_type)
260 query = map(lambda x: list(x), zip(*query))
262 table_head = [[type_dict["FrameSize"]] +
263 map(lambda x: " %4d " % (x), query[0])]
266 lambda x: item_dict[item] + "%.1f" %
267 x + item_dict[item], query[1])
270 lambda x: item_dict[item] + "%.2f" %
271 x + item_dict[item], query[1])
273 line_table = map(lambda x: "%.2f" % (
274 line_speed * 1000 / (8 * (x + 20))), query[0])
275 table.append([type_dict[provider]] + data)
278 table.append([type_dict["line"]] + line_table)
279 table = table_head + table
282 def get_frameloss_tabledata(self, case, test_type):
284 table = self.get_tabledata(case, test_type, item)
287 def get_frameloss_chartdata(self, case, test_type):
288 result = self.get_frameloss_tabledata(case, test_type)
289 result = map(list, zip(*result))
292 def get_framerate_tabledata(self, case, test_type):
294 table = self.get_tabledata(case, test_type, item)
297 def get_framerate_chartdata(self, case, test_type):
298 result = self.get_framerate_tabledata(case, test_type)
299 result = map(list, zip(*result))
302 def get_latency_tabledata(self, case):
303 test_type = "latency"
305 table = self.get_tabledata(case, test_type, item)
308 def get_latency_chartdata(self, case):
309 result = self.get_latency_tabledata(case)
310 result = map(list, zip(*result))
313 def get_latency_bardata(self, case):
314 table_data = self.get_latency_tabledata(case)
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]
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)
331 query = self._dbase.query_load(
332 self._taskid, case, provider, test_type)
336 "Avg": "Latency (uSec)",
337 "Percent": test_type + " (%)"
341 "Percent": " OF:100 "
347 ytitle = title_dict[item]
348 query = map(lambda x: list(x), zip(*query))
351 category_names = map(
353 x + name_dict[item], query[0])
355 bar_ = [color_dict[item]]
356 result = [ytitle, category_names, bar_, data]
360 class TaskData(object):
362 def __init__(self, taskid, dbase):
363 self.__common = CommonData(taskid, dbase)
364 scenario_list = self.__common.get_scenariolist()
366 for scenario in scenario_list:
367 scenario_dic[scenario] = ScenarioData(taskid, dbase, scenario)
368 self.__dict__.update(scenario_dic)
375 class HistoryData(DataProvider):
377 def get_data(self, task_list, case, provider, ttype, item):
379 @provider in ["fastlink", "rdp", "l2switch", ""]
380 @ttype in ["throughput", "frameloss", "latency"]
381 @item in ["avg", "ratep", "load"]
387 for taskid in task_list:
389 query = self._dbase.query_bandwidth(
390 taskid, case, provider, ttype)
392 query = self._dbase.query_avglatency(
393 taskid, case, provider, ttype)
397 for size, value in query:
399 sizes.extend(data.keys())
400 sizes = sorted({}.fromkeys(sizes).keys())
401 datas.append({taskid: data})
406 taskid = data.keys()[0]
407 data_th = self._dbase.query_taskdate(taskid)
408 testdata = data[taskid]
411 item.append(str(testdata.get(size, '')))
415 head_th = "FrameSize (byte)"
416 table_head = [[head_th] + map(lambda x: " %4d " % (x), sizes)]
417 table = table_head + result
421 def get_tasklist(self, count=5):
423 query = self._dbase.query_tasklist()
426 if item.TaskID <= self._taskid:
427 task_list.append(item.TaskID)
429 task_list = task_list[-count:]
432 def get_history_info(self, case):
434 "fastlink": "Fast Link ",
435 "l2switch": "L2Switch ",
436 "rdp": "Kernel RDP "}
438 "throughput": "Throughput Testing ",
439 "frameloss": "Frame Loss Testing ",
440 "latency": "Latency Testing "
444 "ratep": "RX Frame Rate(Mpps) ",
445 "avg": "Average Latency (uSec) "
448 task_list = self.get_tasklist()
451 for ttype in cst.TTYPES:
453 if ttype == "latency":
458 for provider in cst.PROVIDERS:
459 table_data = self.get_data(
460 task_list, case, provider, ttype, item)
463 "title": provider_dict[provider] + items_dict[item],
466 content["title"] = ttype_dict[ttype]
467 content.setdefault("data", [])
468 content["data"].append(data)
470 result.append(content)
477 taskid = dbase.get_last_taskid()
478 hdata = HistoryData(taskid, dbase)
479 task_list = hdata.get_tasklist()
481 cdata = CommonData(taskid, dbase)
482 scenario_list = cdata.get_scenariolist()
486 sdata = ScenarioData(taskid, dbase, scenario)
488 case_list = sdata.get_caselist()
493 ttypes = ["throughput", "frameloss"]
494 items = ["ratep", "load"]
496 for provider in cst.PROVIDERS:
502 print hdata.get_data(task_list, case, provider, ttype, item)
504 hdata.get_history_info(case)
507 if __name__ == '__main__':