X-Git-Url: https://gerrit.fd.io/r/gitweb?p=csit.git;a=blobdiff_plain;f=resources%2Ftools%2Fpresentation%2Finput_data_parser.py;h=7f1ccd368bb1b43ec79e899da82f726abbe9f4d4;hp=364cdbdbad7f55633e52ae96bf70b3b8ba42fcc8;hb=b7fccd32e5139b98976a7b4f44ef7eed9248f1b5;hpb=4255e5ea90db6f0c2e4a106ff8cc6dc734ac5422 diff --git a/resources/tools/presentation/input_data_parser.py b/resources/tools/presentation/input_data_parser.py index 364cdbdbad..7f1ccd368b 100644 --- a/resources/tools/presentation/input_data_parser.py +++ b/resources/tools/presentation/input_data_parser.py @@ -1,4 +1,4 @@ -# Copyright (c) 2021 Cisco and/or its affiliates. +# Copyright (c) 2022 Cisco and/or its affiliates. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at: @@ -239,6 +239,15 @@ class ExecutionChecker(ResultVisitor): ) REGEX_MRR_MSG_INFO = re.compile(r'.*\[(.*)\]') + REGEX_VSAP_MSG_INFO = re.compile( + r'Transfer Rate: (\d*.\d*).*\n' + r'Latency: (\d*.\d*).*\n' + r'Completed requests: (\d*).*\n' + r'Failed requests: (\d*).*\n' + r'Total data transferred: (\d*).*\n' + r'Connection [cr]ps rate:\s*(\d*.\d*)' + ) + # Needed for CPS and PPS tests REGEX_NDRPDR_LAT_BASE = re.compile( r'LATENCY.*\[\'(.*)\', \'(.*)\'\]\s\n.*\n.*\n' @@ -278,15 +287,17 @@ class ExecutionChecker(ResultVisitor): ) REGEX_TC_TAG = re.compile(r'\d+[tT]\d+[cC]') - REGEX_TC_NAME_OLD = re.compile(r'-\d+[tT]\d+[cC]-') - REGEX_TC_NAME_NEW = re.compile(r'-\d+[cC]-') REGEX_TC_NUMBER = re.compile(r'tc\d{2}-') REGEX_TC_PAPI_CLI = re.compile(r'.*\((\d+.\d+.\d+.\d+.) - (.*)\)') - def __init__(self, metadata, mapping, ignore): + REGEX_SH_RUN_HOST = re.compile( + r'hostname=\"(\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3})\",hook=\"(.*)\"' + ) + + def __init__(self, metadata, mapping, ignore, process_oper): """Initialisation. :param metadata: Key-value pairs to be included in "metadata" part of @@ -294,9 +305,12 @@ class ExecutionChecker(ResultVisitor): :param mapping: Mapping of the old names of test cases to the new (actual) one. :param ignore: List of TCs to be ignored. + :param process_oper: If True, operational data (show run, telemetry) is + processed. :type metadata: dict :type mapping: dict :type ignore: list + :type process_oper: bool """ # Type of message to parse out from the test messages @@ -317,6 +331,8 @@ class ExecutionChecker(ResultVisitor): # Ignore list self._ignore = ignore + self._process_oper = process_oper + # Number of PAPI History messages found: # 0 - no message # 1 - PAPI History of DUT1 @@ -324,6 +340,8 @@ class ExecutionChecker(ResultVisitor): self._conf_history_lookup_nr = 0 self._sh_run_counter = 0 + self._telemetry_kw_counter = 0 + self._telemetry_msg_counter = 0 # Test ID of currently processed test- the lowercase full path to the # test @@ -343,12 +361,12 @@ class ExecutionChecker(ResultVisitor): # Dictionary defining the methods used to parse different types of # messages self.parse_msg = { - u"timestamp": self._get_timestamp, u"vpp-version": self._get_vpp_version, u"dpdk-version": self._get_dpdk_version, u"teardown-papi-history": self._get_papi_history, u"test-show-runtime": self._get_show_run, - u"testbed": self._get_testbed + u"testbed": self._get_testbed, + u"test-telemetry": self._get_telemetry } @property @@ -460,7 +478,8 @@ class ExecutionChecker(ResultVisitor): return u"Test Failed." def _process_lat(in_str_1, in_str_2): - """Extract min, avg, max values from latency string. + """Extract P50, P90 and P99 latencies or min, avg, max values from + latency string. :param in_str_1: Latency string for one direction produced by robot framework. @@ -481,13 +500,13 @@ class ExecutionChecker(ResultVisitor): try: hdr_lat_1 = hdrh.histogram.HdrHistogram.decode(in_list_1[3]) except hdrh.codec.HdrLengthException: - return None + hdr_lat_1 = None in_list_2[3] += u"=" * (len(in_list_2[3]) % 4) try: hdr_lat_2 = hdrh.histogram.HdrHistogram.decode(in_list_2[3]) except hdrh.codec.HdrLengthException: - return None + hdr_lat_2 = None if hdr_lat_1 and hdr_lat_2: hdr_lat = ( @@ -498,11 +517,17 @@ class ExecutionChecker(ResultVisitor): hdr_lat_2.get_value_at_percentile(90.0), hdr_lat_2.get_value_at_percentile(99.0) ) - if all(hdr_lat): return hdr_lat - return None + hdr_lat = ( + int(in_list_1[0]), int(in_list_1[1]), int(in_list_1[2]), + int(in_list_2[0]), int(in_list_2[1]), int(in_list_2[2]) + ) + for item in hdr_lat: + if item in (-1, 4294967295, 0): + return None + return hdr_lat try: out_msg = ( @@ -594,18 +619,6 @@ class ExecutionChecker(ResultVisitor): finally: self._msg_type = None - def _get_timestamp(self, msg): - """Called when extraction of timestamp is required. - - :param msg: Message to process. - :type msg: Message - :returns: Nothing. - """ - - self._timestamp = msg.timestamp[:14] - self._data[u"metadata"][u"generated"] = self._timestamp - self._msg_type = None - def _get_papi_history(self, msg): """Called when extraction of PAPI command history is required. @@ -660,54 +673,90 @@ class ExecutionChecker(ResultVisitor): except (AttributeError, IndexError): sock = u"" - runtime = loads(str(msg.message).replace(u' ', u'').replace(u'\n', u''). - replace(u"'", u'"').replace(u'b"', u'"'). - replace(u'u"', u'"').split(u":", 1)[1]) - - try: - threads_nr = len(runtime[0][u"clocks"]) - except (IndexError, KeyError): - return - dut = u"dut{nr}".format( nr=len(self._data[u'tests'][self._test_id][u'show-run'].keys()) + 1) - oper = { - u"host": host, - u"socket": sock, - # Needed for json converter, enable when 'threads' is gone. - # u"runtime": runtime, - u"threads": OrderedDict({idx: list() for idx in range(threads_nr)}) - } + self._data[u'tests'][self._test_id][u'show-run'][dut] = \ + copy.copy( + { + u"host": host, + u"socket": sock, + u"runtime": str(msg.message).replace(u' ', u''). + replace(u'\n', u'').replace(u"'", u'"'). + replace(u'b"', u'"').replace(u'u"', u'"'). + split(u":", 1)[1] + } + ) - for item in runtime: - for idx in range(threads_nr): - if item[u"vectors"][idx] > 0: - clocks = item[u"clocks"][idx] / item[u"vectors"][idx] - elif item[u"calls"][idx] > 0: - clocks = item[u"clocks"][idx] / item[u"calls"][idx] - elif item[u"suspends"][idx] > 0: - clocks = item[u"clocks"][idx] / item[u"suspends"][idx] - else: - clocks = 0.0 + def _get_telemetry(self, msg): + """Called when extraction of VPP telemetry data is required. - if item[u"calls"][idx] > 0: - vectors_call = item[u"vectors"][idx] / item[u"calls"][idx] - else: - vectors_call = 0.0 + :param msg: Message to process. + :type msg: Message + :returns: Nothing. + """ - if int(item[u"calls"][idx]) + int(item[u"vectors"][idx]) + \ - int(item[u"suspends"][idx]): - oper[u"threads"][idx].append([ - item[u"name"], - item[u"calls"][idx], - item[u"vectors"][idx], - item[u"suspends"][idx], - clocks, - vectors_call - ]) + if self._telemetry_kw_counter > 1: + return + if not msg.message.count(u"# TYPE vpp_runtime_calls"): + return - self._data[u'tests'][self._test_id][u'show-run'][dut] = copy.copy(oper) + if u"telemetry-show-run" not in \ + self._data[u"tests"][self._test_id].keys(): + self._data[u"tests"][self._test_id][u"telemetry-show-run"] = dict() + + self._telemetry_msg_counter += 1 + groups = re.search(self.REGEX_SH_RUN_HOST, msg.message) + if not groups: + return + try: + host = groups.group(1) + except (AttributeError, IndexError): + host = u"" + try: + sock = groups.group(2) + except (AttributeError, IndexError): + sock = u"" + runtime = { + u"source_type": u"node", + u"source_id": host, + u"msg_type": u"metric", + u"log_level": u"INFO", + u"timestamp": msg.timestamp, + u"msg": u"show_runtime", + u"host": host, + u"socket": sock, + u"data": list() + } + for line in msg.message.splitlines(): + if not line.startswith(u"vpp_runtime_"): + continue + try: + params, value, timestamp = line.rsplit(u" ", maxsplit=2) + cut = params.index(u"{") + name = params[:cut].split(u"_", maxsplit=2)[-1] + labels = eval( + u"dict" + params[cut:].replace('{', '(').replace('}', ')') + ) + labels[u"graph_node"] = labels.pop(u"name") + runtime[u"data"].append( + { + u"name": name, + u"value": value, + u"timestamp": timestamp, + u"labels": labels + } + ) + except (TypeError, ValueError, IndexError): + continue + self._data[u'tests'][self._test_id][u'telemetry-show-run']\ + [f"dut{self._telemetry_msg_counter}"] = copy.copy( + { + u"host": host, + u"socket": sock, + u"runtime": runtime + } + ) def _get_ndrpdr_throughput(self, msg): """Get NDR_LOWER, NDR_UPPER, PDR_LOWER and PDR_UPPER from the test @@ -927,6 +976,39 @@ class ExecutionChecker(ResultVisitor): return result, status + def _get_vsap_data(self, msg, tags): + """Get data from the vsap test message. + + :param msg: The test message to be parsed. + :param tags: Test tags. + :type msg: str + :type tags: list + :returns: Parsed data as a JSON dict and the status (PASS/FAIL). + :rtype: tuple(dict, str) + """ + result = dict() + status = u"FAIL" + + groups = re.search(self.REGEX_VSAP_MSG_INFO, msg) + if groups is not None: + try: + result[u"transfer-rate"] = float(groups.group(1)) * 1e3 + result[u"latency"] = float(groups.group(2)) + result[u"completed-requests"] = int(groups.group(3)) + result[u"failed-requests"] = int(groups.group(4)) + result[u"bytes-transferred"] = int(groups.group(5)) + if u"TCP_CPS"in tags: + result[u"cps"] = float(groups.group(6)) + elif u"TCP_RPS" in tags: + result[u"rps"] = float(groups.group(6)) + else: + return result, status + status = u"PASS" + except (IndexError, ValueError): + pass + + return result, status + def visit_suite(self, suite): """Implements traversing through the suite and its direct children. @@ -961,7 +1043,7 @@ class ExecutionChecker(ResultVisitor): u"level": len(suite.longname.split(u".")) } - suite.keywords.visit(self) + suite.setup.visit(self) def end_suite(self, suite): """Called when suite ends. @@ -979,7 +1061,7 @@ class ExecutionChecker(ResultVisitor): :returns: Nothing. """ if self.start_test(test) is not False: - test.keywords.visit(self) + test.body.visit(self) self.end_test(test) def start_test(self, test): @@ -991,6 +1073,8 @@ class ExecutionChecker(ResultVisitor): """ self._sh_run_counter = 0 + self._telemetry_kw_counter = 0 + self._telemetry_msg_counter = 0 longname_orig = test.longname.lower() @@ -1045,38 +1129,36 @@ class ExecutionChecker(ResultVisitor): else: test_result[u"msg"] = test.message - if u"PERFTEST" in tags: + if u"PERFTEST" in tags and u"TREX" not in tags: # Replace info about cores (e.g. -1c-) with the info about threads # and cores (e.g. -1t1c-) in the long test case names and in the # test case names if necessary. - groups = re.search(self.REGEX_TC_NAME_OLD, self._test_id) - if not groups: - tag_count = 0 - tag_tc = str() - for tag in test_result[u"tags"]: - groups = re.search(self.REGEX_TC_TAG, tag) - if groups: - tag_count += 1 - tag_tc = tag - - if tag_count == 1: - self._test_id = re.sub( - self.REGEX_TC_NAME_NEW, f"-{tag_tc.lower()}-", - self._test_id, count=1 - ) - test_result[u"name"] = re.sub( - self.REGEX_TC_NAME_NEW, f"-{tag_tc.lower()}-", - test_result["name"], count=1 - ) - else: - test_result[u"status"] = u"FAIL" - self._data[u"tests"][self._test_id] = test_result - logging.debug( - f"The test {self._test_id} has no or more than one " - f"multi-threading tags.\n" - f"Tags: {test_result[u'tags']}" - ) - return + tag_count = 0 + tag_tc = str() + for tag in test_result[u"tags"]: + groups = re.search(self.REGEX_TC_TAG, tag) + if groups: + tag_count += 1 + tag_tc = tag + + if tag_count == 1: + self._test_id = re.sub( + self.REGEX_TC_NAME_NEW, f"-{tag_tc.lower()}-", + self._test_id, count=1 + ) + test_result[u"name"] = re.sub( + self.REGEX_TC_NAME_NEW, f"-{tag_tc.lower()}-", + test_result["name"], count=1 + ) + else: + test_result[u"status"] = u"FAIL" + self._data[u"tests"][self._test_id] = test_result + logging.debug( + f"The test {self._test_id} has no or more than one " + f"multi-threading tags.\n" + f"Tags: {test_result[u'tags']}" + ) + return if u"DEVICETEST" in tags: test_result[u"type"] = u"DEVICETEST" @@ -1120,16 +1202,15 @@ class ExecutionChecker(ResultVisitor): if test.status == u"PASS": test_result[u"throughput"], test_result[u"status"] = \ self._get_plr_throughput(test.message) + elif u"LDP_NGINX" in tags: + test_result[u"type"] = u"LDP_NGINX" + test_result[u"result"], test_result[u"status"] = \ + self._get_vsap_data(test.message, tags) elif u"HOSTSTACK" in tags: test_result[u"type"] = u"HOSTSTACK" if test.status == u"PASS": test_result[u"result"], test_result[u"status"] = \ self._get_hoststack_data(test.message, tags) - # elif u"TCP" in tags: # This might be not used - # test_result[u"type"] = u"TCP" - # if test.status == u"PASS": - # groups = re.search(self.REGEX_TCP, test.message) - # test_result[u"result"] = int(groups.group(2)) elif u"RECONF" in tags: test_result[u"type"] = u"RECONF" if test.status == u"PASS": @@ -1199,7 +1280,7 @@ class ExecutionChecker(ResultVisitor): :type test_kw: Keyword :returns: Nothing. """ - for keyword in test_kw.keywords: + for keyword in test_kw.body: if self.start_test_kw(keyword) is not False: self.visit_test_kw(keyword) self.end_test_kw(keyword) @@ -1212,9 +1293,13 @@ class ExecutionChecker(ResultVisitor): :type test_kw: Keyword :returns: Nothing. """ - if test_kw.name.count(u"Show Runtime On All Duts") or \ - test_kw.name.count(u"Show Runtime Counters On All Duts") or \ - test_kw.name.count(u"Vpp Show Runtime On All Duts"): + if not self._process_oper: + return + + if test_kw.name.count(u"Run Telemetry On All Duts"): + self._msg_type = u"test-telemetry" + self._telemetry_kw_counter += 1 + elif test_kw.name.count(u"Show Runtime On All Duts"): self._msg_type = u"test-show-runtime" self._sh_run_counter += 1 else: @@ -1237,7 +1322,7 @@ class ExecutionChecker(ResultVisitor): :type setup_kw: Keyword :returns: Nothing. """ - for keyword in setup_kw.keywords: + for keyword in setup_kw.body: if self.start_setup_kw(keyword) is not False: self.visit_setup_kw(keyword) self.end_setup_kw(keyword) @@ -1256,9 +1341,6 @@ class ExecutionChecker(ResultVisitor): elif setup_kw.name.count(u"Install Dpdk Framework On All Duts") and \ not self._version: self._msg_type = u"dpdk-version" - elif setup_kw.name.count(u"Set Global Variable") \ - and not self._timestamp: - self._msg_type = u"timestamp" elif setup_kw.name.count(u"Setup Framework") and not self._testbed: self._msg_type = u"testbed" else: @@ -1281,7 +1363,7 @@ class ExecutionChecker(ResultVisitor): :type teardown_kw: Keyword :returns: Nothing. """ - for keyword in teardown_kw.keywords: + for keyword in teardown_kw.body: if self.start_teardown_kw(keyword) is not False: self.visit_teardown_kw(keyword) self.end_teardown_kw(keyword) @@ -1353,18 +1435,22 @@ class InputData: (as described in ExecutionChecker documentation) """ - def __init__(self, spec): + def __init__(self, spec, for_output): """Initialization. :param spec: Specification. + :param for_output: Output to be generated from downloaded data. :type spec: Specification + :type for_output: str """ # Specification: self._cfg = spec + self._for_output = for_output + # Data store: - self._input_data = pd.Series() + self._input_data = pd.Series(dtype="object") @property def data(self): @@ -1436,11 +1522,30 @@ class InputData: f"Error occurred while parsing output.xml: {repr(err)}" ) return None + + process_oper = False + if u"-vpp-perf-report-coverage-" in job: + process_oper = True + # elif u"-vpp-perf-report-iterative-" in job: + # # Exceptions for TBs where we do not have coverage data: + # for item in (u"-2n-icx", ): + # if item in job: + # process_oper = True + # break checker = ExecutionChecker( - metadata, self._cfg.mapping, self._cfg.ignore + metadata, self._cfg.mapping, self._cfg.ignore, process_oper ) result.visit(checker) + checker.data[u"metadata"][u"tests_total"] = \ + result.statistics.total.all.total + checker.data[u"metadata"][u"tests_passed"] = \ + result.statistics.total.all.passed + checker.data[u"metadata"][u"tests_failed"] = \ + result.statistics.total.all.failed + checker.data[u"metadata"][u"elapsedtime"] = result.suite.elapsedtime + checker.data[u"metadata"][u"generated"] = result.suite.endtime[:14] + return checker.data def _download_and_parse_build(self, job, build, repeat, pid=10000): @@ -1560,7 +1665,7 @@ class InputData: }) if self._input_data.get(job, None) is None: - self._input_data[job] = pd.Series() + self._input_data[job] = pd.Series(dtype="object") self._input_data[job][str(build_nr)] = build_data self._cfg.set_input_file_name( job, build_nr, result[u"build"][u"file-name"] @@ -1639,7 +1744,7 @@ class InputData: }) if self._input_data.get(job, None) is None: - self._input_data[job] = pd.Series() + self._input_data[job] = pd.Series(dtype="object") self._input_data[job][str(build_nr)] = build_data self._cfg.set_input_state(job, build_nr, u"processed") @@ -1796,12 +1901,12 @@ class InputData: params.extend((u"type", u"status")) data_to_filter = data if data else element[u"data"] - data = pd.Series() + data = pd.Series(dtype="object") try: for job, builds in data_to_filter.items(): - data[job] = pd.Series() + data[job] = pd.Series(dtype="object") for build in builds: - data[job][str(build)] = pd.Series() + data[job][str(build)] = pd.Series(dtype="object") try: data_dict = dict( self.data[job][str(build)][data_set].items()) @@ -1812,7 +1917,8 @@ class InputData: for test_id, test_data in data_dict.items(): if eval(cond, {u"tags": test_data.get(u"tags", u"")}): - data[job][str(build)][test_id] = pd.Series() + data[job][str(build)][test_id] = \ + pd.Series(dtype="object") if params is None: for param, val in test_data.items(): data[job][str(build)][test_id][param] = val @@ -1896,12 +2002,12 @@ class InputData: else: tests = include - data = pd.Series() + data = pd.Series(dtype="object") try: for job, builds in element[u"data"].items(): - data[job] = pd.Series() + data[job] = pd.Series(dtype="object") for build in builds: - data[job][str(build)] = pd.Series() + data[job][str(build)] = pd.Series(dtype="object") for test in tests: try: reg_ex = re.compile(str(test).lower()) @@ -1910,7 +2016,8 @@ class InputData: if re.match(reg_ex, str(test_id).lower()): test_data = self.data[job][ str(build)][data_set][test_id] - data[job][str(build)][test_id] = pd.Series() + data[job][str(build)][test_id] = \ + pd.Series(dtype="object") if params is None: for param, val in test_data.items(): data[job][str(build)][test_id]\ @@ -1965,7 +2072,7 @@ class InputData: logging.info(u" Merging data ...") - merged_data = pd.Series() + merged_data = pd.Series(dtype="object") for builds in data.values: for item in builds.values: for item_id, item_data in item.items(): @@ -1976,15 +2083,6 @@ class InputData: """Print all operational data to console. """ - tbl_hdr = ( - u"Name", - u"Nr of Vectors", - u"Nr of Packets", - u"Suspends", - u"Cycles per Packet", - u"Average Vector Size" - ) - for job in self._input_data.values: for build in job.values: for test_id, test_data in build[u"tests"].items(): @@ -1992,12 +2090,60 @@ class InputData: if test_data.get(u"show-run", None) is None: continue for dut_name, data in test_data[u"show-run"].items(): - if data.get(u"threads", None) is None: + if data.get(u"runtime", None) is None: continue + runtime = loads(data[u"runtime"]) + try: + threads_nr = len(runtime[0][u"clocks"]) + except (IndexError, KeyError): + continue + threads = OrderedDict( + {idx: list() for idx in range(threads_nr)}) + for item in runtime: + for idx in range(threads_nr): + if item[u"vectors"][idx] > 0: + clocks = item[u"clocks"][idx] / \ + item[u"vectors"][idx] + elif item[u"calls"][idx] > 0: + clocks = item[u"clocks"][idx] / \ + item[u"calls"][idx] + elif item[u"suspends"][idx] > 0: + clocks = item[u"clocks"][idx] / \ + item[u"suspends"][idx] + else: + clocks = 0.0 + + if item[u"calls"][idx] > 0: + vectors_call = item[u"vectors"][idx] / \ + item[u"calls"][idx] + else: + vectors_call = 0.0 + + if int(item[u"calls"][idx]) + int( + item[u"vectors"][idx]) + \ + int(item[u"suspends"][idx]): + threads[idx].append([ + item[u"name"], + item[u"calls"][idx], + item[u"vectors"][idx], + item[u"suspends"][idx], + clocks, + vectors_call + ]) + print(f"Host IP: {data.get(u'host', '')}, " f"Socket: {data.get(u'socket', '')}") - for thread_nr, thread in data[u"threads"].items(): - txt_table = prettytable.PrettyTable(tbl_hdr) + for thread_nr, thread in threads.items(): + txt_table = prettytable.PrettyTable( + ( + u"Name", + u"Nr of Vectors", + u"Nr of Packets", + u"Suspends", + u"Cycles per Packet", + u"Average Vector Size" + ) + ) avg = 0.0 for row in thread: txt_table.add_row(row)