Trending: Remove unneeded tests from Dashboard
[csit.git] / resources / tools / presentation / input_data_parser.py
index d0f9eed..703ea33 100644 (file)
 - extract data from output.xml files generated by Jenkins jobs and store in
   pandas' Series,
 - provide access to the data.
 - 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
 import re
 import pandas as pd
 import logging
-import xml.etree.ElementTree as ET
 
 from robot.api import ExecutionResult, ResultVisitor
 from robot import errors
 from collections import OrderedDict
 from string import replace
 from os import remove
 
 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 input_data_files import download_and_unzip_data_file
+from utils import Worker
+
+
+# Separator used in file names
+SEPARATOR = "__"
 
 
 class ExecutionChecker(ResultVisitor):
 
 
 class ExecutionChecker(ResultVisitor):
@@ -40,36 +52,117 @@ class ExecutionChecker(ResultVisitor):
     Performance tests:
 
     {
     Performance tests:
 
     {
-        "metadata": {  # Optional
-            "version": "VPP version",
+        "metadata": {
+            "generated": "Timestamp",
+            "version": "SUT version",
             "job": "Jenkins job name",
             "build": "Information about the build"
         },
         "suites": {
             "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"
             }
                 "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": {
                 "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",
             "ID": {
                 "name": "Test name",
                 "parent": "Name of the parent of the test",
-                "doc": "Test documentation"
-                "msg": "Test message"
+                "doc": "Test documentation",
+                "msg": "Test message",
+                "vat-history": "DUT1 and DUT2 VAT History",
+                "show-run": "Show Run",
                 "tags": ["tag 1", "tag 2", "tag n"],
                 "tags": ["tag 1", "tag 2", "tag n"],
-                "type": "PDR" | "NDR",
+                "type": "NDRPDR",
+                "status": "PASS" | "FAIL",
                 "throughput": {
                 "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"
                 },
                     "value": int,
                     "unit": "pps" | "bps" | "percentage"
                 },
-                "latency": {
+                "latency": {  # Only type: "PDR" | "NDR"
                     "direction1": {
                         "100": {
                             "min": int,
                     "direction1": {
                         "100": {
                             "min": int,
@@ -105,9 +198,8 @@ class ExecutionChecker(ResultVisitor):
                         }
                     }
                 },
                         }
                     }
                 },
-                "lossTolerance": "lossTolerance",  # Only for PDR
+                "lossTolerance": "lossTolerance",  # Only type: "PDR"
                 "vat-history": "DUT1 and DUT2 VAT History"
                 "vat-history": "DUT1 and DUT2 VAT History"
-                },
                 "show-run": "Show Run"
             },
             "ID" {
                 "show-run": "Show Run"
             },
             "ID" {
@@ -116,8 +208,8 @@ class ExecutionChecker(ResultVisitor):
         }
     }
 
         }
     }
 
