from datetime import datetime as dt
from datetime import timedelta
from json import loads
+from json.decoder import JSONDecodeError
+import hdrh.histogram
+import hdrh.codec
import prettytable
import pandas as pd
r'PDR_UPPER:\s(\d+.\d+)'
)
REGEX_PERF_MSG_INFO = re.compile(
- r'NDR_LOWER:\s(\d+.\d+)\s([a-zA-Z]*).*\s(\d+.\d+)\s([a-zA-Z]*).*\n'
- r'LATENCY.*\[\'(.*)\', \'(.*)\'\].*\n'
- r'NDR_UPPER:\s(\d+.\d+)\s([a-zA-Z]*).*\s(\d+.\d+)\s([a-zA-Z]*).*\n'
- r'PDR_LOWER:\s(\d+.\d+)\s([a-zA-Z]*).*\s(\d+.\d+)\s([a-zA-Z]*).*\n'
- r'LATENCY.*\[\'(.*)\', \'(.*)\'\].*\n'
- r'PDR_UPPER:\s(\d+.\d+)\s([a-zA-Z]*).*\s(\d+.\d+)\s([a-zA-Z]*)'
+ r'NDR_LOWER:\s(\d+.\d+)\s.*\s(\d+.\d+)\s.*\n.*\n.*\n'
+ r'PDR_LOWER:\s(\d+.\d+)\s.*\s(\d+.\d+)\s.*\n.*\n.*\n'
+ r'Latency at 90% PDR:.*\[\'(.*)\', \'(.*)\'\].*\n'
+ r'Latency at 50% PDR:.*\[\'(.*)\', \'(.*)\'\].*\n'
+ r'Latency at 10% PDR:.*\[\'(.*)\', \'(.*)\'\].*\n'
)
+ REGEX_MRR_MSG_INFO = re.compile(r'.*\[(.*)\]')
+
# TODO: Remove when not needed
REGEX_NDRPDR_LAT_BASE = re.compile(
r'LATENCY.*\[\'(.*)\', \'(.*)\'\]\s\n.*\n.*\n'
# 2 - PAPI History of DUT2
self._conf_history_lookup_nr = 0
+ self._sh_run_counter = 0
+
# Test ID of currently processed test- the lowercase full path to the
# test
self._test_id = None
"""
return self._data
+ def _get_data_from_mrr_test_msg(self, msg):
+ """Get info from message of MRR performance tests.
+
+ :param msg: Message to be processed.
+ :type msg: str
+ :returns: Processed message or original message if a problem occurs.
+ :rtype: str
+ """
+
+ groups = re.search(self.REGEX_MRR_MSG_INFO, msg)
+ if not groups or groups.lastindex != 1:
+ return u"Test Failed."
+
+ try:
+ data = groups.group(1).split(u", ")
+ except (AttributeError, IndexError, ValueError, KeyError):
+ return u"Test Failed."
+
+ out_str = u"["
+ try:
+ for item in data:
+ out_str += f"{(float(item) / 1e6):.2f}, "
+ return out_str[:-2] + u"]"
+ except (AttributeError, IndexError, ValueError, KeyError):
+ return u"Test Failed."
+
def _get_data_from_perf_test_msg(self, msg):
- """Get
- - NDR_LOWER
- - LATENCY
- - NDR_UPPER
- - PDR_LOWER
- - LATENCY
- - PDR_UPPER
- from message of NDRPDR performance tests.
+ """Get info from message of NDRPDR performance tests.
:param msg: Message to be processed.
:type msg: str
"""
groups = re.search(self.REGEX_PERF_MSG_INFO, msg)
- if not groups or groups.lastindex != 20:
- return msg
+ if not groups or groups.lastindex != 10:
+ return u"Test Failed."
try:
data = {
u"ndr_low": float(groups.group(1)),
- u"ndr_low_unit": groups.group(2),
- u"ndr_low_b": float(groups.group(3)),
- u"ndr_low_b_unit": groups.group(4),
- u"ndr_lat_1": groups.group(5),
- u"ndr_lat_2": groups.group(6),
- u"ndr_up": float(groups.group(7)),
- u"ndr_up_unit": groups.group(8),
- u"ndr_up_b": float(groups.group(9)),
- u"ndr_up_b_unit": groups.group(10),
- u"pdr_low": float(groups.group(11)),
- u"pdr_low_unit": groups.group(12),
- u"pdr_low_b": float(groups.group(13)),
- u"pdr_low_b_unit": groups.group(14),
- u"pdr_lat_1": groups.group(15),
- u"pdr_lat_2": groups.group(16),
- u"pdr_up": float(groups.group(17)),
- u"pdr_up_unit": groups.group(18),
- u"pdr_up_b": float(groups.group(19)),
- u"pdr_up_b_unit": groups.group(20)
+ u"ndr_low_b": float(groups.group(2)),
+ u"pdr_low": float(groups.group(3)),
+ u"pdr_low_b": float(groups.group(4)),
+ u"pdr_lat_90_1": groups.group(5),
+ u"pdr_lat_90_2": groups.group(6),
+ u"pdr_lat_50_1": groups.group(7),
+ u"pdr_lat_50_2": groups.group(8),
+ u"pdr_lat_10_1": groups.group(9),
+ u"pdr_lat_10_2": groups.group(10),
}
except (AttributeError, IndexError, ValueError, KeyError):
- return msg
+ return u"Test Failed."
- def _process_lat(in_str):
+ def _process_lat(in_str_1, in_str_2):
"""Extract min, avg, max values from latency string.
- :param in_str: Latency string produced by robot framework.
- :type in_str: str
- :returns: Processed latency string or original string if a problem
- occurs.
- :rtype: str
+ :param in_str_1: Latency string for one direction produced by robot
+ framework.
+ :param in_str_2: Latency string for second direction produced by
+ robot framework.
+ :type in_str_1: str
+ :type in_str_2: str
+ :returns: Processed latency string or None if a problem occurs.
+ :rtype: tuple
"""
- in_list = in_str.split('/', 3)
- if len(in_list) < 3:
- return in_str
+ in_list_1 = in_str_1.split('/', 3)
+ in_list_2 = in_str_2.split('/', 3)
+
+ if len(in_list_1) != 4 and len(in_list_2) != 4:
+ return None
+
+ in_list_1[3] += u"=" * (len(in_list_1[3]) % 4)
+ try:
+ hdr_lat_1 = hdrh.histogram.HdrHistogram.decode(in_list_1[3])
+ except hdrh.codec.HdrLengthException:
+ return 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
+
+ if hdr_lat_1 and hdr_lat_2:
+ hdr_lat = (
+ hdr_lat_1.get_value_at_percentile(50.0),
+ hdr_lat_1.get_value_at_percentile(90.0),
+ hdr_lat_1.get_value_at_percentile(99.0),
+ hdr_lat_2.get_value_at_percentile(50.0),
+ hdr_lat_2.get_value_at_percentile(90.0),
+ hdr_lat_2.get_value_at_percentile(99.0)
+ )
- return f"min={in_list[0]}, avg={in_list[1]}, max={in_list[2]}"
+ if all(hdr_lat):
+ return hdr_lat
+
+ return None
try:
- return (
- f"NDR Lower: {(data[u'ndr_low'] / 1e6):.2f}"
- f"M{data[u'ndr_low_unit']}, "
- f"{data[u'ndr_low_b']:.2f}{data[u'ndr_low_b_unit']}\n"
- # f"NDR Upper: {(data[u'ndr_up'] / 1e6):.2f}"
- # f"M{data[u'ndr_up_unit']}, "
- # f"{data[u'ndr_up_b']:.2f}{data[u'ndr_up_b_unit']}\n"
- f"NDR Latency W-E: {_process_lat(data[u'ndr_lat_1'])}\n"
- f"NDR Latency E-W: {_process_lat(data[u'ndr_lat_2'])}\n"
- f"PDR Lower: {(data[u'pdr_low'] / 1e6):.2f}"
- f"M{data[u'pdr_low_unit']}, "
- f"{data[u'pdr_low_b']:.2f}{data[u'pdr_low_b_unit']}\n"
- # f"PDR Upper: {(data[u'pdr_up'] / 1e6):.2f}"
- # f"M{data[u'pdr_up_unit']}, "
- # f"{data[u'pdr_up_b']:.2f}{data[u'pdr_up_b_unit']}\n"
- f"PDR Latency W-E: {_process_lat(data[u'pdr_lat_1'])}\n"
- f"PDR Latency E-W: {_process_lat(data[u'pdr_lat_2'])}"
+ out_msg = (
+ f"1. {(data[u'ndr_low'] / 1e6):5.2f} "
+ f"{data[u'ndr_low_b']:5.2f}"
+ f"\n2. {(data[u'pdr_low'] / 1e6):5.2f} "
+ f"{data[u'pdr_low_b']:5.2f}"
)
+ latency = (
+ _process_lat(data[u'pdr_lat_10_1'], data[u'pdr_lat_10_2']),
+ _process_lat(data[u'pdr_lat_50_1'], data[u'pdr_lat_50_2']),
+ _process_lat(data[u'pdr_lat_90_1'], data[u'pdr_lat_90_2'])
+ )
+ if all(latency):
+ max_len = len(str(max((max(item) for item in latency))))
+ max_len = 4 if max_len < 4 else max_len
+
+ for idx, lat in enumerate(latency):
+ if not idx:
+ out_msg += u"\n"
+ out_msg += (
+ f"\n{idx + 3}. "
+ f"{lat[0]:{max_len}d} "
+ f"{lat[1]:{max_len}d} "
+ f"{lat[2]:{max_len}d} "
+ f"{lat[3]:{max_len}d} "
+ f"{lat[4]:{max_len}d} "
+ f"{lat[5]:{max_len}d} "
+ )
+
+ return out_msg
+
except (AttributeError, IndexError, ValueError, KeyError):
- return msg
+ return u"Test Failed."
def _get_testbed(self, msg):
"""Called when extraction of testbed IP is required.
if not msg.message.count(u"stats runtime"):
return
+ # Temporary solution
+ if self._sh_run_counter > 1:
+ return
+
if u"show-run" not in self._data[u"tests"][self._test_id].keys():
self._data[u"tests"][self._test_id][u"show-run"] = dict()
return latency, u"FAIL"
+ @staticmethod
+ def _get_hoststack_data(msg, tags):
+ """Get data from the hoststack 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"
+
+ msg = msg.replace(u"'", u'"').replace(u" ", u"")
+ if u"LDPRELOAD" in tags:
+ try:
+ result = loads(msg)
+ status = u"PASS"
+ except JSONDecodeError:
+ pass
+ elif u"VPPECHO" in tags:
+ try:
+ msg_lst = msg.replace(u"}{", u"} {").split(u" ")
+ result = dict(
+ client=loads(msg_lst[0]),
+ server=loads(msg_lst[1])
+ )
+ status = u"PASS"
+ except (JSONDecodeError, IndexError):
+ pass
+
+ return result, status
+
def visit_suite(self, suite):
"""Implements traversing through the suite and its direct children.
:returns: Nothing.
"""
+ self._sh_run_counter = 0
+
longname_orig = test.longname.lower()
# Check the ignore list
replace(u'\r', u'').\
replace(u'[', u' |br| [').\
replace(u' |br| [', u'[', 1)
- test_result[u"msg"] = self._get_data_from_perf_test_msg(test.message).\
- replace(u'\n', u' |br| ').\
- replace(u'\r', u'').\
- replace(u'"', u"'")
test_result[u"type"] = u"FUNC"
test_result[u"status"] = test.status
+ if test.status == u"PASS":
+ if u"NDRPDR" in tags:
+ test_result[u"msg"] = self._get_data_from_perf_test_msg(
+ test.message).replace(u'\n', u' |br| ').\
+ replace(u'\r', u'').replace(u'"', u"'")
+ elif u"MRR" in tags or u"FRMOBL" in tags or u"BMRR" in tags:
+ test_result[u"msg"] = self._get_data_from_mrr_test_msg(
+ test.message).replace(u'\n', u' |br| ').\
+ replace(u'\r', u'').replace(u'"', u"'")
+ else:
+ test_result[u"msg"] = test.message.replace(u'\n', u' |br| ').\
+ replace(u'\r', u'').replace(u'"', u"'")
+ else:
+ test_result[u"msg"] = u"Test Failed."
+
if u"PERFTEST" 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
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)
+ 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
test_result[u"type"] = u"SOAK"
test_result[u"throughput"], test_result[u"status"] = \
self._get_plr_throughput(test.message)
+ elif u"HOSTSTACK" in tags:
+ test_result[u"type"] = u"HOSTSTACK"
+ test_result[u"result"], test_result[u"status"] = \
+ self._get_hoststack_data(test.message, tags)
elif u"TCP" in tags:
test_result[u"type"] = u"TCP"
groups = re.search(self.REGEX_TCP, test.message)
}
except (AttributeError, IndexError, ValueError, TypeError):
test_result[u"status"] = u"FAIL"
+ elif u"DEVICETEST" in tags:
+ test_result[u"type"] = u"DEVICETEST"
else:
test_result[u"status"] = u"FAIL"
self._data[u"tests"][self._test_id] = test_result
if test_kw.name.count(u"Show Runtime On All Duts") or \
test_kw.name.count(u"Show Runtime Counters On All Duts"):
self._msg_type = u"test-show-runtime"
- elif test_kw.name.count(u"Install Dpdk Test") and not self._version:
+ self._sh_run_counter += 1
+ elif test_kw.name.count(u"Install Dpdk Test On All Duts") and \
+ not self._version:
self._msg_type = u"dpdk-version"
else:
return
Code Review / csit.git / blobdiff