-# Copyright (c) 2017 Cisco and/or its affiliates.
+# Copyright (c) 2019 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:
- extract data from output.xml files generated by Jenkins jobs and store in
pandas' Series,
- provide access to the data.
+- filter the data using tags,
"""
+import multiprocessing
+import os
import re
import pandas as pd
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
+
+from input_data_files import download_and_unzip_data_file
+from utils import Worker
+
+
+# Separator used in file names
+SEPARATOR = "__"
class ExecutionChecker(ResultVisitor):
Performance tests:
{
- "metadata": { # Optional
- "version": "VPP version",
+ "metadata": {
+ "generated": "Timestamp",
+ "version": "SUT version",
"job": "Jenkins job name",
"build": "Information about the build"
},
"suites": {
- "Suite name 1": {
+ "Suite long name 1": {
+ "name": Suite name,
"doc": "Suite 1 documentation",
"parent": "Suite 1 parent",
"level": "Level of the suite in the suite hierarchy"
}
- "Suite name N": {
+ "Suite long name N": {
+ "name": Suite name,
"doc": "Suite N documentation",
"parent": "Suite 2 parent",
"level": "Level of the suite in the suite hierarchy"
}
}
"tests": {
+ # NDRPDR tests:
"ID": {
"name": "Test name",
"parent": "Name of the parent of the test",
- "doc": "Test documentation"
- "msg": "Test message"
+ "doc": "Test documentation",
+ "msg": "Test message",
+ "conf-history": "DUT1 and DUT2 VAT History",
+ "show-run": "Show Run",
"tags": ["tag 1", "tag 2", "tag n"],
- "type": "PDR" | "NDR",
+ "type": "NDRPDR",
+ "status": "PASS" | "FAIL",
"throughput": {
+ "NDR": {
+ "LOWER": float,
+ "UPPER": float
+ },
+ "PDR": {
+ "LOWER": float,
+ "UPPER": float
+ }
+ },
+ "latency": {
+ "NDR": {
+ "direction1": {
+ "min": float,
+ "avg": float,
+ "max": float
+ },
+ "direction2": {
+ "min": float,
+ "avg": float,
+ "max": float
+ }
+ },
+ "PDR": {
+ "direction1": {
+ "min": float,
+ "avg": float,
+ "max": float
+ },
+ "direction2": {
+ "min": float,
+ "avg": float,
+ "max": float
+ }
+ }
+ }
+ }
+
+ # TCP 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": "TCP",
+ "status": "PASS" | "FAIL",
+ "result": int
+ }
+
+ # MRR, BMRR 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": "MRR" | "BMRR",
+ "status": "PASS" | "FAIL",
+ "result": {
+ "receive-rate": AvgStdevMetadata,
+ }
+ }
+
+ # 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": {
+ "latency": { # Only type: "PDR" | "NDR"
"direction1": {
"100": {
"min": int,
}
}
},
- "lossTolerance": "lossTolerance", # Only for PDR
- "vat-history": "DUT1 and DUT2 VAT History"
- },
+ "lossTolerance": "lossTolerance", # Only type: "PDR"
+ "conf-history": "DUT1 and DUT2 VAT History"
"show-run": "Show Run"
},
"ID" {
}
}
- Functional tests:
+ Functional tests:
{
"metadata": { # Optional
"doc": "Test documentation"
"msg": "Test message"
"tags": ["tag 1", "tag 2", "tag n"],
- "vat-history": "DUT1 and DUT2 VAT History"
+ "conf-history": "DUT1 and DUT2 VAT History"
"show-run": "Show Run"
"status": "PASS" | "FAIL"
},
.. 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_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'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+%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_TOLERANCE = re.compile(r'^[\D\d]*LOSS_ACCEPTANCE:\s(\d*\.\d*)\s'
r'[\D\d]*')
- REGEX_VERSION = re.compile(r"(stdout: 'vat# vat# Version:)(\s*)(.*)")
+ REGEX_VERSION_VPP = re.compile(r"(return STDOUT Version:\s*|"
+ r"VPP Version:\s*)(.*)")
+
+ REGEX_VERSION_DPDK = re.compile(r"(return STDOUT testpmd)([\d\D\n]*)"
+ r"(RTE Version: 'DPDK )(.*)(')")
+
+ REGEX_TCP = re.compile(r'Total\s(rps|cps|throughput):\s([0-9]*).*$')
+
+ REGEX_MRR = re.compile(r'MaxReceivedRate_Results\s\[pkts/(\d*)sec\]:\s'
+ r'tx\s(\d*),\srx\s(\d*)')
- def __init__(self, **metadata):
+ REGEX_BMRR = re.compile(r'Maximum Receive Rate trial results'
+ r' in packets per second: \[(.*)\]')
+
+ 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}-')
+
+ def __init__(self, metadata, mapping, ignore):
"""Initialisation.
:param metadata: Key-value pairs to be included in "metadata" part of
- JSON structure.
+ JSON structure.
+ :param mapping: Mapping of the old names of test cases to the new
+ (actual) one.
+ :param ignore: List of TCs to be ignored.
:type metadata: dict
+ :type mapping: dict
+ :type ignore: list
"""
# Type of message to parse out from the test messages
# VPP version
self._version = None
+ # Timestamp
+ self._timestamp = None
+
+ # Testbed. The testbed is identified by TG node IP address.
+ self._testbed = None
+
+ # Mapping of TCs long names
+ self._mapping = mapping
+
+ # Ignore list
+ self._ignore = ignore
+
# Number of VAT History messages found:
# 0 - no message
# 1 - VAT History of DUT1
# 2 - VAT History of DUT2
self._lookup_kw_nr = 0
- self._vat_history_lookup_nr = 0
+ self._conf_history_lookup_nr = 0
# Number of Show Running messages found
# 0 - no message
# Dictionary defining the methods used to parse different types of
# messages
self.parse_msg = {
- "setup-version": self._get_version,
+ "timestamp": self._get_timestamp,
+ "vpp-version": self._get_vpp_version,
+ "dpdk-version": self._get_dpdk_version,
"teardown-vat-history": self._get_vat_history,
- "teardown-show-runtime": self._get_show_run
+ "teardown-papi-history": self._get_papi_history,
+ "test-show-runtime": self._get_show_run,
+ "testbed": self._get_testbed
}
@property
"""
return self._data
- def _get_version(self, msg):
+ def _get_testbed(self, msg):
+ """Called when extraction of testbed IP is required.
+ The testbed is identified by TG node IP address.
+
+ :param msg: Message to process.
+ :type msg: Message
+ :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])
+ try:
+ self._testbed = message["TG"]["host"]
+ except (KeyError, ValueError):
+ pass
+ finally:
+ self._data["metadata"]["testbed"] = self._testbed
+ self._msg_type = None
+
+ def _get_vpp_version(self, msg):
"""Called when extraction of VPP version is required.
:param msg: Message to process.
:returns: Nothing.
"""
- if msg.message.count("stdout: 'vat# vat# Version:"):
- self._version = str(re.search(self.REGEX_VERSION, msg.message).
- group(3))
+ if msg.message.count("return STDOUT Version:") or \
+ msg.message.count("VPP Version:") or \
+ msg.message.count("VPP version:"):
+ self._version = str(re.search(self.REGEX_VERSION_VPP, msg.message).
+ group(2))
self._data["metadata"]["version"] = self._version
self._msg_type = None
- logging.debug(" VPP version: {0}".format(self._version))
+ def _get_dpdk_version(self, msg):
+ """Called when extraction of DPDK version is required.
+
+ :param msg: Message to process.
+ :type msg: Message
+ :returns: Nothing.
+ """
+
+ if msg.message.count("return STDOUT testpmd"):
+ try:
+ self._version = str(re.search(
+ self.REGEX_VERSION_DPDK, msg.message). group(4))
+ self._data["metadata"]["version"] = self._version
+ except IndexError:
+ pass
+ 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["metadata"]["generated"] = self._timestamp
+ self._msg_type = None
def _get_vat_history(self, msg):
"""Called when extraction of VAT command history is required.
:returns: Nothing.
"""
if msg.message.count("VAT command history:"):
- self._vat_history_lookup_nr += 1
- if self._vat_history_lookup_nr == 1:
- self._data["tests"][self._test_ID]["vat-history"] = str()
+ self._conf_history_lookup_nr += 1
+ if self._conf_history_lookup_nr == 1:
+ self._data["tests"][self._test_ID]["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} "
replace("\n\n", "\n").replace('\n', ' |br| ').\
replace('\r', '').replace('"', "'")
- self._data["tests"][self._test_ID]["vat-history"] += " |br| "
- self._data["tests"][self._test_ID]["vat-history"] += \
- "**DUT" + str(self._vat_history_lookup_nr) + ":** " + text
+ 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
+
+ def _get_papi_history(self, msg):
+ """Called when extraction of PAPI command history is required.
+
+ :param msg: Message to process.
+ :type msg: Message
+ :returns: Nothing.
+ """
+ if msg.message.count("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()
+ 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
def _get_show_run(self, msg):
"""Called when extraction of VPP operational data (output of CLI command
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.
return latency
+ def _get_ndrpdr_throughput(self, msg):
+ """Get NDR_LOWER, NDR_UPPER, PDR_LOWER and PDR_UPPER from the test
+ message.
+
+ :param msg: The test message to be parsed.
+ :type msg: str
+ :returns: Parsed data as a dict and the status (PASS/FAIL).
+ :rtype: tuple(dict, str)
+ """
+
+ throughput = {
+ "NDR": {"LOWER": -1.0, "UPPER": -1.0},
+ "PDR": {"LOWER": -1.0, "UPPER": -1.0}
+ }
+ status = "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"
+ except (IndexError, ValueError):
+ pass
+
+ return throughput, status
+
+ def _get_plr_throughput(self, msg):
+ """Get PLRsearch lower bound and PLRsearch upper bound from the test
+ message.
+
+ :param msg: The test message to be parsed.
+ :type msg: str
+ :returns: Parsed data as a dict and the status (PASS/FAIL).
+ :rtype: tuple(dict, str)
+ """
+
+ throughput = {
+ "LOWER": -1.0,
+ "UPPER": -1.0
+ }
+ status = "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"
+ except (IndexError, ValueError):
+ pass
+
+ return throughput, status
+
+ def _get_ndrpdr_latency(self, msg):
+ """Get LATENCY from the test message.
+
+ :param msg: The test message to be parsed.
+ :type msg: str
+ :returns: Parsed data as a dict and the status (PASS/FAIL).
+ :rtype: tuple(dict, str)
+ """
+
+ latency = {
+ "NDR": {
+ "direction1": {"min": -1.0, "avg": -1.0, "max": -1.0},
+ "direction2": {"min": -1.0, "avg": -1.0, "max": -1.0}
+ },
+ "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 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
+
+ return latency, status
+
def visit_suite(self, suite):
"""Implements traversing through the suite and its direct children.
self._data["suites"][suite.longname.lower().replace('"', "'").
replace(" ", "_")] = {
- "name": suite.name.lower(),
- "doc": doc_str,
- "parent": parent_name,
- "level": len(suite.longname.split("."))
- }
+ "name": suite.name.lower(),
+ "doc": doc_str,
+ "parent": parent_name,
+ "level": len(suite.longname.split("."))
+ }
suite.keywords.visit(self)
:returns: Nothing.
"""
+ longname_orig = test.longname.lower()
+
+ # Check the ignore list
+ if longname_orig in self._ignore:
+ return
+
tags = [str(tag) for tag in test.tags]
test_result = dict()
- test_result["name"] = test.name.lower()
+
+ # 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))
+ 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)
+ # 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["doc"] = replace(doc_str, ' |br| [', '[', maxreplace=1)
test_result["msg"] = test.message.replace('\n', ' |br| '). \
replace('\r', '').replace('"', "'")
- if test.status == "PASS" and "NDRPDRDISC" in tags:
-
+ test_result["type"] = "FUNC"
+ test_result["status"] = test.status
+
+ if "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)
+ if not groups:
+ tag_count = 0
+ for tag in test_result["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,
+ count=1)
+ test_result["name"] = re.sub(self.REGEX_TC_NAME_NEW,
+ "-{0}-".format(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"]))
+ 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_type = "NDR"
+ test_result["type"] = "NDR"
+ # TODO: Remove when definitely no NDRPDRDISC tests are used:
elif "PDRDISC" in tags:
- test_type = "PDR"
+ 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
- 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["type"] = test_type
- 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_type)
- if test_type == "PDR":
- test_result["lossTolerance"] = str(re.search(
- self.REGEX_TOLERANCE, test.message).group(1))
- else:
- test_result["status"] = test.status
+ # 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"] = \
+ self._get_ndrpdr_throughput(test.message)
+ test_result["latency"], test_result["status"] = \
+ self._get_ndrpdr_latency(test.message)
+
+ elif test_result["type"] in ("SOAK", ):
+ test_result["throughput"], test_result["status"] = \
+ self._get_plr_throughput(test.message)
+
+ elif test_result["type"] in ("TCP", ):
+ groups = re.search(self.REGEX_TCP, test.message)
+ test_result["result"] = int(groups.group(2))
+
+ elif test_result["type"] in ("MRR", "BMRR"):
+ test_result["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
+ 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)), ])
- self._test_ID = test.longname.lower()
self._data["tests"][self._test_ID] = test_result
def end_test(self, test):
elif keyword.type == "teardown":
self._lookup_kw_nr = 0
self.visit_teardown_kw(keyword)
+ else:
+ self._lookup_kw_nr = 0
+ self.visit_test_kw(keyword)
except AttributeError:
pass
"""
pass
+ def visit_test_kw(self, test_kw):
+ """Implements traversing through the test keyword and its child
+ keywords.
+
+ :param test_kw: Keyword to process.
+ :type test_kw: Keyword
+ :returns: Nothing.
+ """
+ for keyword in test_kw.keywords:
+ if self.start_test_kw(keyword) is not False:
+ self.visit_test_kw(keyword)
+ self.end_test_kw(keyword)
+
+ def start_test_kw(self, test_kw):
+ """Called when test keyword starts. Default implementation does
+ nothing.
+
+ :param test_kw: Keyword to process.
+ :type test_kw: Keyword
+ :returns: Nothing.
+ """
+ if test_kw.name.count("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"
+ else:
+ return
+ test_kw.messages.visit(self)
+
+ def end_test_kw(self, test_kw):
+ """Called when keyword ends. Default implementation does nothing.
+
+ :param test_kw: Keyword to process.
+ :type test_kw: Keyword
+ :returns: Nothing.
+ """
+ pass
+
def visit_setup_kw(self, setup_kw):
"""Implements traversing through the teardown keyword and its child
keywords.
:type setup_kw: Keyword
:returns: Nothing.
"""
- if setup_kw.name.count("Vpp Show Version Verbose") \
+ if setup_kw.name.count("Show Vpp Version On All Duts") \
and not self._version:
- self._msg_type = "setup-version"
- setup_kw.messages.visit(self)
+ self._msg_type = "vpp-version"
+
+ elif setup_kw.name.count("Setup performance global Variables") \
+ and not self._timestamp:
+ self._msg_type = "timestamp"
+ elif setup_kw.name.count("Setup Framework") and not self._testbed:
+ self._msg_type = "testbed"
+ else:
+ return
+ setup_kw.messages.visit(self)
def end_setup_kw(self, setup_kw):
"""Called when keyword ends. Default implementation does nothing.
"""
if teardown_kw.name.count("Show Vat History On All Duts"):
- self._vat_history_lookup_nr = 0
+ self._conf_history_lookup_nr = 0
self._msg_type = "teardown-vat-history"
- elif teardown_kw.name.count("Show Statistics On All Duts"):
- self._lookup_kw_nr += 1
- self._show_run_lookup_nr = 0
- self._msg_type = "teardown-show-runtime"
-
- if self._msg_type:
+ teardown_kw.messages.visit(self)
+ elif teardown_kw.name.count("Show Papi History On All Duts"):
+ self._conf_history_lookup_nr = 0
+ self._msg_type = "teardown-papi-history"
teardown_kw.messages.visit(self)
def end_teardown_kw(self, teardown_kw):
- job name
- build number
- metadata
- - job
- - build
- - vpp version
+ (as described in ExecutionChecker documentation)
- suites
+ (as described in ExecutionChecker documentation)
- tests
- - ID: test data (as described in ExecutionChecker documentation)
+ (as described in ExecutionChecker documentation)
"""
def __init__(self, spec):
self._cfg = spec
# Data store:
- self._input_data = None
+ self._input_data = pd.Series()
@property
def data(self):
return self.data[job][build]["tests"]
- @staticmethod
- def _parse_tests(job, build):
+ def _parse_tests(self, job, build, log):
"""Process data from robot output.xml file and return JSON structured
data.
:param job: The name of job which build output data will be processed.
:param build: The build which output data will be processed.
+ :param log: List of log messages.
:type job: str
:type build: dict
+ :type log: list of tuples (severity, msg)
:returns: JSON data structure.
:rtype: dict
"""
+ metadata = {
+ "job": job,
+ "build": build
+ }
+
with open(build["file-name"], 'r') as data_file:
- result = ExecutionResult(data_file)
- checker = ExecutionChecker(job=job, build=build)
+ try:
+ result = ExecutionResult(data_file)
+ except errors.DataError as err:
+ log.append(("ERROR", "Error occurred while parsing output.xml: "
+ "{0}".format(err)))
+ return None
+ checker = ExecutionChecker(metadata, self._cfg.mapping,
+ self._cfg.ignore)
result.visit(checker)
return checker.data
- def read_data(self):
- """Parse input data from input files and store in pandas' Series.
+ def _download_and_parse_build(self, pid, data_queue, job, build, repeat):
+ """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
+ processed input file.
+ :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()
+
+ logging.info(" Processing the job/build: {0}: {1}".
+ format(job, build["build"]))
+
+ logs.append(("INFO", " Processing the job/build: {0}: {1}".
+ format(job, build["build"])))
+
+ state = "failed"
+ success = False
+ data = None
+ do_repeat = repeat
+ while do_repeat:
+ success = download_and_unzip_data_file(self._cfg, job, build, pid,
+ logs)
+ if success:
+ 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"])))
+ if success:
+ logs.append(("INFO", " Processing data from the build '{0}' ...".
+ format(build["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"])))
+ else:
+ state = "processed"
+
+ try:
+ remove(build["file-name"])
+ except OSError as err:
+ logs.append(("ERROR", "Cannot remove the file '{0}': {1}".
+ format(build["file-name"], 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)
+ if timeperiod and data:
+ now = dt.utcnow()
+ timeperiod = timedelta(int(timeperiod))
+ metadata = data.get("metadata", None)
+ if metadata:
+ generated = metadata.get("generated", None)
+ if generated:
+ generated = dt.strptime(generated, "%Y%m%d %H:%M")
+ if (now - generated) > timeperiod:
+ # Remove the data and the file:
+ state = "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."))
+
+ result = {
+ "data": data,
+ "state": state,
+ "job": job,
+ "build": build,
+ "logs": logs
+ }
+ data_queue.put(result)
+
+ def download_and_parse_data(self, repeat=1):
+ """Download the input data files, parse input data from input files and
+ store in pandas' Series.
+
+ :param repeat: Repeat the download specified number of times if not
+ successful.
+ :type repeat: int
"""
- logging.info("Parsing input files ...")
+ 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))
- job_data = dict()
for job, builds in self._cfg.builds.items():
- logging.info(" Extracting data from the job '{0}' ...'".
- format(job))
- builds_data = dict()
for build in builds:
- if build["status"] == "failed" \
- or build["status"] == "not found":
- continue
- logging.info(" Extracting data from the build '{0}'".
- format(build["build"]))
- logging.info(" Processing the file '{0}'".
- format(build["file-name"]))
- data = InputData._parse_tests(job, build)
+ work_queue.put((job, build, repeat))
+
+ work_queue.join()
+
+ logging.info("Done.")
+
+ while not data_queue.empty():
+ result = data_queue.get()
+
+ job = result["job"]
+ build_nr = result["build"]["build"]
+ if result["data"]:
+ data = result["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()),
- })
- builds_data[str(build["build"])] = build_data
- logging.info(" Done.")
+ index=data["tests"].keys())})
- job_data[job] = pd.Series(builds_data.values(),
- index=builds_data.keys())
- logging.info(" Done.")
+ 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_state(job, build_nr, result["state"])
+
+ for item in result["logs"]:
+ if item[0] == "INFO":
+ logging.info(item[1])
+ elif item[0] == "ERROR":
+ logging.error(item[1])
+ elif item[0] == "DEBUG":
+ logging.debug(item[1])
+ elif item[0] == "CRITICAL":
+ logging.critical(item[1])
+ elif item[0] == "WARNING":
+ logging.warning(item[1])
+
+ del data_queue
+
+ # Terminate all workers
+ for worker in workers:
+ worker.terminate()
+ worker.join()
- self._input_data = pd.Series(job_data.values(), index=job_data.keys())
logging.info("Done.")
@staticmethod
index += 1
tag_filter = tag_filter[:index] + " in tags" + tag_filter[index:]
- def filter_data(self, element, params=None, data_set="tests"):
+ def filter_data(self, element, params=None, data_set="tests",
+ continue_on_error=False):
"""Filter required data from the given jobs and builds.
The output data structure is:
- job 1
- build 1
- - test (suite) 1 ID:
+ - test (or suite) 1 ID:
- param 1
- param 2
...
- param n
...
- - test (suite) n ID:
+ - test (or suite) n ID:
...
...
- build n
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
"""
- logging.info(" Creating the data set for the {0} '{1}'.".
- format(element["type"], element.get("title", "")))
-
try:
if element["filter"] in ("all", "template"):
cond = "True"
if params is None:
params = element.get("parameters", None)
+ if params:
+ params.append("type")
data = pd.Series()
try:
data[job] = pd.Series()
for build in builds:
data[job][str(build)] = pd.Series()
- for test_ID, test_data in \
- self.data[job][str(build)][data_set].iteritems():
+ try:
+ data_iter = self.data[job][str(build)][data_set].\
+ iteritems()
+ 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()
if params is None:
except (KeyError, IndexError, ValueError) as err:
logging.error(" Missing mandatory parameter in the element "
- "specification.", err)
+ "specification: {0}".format(err))
return None
except AttributeError:
return None
Code Review / csit.git / blobdiff