-    Functional tests:
 
 
+    Functional tests:
 
     {
         "metadata": {  # Optional
 
     {
         "metadata": {  # Optional
@@ -157,10 +249,17 @@ class ExecutionChecker(ResultVisitor):
     .. note:: ID is the lowercase full path to the 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_RATE = re.compile(r'^[\D\d]*FINAL_RATE:\s(\d+\.\d+)\s(\w+)')
 
+    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]*'
     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'\s\'(-?\d+/-?\d+/-?\d+)\'\]\s\n'
                                r'LAT_\d+%NDR:\s\[\'(-?\d+/-?\d+/-?\d+)\','
                                r'\s\'(-?\d+/-?\d+/-?\d+)\'\]\s\n'
@@ -171,22 +270,45 @@ class ExecutionChecker(ResultVisitor):
                                r'LAT_\d+%PDR:\s\[\'(-?\d+/-?\d+/-?\d+)\','
                                r'\s\'(-?\d+/-?\d+/-?\d+)\'\][\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_TOLERANCE = re.compile(r'^[\D\d]*LOSS_ACCEPTANCE:\s(\d*\.\d*)\s'
                                  r'[\D\d]*')
 
     REGEX_TOLERANCE = re.compile(r'^[\D\d]*LOSS_ACCEPTANCE:\s(\d*\.\d*)\s'
                                  r'[\D\d]*')
 
-    REGEX_VERSION = re.compile(r"(return STDOUT 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*)')
 
 
     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
         """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 metadata: dict
+        :type mapping: dict
+        :type ignore: list
         """
 
         # Type of message to parse out from the test messages
         """
 
         # Type of message to parse out from the test messages
@@ -195,6 +317,18 @@ class ExecutionChecker(ResultVisitor):
         # VPP version
         self._version = None
 
         # 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
         # Number of VAT History messages found:
         # 0 - no message
         # 1 - VAT History of DUT1
@@ -225,9 +359,12 @@ class ExecutionChecker(ResultVisitor):
         # Dictionary defining the methods used to parse different types of
         # messages
         self.parse_msg = {
         # 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-vat-history": self._get_vat_history,
-            "test-show-runtime": self._get_show_run
+            "test-show-runtime": self._get_show_run,
+            "testbed": self._get_testbed
         }
 
     @property
         }
 
     @property
@@ -239,7 +376,29 @@ class ExecutionChecker(ResultVisitor):
         """
         return self._data
 
         """
         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.
         """Called when extraction of VPP version is required.
 
         :param msg: Message to process.
@@ -247,13 +406,43 @@ class ExecutionChecker(ResultVisitor):
         :returns: Nothing.
         """
 
         :returns: Nothing.
         """
 
-        if msg.message.count("return STDOUT Version:"):
-            self._version = str(re.search(self.REGEX_VERSION, msg.message).
+        if msg.message.count("return STDOUT 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
                                 group(2))
             self._data["metadata"]["version"] = self._version
-            self._data["metadata"]["generated"] = msg.timestamp
             self._msg_type = None
 
             self._msg_type = None
 
+    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.
 
     def _get_vat_history(self, msg):
         """Called when extraction of VAT command history is required.
 
@@ -302,6 +491,7 @@ class ExecutionChecker(ResultVisitor):
                 except KeyError:
                     pass
 
                 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.
 
     def _get_latency(self, msg, test_type):
         """Get the latency data from the test message.
 
@@ -348,6 +538,74 @@ class ExecutionChecker(ResultVisitor):
 
         return latency
 
 
         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_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.
 
     def visit_suite(self, suite):
         """Implements traversing through the suite and its direct children.
 
@@ -415,9 +673,30 @@ class ExecutionChecker(ResultVisitor):
         :returns: Nothing.
         """
 
         :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()
         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', ' '). \
         test_result["parent"] = test.parent.name.lower()
         test_result["tags"] = tags
         doc_str = test.doc.replace('"', "'").replace('\n', ' '). \
@@ -425,23 +704,65 @@ class ExecutionChecker(ResultVisitor):
         test_result["doc"] = replace(doc_str, ' |br| [', '[', maxreplace=1)
         test_result["msg"] = test.message.replace('\n', ' |br| '). \
             replace('\r', '').replace('"', "'")
         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:
+            # 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
         if test.status == "PASS" and ("NDRPDRDISC" in tags or
+                                      "NDRPDR" in tags or
                                       "TCP" in tags or
                                       "TCP" in tags or
-                                      "MRR" in tags):
+                                      "MRR" in tags or
+                                      "BMRR" in tags):
+            # TODO: Remove when definitely no NDRPDRDISC tests are used:
             if "NDRDISC" in tags:
             if "NDRDISC" in tags:
-                test_type = "NDR"
+                test_result["type"] = "NDR"
+            # TODO: Remove when definitely no NDRPDRDISC tests are used:
             elif "PDRDISC" in tags:
             elif "PDRDISC" in tags:
-                test_type = "PDR"
+                test_result["type"] = "PDR"
+            elif "NDRPDR" in tags:
+                test_result["type"] = "NDRPDR"
             elif "TCP" in tags:
             elif "TCP" in tags:
-                test_type = "TCP"
+                test_result["type"] = "TCP"
             elif "MRR" in tags:
             elif "MRR" in tags:
-                test_type = "MRR"
+                test_result["type"] = "MRR"
+            elif "FRMOBL" in tags or "BMRR" in tags:
+                test_result["type"] = "BMRR"
             else:
             else:
+                test_result["status"] = "FAIL"
+                self._data["tests"][self._test_ID] = test_result
                 return
 
                 return
 
-            test_result["type"] = test_type
-
-            if test_type in ("NDR", "PDR"):
+            # 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))
                 try:
                     rate_value = str(re.search(
                         self.REGEX_RATE, test.message).group(1))
@@ -458,29 +779,40 @@ class ExecutionChecker(ResultVisitor):
                     int(rate_value.split('.')[0])
                 test_result["throughput"]["unit"] = rate_unit
                 test_result["latency"] = \
                     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":
+                    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))
 
                     test_result["lossTolerance"] = str(re.search(
                         self.REGEX_TOLERANCE, test.message).group(1))
 
-            elif test_type in ("TCP", ):
+            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 ("TCP", ):
                 groups = re.search(self.REGEX_TCP, test.message)
                 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()
                 test_result["result"] = dict()
-                test_result["result"]["value"] = int(groups.group(2))
-                test_result["result"]["unit"] = groups.group(1)
-            elif test_type in ("MRR", ):
-                groups = re.search(self.REGEX_MRR, test.message)
-                test_result["result"] = dict()
-                test_result["result"]["duration"] = int(groups.group(1))
-                test_result["result"]["tx"] = int(groups.group(2))
-                test_result["result"]["rx"] = int(groups.group(3))
-                test_result["result"]["throughput"] = int(
-                    test_result["result"]["rx"] /
-                    test_result["result"]["duration"])
-        else:
-            test_result["status"] = test.status
+                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):
         self._data["tests"][self._test_ID] = test_result
 
     def end_test(self, test):
