- filter the data using tags,
"""
-import multiprocessing
-import os
import re
-import pandas as pd
+import copy
+import resource
import logging
-from robot.api import ExecutionResult, ResultVisitor
-from robot import errors
from collections import OrderedDict
-from string import replace
from os import remove
-from os.path import join
from datetime import datetime as dt
from datetime import timedelta
from json import loads
-from jumpavg.AvgStdevMetadataFactory import AvgStdevMetadataFactory
+import prettytable
+import pandas as pd
+
+from robot.api import ExecutionResult, ResultVisitor
+from robot import errors
+
+from resources.libraries.python import jumpavg
from input_data_files import download_and_unzip_data_file
-from utils import Worker
# Separator used in file names
-SEPARATOR = "__"
+SEPARATOR = u"__"
class ExecutionChecker(ResultVisitor):
"direction1": {
"min": float,
"avg": float,
- "max": float
+ "max": float,
+ "hdrh": str
},
"direction2": {
"min": float,
"avg": float,
- "max": float
+ "max": float,
+ "hdrh": str
}
},
"PDR": {
"direction1": {
"min": float,
"avg": float,
- "max": float
+ "max": float,
+ "hdrh": str
},
"direction2": {
"min": float,
"avg": float,
- "max": float
+ "max": float,
+ "hdrh": str
}
}
}
"type": "MRR" | "BMRR",
"status": "PASS" | "FAIL",
"result": {
- "receive-rate": AvgStdevMetadata,
+ "receive-rate": float,
+ # Average of a list, computed using AvgStdevStats.
+ # In CSIT-1180, replace with List[float].
}
}
- # TODO: Remove when definitely no NDRPDRDISC tests are used:
- # NDRPDRDISC tests:
- "ID": {
- "name": "Test name",
- "parent": "Name of the parent of the test",
- "doc": "Test documentation",
- "msg": "Test message",
- "tags": ["tag 1", "tag 2", "tag n"],
- "type": "PDR" | "NDR",
- "status": "PASS" | "FAIL",
- "throughput": { # Only type: "PDR" | "NDR"
- "value": int,
- "unit": "pps" | "bps" | "percentage"
- },
- "latency": { # Only type: "PDR" | "NDR"
- "direction1": {
- "100": {
- "min": int,
- "avg": int,
- "max": int
- },
- "50": { # Only for NDR
- "min": int,
- "avg": int,
- "max": int
- },
- "10": { # Only for NDR
- "min": int,
- "avg": int,
- "max": int
- }
- },
- "direction2": {
- "100": {
- "min": int,
- "avg": int,
- "max": int
- },
- "50": { # Only for NDR
- "min": int,
- "avg": int,
- "max": int
- },
- "10": { # Only for NDR
- "min": int,
- "avg": int,
- "max": int
- }
- }
- },
- "lossTolerance": "lossTolerance", # Only type: "PDR"
- "conf-history": "DUT1 and DUT2 VAT History"
- "show-run": "Show Run"
- },
"ID" {
# next test
}
.. note:: ID is the lowercase full path to the test.
"""
- # TODO: Remove when definitely no NDRPDRDISC tests are used:
- REGEX_RATE = re.compile(r'^[\D\d]*FINAL_RATE:\s(\d+\.\d+)\s(\w+)')
-
- REGEX_PLR_RATE = re.compile(r'PLRsearch lower bound::\s(\d+.\d+).*\n'
- r'PLRsearch upper bound::\s(\d+.\d+)')
+ REGEX_PLR_RATE = re.compile(r'PLRsearch lower bound::?\s(\d+.\d+).*\n'
+ r'PLRsearch upper bound::?\s(\d+.\d+)')
REGEX_NDRPDR_RATE = re.compile(r'NDR_LOWER:\s(\d+.\d+).*\n.*\n'
r'NDR_UPPER:\s(\d+.\d+).*\n'
r'PDR_LOWER:\s(\d+.\d+).*\n.*\n'
r'PDR_UPPER:\s(\d+.\d+)')
- # TODO: Remove when definitely no NDRPDRDISC tests are used:
- REGEX_LAT_NDR = re.compile(r'^[\D\d]*'
- r'LAT_\d+%NDR:\s\[\'(-?\d+/-?\d+/-?\d+)\','
- r'\s\'(-?\d+/-?\d+/-?\d+)\'\]\s\n'
- r'LAT_\d+%NDR:\s\[\'(-?\d+/-?\d+/-?\d+)\','
- r'\s\'(-?\d+/-?\d+/-?\d+)\'\]\s\n'
- r'LAT_\d+%NDR:\s\[\'(-?\d+/-?\d+/-?\d+)\','
- r'\s\'(-?\d+/-?\d+/-?\d+)\'\]')
-
- REGEX_LAT_PDR = re.compile(r'^[\D\d]*'
- r'LAT_\d+%PDR:\s\[\'(-?\d+/-?\d+/-?\d+)\','
- r'\s\'(-?\d+/-?\d+/-?\d+)\'\][\D\d]*')
-
REGEX_NDRPDR_LAT = re.compile(r'LATENCY.*\[\'(.*)\', \'(.*)\'\]\s\n.*\n.*\n'
r'LATENCY.*\[\'(.*)\', \'(.*)\'\]')
+ REGEX_NDRPDR_LAT_LONG = re.compile(
+ r'LATENCY.*\[\'(.*)\', \'(.*)\'\]\s\n.*\n.*\n'
+ r'LATENCY.*\[\'(.*)\', \'(.*)\'\]\s\n.*\n'
+ r'Latency.*\[\'(.*)\', \'(.*)\'\]\s\n'
+ r'Latency.*\[\'(.*)\', \'(.*)\'\]\s\n'
+ r'Latency.*\[\'(.*)\', \'(.*)\'\]\s\n'
+ r'Latency.*\[\'(.*)\', \'(.*)\'\]\s\n'
+ r'Latency.*\[\'(.*)\', \'(.*)\'\]\s\n'
+ r'Latency.*\[\'(.*)\', \'(.*)\'\]\s\n'
+ r'Latency.*\[\'(.*)\', \'(.*)\'\]'
+ )
+
REGEX_TOLERANCE = re.compile(r'^[\D\d]*LOSS_ACCEPTANCE:\s(\d*\.\d*)\s'
r'[\D\d]*')
REGEX_VERSION_VPP = re.compile(r"(return STDOUT Version:\s*|"
r"VPP Version:\s*|VPP version:\s*)(.*)")
- REGEX_VERSION_DPDK = re.compile(r"(return STDOUT testpmd)([\d\D\n]*)"
- r"(RTE Version: 'DPDK )(.*)(')")
+ REGEX_VERSION_DPDK = re.compile(r"(DPDK version:\s*|DPDK Version:\s*)(.*)")
- REGEX_TCP = re.compile(r'Total\s(rps|cps|throughput):\s([0-9]*).*$')
+ REGEX_TCP = re.compile(r'Total\s(rps|cps|throughput):\s(\d*).*$')
REGEX_MRR = re.compile(r'MaxReceivedRate_Results\s\[pkts/(\d*)sec\]:\s'
r'tx\s(\d*),\srx\s(\d*)')
REGEX_BMRR = re.compile(r'Maximum Receive Rate trial results'
r' in packets per second: \[(.*)\]')
+ REGEX_RECONF_LOSS = re.compile(r'Packets lost due to reconfig: (\d*)')
+ REGEX_RECONF_TIME = re.compile(r'Implied time lost: (\d*.[\de-]*)')
+
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[0-9]{2}-')
+ 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):
"""Initialisation.
# Ignore list
self._ignore = ignore
- # Number of VAT History messages found:
+ # Number of PAPI History messages found:
# 0 - no message
- # 1 - VAT History of DUT1
- # 2 - VAT History of DUT2
+ # 1 - PAPI History of DUT1
+ # 2 - PAPI History of DUT2
self._lookup_kw_nr = 0
self._conf_history_lookup_nr = 0
# Test ID of currently processed test- the lowercase full path to the
# test
- self._test_ID = None
+ self._test_id = None
# The main data structure
self._data = {
- "metadata": OrderedDict(),
- "suites": OrderedDict(),
- "tests": OrderedDict()
+ u"metadata": OrderedDict(),
+ u"suites": OrderedDict(),
+ u"tests": OrderedDict()
}
# Save the provided metadata
for key, val in metadata.items():
- self._data["metadata"][key] = val
+ self._data[u"metadata"][key] = val
# Dictionary defining the methods used to parse different types of
# messages
self.parse_msg = {
- "timestamp": self._get_timestamp,
- "vpp-version": self._get_vpp_version,
- "dpdk-version": self._get_dpdk_version,
- "teardown-vat-history": self._get_vat_history,
- "teardown-papi-history": self._get_papi_history,
- "test-show-runtime": self._get_show_run,
- "testbed": self._get_testbed
+ u"timestamp": self._get_timestamp,
+ u"vpp-version": self._get_vpp_version,
+ u"dpdk-version": self._get_dpdk_version,
+ # TODO: Remove when not needed:
+ u"teardown-vat-history": self._get_vat_history,
+ u"teardown-papi-history": self._get_papi_history,
+ u"test-show-runtime": self._get_show_run,
+ u"testbed": self._get_testbed
}
@property
:returns: Nothing.
"""
- if msg.message.count("Arguments:"):
- message = str(msg.message).replace(' ', '').replace('\n', '').\
- replace("'", '"').replace('b"', '"').\
- replace("honeycom", "honeycomb")
- message = loads(message[11:-1])
+ if msg.message.count(u"Setup of TG node") or \
+ msg.message.count(u"Setup of node TG host"):
+ reg_tg_ip = re.compile(
+ r'.*TG .* (\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3}).*')
try:
- self._testbed = message["TG"]["host"]
- except (KeyError, ValueError):
+ self._testbed = str(re.search(reg_tg_ip, msg.message).group(1))
+ except (KeyError, ValueError, IndexError, AttributeError):
pass
finally:
- self._data["metadata"]["testbed"] = self._testbed
+ self._data[u"metadata"][u"testbed"] = self._testbed
self._msg_type = None
def _get_vpp_version(self, msg):
:returns: Nothing.
"""
- if msg.message.count("return STDOUT Version:") or \
- msg.message.count("VPP Version:") or \
- msg.message.count("VPP version:"):
+ if msg.message.count(u"return STDOUT Version:") or \
+ msg.message.count(u"VPP Version:") or \
+ msg.message.count(u"VPP version:"):
self._version = str(re.search(self.REGEX_VERSION_VPP, msg.message).
group(2))
- self._data["metadata"]["version"] = self._version
+ self._data[u"metadata"][u"version"] = self._version
self._msg_type = None
def _get_dpdk_version(self, msg):
:returns: Nothing.
"""
- if msg.message.count("return STDOUT testpmd"):
+ if msg.message.count(u"DPDK Version:"):
try:
self._version = str(re.search(
- self.REGEX_VERSION_DPDK, msg.message). group(4))
- self._data["metadata"]["version"] = self._version
+ self.REGEX_VERSION_DPDK, msg.message).group(2))
+ self._data[u"metadata"][u"version"] = self._version
except IndexError:
pass
finally:
"""
self._timestamp = msg.timestamp[:14]
- self._data["metadata"]["generated"] = self._timestamp
+ self._data[u"metadata"][u"generated"] = self._timestamp
self._msg_type = None
def _get_vat_history(self, msg):
"""Called when extraction of VAT command history is required.
+ TODO: Remove when not needed.
+
:param msg: Message to process.
:type msg: Message
:returns: Nothing.
"""
- if msg.message.count("VAT command history:"):
+ if msg.message.count(u"VAT command history:"):
self._conf_history_lookup_nr += 1
if self._conf_history_lookup_nr == 1:
- self._data["tests"][self._test_ID]["conf-history"] = str()
+ self._data[u"tests"][self._test_id][u"conf-history"] = str()
else:
self._msg_type = None
- text = re.sub("[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3} "
- "VAT command history:", "", msg.message, count=1). \
- replace("\n\n", "\n").replace('\n', ' |br| ').\
- replace('\r', '').replace('"', "'")
+ text = re.sub(r"\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3} "
+ r"VAT command history:", u"",
+ msg.message, count=1).replace(u'\n', u' |br| ').\
+ replace(u'"', u"'")
- self._data["tests"][self._test_ID]["conf-history"] += " |br| "
- self._data["tests"][self._test_ID]["conf-history"] += \
- "**DUT" + str(self._conf_history_lookup_nr) + ":** " + text
+ self._data[u"tests"][self._test_id][u"conf-history"] += (
+ f" |br| **DUT{str(self._conf_history_lookup_nr)}:** {text}"
+ )
def _get_papi_history(self, msg):
"""Called when extraction of PAPI command history is required.
:type msg: Message
:returns: Nothing.
"""
- if msg.message.count("PAPI command history:"):
+ if msg.message.count(u"PAPI command history:"):
self._conf_history_lookup_nr += 1
if self._conf_history_lookup_nr == 1:
- self._data["tests"][self._test_ID]["conf-history"] = str()
+ self._data[u"tests"][self._test_id][u"conf-history"] = str()
else:
self._msg_type = None
- text = re.sub("[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3} "
- "PAPI command history:", "", msg.message, count=1). \
- replace("\n\n", "\n").replace('\n', ' |br| ').\
- replace('\r', '').replace('"', "'")
-
- self._data["tests"][self._test_ID]["conf-history"] += " |br| "
- self._data["tests"][self._test_ID]["conf-history"] += \
- "**DUT" + str(self._conf_history_lookup_nr) + ":** " + text
+ text = re.sub(r"\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3} "
+ r"PAPI command history:", u"",
+ msg.message, count=1).replace(u'\n', u' |br| ').\
+ replace(u'"', u"'")
+ self._data[u"tests"][self._test_id][u"conf-history"] += (
+ f" |br| **DUT{str(self._conf_history_lookup_nr)}:** {text}"
+ )
def _get_show_run(self, msg):
"""Called when extraction of VPP operational data (output of CLI command
:type msg: Message
:returns: Nothing.
"""
- if msg.message.count("Thread 0 vpp_main"):
- self._show_run_lookup_nr += 1
- if self._lookup_kw_nr == 1 and self._show_run_lookup_nr == 1:
- self._data["tests"][self._test_ID]["show-run"] = str()
- if self._lookup_kw_nr > 1:
- self._msg_type = None
- if self._show_run_lookup_nr == 1:
- text = msg.message.replace("vat# ", "").\
- replace("return STDOUT ", "").replace("\n\n", "\n").\
- replace('\n', ' |br| ').\
- replace('\r', '').replace('"', "'")
- try:
- self._data["tests"][self._test_ID]["show-run"] += " |br| "
- self._data["tests"][self._test_ID]["show-run"] += \
- "**DUT" + str(self._lookup_kw_nr) + ":** |br| " + text
- except KeyError:
- pass
-
- # TODO: Remove when definitely no NDRPDRDISC tests are used:
- def _get_latency(self, msg, test_type):
- """Get the latency data from the test message.
-
- :param msg: Message to be parsed.
- :param test_type: Type of the test - NDR or PDR.
- :type msg: str
- :type test_type: str
- :returns: Latencies parsed from the message.
- :rtype: dict
- """
- if test_type == "NDR":
- groups = re.search(self.REGEX_LAT_NDR, msg)
- groups_range = range(1, 7)
- elif test_type == "PDR":
- groups = re.search(self.REGEX_LAT_PDR, msg)
- groups_range = range(1, 3)
- else:
- 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"] = str()
- latencies = list()
- for idx in groups_range:
+ if msg.message.count(u"stats runtime") or \
+ msg.message.count(u"Runtime"):
try:
- lat = [int(item) for item in str(groups.group(idx)).split('/')]
- except (AttributeError, ValueError):
- lat = [-1, -1, -1]
- latencies.append(lat)
-
- keys = ("min", "avg", "max")
- latency = {
- "direction1": {
- },
- "direction2": {
- }
- }
-
- latency["direction1"]["100"] = dict(zip(keys, latencies[0]))
- latency["direction2"]["100"] = dict(zip(keys, latencies[1]))
- if test_type == "NDR":
- latency["direction1"]["50"] = dict(zip(keys, latencies[2]))
- latency["direction2"]["50"] = dict(zip(keys, latencies[3]))
- latency["direction1"]["10"] = dict(zip(keys, latencies[4]))
- latency["direction2"]["10"] = dict(zip(keys, latencies[5]))
-
- return latency
+ host = str(re.search(self.REGEX_TC_PAPI_CLI, msg.message).
+ group(1))
+ except (AttributeError, IndexError):
+ host = self._data[u"tests"][self._test_id][u"show-run"].\
+ count(u"DUT:") + 1
+ try:
+ socket = str(re.search(self.REGEX_TC_PAPI_CLI, msg.message).
+ group(2))
+ socket = f"/{socket}"
+ except (AttributeError, IndexError):
+ socket = 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
+ tbl_hdr = [
+ u"Name",
+ u"Calls",
+ u"Vectors",
+ u"Suspends",
+ u"Clocks",
+ u"Vectors/Calls"
+ ]
+ table = [[tbl_hdr, ] for _ in range(threads_nr)]
+ for item in runtime:
+ for idx in range(threads_nr):
+ name = format(item[u"name"])
+ calls = format(item[u"calls"][idx])
+ vectors = format(item[u"vectors"][idx])
+ suspends = format(item[u"suspends"][idx])
+ if item[u"vectors"][idx] > 0:
+ clocks = format(
+ item[u"clocks"][idx]/item[u"vectors"][idx], u".2e")
+ elif item[u"calls"][idx] > 0:
+ clocks = format(
+ item[u"clocks"][idx]/item[u"calls"][idx], u".2e")
+ elif item[u"suspends"][idx] > 0:
+ clocks = format(
+ item[u"clocks"][idx]/item[u"suspends"][idx], u".2e")
+ else:
+ clocks = 0
+ if item[u"calls"][idx] > 0:
+ vectors_call = format(
+ item[u"vectors"][idx]/item[u"calls"][idx], u".2f")
+ else:
+ vectors_call = format(0, u".2f")
+ if int(calls) + int(vectors) + int(suspends):
+ table[idx].append([
+ name, calls, vectors, suspends, clocks, vectors_call
+ ])
+ text = ""
+ for idx in range(threads_nr):
+ text += f"Thread {idx} "
+ text += u"vpp_main\n" if idx == 0 else f"vpp_wk_{idx-1}\n"
+ txt_table = None
+ for row in table[idx]:
+ if txt_table is None:
+ txt_table = prettytable.PrettyTable(row)
+ else:
+ if any(row[1:]):
+ txt_table.add_row(row)
+ txt_table.set_style(prettytable.MSWORD_FRIENDLY)
+ txt_table.align[u"Name"] = u"l"
+ txt_table.align[u"Calls"] = u"r"
+ txt_table.align[u"Vectors"] = u"r"
+ txt_table.align[u"Suspends"] = u"r"
+ txt_table.align[u"Clocks"] = u"r"
+ txt_table.align[u"Vectors/Calls"] = u"r"
+
+ text += txt_table.get_string(sortby=u"Name") + u'\n'
+ text = f"\n**DUT: {host}{socket}**\n{text}".\
+ replace(u'\n', u' |br| ').\
+ replace(u'\r', u'').\
+ replace(u'"', u"'")
+ self._data[u"tests"][self._test_id][u"show-run"] += text
def _get_ndrpdr_throughput(self, msg):
"""Get NDR_LOWER, NDR_UPPER, PDR_LOWER and PDR_UPPER from the test
"""
throughput = {
- "NDR": {"LOWER": -1.0, "UPPER": -1.0},
- "PDR": {"LOWER": -1.0, "UPPER": -1.0}
+ u"NDR": {u"LOWER": -1.0, u"UPPER": -1.0},
+ u"PDR": {u"LOWER": -1.0, u"UPPER": -1.0}
}
- status = "FAIL"
+ status = u"FAIL"
groups = re.search(self.REGEX_NDRPDR_RATE, msg)
if groups is not None:
try:
- throughput["NDR"]["LOWER"] = float(groups.group(1))
- throughput["NDR"]["UPPER"] = float(groups.group(2))
- throughput["PDR"]["LOWER"] = float(groups.group(3))
- throughput["PDR"]["UPPER"] = float(groups.group(4))
- status = "PASS"
+ throughput[u"NDR"][u"LOWER"] = float(groups.group(1))
+ throughput[u"NDR"][u"UPPER"] = float(groups.group(2))
+ throughput[u"PDR"][u"LOWER"] = float(groups.group(3))
+ throughput[u"PDR"][u"UPPER"] = float(groups.group(4))
+ status = u"PASS"
except (IndexError, ValueError):
pass
"""
throughput = {
- "LOWER": -1.0,
- "UPPER": -1.0
+ u"LOWER": -1.0,
+ u"UPPER": -1.0
}
- status = "FAIL"
+ status = u"FAIL"
groups = re.search(self.REGEX_PLR_RATE, msg)
if groups is not None:
try:
- throughput["LOWER"] = float(groups.group(1))
- throughput["UPPER"] = float(groups.group(2))
- status = "PASS"
+ throughput[u"LOWER"] = float(groups.group(1))
+ throughput[u"UPPER"] = float(groups.group(2))
+ status = u"PASS"
except (IndexError, ValueError):
pass
:returns: Parsed data as a dict and the status (PASS/FAIL).
:rtype: tuple(dict, str)
"""
-
+ latency_default = {
+ u"min": -1.0,
+ u"avg": -1.0,
+ u"max": -1.0,
+ u"hdrh": u""
+ }
latency = {
- "NDR": {
- "direction1": {"min": -1.0, "avg": -1.0, "max": -1.0},
- "direction2": {"min": -1.0, "avg": -1.0, "max": -1.0}
+ u"NDR": {
+ u"direction1": copy.copy(latency_default),
+ u"direction2": copy.copy(latency_default)
+ },
+ u"PDR": {
+ u"direction1": copy.copy(latency_default),
+ u"direction2": copy.copy(latency_default)
+ },
+ u"LAT0": {
+ u"direction1": copy.copy(latency_default),
+ u"direction2": copy.copy(latency_default)
+ },
+ u"NDR10": {
+ u"direction1": copy.copy(latency_default),
+ u"direction2": copy.copy(latency_default)
+ },
+ u"NDR50": {
+ u"direction1": copy.copy(latency_default),
+ u"direction2": copy.copy(latency_default)
+ },
+ u"NDR90": {
+ u"direction1": copy.copy(latency_default),
+ u"direction2": copy.copy(latency_default)
+ },
+ u"PDR10": {
+ u"direction1": copy.copy(latency_default),
+ u"direction2": copy.copy(latency_default)
+ },
+ u"PDR50": {
+ u"direction1": copy.copy(latency_default),
+ u"direction2": copy.copy(latency_default)
+ },
+ u"PDR90": {
+ u"direction1": copy.copy(latency_default),
+ u"direction2": copy.copy(latency_default)
},
- "PDR": {
- "direction1": {"min": -1.0, "avg": -1.0, "max": -1.0},
- "direction2": {"min": -1.0, "avg": -1.0, "max": -1.0}
- }
}
- status = "FAIL"
+
groups = re.search(self.REGEX_NDRPDR_LAT, msg)
+ if groups is None:
+ groups = re.search(self.REGEX_NDRPDR_LAT_LONG, msg)
+
+ if groups is None:
+ return latency, u"FAIL"
+
+ def process_latency(in_str):
+ """Return object with parsed latency values.
+
+ TODO: Define class for the return type.
+
+ :param in_str: Input string, min/avg/max/hdrh format.
+ :type in_str: str
+ :returns: Dict with corresponding keys, except hdrh float values.
+ :rtype dict:
+ :throws IndexError: If in_str does not have enough substrings.
+ :throws ValueError: If a substring does not convert to float.
+ """
+ in_list = in_str.split('/', 3)
+
+ rval = {
+ u"min": float(in_list[0]),
+ u"avg": float(in_list[1]),
+ u"max": float(in_list[2]),
+ u"hdrh": u""
+ }
- if groups is not None:
- keys = ("min", "avg", "max")
- try:
- latency["NDR"]["direction1"] = dict(
- zip(keys, [float(l) for l in groups.group(1).split('/')]))
- latency["NDR"]["direction2"] = dict(
- zip(keys, [float(l) for l in groups.group(2).split('/')]))
- latency["PDR"]["direction1"] = dict(
- zip(keys, [float(l) for l in groups.group(3).split('/')]))
- latency["PDR"]["direction2"] = dict(
- zip(keys, [float(l) for l in groups.group(4).split('/')]))
- status = "PASS"
- except (IndexError, ValueError):
- pass
+ if len(in_list) == 4:
+ rval[u"hdrh"] = str(in_list[3])
+
+ return rval
+
+ try:
+ latency[u"NDR"][u"direction1"] = process_latency(groups.group(1))
+ latency[u"NDR"][u"direction2"] = process_latency(groups.group(2))
+ latency[u"PDR"][u"direction1"] = process_latency(groups.group(3))
+ latency[u"PDR"][u"direction2"] = process_latency(groups.group(4))
+ if groups.lastindex == 4:
+ return latency, u"PASS"
+ except (IndexError, ValueError):
+ pass
- return latency, status
+ try:
+ latency[u"LAT0"][u"direction1"] = process_latency(groups.group(5))
+ latency[u"LAT0"][u"direction2"] = process_latency(groups.group(6))
+ latency[u"NDR10"][u"direction1"] = process_latency(groups.group(7))
+ latency[u"NDR10"][u"direction2"] = process_latency(groups.group(8))
+ latency[u"NDR50"][u"direction1"] = process_latency(groups.group(9))
+ latency[u"NDR50"][u"direction2"] = process_latency(groups.group(10))
+ latency[u"NDR90"][u"direction1"] = process_latency(groups.group(11))
+ latency[u"NDR90"][u"direction2"] = process_latency(groups.group(12))
+ latency[u"PDR10"][u"direction1"] = process_latency(groups.group(13))
+ latency[u"PDR10"][u"direction2"] = process_latency(groups.group(14))
+ latency[u"PDR50"][u"direction1"] = process_latency(groups.group(15))
+ latency[u"PDR50"][u"direction2"] = process_latency(groups.group(16))
+ latency[u"PDR90"][u"direction1"] = process_latency(groups.group(17))
+ latency[u"PDR90"][u"direction2"] = process_latency(groups.group(18))
+ return latency, u"PASS"
+ except (IndexError, ValueError):
+ pass
+
+ return latency, u"FAIL"
def visit_suite(self, suite):
"""Implements traversing through the suite and its direct children.
except AttributeError:
return
- doc_str = suite.doc.replace('"', "'").replace('\n', ' ').\
- replace('\r', '').replace('*[', ' |br| *[').replace("*", "**")
- doc_str = replace(doc_str, ' |br| *[', '*[', maxreplace=1)
-
- self._data["suites"][suite.longname.lower().replace('"', "'").
- replace(" ", "_")] = {
- "name": suite.name.lower(),
- "doc": doc_str,
- "parent": parent_name,
- "level": len(suite.longname.split("."))
- }
+ doc_str = suite.doc.\
+ replace(u'"', u"'").\
+ replace(u'\n', u' ').\
+ replace(u'\r', u'').\
+ replace(u'*[', u' |br| *[').\
+ replace(u"*", u"**").\
+ replace(u' |br| *[', u'*[', 1)
+
+ self._data[u"suites"][suite.longname.lower().
+ replace(u'"', u"'").
+ replace(u" ", u"_")] = {
+ u"name": suite.name.lower(),
+ u"doc": doc_str,
+ u"parent": parent_name,
+ u"level": len(suite.longname.split(u"."))
+ }
suite.keywords.visit(self)
:type suite: Suite
:returns: Nothing.
"""
- pass
def visit_test(self, test):
"""Implements traversing through the test.
# Change the TC long name and name if defined in the mapping table
longname = self._mapping.get(longname_orig, None)
if longname is not None:
- name = longname.split('.')[-1]
- logging.debug("{0}\n{1}\n{2}\n{3}".format(
- self._data["metadata"], longname_orig, longname, name))
+ name = longname.split(u'.')[-1]
+ logging.debug(
+ f"{self._data[u'metadata']}\n{longname_orig}\n{longname}\n"
+ f"{name}"
+ )
else:
longname = longname_orig
name = test.name.lower()
# Remove TC number from the TC long name (backward compatibility):
- self._test_ID = re.sub(self.REGEX_TC_NUMBER, "", longname)
+ self._test_id = re.sub(self.REGEX_TC_NUMBER, u"", longname)
# Remove TC number from the TC name (not needed):
- test_result["name"] = re.sub(self.REGEX_TC_NUMBER, "", name)
-
- test_result["parent"] = test.parent.name.lower()
- test_result["tags"] = tags
- doc_str = test.doc.replace('"', "'").replace('\n', ' '). \
- replace('\r', '').replace('[', ' |br| [')
- test_result["doc"] = replace(doc_str, ' |br| [', '[', maxreplace=1)
- test_result["msg"] = test.message.replace('\n', ' |br| '). \
- replace('\r', '').replace('"', "'")
- test_result["type"] = "FUNC"
- test_result["status"] = test.status
-
- if "PERFTEST" in tags:
+ test_result[u"name"] = re.sub(self.REGEX_TC_NUMBER, "", name)
+
+ test_result[u"parent"] = test.parent.name.lower()
+ test_result[u"tags"] = tags
+ test_result["doc"] = test.doc.\
+ replace(u'"', u"'").\
+ replace(u'\n', u' ').\
+ replace(u'\r', u'').\
+ replace(u'[', u' |br| [').\
+ replace(u' |br| [', u'[', 1)
+ test_result[u"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 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
# test case names if necessary.
- groups = re.search(self.REGEX_TC_NAME_OLD, self._test_ID)
+ groups = re.search(self.REGEX_TC_NAME_OLD, self._test_id)
if not groups:
tag_count = 0
- for tag in test_result["tags"]:
+ 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,
- "-{0}-".format(tag_tc.lower()),
- self._test_ID,
+ self._test_id = re.sub(self.REGEX_TC_NAME_NEW,
+ f"-{tag_tc.lower()}-",
+ self._test_id,
count=1)
- test_result["name"] = re.sub(self.REGEX_TC_NAME_NEW,
- "-{0}-".format(tag_tc.lower()),
- test_result["name"],
- 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["status"] = "FAIL"
- self._data["tests"][self._test_ID] = test_result
- logging.debug("The test '{0}' has no or more than one "
- "multi-threading tags.".format(self._test_ID))
- logging.debug("Tags: {0}".format(test_result["tags"]))
+ 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 test.status == "PASS" and ("NDRPDRDISC" in tags or
- "NDRPDR" in tags or
- "SOAK" in tags or
- "TCP" in tags or
- "MRR" in tags or
- "BMRR" in tags):
- # TODO: Remove when definitely no NDRPDRDISC tests are used:
- if "NDRDISC" in tags:
- test_result["type"] = "NDR"
- # TODO: Remove when definitely no NDRPDRDISC tests are used:
- elif "PDRDISC" in tags:
- test_result["type"] = "PDR"
- elif "NDRPDR" in tags:
- test_result["type"] = "NDRPDR"
- elif "SOAK" in tags:
- test_result["type"] = "SOAK"
- elif "TCP" in tags:
- test_result["type"] = "TCP"
- elif "MRR" in tags:
- test_result["type"] = "MRR"
- elif "FRMOBL" in tags or "BMRR" in tags:
- test_result["type"] = "BMRR"
- else:
- test_result["status"] = "FAIL"
- self._data["tests"][self._test_ID] = test_result
- return
-
- # TODO: Remove when definitely no NDRPDRDISC tests are used:
- if test_result["type"] in ("NDR", "PDR"):
- try:
- rate_value = str(re.search(
- self.REGEX_RATE, test.message).group(1))
- except AttributeError:
- rate_value = "-1"
- try:
- rate_unit = str(re.search(
- self.REGEX_RATE, test.message).group(2))
- except AttributeError:
- rate_unit = "-1"
-
- test_result["throughput"] = dict()
- test_result["throughput"]["value"] = \
- int(rate_value.split('.')[0])
- test_result["throughput"]["unit"] = rate_unit
- test_result["latency"] = \
- self._get_latency(test.message, test_result["type"])
- if test_result["type"] == "PDR":
- test_result["lossTolerance"] = str(re.search(
- self.REGEX_TOLERANCE, test.message).group(1))
-
- elif test_result["type"] in ("NDRPDR", ):
- test_result["throughput"], test_result["status"] = \
+ if test.status == u"PASS":
+ if u"NDRPDR" in tags:
+ test_result[u"type"] = u"NDRPDR"
+ test_result[u"throughput"], test_result[u"status"] = \
self._get_ndrpdr_throughput(test.message)
- test_result["latency"], test_result["status"] = \
+ test_result[u"latency"], test_result[u"status"] = \
self._get_ndrpdr_latency(test.message)
-
- elif test_result["type"] in ("SOAK", ):
- test_result["throughput"], test_result["status"] = \
+ elif u"SOAK" in tags:
+ test_result[u"type"] = u"SOAK"
+ test_result[u"throughput"], test_result[u"status"] = \
self._get_plr_throughput(test.message)
-
- elif test_result["type"] in ("TCP", ):
+ elif u"TCP" in tags:
+ test_result[u"type"] = u"TCP"
groups = re.search(self.REGEX_TCP, test.message)
- test_result["result"] = int(groups.group(2))
+ test_result[u"result"] = int(groups.group(2))
+ elif u"MRR" in tags or u"FRMOBL" in tags or u"BMRR" in tags:
+ if u"MRR" in tags:
+ test_result[u"type"] = u"MRR"
+ else:
+ test_result[u"type"] = u"BMRR"
- elif test_result["type"] in ("MRR", "BMRR"):
- test_result["result"] = dict()
+ test_result[u"result"] = dict()
groups = re.search(self.REGEX_BMRR, test.message)
if groups is not None:
items_str = groups.group(1)
items_float = [float(item.strip()) for item
in items_str.split(",")]
- metadata = AvgStdevMetadataFactory.from_data(items_float)
- # Next two lines have been introduced in CSIT-1179,
- # to be removed in CSIT-1180.
- metadata.size = 1
- metadata.stdev = 0.0
- test_result["result"]["receive-rate"] = metadata
+ # Use whole list in CSIT-1180.
+ stats = jumpavg.AvgStdevStats.for_runs(items_float)
+ test_result[u"result"][u"receive-rate"] = stats.avg
else:
groups = re.search(self.REGEX_MRR, test.message)
- test_result["result"]["receive-rate"] = \
- AvgStdevMetadataFactory.from_data([
- float(groups.group(3)) / float(groups.group(1)), ])
+ test_result[u"result"][u"receive-rate"] = \
+ float(groups.group(3)) / float(groups.group(1))
+ elif u"RECONF" in tags:
+ test_result[u"type"] = u"RECONF"
+ test_result[u"result"] = None
+ try:
+ grps_loss = re.search(self.REGEX_RECONF_LOSS, test.message)
+ grps_time = re.search(self.REGEX_RECONF_TIME, test.message)
+ test_result[u"result"] = {
+ u"loss": int(grps_loss.group(1)),
+ u"time": float(grps_time.group(1))
+ }
+ except (AttributeError, IndexError, ValueError, TypeError):
+ test_result[u"status"] = u"FAIL"
+ else:
+ test_result[u"status"] = u"FAIL"
+ self._data[u"tests"][self._test_id] = test_result
+ return
- self._data["tests"][self._test_ID] = test_result
+ self._data[u"tests"][self._test_id] = test_result
def end_test(self, test):
"""Called when test ends.
:type test: Test
:returns: Nothing.
"""
- pass
def visit_keyword(self, keyword):
"""Implements traversing through the keyword and its child keywords.
:returns: Nothing.
"""
try:
- if keyword.type == "setup":
+ if keyword.type == u"setup":
self.visit_setup_kw(keyword)
- elif keyword.type == "teardown":
+ elif keyword.type == u"teardown":
self._lookup_kw_nr = 0
self.visit_teardown_kw(keyword)
else:
:type keyword: Keyword
:returns: Nothing.
"""
- pass
def visit_test_kw(self, test_kw):
"""Implements traversing through the test keyword and its child
:type test_kw: Keyword
:returns: Nothing.
"""
- if test_kw.name.count("Show Runtime Counters On All Duts"):
+ if test_kw.name.count(u"Show Runtime On All Duts") or \
+ test_kw.name.count(u"Show Runtime Counters On All Duts"):
self._lookup_kw_nr += 1
self._show_run_lookup_nr = 0
- self._msg_type = "test-show-runtime"
- elif test_kw.name.count("Start The L2fwd Test") and not self._version:
- self._msg_type = "dpdk-version"
+ self._msg_type = u"test-show-runtime"
+ elif test_kw.name.count(u"Install Dpdk Test") and not self._version:
+ self._msg_type = u"dpdk-version"
else:
return
test_kw.messages.visit(self)
:type test_kw: Keyword
:returns: Nothing.
"""
- pass
def visit_setup_kw(self, setup_kw):
"""Implements traversing through the teardown keyword and its child
:type setup_kw: Keyword
:returns: Nothing.
"""
- if setup_kw.name.count("Show Vpp Version On All Duts") \
+ if setup_kw.name.count(u"Show Vpp Version On All Duts") \
and not self._version:
- self._msg_type = "vpp-version"
- elif setup_kw.name.count("Set Global Variable") \
+ self._msg_type = u"vpp-version"
+ elif setup_kw.name.count(u"Set Global Variable") \
and not self._timestamp:
- self._msg_type = "timestamp"
- elif setup_kw.name.count("Setup Framework") and not self._testbed:
- self._msg_type = "testbed"
+ self._msg_type = u"timestamp"
+ elif setup_kw.name.count(u"Setup Framework") and not self._testbed:
+ self._msg_type = u"testbed"
else:
return
setup_kw.messages.visit(self)
:type setup_kw: Keyword
:returns: Nothing.
"""
- pass
def visit_teardown_kw(self, teardown_kw):
"""Implements traversing through the teardown keyword and its child
self.end_teardown_kw(keyword)
def start_teardown_kw(self, teardown_kw):
- """Called when teardown keyword starts. Default implementation does
- nothing.
+ """Called when teardown keyword starts
:param teardown_kw: Keyword to process.
:type teardown_kw: Keyword
:returns: Nothing.
"""
- if teardown_kw.name.count("Show Vat History On All Duts"):
+ if teardown_kw.name.count(u"Show Vat History On All Duts"):
+ # TODO: Remove when not needed:
self._conf_history_lookup_nr = 0
- self._msg_type = "teardown-vat-history"
+ self._msg_type = u"teardown-vat-history"
teardown_kw.messages.visit(self)
- elif teardown_kw.name.count("Show Papi History On All Duts"):
+ elif teardown_kw.name.count(u"Show Papi History On All Duts"):
self._conf_history_lookup_nr = 0
- self._msg_type = "teardown-papi-history"
+ self._msg_type = u"teardown-papi-history"
teardown_kw.messages.visit(self)
def end_teardown_kw(self, teardown_kw):
:type teardown_kw: Keyword
:returns: Nothing.
"""
- pass
def visit_message(self, msg):
"""Implements visiting the message.
:type msg: Message
:returns: Nothing.
"""
- pass
-class InputData(object):
+class InputData:
"""Input data
The data is extracted from output.xml files generated by Jenkins jobs and
:rtype: pandas.Series
"""
- return self.data[job][build]["metadata"]
+ return self.data[job][build][u"metadata"]
def suites(self, job, build):
"""Getter - suites
:rtype: pandas.Series
"""
- return self.data[job][str(build)]["suites"]
+ return self.data[job][str(build)][u"suites"]
def tests(self, job, build):
"""Getter - tests
:rtype: pandas.Series
"""
- return self.data[job][build]["tests"]
+ return self.data[job][build][u"tests"]
def _parse_tests(self, job, build, log):
"""Process data from robot output.xml file and return JSON structured
"""
metadata = {
- "job": job,
- "build": build
+ u"job": job,
+ u"build": build
}
- with open(build["file-name"], 'r') as data_file:
+ with open(build[u"file-name"], u'r') as data_file:
try:
result = ExecutionResult(data_file)
except errors.DataError as err:
- log.append(("ERROR", "Error occurred while parsing output.xml: "
- "{0}".format(err)))
+ log.append(
+ (u"ERROR", f"Error occurred while parsing output.xml: "
+ f"{repr(err)}")
+ )
return None
checker = ExecutionChecker(metadata, self._cfg.mapping,
self._cfg.ignore)
return checker.data
- def _download_and_parse_build(self, pid, data_queue, job, build, repeat):
+ def _download_and_parse_build(self, job, build, repeat, pid=10000):
"""Download and parse the input data file.
:param pid: PID of the process executing this method.
- :param data_queue: Shared memory between processes. Queue which keeps
- the result data. This data is then read by the main process and used
- in further processing.
:param job: Name of the Jenkins job which generated the processed input
file.
:param build: Information about the Jenkins build which generated the
:param repeat: Repeat the download specified number of times if not
successful.
:type pid: int
- :type data_queue: multiprocessing.Manager().Queue()
:type job: str
:type build: dict
:type repeat: int
logs = list()
- logs.append(("INFO", " Processing the job/build: {0}: {1}".
- format(job, build["build"])))
+ logs.append(
+ (u"INFO", f" Processing the job/build: {job}: {build[u'build']}")
+ )
- state = "failed"
+ state = u"failed"
success = False
data = None
do_repeat = repeat
break
do_repeat -= 1
if not success:
- logs.append(("ERROR", "It is not possible to download the input "
- "data file from the job '{job}', build "
- "'{build}', or it is damaged. Skipped.".
- format(job=job, build=build["build"])))
+ logs.append(
+ (u"ERROR",
+ f"It is not possible to download the input data file from the "
+ f"job {job}, build {build[u'build']}, or it is damaged. "
+ f"Skipped.")
+ )
if success:
- logs.append(("INFO", " Processing data from the build '{0}' ...".
- format(build["build"])))
+ logs.append(
+ (u"INFO",
+ f" Processing data from the build {build[u'build']} ...")
+ )
data = self._parse_tests(job, build, logs)
if data is None:
- logs.append(("ERROR", "Input data file from the job '{job}', "
- "build '{build}' is damaged. Skipped.".
- format(job=job, build=build["build"])))
+ logs.append(
+ (u"ERROR",
+ f"Input data file from the job {job}, build "
+ f"{build[u'build']} is damaged. Skipped.")
+ )
else:
- state = "processed"
+ state = u"processed"
try:
- remove(build["file-name"])
+ remove(build[u"file-name"])
except OSError as err:
- logs.append(("ERROR", "Cannot remove the file '{0}': {1}".
- format(build["file-name"], repr(err))))
+ logs.append(
+ ("ERROR", f"Cannot remove the file {build[u'file-name']}: "
+ f"{repr(err)}")
+ )
# If the time-period is defined in the specification file, remove all
# files which are outside the time period.
- timeperiod = self._cfg.input.get("time-period", None)
+ timeperiod = self._cfg.input.get(u"time-period", None)
if timeperiod and data:
now = dt.utcnow()
timeperiod = timedelta(int(timeperiod))
- metadata = data.get("metadata", None)
+ metadata = data.get(u"metadata", None)
if metadata:
- generated = metadata.get("generated", None)
+ generated = metadata.get(u"generated", None)
if generated:
- generated = dt.strptime(generated, "%Y%m%d %H:%M")
+ generated = dt.strptime(generated, u"%Y%m%d %H:%M")
if (now - generated) > timeperiod:
# Remove the data and the file:
- state = "removed"
+ state = u"removed"
data = None
logs.append(
- ("INFO",
- " The build {job}/{build} is outdated, will be "
- "removed".format(job=job, build=build["build"])))
- file_name = self._cfg.input["file-name"]
- full_name = join(
- self._cfg.environment["paths"]["DIR[WORKING,DATA]"],
- "{job}{sep}{build}{sep}{name}".
- format(job=job,
- sep=SEPARATOR,
- build=build["build"],
- name=file_name))
- try:
- remove(full_name)
- logs.append(("INFO",
- " The file {name} has been removed".
- format(name=full_name)))
- except OSError as err:
- logs.append(("ERROR",
- "Cannot remove the file '{0}': {1}".
- format(full_name, repr(err))))
- logs.append(("INFO", " Done."))
+ (u"INFO",
+ f" The build {job}/{build[u'build']} is "
+ f"outdated, will be removed.")
+ )
+ logs.append((u"INFO", u" Done."))
for level, line in logs:
- if level == "INFO":
+ if level == u"INFO":
logging.info(line)
- elif level == "ERROR":
+ elif level == u"ERROR":
logging.error(line)
- elif level == "DEBUG":
+ elif level == u"DEBUG":
logging.debug(line)
- elif level == "CRITICAL":
+ elif level == u"CRITICAL":
logging.critical(line)
- elif level == "WARNING":
+ elif level == u"WARNING":
logging.warning(line)
- result = {
- "data": data,
- "state": state,
- "job": job,
- "build": build
- }
- data_queue.put(result)
+ return {u"data": data, u"state": state, u"job": job, u"build": build}
def download_and_parse_data(self, repeat=1):
"""Download the input data files, parse input data from input files and
:type repeat: int
"""
- logging.info("Downloading and parsing input files ...")
-
- work_queue = multiprocessing.JoinableQueue()
- manager = multiprocessing.Manager()
- data_queue = manager.Queue()
- cpus = multiprocessing.cpu_count()
-
- workers = list()
- for cpu in range(cpus):
- worker = Worker(work_queue,
- data_queue,
- self._download_and_parse_build)
- worker.daemon = True
- worker.start()
- workers.append(worker)
- os.system("taskset -p -c {0} {1} > /dev/null 2>&1".
- format(cpu, worker.pid))
+ logging.info(u"Downloading and parsing input files ...")
for job, builds in self._cfg.builds.items():
for build in builds:
- work_queue.put((job, build, repeat))
-
- work_queue.join()
-
- logging.info("Done.")
-
- logging.info("Collecting data:")
-
- while not data_queue.empty():
-
- try:
- result = data_queue.get()
-
- job = result["job"]
- build_nr = result["build"]["build"]
- logging.info(" {job}-{build}".format(job=job, build=build_nr))
+ result = self._download_and_parse_build(job, build, repeat)
+ build_nr = result[u"build"][u"build"]
- if result["data"]:
- data = result["data"]
+ if result[u"data"]:
+ data = result[u"data"]
build_data = pd.Series({
- "metadata": pd.Series(data["metadata"].values(),
- index=data["metadata"].keys()),
- "suites": pd.Series(data["suites"].values(),
- index=data["suites"].keys()),
- "tests": pd.Series(data["tests"].values(),
- index=data["tests"].keys())})
+ u"metadata": pd.Series(
+ list(data[u"metadata"].values()),
+ index=list(data[u"metadata"].keys())
+ ),
+ u"suites": pd.Series(
+ list(data[u"suites"].values()),
+ index=list(data[u"suites"].keys())
+ ),
+ u"tests": pd.Series(
+ list(data[u"tests"].values()),
+ index=list(data[u"tests"].keys())
+ )
+ })
if self._input_data.get(job, None) is None:
self._input_data[job] = pd.Series()
self._input_data[job][str(build_nr)] = build_data
- self._cfg.set_input_file_name(job, build_nr,
- result["build"]["file-name"])
+ self._cfg.set_input_file_name(
+ job, build_nr, result[u"build"][u"file-name"])
- self._cfg.set_input_state(job, build_nr, result["state"])
+ self._cfg.set_input_state(job, build_nr, result[u"state"])
- except (MemoryError, EOFError) as err:
- logging.error(repr(err))
- raise
+ mem_alloc = \
+ resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1000
+ logging.info(f"Memory allocation: {mem_alloc:.0f}MB")
-
- del data_queue
-
- # Terminate all workers
- for worker in workers:
- worker.terminate()
- worker.join()
-
- logging.info("Done.")
+ logging.info(u"Done.")
@staticmethod
- def _end_of_tag(tag_filter, start=0, closer="'"):
+ def _end_of_tag(tag_filter, start=0, closer=u"'"):
"""Return the index of character in the string which is the end of tag.
:param tag_filter: The string where the end of tag is being searched.
if index is None:
return tag_filter
index += 1
- tag_filter = tag_filter[:index] + " in tags" + tag_filter[index:]
+ tag_filter = tag_filter[:index] + u" in tags" + tag_filter[index:]
- def filter_data(self, element, params=None, data_set="tests",
+ def filter_data(self, element, params=None, data=None, data_set=u"tests",
continue_on_error=False):
"""Filter required data from the given jobs and builds.
:param element: Element which will use the filtered data.
:param params: Parameters which will be included in the output. If None,
- all parameters are included.
+ all parameters are included.
+ :param data: If not None, this data is used instead of data specified
+ in the element.
:param data_set: The set of data to be filtered: tests, suites,
- metadata.
+ metadata.
:param continue_on_error: Continue if there is error while reading the
- data. The Item will be empty then
+ data. The Item will be empty then
:type element: pandas.Series
:type params: list
+ :type data: dict
:type data_set: str
:type continue_on_error: bool
:returns: Filtered data.
"""
try:
- if element["filter"] in ("all", "template"):
- cond = "True"
+ if element[u"filter"] in (u"all", u"template"):
+ cond = u"True"
else:
- cond = InputData._condition(element["filter"])
- logging.debug(" Filter: {0}".format(cond))
+ cond = InputData._condition(element[u"filter"])
+ logging.debug(f" Filter: {cond}")
except KeyError:
- logging.error(" No filter defined.")
+ logging.error(u" No filter defined.")
return None
if params is None:
- params = element.get("parameters", None)
+ params = element.get(u"parameters", None)
if params:
- params.append("type")
+ params.append(u"type")
+ data_to_filter = data if data else element[u"data"]
data = pd.Series()
try:
- for job, builds in element["data"].items():
+ for job, builds in data_to_filter.items():
data[job] = pd.Series()
for build in builds:
data[job][str(build)] = pd.Series()
try:
- data_iter = self.data[job][str(build)][data_set].\
- iteritems()
+ data_dict = dict(
+ self.data[job][str(build)][data_set].items())
except KeyError:
if continue_on_error:
continue
- else:
- return None
- for test_ID, test_data in data_iter:
- if eval(cond, {"tags": test_data.get("tags", "")}):
- data[job][str(build)][test_ID] = pd.Series()
+ return None
+
+ 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()
if params is None:
for param, val in test_data.items():
- data[job][str(build)][test_ID][param] = val
+ data[job][str(build)][test_id][param] = val
else:
for param in params:
try:
- data[job][str(build)][test_ID][param] =\
+ data[job][str(build)][test_id][param] =\
test_data[param]
except KeyError:
- data[job][str(build)][test_ID][param] =\
- "No Data"
+ data[job][str(build)][test_id][param] =\
+ u"No Data"
return data
except (KeyError, IndexError, ValueError) as err:
- logging.error(" Missing mandatory parameter in the element "
- "specification: {0}".format(err))
+ logging.error(
+ f"Missing mandatory parameter in the element specification: "
+ f"{repr(err)}"
+ )
return None
- except AttributeError:
+ except AttributeError as err:
+ logging.error(repr(err))
+ return None
+ except SyntaxError as err:
+ logging.error(
+ f"The filter {cond} is not correct. Check if all tags are "
+ f"enclosed by apostrophes.\n{repr(err)}"
+ )
+ return None
+
+ def filter_tests_by_name(self, element, params=None, data_set=u"tests",
+ continue_on_error=False):
+ """Filter required data from the given jobs and builds.
+
+ The output data structure is:
+
+ - job 1
+ - build 1
+ - test (or suite) 1 ID:
+ - param 1
+ - param 2
+ ...
+ - param n
+ ...
+ - test (or suite) n ID:
+ ...
+ ...
+ - build n
+ ...
+ - job n
+
+ :param element: Element which will use the filtered data.
+ :param params: Parameters which will be included in the output. If None,
+ all parameters are included.
+ :param data_set: The set of data to be filtered: tests, suites,
+ metadata.
+ :param continue_on_error: Continue if there is error while reading the
+ data. The Item will be empty then
+ :type element: pandas.Series
+ :type params: list
+ :type data_set: str
+ :type continue_on_error: bool
+ :returns: Filtered data.
+ :rtype pandas.Series
+ """
+
+ include = element.get(u"include", None)
+ if not include:
+ logging.warning(u"No tests to include, skipping the element.")
+ return None
+
+ if params is None:
+ params = element.get(u"parameters", None)
+ if params:
+ params.append(u"type")
+
+ data = pd.Series()
+ try:
+ for job, builds in element[u"data"].items():
+ data[job] = pd.Series()
+ for build in builds:
+ data[job][str(build)] = pd.Series()
+ for test in include:
+ try:
+ reg_ex = re.compile(str(test).lower())
+ for test_id in self.data[job][
+ str(build)][data_set].keys():
+ 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()
+ if params is None:
+ for param, val in test_data.items():
+ data[job][str(build)][test_id]\
+ [param] = val
+ else:
+ for param in params:
+ try:
+ data[job][str(build)][
+ test_id][param] = \
+ test_data[param]
+ except KeyError:
+ data[job][str(build)][
+ test_id][param] = u"No Data"
+ except KeyError as err:
+ logging.error(repr(err))
+ if continue_on_error:
+ continue
+ return None
+ return data
+
+ except (KeyError, IndexError, ValueError) as err:
+ logging.error(
+ f"Missing mandatory parameter in the element "
+ f"specification: {repr(err)}"
+ )
return None
- except SyntaxError:
- logging.error(" The filter '{0}' is not correct. Check if all "
- "tags are enclosed by apostrophes.".format(cond))
+ except AttributeError as err:
+ logging.error(repr(err))
return None
@staticmethod
:rtype: pandas.Series
"""
- logging.info(" Merging data ...")
+ logging.info(u" Merging data ...")
merged_data = pd.Series()
- for _, builds in data.iteritems():
- for _, item in builds.iteritems():
- for ID, item_data in item.iteritems():
- merged_data[ID] = item_data
+ for builds in data.values:
+ for item in builds.values:
+ for item_id, item_data in item.items():
+ merged_data[item_id] = item_data
return merged_data