5 # see license for license details
8 from vstf.controller.database.dbinterface import DbManage
11 class DataProvider(object):
12 def __init__(self, taskid, dbase):
17 class CommonData(DataProvider):
18 def get_components(self):
20 query = self._dbase.query_exten_info(self._taskid)
21 print "CommonData", query
24 context = "%s:%s(%s)" % (item[0], item[1], item[2])
26 context = "%s:%s" % (item[0], item[1])
27 result.append(context)
30 def get_software(self):
32 " Host OS: ubuntu 14.04.2",
33 " Guest OS: ubuntu 12.04.4"
37 def get_hardware(self):
40 " CPU: E7-8893/2P/3.4GHz/10-Cores/37.5M-L3C",
46 def get_taskname(self):
47 return self._dbase.query_taskname(self._taskid)
49 def get_gitinfo_tabledata(self):
53 def get_profileparameters_tabledData(self):
58 def get_testingoptions_tabledata(self):
63 def get_systeminfo_tabledata(self):
68 def get_systeminfo(self):
70 ['host', 'Server', 'CPU', 'MEM', 'NIC', 'OS'],
72 query = self._dbase.query_task_host_list(self._taskid)
73 query = map(lambda x: list(x), 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')
80 systable = map(lambda x: list(x), zip(*systable))
83 def get_introduct_tabledata(self):
85 ["Type", "Case", "Name", "Direction", "Configure"]
87 query = self._dbase.query_caseinfo()
88 result += map(lambda x: list(x), query)
91 def get_scenariolist(self):
92 query = self._dbase.query_scenariolist(self._taskid)
93 result = map(lambda x: list(x), zip(*query))
99 def is_scenario_start(self):
100 scenarioList = self.get_scenariolist()
101 print "scenarioList: ", scenarioList
106 def get_contact(self):
110 "Email: xxxx@xxx.com"
114 def get_casename(self, case):
115 return self._dbase.query_casename(case)
117 def get_casefigure(self, case, tools):
118 return self._dbase.query_casefigure(case, tools)
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
127 def get_covertitle(self):
131 "Elastic Virtual Switching Performance "
133 "Scenario %s" % (self._scenario)
139 "Scenario: %s" % (self._scenario),
140 "Configuration: without VLAN",
144 def get_test_tools(self, case):
145 query = self._dbase.query_casetools(self._taskid, case)
146 result = map(lambda x: list(x), query)
152 def get_caselist(self):
153 query = self._dbase.query_caselist(self._taskid, self._scenario)
154 result = map(lambda x: list(x), zip(*query))
160 def is_provider_start(self, case, provider):
161 count = self._dbase.query_case_provider_count(self._taskid, case, provider)
166 def is_type_provider_start(self, case, provider, ptype):
167 count = self._dbase.query_case_type_provider_count(self._taskid, case, provider, ptype)
172 def is_type_start(self, case, ptype):
173 count = self._dbase.query_case_type_count(self._taskid, case, ptype)
178 def is_throughput_start(self, case):
179 test_type = "throughput"
180 return self.is_type_start(case, test_type)
182 def is_frameloss_start(self, case):
183 test_type = "frameloss"
184 return self.is_type_start(case, test_type)
186 def is_latency_start(self, case):
187 test_type = "latency"
188 return self.is_type_start(case, test_type)
190 def get_summary_throughput_data(self, case, provider):
191 test_type = "throughput"
192 return self.get_summary_tabledata(case, provider, test_type)
194 def get_summary_frameLoss_data(self, case, provider):
195 test_type = "frameloss"
196 return self.get_summary_tabledata(case, provider, test_type)
198 def get_summary_tabledata(self, case, provider, test_type, table_type='pdf'):
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:
210 ["FrameSize (byte)", test_type, "", "", "", "Latency(uSec)", "", ""],
211 ["", " Mpps ", " " + type_title[test_type] + " (%) ", "CPU Used (%)", " Mpps/Ghz ",
212 " Min ", " Max ", " Avg "]
216 ["FrameSize (byte)", " Mpps ", " " + type_title[test_type] + " (%) ", "CPU Used (%)",
217 " Mpps/Ghz ", "MinLatency(uSec)", "MaxLatency(uSec)", "AvgLatency(uSec)"],
220 table_body = self._dbase.query_summary_simpletable(self._taskid, case, provider, test_type)
221 if 'pdf' == table_type:
223 ["FrameSize (byte)", test_type, "", "", "", "Latency(uSec)"],
224 ["", " Mpps ", " " + type_title[test_type] + " (%)", "CPU Used (%)", " Mpps/Ghz ",
229 ["FrameSize (byte)", " Mpps ", " " + type_title[test_type] + " (%) ", "CPU Used (%)",
230 " Mpps/Ghz ", "AvgLatency(uSec)"],
232 return table_head + table_body
234 def get_tabledata(self, case, test_type, item):
236 "FrameSize": "FrameSize (byte)",
237 "fastlink": "fastlink",
238 "l2switch": "l2switch",
247 provider_list = ["fastlink", "rdp", "l2switch"]
249 line_speed = 20.0 if case in ["Tn-2v", "Tn-2"] else 10.0
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)
256 query = self._dbase.query_bandwidth(self._taskid, case, provider, test_type)
258 query = self._dbase.query_avglatency(self._taskid, case, provider, test_type)
259 query = map(lambda x: list(x), zip(*query))
261 table_head = [[type_dict["FrameSize"]] + map(lambda x: " %4d " % (x), query[0])]
263 data = map(lambda x: item_dict[item] + "%.1f" % (x) + item_dict[item], query[1])
265 data = map(lambda x: item_dict[item] + "%.2f" % (x) + item_dict[item], query[1])
267 line_table = map(lambda x: "%.2f" % (line_speed * 1000 / (8 * (x + 20))), query[0])
268 table.append([type_dict[provider]] + data)
271 table.append([type_dict["line"]] + line_table)
272 table = table_head + table
275 def get_frameloss_tabledata(self, case, test_type):
277 table = self.get_tabledata(case, test_type, item)
280 def get_frameloss_chartdata(self, case, test_type):
281 result = self.get_frameloss_tabledata(case, test_type)
282 result = map(list, zip(*result))
285 def get_framerate_tabledata(self, case, test_type):
287 table = self.get_tabledata(case, test_type, item)
290 def get_framerate_chartdata(self, case, test_type):
291 result = self.get_framerate_tabledata(case, test_type)
292 result = map(list, zip(*result))
295 def get_latency_tabledata(self, case):
296 test_type = "latency"
298 table = self.get_tabledata(case, test_type, item)
301 def get_latency_chartdata(self, case):
302 result = self.get_latency_tabledata(case)
303 result = map(list, zip(*result))
306 def get_latency_bardata(self, case):
307 table_data = self.get_latency_tabledata(case)
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]
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)
322 query = self._dbase.query_load(self._taskid, case, provider, test_type)
326 "Avg": "Latency (uSec)",
327 "Percent": test_type + " (%)"
331 "Percent": " OF:100 "
337 ytitle = title_dict[item]
338 query = map(lambda x: list(x), zip(*query))
341 category_names = map(lambda x: "FS:%4d" % x + name_dict[item], query[0])
343 bar_ = [color_dict[item]]
344 result = [ytitle, category_names, bar_, data]
348 class TaskData(object):
349 def __init__(self, taskid, dbase):
350 self.__common = CommonData(taskid, dbase)
351 scenario_list = self.__common.get_scenariolist()
353 for scenario in scenario_list:
354 scenario_dic[scenario] = ScenarioData(taskid, dbase, scenario)
355 self.__dict__.update(scenario_dic)
362 class HistoryData(DataProvider):
363 def get_data(self, task_list, case, provider, ttype, item):
365 @provider in ["fastlink", "rdp", "l2switch"]
366 @ttype in ["throughput", "frameloss", "latency"]
367 @item in ["avg", "ratep", "load"]
373 for taskid in task_list:
375 query = self._dbase.query_bandwidth(taskid, case, provider, ttype)
377 query = self._dbase.query_avglatency(taskid, case, provider, ttype)
381 for size, value in query:
383 sizes.extend(data.keys())
384 sizes = {}.fromkeys(sizes).keys()
386 datas.append({taskid: data})
391 taskid = data.keys()[0]
392 data_th = self._dbase.query_taskdate(taskid)
393 testdata = data[taskid]
396 item.append(str(testdata.get(size, '')))
400 head_th = "FrameSize (byte)"
401 table_head = [[head_th] + map(lambda x: " %4d " % (x), sizes)]
402 table = table_head + result
406 def get_tasklist(self, count=5):
408 query = self._dbase.query_tasklist()
411 if item.TaskID <= self._taskid:
412 task_list.append(item.TaskID)
414 task_list = task_list[-count:]
417 def get_history_info(self, case):
418 providers = ["fastlink", "rdp", "l2switch"]
419 provider_dict = {"fastlink": "Fast Link ", "l2switch": "L2Switch ", "rdp": "Kernel RDP "}
421 "throughput": "Throughput Testing ",
422 "frameloss": "Frame Loss Testing ",
423 "latency": "Latency Testing "
427 "ratep": "RX Frame Rate(Mpps) ",
428 "avg": "Average Latency (uSec) "
431 task_list = self.get_tasklist()
434 ttypes = ["throughput", "frameloss", "latency"]
437 if ttype == "latency":
442 for provider in providers:
443 table_data = self.get_data(task_list, case, provider, ttype, item)
446 "title": provider_dict[provider] + items_dict[item],
449 content["title"] = ttype_dict[ttype]
450 content.setdefault("data", [])
451 content["data"].append(data)
453 result.append(content)
454 print "xxxxxxxxxxxxxx"
456 print "xxxxxxxxxxxxxx"
462 taskid = dbase.get_last_taskid()
463 hdata = HistoryData(taskid, dbase)
464 task_list = hdata.get_tasklist()
466 cdata = CommonData(taskid, dbase)
467 scenario_list = cdata.get_scenariolist()
471 sdata = ScenarioData(taskid, dbase, scenario)
473 case_list = sdata.get_caselist()
478 providers = ["fastlink", "rdp", "l2switch"]
479 ttypes = ["throughput", "frameloss"]
480 items = ["ratep", "load"]
482 for provider in providers:
488 print hdata.get_data(task_list, case, provider, ttype, item)
490 hdata.get_history_info(case)
493 if __name__ == '__main__':