@@ -555,7 +887,11 @@ class ExecutionChecker(ResultVisitor):
             self._lookup_kw_nr += 1
             self._show_run_lookup_nr = 0
             self._msg_type = "test-show-runtime"
             self._lookup_kw_nr += 1
             self._show_run_lookup_nr = 0
             self._msg_type = "test-show-runtime"
-            test_kw.messages.visit(self)
+        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.
 
     def end_test_kw(self, test_kw):
         """Called when keyword ends. Default implementation does nothing.
@@ -589,8 +925,16 @@ class ExecutionChecker(ResultVisitor):
         """
         if setup_kw.name.count("Show Vpp Version On All Duts") \
                 and not self._version:
         """
         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.
 
     def end_setup_kw(self, setup_kw):
         """Called when keyword ends. Default implementation does nothing.
@@ -679,12 +1023,11 @@ class InputData(object):
     - job name
       - build number
         - metadata
     - job name
       - build number
         - metadata
-          - job
-          - build
-          - vpp version
+          (as described in ExecutionChecker documentation)
         - suites
         - suites
+          (as described in ExecutionChecker documentation)
         - tests
         - tests
-          - ID: test data (as described in ExecutionChecker documentation)
+          (as described in ExecutionChecker documentation)
     """
 
     def __init__(self, spec):
     """
 
     def __init__(self, spec):
@@ -698,7 +1041,7 @@ class InputData(object):
         self._cfg = spec
 
         # Data store:
         self._cfg = spec
 
         # Data store:
-        self._input_data = None
+        self._input_data = pd.Series()
 
     @property
     def data(self):
 
     @property
     def data(self):
