--- /dev/null
+#!/usr/bin/python
+# -*- coding: utf8 -*-
+# author: wly
+# date: 2015-07-29
+# see license for license details
+__version__ = ''' '''
+
+from vstf.controller.database.dbinterface import DbManage
+
+
+class DataProvider(object):
+ def __init__(self, taskid, dbase):
+ self._dbase = dbase
+ self._taskid = taskid
+
+
+class CommonData(DataProvider):
+ def get_components(self):
+ result = []
+ query = self._dbase.query_exten_info(self._taskid)
+ print "CommonData", query
+ for item in query:
+ if item[2]:
+ context = "%s:%s(%s)" % (item[0], item[1], item[2])
+ else:
+ context = "%s:%s" % (item[0], item[1])
+ result.append(context)
+ return result
+
+ def get_software(self):
+ result = [
+ " Host OS: ubuntu 14.04.2",
+ " Guest OS: ubuntu 12.04.4"
+ ]
+ return result
+
+ def get_hardware(self):
+ result = [
+ " Server: Dell R920",
+ " CPU: E7-8893/2P/3.4GHz/10-Cores/37.5M-L3C",
+ " MEM: 128G",
+ " NIC: Intel 82599"
+ ]
+ return result
+
+ def get_taskname(self):
+ return self._dbase.query_taskname(self._taskid)
+
+ def get_gitinfo_tabledata(self):
+ result = []
+ return result
+
+ def get_profileparameters_tabledData(self):
+ result = [
+ ]
+ return result
+
+ def get_testingoptions_tabledata(self):
+ result = [
+ ]
+ return result
+
+ def get_systeminfo_tabledata(self):
+ result = [
+ ]
+ return result
+
+ def get_systeminfo(self):
+ systable = [
+ ['host', 'Server', 'CPU', 'MEM', 'NIC', 'OS'],
+ ]
+ query = self._dbase.query_task_host_list(self._taskid)
+ query = map(lambda x: list(x), query)
+ # rows = len(query)
+ # cols = len(zip(*query))
+ # for i in range(rows):
+ # for j in range(cols):
+ # query[i][j] = query[i][j].replace('\",','\"\n')
+ systable += query
+ systable = map(lambda x: list(x), zip(*systable))
+ return systable
+
+ def get_introduct_tabledata(self):
+ result = [
+ ["Type", "Case", "Name", "Direction", "Configure"]
+ ]
+ query = self._dbase.query_caseinfo()
+ result += map(lambda x: list(x), query)
+ return result
+
+ def get_scenariolist(self):
+ query = self._dbase.query_scenariolist(self._taskid)
+ result = map(lambda x: list(x), zip(*query))
+ if result:
+ return result[0]
+ else:
+ return result
+
+ def is_scenario_start(self):
+ scenarioList = self.get_scenariolist()
+ print "scenarioList: ", scenarioList
+ if scenarioList:
+ return True
+ return False
+
+ def get_contact(self):
+ result = [
+ "Name: xxx",
+ "ID: xxxxxxxx",
+ "Email: xxxx@xxx.com"
+ ]
+ return result
+
+ def get_casename(self, case):
+ return self._dbase.query_casename(case)
+
+ def get_casefigure(self, case, tools):
+ return self._dbase.query_casefigure(case, tools)
+
+
+class ScenarioData(DataProvider):
+ def __init__(self, taskid, dbase, scenario):
+ print "ScenarioData in"
+ DataProvider.__init__(self, taskid, dbase)
+ self._scenario = scenario
+
+ def get_covertitle(self):
+ result = [
+ "",
+ "",
+ "Elastic Virtual Switching Performance "
+ "Test Report",
+ "Scenario %s" % (self._scenario)
+ ]
+ return result
+
+ def get_test(self):
+ result = [
+ "Scenario: %s" % (self._scenario),
+ "Configuration: without VLAN",
+ ]
+ return result
+
+ def get_test_tools(self, case):
+ query = self._dbase.query_casetools(self._taskid, case)
+ result = map(lambda x: list(x), query)
+ if result:
+ return result[0][0]
+ else:
+ return result
+
+ def get_caselist(self):
+ query = self._dbase.query_caselist(self._taskid, self._scenario)
+ result = map(lambda x: list(x), zip(*query))
+ if result:
+ return result[0]
+ else:
+ return result
+
+ def is_provider_start(self, case, provider):
+ count = self._dbase.query_case_provider_count(self._taskid, case, provider)
+ if count:
+ return True
+ return False
+
+ def is_type_provider_start(self, case, provider, ptype):
+ count = self._dbase.query_case_type_provider_count(self._taskid, case, provider, ptype)
+ if count:
+ return True
+ return False
+
+ def is_type_start(self, case, ptype):
+ count = self._dbase.query_case_type_count(self._taskid, case, ptype)
+ if count:
+ return True
+ return False
+
+ def is_throughput_start(self, case):
+ test_type = "throughput"
+ return self.is_type_start(case, test_type)
+
+ def is_frameloss_start(self, case):
+ test_type = "frameloss"
+ return self.is_type_start(case, test_type)
+
+ def is_latency_start(self, case):
+ test_type = "latency"
+ return self.is_type_start(case, test_type)
+
+ def get_summary_throughput_data(self, case, provider):
+ test_type = "throughput"
+ return self.get_summary_tabledata(case, provider, test_type)
+
+ def get_summary_frameLoss_data(self, case, provider):
+ test_type = "frameloss"
+ return self.get_summary_tabledata(case, provider, test_type)
+
+ def get_summary_tabledata(self, case, provider, test_type, table_type='pdf'):
+ table_head = []
+ table_body = []
+ type_title = {
+ "frameloss": "Load",
+ "throughput": "Load"
+ }
+ tools = self.get_test_tools(case)
+ if "spirent" in tools:
+ table_body = self._dbase.query_summary_table(self._taskid, case, provider, test_type)
+ if 'pdf' == table_type:
+ table_head = [
+ ["FrameSize (byte)", test_type, "", "", "", "Latency(uSec)", "", ""],
+ ["", " Mpps ", " " + type_title[test_type] + " (%) ", "CPU Used (%)", " Mpps/Ghz ",
+ " Min ", " Max ", " Avg "]
+ ]
+ else:
+ table_head = [
+ ["FrameSize (byte)", " Mpps ", " " + type_title[test_type] + " (%) ", "CPU Used (%)",
+ " Mpps/Ghz ", "MinLatency(uSec)", "MaxLatency(uSec)", "AvgLatency(uSec)"],
+ ]
+ else:
+ table_body = self._dbase.query_summary_simpletable(self._taskid, case, provider, test_type)
+ if 'pdf' == table_type:
+ table_head = [
+ ["FrameSize (byte)", test_type, "", "", "", "Latency(uSec)"],
+ ["", " Mpps ", " " + type_title[test_type] + " (%)", "CPU Used (%)", " Mpps/Ghz ",
+ " Avg "]
+ ]
+ else:
+ table_head = [
+ ["FrameSize (byte)", " Mpps ", " " + type_title[test_type] + " (%) ", "CPU Used (%)",
+ " Mpps/Ghz ", "AvgLatency(uSec)"],
+ ]
+ return table_head + table_body
+
+ def get_tabledata(self, case, test_type, item):
+ type_dict = {
+ "FrameSize": "FrameSize (byte)",
+ "fastlink": "fastlink",
+ "l2switch": "l2switch",
+ "rdp": "kernel rdp",
+ "line": "line speed"
+ }
+ item_dict = {
+ "Percent": " ",
+ "Mpps": " ",
+ "Avg": " ",
+ }
+ provider_list = ["fastlink", "rdp", "l2switch"]
+ table = []
+ line_speed = 20.0 if case in ["Tn-2v", "Tn-2"] else 10.0
+
+ for provider in provider_list:
+ if self.is_provider_start(case, provider):
+ if item == 'Percent':
+ query = self._dbase.query_load(self._taskid, case, provider, test_type)
+ elif item == 'Mpps':
+ query = self._dbase.query_bandwidth(self._taskid, case, provider, test_type)
+ else:
+ query = self._dbase.query_avglatency(self._taskid, case, provider, test_type)
+ query = map(lambda x: list(x), zip(*query))
+ if query:
+ table_head = [[type_dict["FrameSize"]] + map(lambda x: " %4d " % (x), query[0])]
+ if item == "Avg":
+ data = map(lambda x: item_dict[item] + "%.1f" % (x) + item_dict[item], query[1])
+ else:
+ data = map(lambda x: item_dict[item] + "%.2f" % (x) + item_dict[item], query[1])
+ if item == "Mpps":
+ line_table = map(lambda x: "%.2f" % (line_speed * 1000 / (8 * (x + 20))), query[0])
+ table.append([type_dict[provider]] + data)
+ if table:
+ if item == "Mpps":
+ table.append([type_dict["line"]] + line_table)
+ table = table_head + table
+ return table
+
+ def get_frameloss_tabledata(self, case, test_type):
+ item = "Percent"
+ table = self.get_tabledata(case, test_type, item)
+ return table
+
+ def get_frameloss_chartdata(self, case, test_type):
+ result = self.get_frameloss_tabledata(case, test_type)
+ result = map(list, zip(*result))
+ return result
+
+ def get_framerate_tabledata(self, case, test_type):
+ item = "Mpps"
+ table = self.get_tabledata(case, test_type, item)
+ return table
+
+ def get_framerate_chartdata(self, case, test_type):
+ result = self.get_framerate_tabledata(case, test_type)
+ result = map(list, zip(*result))
+ return result
+
+ def get_latency_tabledata(self, case):
+ test_type = "latency"
+ item = "Avg"
+ table = self.get_tabledata(case, test_type, item)
+ return table
+
+ def get_latency_chartdata(self, case):
+ result = self.get_latency_tabledata(case)
+ result = map(list, zip(*result))
+ return result
+
+ def get_latency_bardata(self, case):
+ table_data = self.get_latency_tabledata(case)
+ result = []
+ if table_data:
+ ytitle = "Average Latency (uSec)"
+ category_names = map(lambda x: "FS:%4d" % int(float(x)) + "LOAD:50", table_data[0][1:])
+ bar_ = map(lambda x: x[0], table_data[1:])
+ data = map(lambda x: x[1:], table_data[1:])
+ result = [ytitle, category_names, bar_, data]
+ return result
+
+ def get_bardata(self, case, provider, test_type):
+ if test_type == "latency":
+ query = self._dbase.query_avglatency(self._taskid, case, provider, test_type)
+ item = "Avg"
+ else:
+ query = self._dbase.query_load(self._taskid, case, provider, test_type)
+ item = "Percent"
+
+ title_dict = {
+ "Avg": "Latency (uSec)",
+ "Percent": test_type + " (%)"
+ }
+ name_dict = {
+ "Avg": " LOAD:50",
+ "Percent": " OF:100 "
+ }
+ color_dict = {
+ "Avg": "latency",
+ "Percent": "loss"
+ }
+ ytitle = title_dict[item]
+ query = map(lambda x: list(x), zip(*query))
+ result = []
+ if query:
+ category_names = map(lambda x: "FS:%4d" % x + name_dict[item], query[0])
+ data = query[1:]
+ bar_ = [color_dict[item]]
+ result = [ytitle, category_names, bar_, data]
+ return result
+
+
+class TaskData(object):
+ def __init__(self, taskid, dbase):
+ self.__common = CommonData(taskid, dbase)
+ scenario_list = self.__common.get_scenariolist()
+ scenario_dic = {}
+ for scenario in scenario_list:
+ scenario_dic[scenario] = ScenarioData(taskid, dbase, scenario)
+ self.__dict__.update(scenario_dic)
+
+ @property
+ def common(self):
+ return self.__common
+
+
+class HistoryData(DataProvider):
+ def get_data(self, task_list, case, provider, ttype, item):
+ """
+ @provider in ["fastlink", "rdp", "l2switch"]
+ @ttype in ["throughput", "frameloss", "latency"]
+ @item in ["avg", "ratep", "load"]
+ """
+ table = []
+ table_head = []
+ datas = []
+ sizes = []
+ for taskid in task_list:
+ if item == 'ratep':
+ query = self._dbase.query_bandwidth(taskid, case, provider, ttype)
+ else:
+ query = self._dbase.query_avglatency(taskid, case, provider, ttype)
+
+ if query:
+ data = {}
+ for size, value in query:
+ data[size] = value
+ sizes.extend(data.keys())
+ sizes = {}.fromkeys(sizes).keys()
+ sizes.sort()
+ datas.append({taskid: data})
+
+ result = []
+ for data in datas:
+ print data
+ taskid = data.keys()[0]
+ data_th = self._dbase.query_taskdate(taskid)
+ testdata = data[taskid]
+ item = [data_th]
+ for size in sizes:
+ item.append(str(testdata.get(size, '')))
+ result.append(item)
+
+ if result:
+ head_th = "FrameSize (byte)"
+ table_head = [[head_th] + map(lambda x: " %4d " % (x), sizes)]
+ table = table_head + result
+
+ return table
+
+ def get_tasklist(self, count=5):
+ task_list = []
+ query = self._dbase.query_tasklist()
+ if query:
+ for item in query:
+ if item.TaskID <= self._taskid:
+ task_list.append(item.TaskID)
+
+ task_list = task_list[-count:]
+ return task_list
+
+ def get_history_info(self, case):
+ providers = ["fastlink", "rdp", "l2switch"]
+ provider_dict = {"fastlink": "Fast Link ", "l2switch": "L2Switch ", "rdp": "Kernel RDP "}
+ ttype_dict = {
+ "throughput": "Throughput Testing ",
+ "frameloss": "Frame Loss Testing ",
+ "latency": "Latency Testing "
+ }
+
+ items_dict = {
+ "ratep": "RX Frame Rate(Mpps) ",
+ "avg": "Average Latency (uSec) "
+ }
+
+ task_list = self.get_tasklist()
+ result = []
+
+ ttypes = ["throughput", "frameloss", "latency"]
+ for ttype in ttypes:
+ content = {}
+ if ttype == "latency":
+ item = "avg"
+ else:
+ item = "ratep"
+
+ for provider in providers:
+ table_data = self.get_data(task_list, case, provider, ttype, item)
+ if table_data:
+ data = {
+ "title": provider_dict[provider] + items_dict[item],
+ "data": table_data
+ }
+ content["title"] = ttype_dict[ttype]
+ content.setdefault("data", [])
+ content["data"].append(data)
+ if content:
+ result.append(content)
+ print "xxxxxxxxxxxxxx"
+ print result
+ print "xxxxxxxxxxxxxx"
+ return result
+
+
+def unit_test():
+ dbase = DbManage()
+ taskid = dbase.get_last_taskid()
+ hdata = HistoryData(taskid, dbase)
+ task_list = hdata.get_tasklist()
+
+ cdata = CommonData(taskid, dbase)
+ scenario_list = cdata.get_scenariolist()
+ print scenario_list
+
+ scenario = "Tn"
+ sdata = ScenarioData(taskid, dbase, scenario)
+
+ case_list = sdata.get_caselist()
+ print case_list
+
+ case = "Tn-1"
+
+ providers = ["fastlink", "rdp", "l2switch"]
+ ttypes = ["throughput", "frameloss"]
+ items = ["ratep", "load"]
+
+ for provider in providers:
+ for ttype in ttypes:
+ for item in items:
+ print provider
+ print ttype
+ print item
+ print hdata.get_data(task_list, case, provider, ttype, item)
+
+ hdata.get_history_info(case)
+
+
+if __name__ == '__main__':
+ unit_test()
Code Review / bottlenecks.git / blobdiff