From 8f1101df131a4d3e03b377738507d88b745831c0 Mon Sep 17 00:00:00 2001
From: "Yiting.Li" <liyiting@huawei.com>
Date: Tue, 22 Dec 2015 17:11:12 -0800
Subject:     Upload the contribution of vstf as bottleneck network framework.

    End to End Performance test

    JIRA:BOTTLENECK-29

Change-Id: Ib2c553c8b60d6cda9e7a7b52b737c9139f706ebd
Signed-off-by: Yiting.Li <liyiting@huawei.com>
---
 .../controller/reporters/report/data_factory.py    | 494 +++++++++++++++++++++
 1 file changed, 494 insertions(+)
 create mode 100755 vstf/vstf/controller/reporters/report/data_factory.py

(limited to 'vstf/vstf/controller/reporters/report/data_factory.py')

diff --git a/vstf/vstf/controller/reporters/report/data_factory.py b/vstf/vstf/controller/reporters/report/data_factory.py
new file mode 100755
index 00000000..39c534b6
--- /dev/null
+++ b/vstf/vstf/controller/reporters/report/data_factory.py
@@ -0,0 +1,494 @@
+#!/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()
-- 
cgit 1.2.3-korg