@@ -748,15 +1091,16 @@ class InputData(object):
 
         return self.data[job][build]["tests"]
 
 
         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.
         """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 job: str
         :type build: dict
+        :type log: list of tuples (severity, msg)
         :returns: JSON data structure.
         :rtype: dict
         """
         :returns: JSON data structure.
         :rtype: dict
         """
@@ -770,54 +1114,166 @@ class InputData(object):
             try:
                 result = ExecutionResult(data_file)
             except errors.DataError as err:
             try:
                 result = ExecutionResult(data_file)
             except errors.DataError as err:
-                logging.error("Error occurred while parsing output.xml: {0}".
-                              format(err))
+                log.append(("ERROR", "Error occurred while parsing output.xml: "
+                                     "{0}".format(err)))
                 return None
                 return None
-        checker = ExecutionChecker(metadata)
+        checker = ExecutionChecker(metadata, self._cfg.mapping,
+                                   self._cfg.ignore)
         result.visit(checker)
 
         return checker.data
 
         result.visit(checker)
 
         return checker.data
 
-    def download_and_parse_data(self):
+    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.
         """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("Downloading and parsing input files ...")
 
         """
 
         logging.info("Downloading and parsing input files ...")
 
-        job_data = dict()
+        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))
+
         for job, builds in self._cfg.builds.items():
         for job, builds in self._cfg.builds.items():
-            logging.info("  Processing data from the job '{0}' ...".
-                         format(job))
-            builds_data = dict()
             for build in builds:
             for build in builds:
-                logging.info("    Processing the build '{0}'".
-                             format(build["build"]))
-                self._cfg.set_input_state(job, build["build"], "failed")
-                if not download_and_unzip_data_file(self._cfg, job, build):
-                    logging.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"]))
-                    continue
+                work_queue.put((job, build, repeat))
 
 
-                logging.info("      Processing data from the build '{0}' ...".
-                             format(build["build"]))
-                data = InputData._parse_tests(job, build)
-                if data is None:
-                    logging.error("Input data file from the job '{job}', build "
-                                  "'{build}' is damaged. Skipped.".
-                                  format(job=job, build=build["build"]))
-                    continue
+        work_queue.join()
 
 
-                self._cfg.set_input_state(job, build["build"], "processed")
+        logging.info("Done.")
 
 
-                try:
-                    remove(build["file-name"])
-                except OSError as err:
-                    logging.error("Cannot remove the file '{0}': {1}".
-                                  format(build["file-name"], err))
+        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()),
                 build_data = pd.Series({
                     "metadata": pd.Series(data["metadata"].values(),
                                           index=data["metadata"].keys()),
@@ -825,15 +1281,35 @@ class InputData(object):
                                         index=data["suites"].keys()),
                     "tests": pd.Series(data["tests"].values(),
                                        index=data["tests"].keys())})
                                         index=data["suites"].keys()),
                     "tests": pd.Series(data["tests"].values(),
                                        index=data["tests"].keys())})
-                builds_data[str(build["build"])] = build_data
-                build["status"] = "processed"
-                logging.info("    Done.")
 
 
-            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
         logging.info("Done.")
 
     @staticmethod
@@ -882,13 +1358,13 @@ class InputData(object):
 
         - job 1
           - build 1
 
         - job 1
           - build 1
-            - test (suite) 1 ID:
+            - test (or suite) 1 ID:
               - param 1
               - param 2
               ...
               - param n
             ...
               - param 1
               - param 2
               ...
               - param n
             ...
-            - test (suite) n ID:
+            - test (or suite) n ID:
             ...
           ...
           - build n
             ...
           ...
           - build n
@@ -910,9 +1386,6 @@ class InputData(object):
         :rtype pandas.Series
         """
 
         :rtype pandas.Series
         """
 
-        logging.info("    Creating the data set for the {0} '{1}'.".
-                     format(element.get("type", ""), element.get("title", "")))
-
         try:
             if element["filter"] in ("all", "template"):
                 cond = "True"
         try:
             if element["filter"] in ("all", "template"):
                 cond = "True"
@@ -925,6 +1398,8 @@ class InputData(object):
 
         if params is None:
             params = element.get("parameters", None)
 
         if params is None:
             params = element.get("parameters", None)
+            if params:
+                params.append("type")
 
         data = pd.Series()
         try:
 
         data = pd.Series()
         try: