fix(cdash): Rename

Signed-off-by: pmikus <peter.mikus@protonmail.ch>
Change-Id: Ia6dff2674a28b42ebfbe91230587f1e175ae1137

5 files changed, 1935 insertions, 0 deletions

diff --git a/csit.infra.dash/app/cdash/report/__init__.py b/csit.infra.dash/app/cdash/report/__init__.py
new file mode 100644
index 0000000000..5692432123
--- /dev/null
+++ b/csit.infra.dash/app/cdash/report/__init__.py
@@ -0,0 +1,12 @@
+# Copyright (c) 2022 Cisco and/or its affiliates.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at:
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
diff --git a/csit.infra.dash/app/cdash/report/graphs.py b/csit.infra.dash/app/cdash/report/graphs.py
new file mode 100644
index 0000000000..36f28d09e8
--- /dev/null
+++ b/csit.infra.dash/app/cdash/report/graphs.py
@@ -0,0 +1,275 @@
+# Copyright (c) 2022 Cisco and/or its affiliates.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at:
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+"""
+
+import re
+import plotly.graph_objects as go
+import pandas as pd
+
+from copy import deepcopy
+
+from ..utils.constants import Constants as C
+from ..utils.utils import get_color
+
+
+def get_short_version(version: str, dut_type: str="vpp") -> str:
+    """Returns the short version of DUT without build number.
+
+    :param version: Original version string.
+    :param dut_type: DUT type.
+    :type version: str
+    :type dut_type: str
+    :returns: Short verion string.
+    :rtype: str
+    """
+
+    if dut_type in ("trex", "dpdk"):
+        return version
+
+    s_version = str()
+    groups = re.search(
+        pattern=re.compile(r"^(\d{2}).(\d{2})-(rc0|rc1|rc2|release$)"),
+        string=version
+    )
+    if groups:
+        try:
+            s_version = \
+                f"{groups.group(1)}.{groups.group(2)}.{groups.group(3)}".\
+                    replace("release", "rls")
+        except IndexError:
+            pass
+
+    return s_version
+
+
+def select_iterative_data(data: pd.DataFrame, itm:dict) -> pd.DataFrame:
+    """Select the data for graphs and tables from the provided data frame.
+
+    :param data: Data frame with data for graphs and tables.
+    :param itm: Item (in this case job name) which data will be selected from
+        the input data frame.
+    :type data: pandas.DataFrame
+    :type itm: str
+    :returns: A data frame with selected data.
+    :rtype: pandas.DataFrame
+    """
+
+    phy = itm["phy"].split("-")
+    if len(phy) == 4:
+        topo, arch, nic, drv = phy
+        if drv == "dpdk":
+            drv = ""
+        else:
+            drv += "-"
+            drv = drv.replace("_", "-")
+    else:
+        return None
+
+    core = str() if itm["dut"] == "trex" else f"{itm['core']}"
+    ttype = "ndrpdr" if itm["testtype"] in ("ndr", "pdr") else itm["testtype"]
+    dut_v100 = "none" if itm["dut"] == "trex" else itm["dut"]
+    dut_v101 = itm["dut"]
+
+    df = data.loc[(
+        (data["release"] == itm["rls"]) &
+        (
+            (
+                (data["version"] == "1.0.0") &
+                (data["dut_type"].str.lower() == dut_v100)
+            ) |
+            (
+                (data["version"] == "1.0.1") &
+                (data["dut_type"].str.lower() == dut_v101)
+            )
+        ) &
+        (data["test_type"] == ttype) &
+        (data["passed"] == True)
+    )]
+    regex_test = \
+        f"^.*[.|-]{nic}.*{itm['framesize']}-{core}-{drv}{itm['test']}-{ttype}$"
+    df = df[
+        (df.job.str.endswith(f"{topo}-{arch}")) &
+        (df.dut_version.str.contains(itm["dutver"].replace(".r", "-r").\
+            replace("rls", "release"))) &
+        (df.test_id.str.contains(regex_test, regex=True))
+    ]
+
+    return df
+
+
+def graph_iterative(data: pd.DataFrame, sel:dict, layout: dict,
+        normalize: bool) -> tuple:
+    """Generate the statistical box graph with iterative data (MRR, NDR and PDR,
+    for PDR also Latencies).
+
+    :param data: Data frame with iterative data.
+    :param sel: Selected tests.
+    :param layout: Layout of plot.ly graph.
+    :param normalize: If True, the data is normalized to CPU frquency
+        Constants.NORM_FREQUENCY.
+    :param data: pandas.DataFrame
+    :param sel: dict
+    :param layout: dict
+    :param normalize: bool
+    :returns: Tuple of graphs - throughput and latency.
+    :rtype: tuple(plotly.graph_objects.Figure, plotly.graph_objects.Figure)
+    """
+
+    fig_tput = None
+    fig_lat = None
+
+    tput_traces = list()
+    y_tput_max = 0
+    lat_traces = list()
+    y_lat_max = 0
+    x_lat = list()
+    show_latency = False
+    show_tput = False
+    for idx, itm in enumerate(sel):
+        itm_data = select_iterative_data(data, itm)
+        if itm_data.empty:
+            continue
+        phy = itm["phy"].split("-")
+        topo_arch = f"{phy[0]}-{phy[1]}" if len(phy) == 4 else str()
+        norm_factor = (C.NORM_FREQUENCY / C.FREQUENCY[topo_arch]) \
+            if normalize else 1.0
+        if itm["testtype"] == "mrr":
+            y_data_raw = itm_data[C.VALUE_ITER[itm["testtype"]]].to_list()[0]
+            y_data = [(y * norm_factor) for y in y_data_raw]
+            if len(y_data) > 0:
+                y_tput_max = \
+                    max(y_data) if max(y_data) > y_tput_max else y_tput_max
+        else:
+            y_data_raw = itm_data[C.VALUE_ITER[itm["testtype"]]].to_list()
+            y_data = [(y * norm_factor) for y in y_data_raw]
+            if y_data:
+                y_tput_max = \
+                    max(y_data) if max(y_data) > y_tput_max else y_tput_max
+        nr_of_samples = len(y_data)
+        tput_kwargs = dict(
+            y=y_data,
+            name=(
+                f"{idx + 1}. "
+                f"({nr_of_samples:02d} "
+                f"run{'s' if nr_of_samples > 1 else ''}) "
+                f"{itm['id']}"
+            ),
+            hoverinfo=u"y+name",
+            boxpoints="all",
+            jitter=0.3,
+            marker=dict(color=get_color(idx))
+        )
+        tput_traces.append(go.Box(**tput_kwargs))
+        show_tput = True
+
+        if itm["testtype"] == "pdr":
+            y_lat_row = itm_data[C.VALUE_ITER["pdr-lat"]].to_list()
+            y_lat = [(y / norm_factor) for y in y_lat_row]
+            if y_lat:
+                y_lat_max = max(y_lat) if max(y_lat) > y_lat_max else y_lat_max
+            nr_of_samples = len(y_lat)
+            lat_kwargs = dict(
+                y=y_lat,
+                name=(
+                    f"{idx + 1}. "
+                    f"({nr_of_samples:02d} "
+                    f"run{u's' if nr_of_samples > 1 else u''}) "
+                    f"{itm['id']}"
+                ),
+                hoverinfo="all",
+                boxpoints="all",
+                jitter=0.3,
+                marker=dict(color=get_color(idx))
+            )
+            x_lat.append(idx + 1)
+            lat_traces.append(go.Box(**lat_kwargs))
+            show_latency = True
+        else:
+            lat_traces.append(go.Box())
+
+    if show_tput:
+        pl_tput = deepcopy(layout["plot-throughput"])
+        pl_tput["xaxis"]["tickvals"] = [i for i in range(len(sel))]
+        pl_tput["xaxis"]["ticktext"] = [str(i + 1) for i in range(len(sel))]
+        if y_tput_max:
+            pl_tput["yaxis"]["range"] = [0, (int(y_tput_max / 1e6) + 1) * 1e6]
+        fig_tput = go.Figure(data=tput_traces, layout=pl_tput)
+
+    if show_latency:
+        pl_lat = deepcopy(layout["plot-latency"])
+        pl_lat["xaxis"]["tickvals"] = [i for i in range(len(x_lat))]
+        pl_lat["xaxis"]["ticktext"] = x_lat
+        if y_lat_max:
+            pl_lat["yaxis"]["range"] = [0, (int(y_lat_max / 10) + 1) * 10]
+        fig_lat = go.Figure(data=lat_traces, layout=pl_lat)
+
+    return fig_tput, fig_lat
+
+
+def table_comparison(data: pd.DataFrame, sel:dict,
+        normalize: bool) -> pd.DataFrame:
+    """Generate the comparison table with selected tests.
+
+    :param data: Data frame with iterative data.
+    :param sel: Selected tests.
+    :param normalize: If True, the data is normalized to CPU frquency
+        Constants.NORM_FREQUENCY.
+    :param data: pandas.DataFrame
+    :param sel: dict
+    :param normalize: bool
+    :returns: Comparison table.
+    :rtype: pandas.DataFrame
+    """
+    table = pd.DataFrame(
+        # {
+        #     "Test Case": [
+        #         "64b-2t1c-avf-eth-l2xcbase-eth-2memif-1dcr",
+        #         "64b-2t1c-avf-eth-l2xcbase-eth-2vhostvr1024-1vm-vppl2xc",
+        #         "64b-2t1c-avf-ethip4udp-ip4base-iacl50sl-10kflows",
+        #         "78b-2t1c-avf-ethip6-ip6scale2m-rnd "],
+        #     "2106.0-8": [
+        #         "14.45 +- 0.08",
+        #         "9.63 +- 0.05",
+        #         "9.7 +- 0.02",
+        #         "8.95 +- 0.06"],
+        #     "2110.0-8": [
+        #         "14.45 +- 0.08",
+        #         "9.63 +- 0.05",
+        #         "9.7 +- 0.02",
+        #         "8.95 +- 0.06"],
+        #     "2110.0-9": [
+        #         "14.45 +- 0.08",
+        #         "9.63 +- 0.05",
+        #         "9.7 +- 0.02",
+        #         "8.95 +- 0.06"],
+        #     "2202.0-9": [
+        #         "14.45 +- 0.08",
+        #         "9.63 +- 0.05",
+        #         "9.7 +- 0.02",
+        #         "8.95 +- 0.06"],
+        #     "2110.0-9 vs 2110.0-8": [
+        #         "-0.23 +-  0.62",
+        #         "-1.37 +-   1.3",
+        #         "+0.08 +-   0.2",
+        #         "-2.16 +-  0.83"],
+        #     "2202.0-9 vs 2110.0-9": [
+        #         "+6.95 +-  0.72",
+        #         "+5.35 +-  1.26",
+        #         "+4.48 +-  1.48",
+        #         "+4.09 +-  0.95"]
+        # }
+    )
+
+    return table
diff --git a/csit.infra.dash/app/cdash/report/layout.py b/csit.infra.dash/app/cdash/report/layout.py
new file mode 100644
index 0000000000..ec33147744
--- /dev/null
+++ b/csit.infra.dash/app/cdash/report/layout.py
@@ -0,0 +1,1472 @@
+# Copyright (c) 2022 Cisco and/or its affiliates.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at:
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Plotly Dash HTML layout override.
+"""
+
+import logging
+import pandas as pd
+import dash_bootstrap_components as dbc
+
+from flask import Flask
+from dash import dcc
+from dash import html
+from dash import callback_context, no_update, ALL
+from dash import Input, Output, State
+from dash.exceptions import PreventUpdate
+from yaml import load, FullLoader, YAMLError
+from copy import deepcopy
+from ast import literal_eval
+
+from ..utils.constants import Constants as C
+from ..utils.utils import show_tooltip, label, sync_checklists, list_tests, \
+    gen_new_url, generate_options
+from ..utils.url_processing import url_decode
+from ..data.data import Data
+from .graphs import graph_iterative, table_comparison, get_short_version, \
+    select_iterative_data
+
+
+class Layout:
+    """The layout of the dash app and the callbacks.
+    """
+
+    def __init__(self, app: Flask, releases: list, html_layout_file: str,
+        graph_layout_file: str, data_spec_file: str, tooltip_file: str) -> None:
+        """Initialization:
+        - save the input parameters,
+        - read and pre-process the data,
+        - prepare data for the control panel,
+        - read HTML layout file,
+        - read tooltips from the tooltip file.
+
+        :param app: Flask application running the dash application.
+        :param releases: Lis of releases to be displayed.
+        :param html_layout_file: Path and name of the file specifying the HTML
+            layout of the dash application.
+        :param graph_layout_file: Path and name of the file with layout of
+            plot.ly graphs.
+        :param data_spec_file: Path and name of the file specifying the data to
+            be read from parquets for this application.
+        :param tooltip_file: Path and name of the yaml file specifying the
+            tooltips.
+        :type app: Flask
+        :type releases: list
+        :type html_layout_file: str
+        :type graph_layout_file: str
+        :type data_spec_file: str
+        :type tooltip_file: str
+        """
+
+        # Inputs
+        self._app = app
+        self.releases = releases
+        self._html_layout_file = html_layout_file
+        self._graph_layout_file = graph_layout_file
+        self._data_spec_file = data_spec_file
+        self._tooltip_file = tooltip_file
+
+        # Read the data:
+        self._data = pd.DataFrame()
+        for rls in releases:
+            data_mrr = Data(self._data_spec_file, True).\
+                read_iterative_mrr(release=rls.replace("csit", "rls"))
+            data_mrr["release"] = rls
+            data_ndrpdr = Data(self._data_spec_file, True).\
+                read_iterative_ndrpdr(release=rls.replace("csit", "rls"))
+            data_ndrpdr["release"] = rls
+            self._data = pd.concat(
+                [self._data, data_mrr, data_ndrpdr], ignore_index=True)
+
+        # Get structure of tests:
+        tbs = dict()
+        cols = ["job", "test_id", "test_type", "dut_version", "release"]
+        for _, row in self._data[cols].drop_duplicates().iterrows():
+            rls = row["release"]
+            ttype = row["test_type"]
+            lst_job = row["job"].split("-")
+            dut = lst_job[1]
+            d_ver = get_short_version(row["dut_version"], dut)
+            tbed = "-".join(lst_job[-2:])
+            lst_test_id = row["test_id"].split(".")
+            if dut == "dpdk":
+                area = "dpdk"
+            else:
+                area = "-".join(lst_test_id[3:-2])
+            suite = lst_test_id[-2].replace("2n1l-", "").replace("1n1l-", "").\
+                replace("2n-", "")
+            test = lst_test_id[-1]
+            nic = suite.split("-")[0]
+            for drv in C.DRIVERS:
+                if drv in test:
+                    driver = drv.replace("-", "_")
+                    test = test.replace(f"{drv}-", "")
+                    break
+            else:
+                driver = "dpdk"
+            infra = "-".join((tbed, nic, driver))
+            lst_test = test.split("-")
+            framesize = lst_test[0]
+            core = lst_test[1] if lst_test[1] else "8C"
+            test = "-".join(lst_test[2: -1])
+
+            if tbs.get(rls, None) is None:
+                tbs[rls] = dict()
+            if tbs[rls].get(dut, None) is None:
+                tbs[rls][dut] = dict()
+            if tbs[rls][dut].get(d_ver, None) is None:
+                tbs[rls][dut][d_ver] = dict()
+            if tbs[rls][dut][d_ver].get(infra, None) is None:
+                tbs[rls][dut][d_ver][infra] = dict()
+            if tbs[rls][dut][d_ver][infra].get(area, None) is None:
+                tbs[rls][dut][d_ver][infra][area] = dict()
+            if tbs[rls][dut][d_ver][infra][area].get(test, None) is None:
+                tbs[rls][dut][d_ver][infra][area][test] = dict()
+                tbs[rls][dut][d_ver][infra][area][test]["core"] = list()
+                tbs[rls][dut][d_ver][infra][area][test]["frame-size"] = list()
+                tbs[rls][dut][d_ver][infra][area][test]["test-type"] = list()
+            if core.upper() not in \
+                    tbs[rls][dut][d_ver][infra][area][test]["core"]:
+                tbs[rls][dut][d_ver][infra][area][test]["core"].append(
+                    core.upper())
+            if framesize.upper() not in \
+                        tbs[rls][dut][d_ver][infra][area][test]["frame-size"]:
+                tbs[rls][dut][d_ver][infra][area][test]["frame-size"].append(
+                    framesize.upper())
+            if ttype == "mrr":
+                if "MRR" not in \
+                        tbs[rls][dut][d_ver][infra][area][test]["test-type"]:
+                    tbs[rls][dut][d_ver][infra][area][test]["test-type"].append(
+                        "MRR")
+            elif ttype == "ndrpdr":
+                if "NDR" not in \
+                        tbs[rls][dut][d_ver][infra][area][test]["test-type"]:
+                    tbs[rls][dut][d_ver][infra][area][test]["test-type"].extend(
+                        ("NDR", "PDR", ))
+        self._spec_tbs = tbs
+
+        # Read from files:
+        self._html_layout = ""
+        self._graph_layout = None
+        self._tooltips = dict()
+
+        try:
+            with open(self._html_layout_file, "r") as file_read:
+                self._html_layout = file_read.read()
+        except IOError as err:
+            raise RuntimeError(
+                f"Not possible to open the file {self._html_layout_file}\n{err}"
+            )
+
+        try:
+            with open(self._graph_layout_file, "r") as file_read:
+                self._graph_layout = load(file_read, Loader=FullLoader)
+        except IOError as err:
+            raise RuntimeError(
+                f"Not possible to open the file {self._graph_layout_file}\n"
+                f"{err}"
+            )
+        except YAMLError as err:
+            raise RuntimeError(
+                f"An error occurred while parsing the specification file "
+                f"{self._graph_layout_file}\n{err}"
+            )
+
+        try:
+            with open(self._tooltip_file, "r") as file_read:
+                self._tooltips = load(file_read, Loader=FullLoader)
+        except IOError as err:
+            logging.warning(
+                f"Not possible to open the file {self._tooltip_file}\n{err}"
+            )
+        except YAMLError as err:
+            logging.warning(
+                f"An error occurred while parsing the specification file "
+                f"{self._tooltip_file}\n{err}"
+            )
+
+        # Callbacks:
+        if self._app is not None and hasattr(self, 'callbacks'):
+            self.callbacks(self._app)
+
+    @property
+    def html_layout(self):
+        return self._html_layout
+
+    @property
+    def spec_tbs(self):
+        return self._spec_tbs
+
+    @property
+    def data(self):
+        return self._data
+
+    @property
+    def layout(self):
+        return self._graph_layout
+
+    def add_content(self):
+        """Top level method which generated the web page.
+
+        It generates:
+        - Store for user input data,
+        - Navigation bar,
+        - Main area with control panel and ploting area.
+
+        If no HTML layout is provided, an error message is displayed instead.
+
+        :returns: The HTML div with the whole page.
+        :rtype: html.Div
+        """
+
+        if self.html_layout and self.spec_tbs:
+            return html.Div(
+                id="div-main",
+                className="small",
+                children=[
+                    dbc.Row(
+                        id="row-navbar",
+                        class_name="g-0",
+                        children=[
+                            self._add_navbar(),
+                        ]
+                    ),
+                    dcc.Loading(
+                        dbc.Offcanvas(
+                            class_name="w-50",
+                            id="offcanvas-metadata",
+                            title="Throughput And Latency",
+                            placement="end",
+                            is_open=False,
+                            children=[
+                                dbc.Row(id="metadata-tput-lat"),
+                                dbc.Row(id="metadata-hdrh-graph"),
+                            ]
+                        )
+                    ),
+                    dbc.Row(
+                        id="row-main",
+                        class_name="g-0",
+                        children=[
+                            dcc.Store(id="selected-tests"),
+                            dcc.Store(id="control-panel"),
+                            dcc.Location(id="url", refresh=False),
+                            self._add_ctrl_col(),
+                            self._add_plotting_col(),
+                        ]
+                    )
+                ]
+            )
+        else:
+            return html.Div(
+                id="div-main-error",
+                children=[
+                    dbc.Alert(
+                        [
+                            "An Error Occured",
+                        ],
+                        color="danger",
+                    ),
+                ]
+            )
+
+    def _add_navbar(self):
+        """Add nav element with navigation panel. It is placed on the top.
+
+        :returns: Navigation bar.
+        :rtype: dbc.NavbarSimple
+        """
+        return dbc.NavbarSimple(
+            id="navbarsimple-main",
+            children=[
+                dbc.NavItem(
+                    dbc.NavLink(
+                        C.REPORT_TITLE,
+                        disabled=True,
+                        external_link=True,
+                        href="#"
+                    )
+                )
+            ],
+            brand=C.BRAND,
+            brand_href="/",
+            brand_external_link=True,
+            class_name="p-2",
+            fluid=True,
+        )
+
+    def _add_ctrl_col(self) -> dbc.Col:
+        """Add column with controls. It is placed on the left side.
+
+        :returns: Column with the control panel.
+        :rtype: dbc.Col
+        """
+        return dbc.Col([
+            html.Div(
+                children=self._add_ctrl_panel(),
+                className="sticky-top"
+            )
+        ])
+
+    def _add_plotting_col(self) -> dbc.Col:
+        """Add column with plots and tables. It is placed on the right side.
+
+        :returns: Column with tables.
+        :rtype: dbc.Col
+        """
+        return dbc.Col(
+            id="col-plotting-area",
+            children=[
+                dcc.Loading(
+                    children=[
+                        dbc.Row(  # Graphs
+                            class_name="g-0 p-2",
+                            children=[
+                                dbc.Col(
+                                    dbc.Row(  # Throughput
+                                        id="row-graph-tput",
+                                        class_name="g-0 p-2",
+                                        children=[C.PLACEHOLDER, ]
+                                    ),
+                                    width=6
+                                ),
+                                dbc.Col(
+                                    dbc.Row(  # Latency
+                                        id="row-graph-lat",
+                                        class_name="g-0 p-2",
+                                        children=[C.PLACEHOLDER, ]
+                                    ),
+                                    width=6
+                                )
+                            ]
+                        ),
+                        dbc.Row(  # Tables
+                            id="row-table",
+                            class_name="g-0 p-2",
+                            children=[C.PLACEHOLDER, ]
+                        ),
+                        dbc.Row(  # Download
+                            id="row-btn-download",
+                            class_name="g-0 p-2",
+                            children=[C.PLACEHOLDER, ]
+                        )
+                    ]
+                )
+            ],
+            width=9
+        )
+
+    def _add_ctrl_panel(self) -> dbc.Row:
+        """Add control panel.
+
+        :returns: Control panel.
+        :rtype: dbc.Row
+        """
+        return [
+            dbc.Row(
+                class_name="g-0 p-1",
+                children=[
+                    dbc.InputGroup(
+                        [
+                            dbc.InputGroupText(
+                                children=show_tooltip(self._tooltips,
+                                    "help-release", "CSIT Release")
+                            ),
+                            dbc.Select(
+                                id="dd-ctrl-rls",
+                                placeholder=("Select a Release..."),
+                                options=sorted(
+                                    [
+                                        {"label": k, "value": k} \
+                                            for k in self.spec_tbs.keys()
+                                    ],
+                                    key=lambda d: d["label"]
+                                )
+                            )
+                        ],
+                        size="sm",
+                    ),
+                ]
+            ),
+            dbc.Row(
+                class_name="g-0 p-1",
+                children=[
+                    dbc.InputGroup(
+                        [
+                            dbc.InputGroupText(
+                                children=show_tooltip(self._tooltips,
+                                    "help-dut", "DUT")
+                            ),
+                            dbc.Select(
+                                id="dd-ctrl-dut",
+                                placeholder=(
+                                    "Select a Device under Test..."
+                                )
+                            )
+                        ],
+                        size="sm",
+                    ),
+                ]
+            ),
+            dbc.Row(
+                class_name="g-0 p-1",
+                children=[
+                    dbc.InputGroup(
+                        [
+                            dbc.InputGroupText(
+                                children=show_tooltip(self._tooltips,
+                                    "help-dut-ver", "DUT Version")
+                            ),
+                            dbc.Select(
+                                id="dd-ctrl-dutver",
+                                placeholder=(
+                                    "Select a Version of "
+                                    "Device under Test..."
+                                )
+                            )
+                        ],
+                        size="sm",
+                    ),
+                ]
+            ),
+            dbc.Row(
+                class_name="g-0 p-1",
+                children=[
+                    dbc.InputGroup(
+                        [
+                            dbc.InputGroupText(
+                                children=show_tooltip(self._tooltips,
+                                    "help-infra", "Infra")
+                            ),
+                            dbc.Select(
+                                id="dd-ctrl-phy",
+                                placeholder=(
+                                    "Select a Physical Test Bed "
+                                    "Topology..."
+                                )
+                            )
+                        ],
+                        size="sm",
+                    ),
+                ]
+            ),
+            dbc.Row(
+                class_name="g-0 p-1",
+                children=[
+                    dbc.InputGroup(
+                        [
+                            dbc.InputGroupText(
+                                children=show_tooltip(self._tooltips,
+                                    "help-area", "Area")
+                            ),
+                            dbc.Select(
+                                id="dd-ctrl-area",
+                                placeholder="Select an Area...",
+                                disabled=True,
+                            ),
+                        ],
+                        size="sm",
+                    ),
+                ]
+            ),
+            dbc.Row(
+                class_name="g-0 p-1",
+                children=[
+                    dbc.InputGroup(
+                        [
+                            dbc.InputGroupText(
+                                children=show_tooltip(self._tooltips,
+                                    "help-test", "Test")
+                            ),
+                            dbc.Select(
+                                id="dd-ctrl-test",
+                                placeholder="Select a Test...",
+                                disabled=True,
+                            ),
+                        ],
+                        size="sm",
+                    ),
+                ]
+            ),
+            dbc.Row(
+                class_name="g-0 p-1",
+                children=[
+                    dbc.Label(
+                        children=show_tooltip(self._tooltips,
+                            "help-framesize", "Frame Size"),
+                    ),
+                    dbc.Col(
+                        children=[
+                            dbc.Checklist(
+                                id="cl-ctrl-framesize-all",
+                                options=C.CL_ALL_DISABLED,
+                                inline=True,
+                                switch=False
+                            ),
+                        ],
+                        width=3
+                    ),
+                    dbc.Col(
+                        children=[
+                            dbc.Checklist(
+                                id="cl-ctrl-framesize",
+                                inline=True,
+                                switch=False
+                            )
+                        ]
+                    )
+                ]
+            ),
+            dbc.Row(
+                class_name="g-0 p-1",
+                children=[
+                    dbc.Label(
+                        children=show_tooltip(self._tooltips,
+                            "help-cores", "Number of Cores"),
+                    ),
+                    dbc.Col(
+                        children=[
+                            dbc.Checklist(
+                                id="cl-ctrl-core-all",
+                                options=C.CL_ALL_DISABLED,
+                                inline=False,
+                                switch=False
+                            )
+                        ],
+                        width=3
+                    ),
+                    dbc.Col(
+                        children=[
+                            dbc.Checklist(
+                                id="cl-ctrl-core",
+                                inline=True,
+                                switch=False
+                            )
+                        ]
+                    )
+                ]
+            ),
+            dbc.Row(
+                class_name="g-0 p-1",
+                children=[
+                    dbc.Label(
+                        children=show_tooltip(self._tooltips,
+                            "help-ttype", "Test Type"),
+                    ),
+                    dbc.Col(
+                        children=[
+                            dbc.Checklist(
+                                id="cl-ctrl-testtype-all",
+                                options=C.CL_ALL_DISABLED,
+                                inline=True,
+                                switch=False
+                            ),
+                        ],
+                        width=3
+                    ),
+                    dbc.Col(
+                        children=[
+                            dbc.Checklist(
+                                id="cl-ctrl-testtype",
+                                inline=True,
+                                switch=False
+                            )
+                        ]
+                    )
+                ]
+            ),
+            dbc.Row(
+                class_name="g-0 p-1",
+                children=[
+                    dbc.Label(
+                        children=show_tooltip(self._tooltips,
+                            "help-normalize", "Normalize"),
+                    ),
+                    dbc.Col(
+                        children=[
+                            dbc.Checklist(
+                                id="cl-ctrl-normalize",
+                                options=[{
+                                    "value": "normalize",
+                                    "label": (
+                                        "Normalize results to CPU "
+                                        "frequency 2GHz"
+                                    )
+                                }],
+                                value=[],
+                                inline=True,
+                                switch=False
+                            ),
+                        ]
+                    )
+                ]
+            ),
+            dbc.Row(
+                class_name="g-0 p-1",
+                children=[
+                    dbc.ButtonGroup(
+                        [
+                            dbc.Button(
+                                id="btn-ctrl-add",
+                                children="Add Selected",
+                                color="info"
+                            )
+                        ]
+                    )
+                ]
+            ),
+            dbc.Row(
+                id="row-card-sel-tests",
+                class_name="g-0 p-1",
+                style=C.STYLE_DISABLED,
+                children=[
+                    dbc.Label("Selected tests"),
+                    dbc.Checklist(
+                        class_name="overflow-auto",
+                        id="cl-selected",
+                        options=[],
+                        inline=False,
+                        style={"max-height": "20em"},
+                    )
+                ],
+            ),
+            dbc.Row(
+                id="row-btns-sel-tests",
+                class_name="g-0 p-1",
+                style=C.STYLE_DISABLED,
+                children=[
+                    dbc.ButtonGroup(
+                        children=[
+                            dbc.Button(
+                                id="btn-sel-remove",
+                                children="Remove Selected",
+                                class_name="w-100",
+                                color="info",
+                                disabled=False
+                            ),
+                            dbc.Button(
+                                id="btn-sel-remove-all",
+                                children="Remove All",
+                                class_name="w-100",
+                                color="info",
+                                disabled=False
+                            ),
+                        ]
+                    )
+                ]
+            ),
+        ]
+
+    class ControlPanel:
+        """A class representing the control panel.
+        """
+
+        def __init__(self, panel: dict) -> None:
+            """Initialisation of the control pannel by default values. If
+            particular values are provided (parameter "panel") they are set
+            afterwards.
+
+            :param panel: Custom values to be set to the control panel.
+            :param default: Default values to be set to the control panel.
+            :type panel: dict
+            :type defaults: dict
+            """
+
+            # Defines also the order of keys
+            self._defaults = {
+                "dd-rls-value": str(),
+                "dd-dut-options": list(),
+                "dd-dut-disabled": True,
+                "dd-dut-value": str(),
+                "dd-dutver-options": list(),
+                "dd-dutver-disabled": True,
+                "dd-dutver-value": str(),
+                "dd-phy-options": list(),
+                "dd-phy-disabled": True,
+                "dd-phy-value": str(),
+                "dd-area-options": list(),
+                "dd-area-disabled": True,
+                "dd-area-value": str(),
+                "dd-test-options": list(),
+                "dd-test-disabled": True,
+                "dd-test-value": str(),
+                "cl-core-options": list(),
+                "cl-core-value": list(),
+                "cl-core-all-value": list(),
+                "cl-core-all-options": C.CL_ALL_DISABLED,
+                "cl-framesize-options": list(),
+                "cl-framesize-value": list(),
+                "cl-framesize-all-value": list(),
+                "cl-framesize-all-options": C.CL_ALL_DISABLED,
+                "cl-testtype-options": list(),
+                "cl-testtype-value": list(),
+                "cl-testtype-all-value": list(),
+                "cl-testtype-all-options": C.CL_ALL_DISABLED,
+                "btn-add-disabled": True,
+                "cl-normalize-value": list(),
+                "cl-selected-options": list()
+            }
+
+            self._panel = deepcopy(self._defaults)
+            if panel:
+                for key in self._defaults:
+                    self._panel[key] = panel[key]
+
+        @property
+        def defaults(self) -> dict:
+            return self._defaults
+
+        @property
+        def panel(self) -> dict:
+            return self._panel
+
+        def set(self, kwargs: dict) -> None:
+            """Set the values of the Control panel.
+
+            :param kwargs: key - value pairs to be set.
+            :type kwargs: dict
+            :raises KeyError: If the key in kwargs is not present in the Control
+                panel.
+            """
+            for key, val in kwargs.items():
+                if key in self._panel:
+                    self._panel[key] = val
+                else:
+                    raise KeyError(f"The key {key} is not defined.")
+
+        def get(self, key: str) -> any:
+            """Returns the value of a key from the Control panel.
+
+            :param key: The key which value should be returned.
+            :type key: str
+            :returns: The value of the key.
+            :rtype: any
+            :raises KeyError: If the key in kwargs is not present in the Control
+                panel.
+            """
+            return self._panel[key]
+
+        def values(self) -> tuple:
+            """Returns the values from the Control panel as a list.
+
+            :returns: The values from the Control panel.
+            :rtype: list
+            """
+            return tuple(self._panel.values())
+
+    def callbacks(self, app):
+        """Callbacks for the whole application.
+
+        :param app: The application.
+        :type app: Flask
+        """
+
+        def _generate_plotting_area(figs: tuple, table: pd.DataFrame,
+                url: str) -> tuple:
+            """Generate the plotting area with all its content.
+
+            :param figs: Figures to be placed in the plotting area.
+            :param table: A table to be placed in the plotting area bellow the
+                figures.
+            :param utl: The URL to be placed in the plotting area bellow the
+                tables.
+            :type figs: tuple of plotly.graph_objects.Figure
+            :type table: pandas.DataFrame
+            :type url: str
+            :returns: tuple of elements to be shown in the plotting area.
+            :rtype: tuple
+                (dcc.Graph, dcc.Graph, dbc.Table, list(dbc.Col, dbc.Col))
+            """
+
+            (fig_tput, fig_lat) = figs
+
+            row_fig_tput = C.PLACEHOLDER
+            row_fig_lat = C.PLACEHOLDER
+            row_table = C.PLACEHOLDER
+            row_btn_dwnld = C.PLACEHOLDER
+
+            if fig_tput:
+                row_fig_tput = [
+                    dcc.Graph(
+                        id={"type": "graph", "index": "tput"},
+                        figure=fig_tput
+                    )
+                ]
+                row_btn_dwnld = [
+                    dbc.Col(  # Download
+                        width=2,
+                        children=[
+                            dcc.Loading(children=[
+                                dbc.Button(
+                                    id="btn-download-data",
+                                    children=show_tooltip(self._tooltips,
+                                        "help-download", "Download Data"),
+                                    class_name="me-1",
+                                    color="info"
+                                ),
+                                dcc.Download(id="download-data")
+                            ]),
+                        ]
+                    ),
+                    dbc.Col(  # Show URL
+                        width=10,
+                        children=[
+                            dbc.InputGroup(
+                                class_name="me-1",
+                                children=[
+                                    dbc.InputGroupText(
+                                        style=C.URL_STYLE,
+                                        children=show_tooltip(self._tooltips,
+                                            "help-url", "URL", "input-url")
+                                    ),
+                                    dbc.Input(
+                                        id="input-url",
+                                        readonly=True,
+                                        type="url",
+                                        style=C.URL_STYLE,
+                                        value=url
+                                    )
+                                ]
+                            )
+                        ]
+                    )
+                ]
+            if fig_lat:
+                row_fig_lat = [
+                    dcc.Graph(
+                        id={"type": "graph", "index": "lat"},
+                        figure=fig_lat
+                    )
+                ]
+            if not table.empty:
+                row_table = [
+                    dbc.Table.from_dataframe(
+                        table,
+                        id={"type": "table", "index": "compare"},
+                        striped=True,
+                        bordered=True,
+                        hover=True
+                    )
+                ]
+
+            return row_fig_tput, row_fig_lat, row_table, row_btn_dwnld
+
+        @app.callback(
+            Output("control-panel", "data"),  # Store
+            Output("selected-tests", "data"),  # Store
+            Output("row-graph-tput", "children"),
+            Output("row-graph-lat", "children"),
+            Output("row-table", "children"),
+            Output("row-btn-download", "children"),
+            Output("row-card-sel-tests", "style"),
+            Output("row-btns-sel-tests", "style"),
+            Output("dd-ctrl-rls", "value"),
+            Output("dd-ctrl-dut", "options"),
+            Output("dd-ctrl-dut", "disabled"),
+            Output("dd-ctrl-dut", "value"),
+            Output("dd-ctrl-dutver", "options"),
+            Output("dd-ctrl-dutver", "disabled"),
+            Output("dd-ctrl-dutver", "value"),
+            Output("dd-ctrl-phy", "options"),
+            Output("dd-ctrl-phy", "disabled"),
+            Output("dd-ctrl-phy", "value"),
+            Output("dd-ctrl-area", "options"),
+            Output("dd-ctrl-area", "disabled"),
+            Output("dd-ctrl-area", "value"),
+            Output("dd-ctrl-test", "options"),
+            Output("dd-ctrl-test", "disabled"),
+            Output("dd-ctrl-test", "value"),
+            Output("cl-ctrl-core", "options"),
+            Output("cl-ctrl-core", "value"),
+            Output("cl-ctrl-core-all", "value"),
+            Output("cl-ctrl-core-all", "options"),
+            Output("cl-ctrl-framesize", "options"),
+            Output("cl-ctrl-framesize", "value"),
+            Output("cl-ctrl-framesize-all", "value"),
+            Output("cl-ctrl-framesize-all", "options"),
+            Output("cl-ctrl-testtype", "options"),
+            Output("cl-ctrl-testtype", "value"),
+            Output("cl-ctrl-testtype-all", "value"),
+            Output("cl-ctrl-testtype-all", "options"),
+            Output("btn-ctrl-add", "disabled"),
+            Output("cl-ctrl-normalize", "value"),
+            Output("cl-selected", "options"),  # User selection
+            State("control-panel", "data"),  # Store
+            State("selected-tests", "data"),  # Store
+            State("cl-selected", "value"),  # User selection
+            Input("dd-ctrl-rls", "value"),
+            Input("dd-ctrl-dut", "value"),
+            Input("dd-ctrl-dutver", "value"),
+            Input("dd-ctrl-phy", "value"),
+            Input("dd-ctrl-area", "value"),
+            Input("dd-ctrl-test", "value"),
+            Input("cl-ctrl-core", "value"),
+            Input("cl-ctrl-core-all", "value"),
+            Input("cl-ctrl-framesize", "value"),
+            Input("cl-ctrl-framesize-all", "value"),
+            Input("cl-ctrl-testtype", "value"),
+            Input("cl-ctrl-testtype-all", "value"),
+            Input("cl-ctrl-normalize", "value"),
+            Input("btn-ctrl-add", "n_clicks"),
+            Input("btn-sel-remove", "n_clicks"),
+            Input("btn-sel-remove-all", "n_clicks"),
+            Input("url", "href")
+        )
+        def _update_ctrl_panel(cp_data: dict, store_sel: list, list_sel: list,
+            dd_rls: str, dd_dut: str, dd_dutver: str, dd_phy: str, dd_area: str,
+            dd_test: str, cl_core: list, cl_core_all: list, cl_framesize: list,
+            cl_framesize_all: list, cl_testtype: list, cl_testtype_all: list,
+            cl_normalize: list, btn_add: int, btn_remove: int,
+            btn_remove_all: int, href: str) -> tuple:
+            """Update the application when the event is detected.
+
+            :param cp_data: Current status of the control panel stored in
+                browser.
+            :param store_sel: List of tests selected by user stored in the
+                browser.
+            :param list_sel: List of tests selected by the user shown in the
+                checklist.
+            :param dd_rls: Input - Releases.
+            :param dd_dut: Input - DUTs.
+            :param dd_dutver: Input - Version of DUT.
+            :param dd_phy: Input - topo- arch-nic-driver.
+            :param dd_area: Input - Tested area.
+            :param dd_test: Input - Test.
+            :param cl_core: Input - Number of cores.
+            :param cl_core_all: Input - All numbers of cores.
+            :param cl_framesize: Input - Frame sizes.
+            :param cl_framesize_all: Input - All frame sizes.
+            :param cl_testtype: Input - Test type (NDR, PDR, MRR).
+            :param cl_testtype_all: Input - All test types.
+            :param cl_normalize: Input - Normalize the results.
+            :param btn_add: Input - Button "Add Selected" tests.
+            :param btn_remove: Input - Button "Remove selected" tests.
+            :param btn_remove_all: Input - Button "Remove All" tests.
+            :param href: Input - The URL provided by the browser.
+            :type cp_data: dict
+            :type store_sel: list
+            :type list_sel: list
+            :type dd_rls: str
+            :type dd_dut: str
+            :type dd_dutver: str
+            :type dd_phy: str
+            :type dd_area: str
+            :type dd_test: str
+            :type cl_core: list
+            :type cl_core_all: list
+            :type cl_framesize: list
+            :type cl_framesize_all: list
+            :type cl_testtype: list
+            :type cl_testtype_all: list
+            :type cl_normalize: list
+            :type btn_add: int
+            :type btn_remove: int
+            :type btn_remove_all: int
+            :type href: str
+            :returns: New values for web page elements.
+            :rtype: tuple
+            """
+
+            ctrl_panel = self.ControlPanel(cp_data)
+            norm = cl_normalize
+
+            # Parse the url:
+            parsed_url = url_decode(href)
+            if parsed_url:
+                url_params = parsed_url["params"]
+            else:
+                url_params = None
+
+            row_fig_tput = no_update
+            row_fig_lat = no_update
+            row_table = no_update
+            row_btn_dwnld = no_update
+            row_card_sel_tests = no_update
+            row_btns_sel_tests = no_update
+
+            trigger_id = callback_context.triggered[0]["prop_id"].split(".")[0]
+
+            if trigger_id == "dd-ctrl-rls":
+                try:
+                    options = \
+                        generate_options(sorted(self.spec_tbs[dd_rls].keys()))
+                    disabled = False
+                except KeyError:
+                    options = list()
+                    disabled = True
+                ctrl_panel.set({
+                    "dd-rls-value": dd_rls,
+                    "dd-dut-value": str(),
+                    "dd-dut-options": options,
+                    "dd-dut-disabled": disabled,
+                    "dd-dutver-value": str(),
+                    "dd-dutver-options": list(),
+                    "dd-dutver-disabled": True,
+                    "dd-phy-value": str(),
+                    "dd-phy-options": list(),
+                    "dd-phy-disabled": True,
+                    "dd-area-value": str(),
+                    "dd-area-options": list(),
+                    "dd-area-disabled": True,
+                    "dd-test-value": str(),
+                    "dd-test-options": list(),
+                    "dd-test-disabled": True,
+                    "cl-core-options": list(),
+                    "cl-core-value": list(),
+                    "cl-core-all-value": list(),
+                    "cl-core-all-options": C.CL_ALL_DISABLED,
+                    "cl-framesize-options": list(),
+                    "cl-framesize-value": list(),
+                    "cl-framesize-all-value": list(),
+                    "cl-framesize-all-options": C.CL_ALL_DISABLED,
+                    "cl-testtype-options": list(),
+                    "cl-testtype-value": list(),
+                    "cl-testtype-all-value": list(),
+                    "cl-testtype-all-options": C.CL_ALL_DISABLED
+                })
+            elif trigger_id == "dd-ctrl-dut":
+                try:
+                    rls = ctrl_panel.get("dd-rls-value")
+                    dut = self.spec_tbs[rls][dd_dut]
+                    options = generate_options(sorted(dut.keys()))
+                    disabled = False
+                except KeyError:
+                    options = list()
+                    disabled = True
+                ctrl_panel.set({
+                    "dd-dut-value": dd_dut,
+                    "dd-dutver-value": str(),
+                    "dd-dutver-options": options,
+                    "dd-dutver-disabled": disabled,
+                    "dd-phy-value": str(),
+                    "dd-phy-options": list(),
+                    "dd-phy-disabled": True,
+                    "dd-area-value": str(),
+                    "dd-area-options": list(),
+                    "dd-area-disabled": True,
+                    "dd-test-value": str(),
+                    "dd-test-options": list(),
+                    "dd-test-disabled": True,
+                    "cl-core-options": list(),
+                    "cl-core-value": list(),
+                    "cl-core-all-value": list(),
+                    "cl-core-all-options": C.CL_ALL_DISABLED,
+                    "cl-framesize-options": list(),
+                    "cl-framesize-value": list(),
+                    "cl-framesize-all-value": list(),
+                    "cl-framesize-all-options": C.CL_ALL_DISABLED,
+                    "cl-testtype-options": list(),
+                    "cl-testtype-value": list(),
+                    "cl-testtype-all-value": list(),
+                    "cl-testtype-all-options": C.CL_ALL_DISABLED
+                })
+            elif trigger_id == "dd-ctrl-dutver":
+                try:
+                    rls = ctrl_panel.get("dd-rls-value")
+                    dut = ctrl_panel.get("dd-dut-value")
+                    dutver = self.spec_tbs[rls][dut][dd_dutver]
+                    options = generate_options(sorted(dutver.keys()))
+                    disabled = False
+                except KeyError:
+                    options = list()
+                    disabled = True
+                ctrl_panel.set({
+                    "dd-dutver-value": dd_dutver,
+                    "dd-phy-value": str(),
+                    "dd-phy-options": options,
+                    "dd-phy-disabled": disabled,
+                    "dd-area-value": str(),
+                    "dd-area-options": list(),
+                    "dd-area-disabled": True,
+                    "dd-test-value": str(),
+                    "dd-test-options": list(),
+                    "dd-test-disabled": True,
+                    "cl-core-options": list(),
+                    "cl-core-value": list(),
+                    "cl-core-all-value": list(),
+                    "cl-core-all-options": C.CL_ALL_DISABLED,
+                    "cl-framesize-options": list(),
+                    "cl-framesize-value": list(),
+                    "cl-framesize-all-value": list(),
+                    "cl-framesize-all-options": C.CL_ALL_DISABLED,
+                    "cl-testtype-options": list(),
+                    "cl-testtype-value": list(),
+                    "cl-testtype-all-value": list(),
+                    "cl-testtype-all-options": C.CL_ALL_DISABLED
+                })
+            elif trigger_id == "dd-ctrl-phy":
+                try:
+                    rls = ctrl_panel.get("dd-rls-value")
+                    dut = ctrl_panel.get("dd-dut-value")
+                    dutver = ctrl_panel.get("dd-dutver-value")
+                    phy = self.spec_tbs[rls][dut][dutver][dd_phy]
+                    options = [{"label": label(v), "value": v} \
+                        for v in sorted(phy.keys())]
+                    disabled = False
+                except KeyError:
+                    options = list()
+                    disabled = True
+                ctrl_panel.set({
+                    "dd-phy-value": dd_phy,
+                    "dd-area-value": str(),
+                    "dd-area-options": options,
+                    "dd-area-disabled": disabled,
+                    "dd-test-value": str(),
+                    "dd-test-options": list(),
+                    "dd-test-disabled": True,
+                    "cl-core-options": list(),
+                    "cl-core-value": list(),
+                    "cl-core-all-value": list(),
+                    "cl-core-all-options": C.CL_ALL_DISABLED,
+                    "cl-framesize-options": list(),
+                    "cl-framesize-value": list(),
+                    "cl-framesize-all-value": list(),
+                    "cl-framesize-all-options": C.CL_ALL_DISABLED,
+                    "cl-testtype-options": list(),
+                    "cl-testtype-value": list(),
+                    "cl-testtype-all-value": list(),
+                    "cl-testtype-all-options": C.CL_ALL_DISABLED
+                })
+            elif trigger_id == "dd-ctrl-area":
+                try:
+                    rls = ctrl_panel.get("dd-rls-value")
+                    dut = ctrl_panel.get("dd-dut-value")
+                    dutver = ctrl_panel.get("dd-dutver-value")
+                    phy = ctrl_panel.get("dd-phy-value")
+                    area = self.spec_tbs[rls][dut][dutver][phy][dd_area]
+                    options = generate_options(sorted(area.keys()))
+                    disabled = False
+                except KeyError:
+                    options = list()
+                    disabled = True
+                ctrl_panel.set({
+                    "dd-area-value": dd_area,
+                    "dd-test-value": str(),
+                    "dd-test-options": options,
+                    "dd-test-disabled": disabled,
+                    "cl-core-options": list(),
+                    "cl-core-value": list(),
+                    "cl-core-all-value": list(),
+                    "cl-core-all-options": C.CL_ALL_DISABLED,
+                    "cl-framesize-options": list(),
+                    "cl-framesize-value": list(),
+                    "cl-framesize-all-value": list(),
+                    "cl-framesize-all-options": C.CL_ALL_DISABLED,
+                    "cl-testtype-options": list(),
+                    "cl-testtype-value": list(),
+                    "cl-testtype-all-value": list(),
+                    "cl-testtype-all-options": C.CL_ALL_DISABLED
+                })
+            elif trigger_id == "dd-ctrl-test":
+                rls = ctrl_panel.get("dd-rls-value")
+                dut = ctrl_panel.get("dd-dut-value")
+                dutver = ctrl_panel.get("dd-dutver-value")
+                phy = ctrl_panel.get("dd-phy-value")
+                area = ctrl_panel.get("dd-area-value")
+                if all((rls, dut, dutver, phy, area, dd_test, )):
+                    test = self.spec_tbs[rls][dut][dutver][phy][area][dd_test]
+                    ctrl_panel.set({
+                        "dd-test-value": dd_test,
+                        "cl-core-options": \
+                            generate_options(sorted(test["core"])),
+                        "cl-core-value": list(),
+                        "cl-core-all-value": list(),
+                        "cl-core-all-options": C.CL_ALL_ENABLED,
+                        "cl-framesize-options": \
+                            generate_options(sorted(test["frame-size"])),
+                        "cl-framesize-value": list(),
+                        "cl-framesize-all-value": list(),
+                        "cl-framesize-all-options": C.CL_ALL_ENABLED,
+                        "cl-testtype-options": \
+                            generate_options(sorted(test["test-type"])),
+                        "cl-testtype-value": list(),
+                        "cl-testtype-all-value": list(),
+                        "cl-testtype-all-options": C.CL_ALL_ENABLED,
+                    })
+            elif trigger_id == "cl-ctrl-core":
+                val_sel, val_all = sync_checklists(
+                    options=ctrl_panel.get("cl-core-options"),
+                    sel=cl_core,
+                    all=list(),
+                    id=""
+                )
+                ctrl_panel.set({
+                    "cl-core-value": val_sel,
+                    "cl-core-all-value": val_all,
+                })
+            elif trigger_id == "cl-ctrl-core-all":
+                val_sel, val_all = sync_checklists(
+                    options = ctrl_panel.get("cl-core-options"),
+                    sel=list(),
+                    all=cl_core_all,
+                    id="all"
+                )
+                ctrl_panel.set({
+                    "cl-core-value": val_sel,
+                    "cl-core-all-value": val_all,
+                })
+            elif trigger_id == "cl-ctrl-framesize":
+                val_sel, val_all = sync_checklists(
+                    options = ctrl_panel.get("cl-framesize-options"),
+                    sel=cl_framesize,
+                    all=list(),
+                    id=""
+                )
+                ctrl_panel.set({
+                    "cl-framesize-value": val_sel,
+                    "cl-framesize-all-value": val_all,
+                })
+            elif trigger_id == "cl-ctrl-framesize-all":
+                val_sel, val_all = sync_checklists(
+                    options = ctrl_panel.get("cl-framesize-options"),
+                    sel=list(),
+                    all=cl_framesize_all,
+                    id="all"
+                )
+                ctrl_panel.set({
+                    "cl-framesize-value": val_sel,
+                    "cl-framesize-all-value": val_all,
+                })
+            elif trigger_id == "cl-ctrl-testtype":
+                val_sel, val_all = sync_checklists(
+                    options = ctrl_panel.get("cl-testtype-options"),
+                    sel=cl_testtype,
+                    all=list(),
+                    id=""
+                )
+                ctrl_panel.set({
+                    "cl-testtype-value": val_sel,
+                    "cl-testtype-all-value": val_all,
+                })
+            elif trigger_id == "cl-ctrl-testtype-all":
+                val_sel, val_all = sync_checklists(
+                    options = ctrl_panel.get("cl-testtype-options"),
+                    sel=list(),
+                    all=cl_testtype_all,
+                    id="all"
+                )
+                ctrl_panel.set({
+                    "cl-testtype-value": val_sel,
+                    "cl-testtype-all-value": val_all,
+                })
+            elif trigger_id == "btn-ctrl-add":
+                _ = btn_add
+                rls = ctrl_panel.get("dd-rls-value")
+                dut = ctrl_panel.get("dd-dut-value")
+                dutver = ctrl_panel.get("dd-dutver-value")
+                phy = ctrl_panel.get("dd-phy-value")
+                area = ctrl_panel.get("dd-area-value")
+                test = ctrl_panel.get("dd-test-value")
+                cores = ctrl_panel.get("cl-core-value")
+                framesizes = ctrl_panel.get("cl-framesize-value")
+                testtypes = ctrl_panel.get("cl-testtype-value")
+                # Add selected test to the list of tests in store:
+                if all((rls, dut, dutver, phy, area, test, cores, framesizes,
+                        testtypes)):
+                    if store_sel is None:
+                        store_sel = list()
+                    for core in cores:
+                        for framesize in framesizes:
+                            for ttype in testtypes:
+                                if dut == "trex":
+                                    core = str()
+                                tid = "-".join((rls, dut, dutver,
+                                    phy.replace('af_xdp', 'af-xdp'), area,
+                                    framesize.lower(), core.lower(), test,
+                                    ttype.lower()))
+                                if tid not in [itm["id"] for itm in store_sel]:
+                                    store_sel.append({
+                                        "id": tid,
+                                        "rls": rls,
+                                        "dut": dut,
+                                        "dutver": dutver,
+                                        "phy": phy,
+                                        "area": area,
+                                        "test": test,
+                                        "framesize": framesize.lower(),
+                                        "core": core.lower(),
+                                        "testtype": ttype.lower()
+                                    })
+                    store_sel = sorted(store_sel, key=lambda d: d["id"])
+                    row_card_sel_tests = C.STYLE_ENABLED
+                    row_btns_sel_tests = C.STYLE_ENABLED
+                    if C.CLEAR_ALL_INPUTS:
+                        ctrl_panel.set(ctrl_panel.defaults)
+                    ctrl_panel.set({
+                        "cl-selected-options": list_tests(store_sel)
+                    })
+            elif trigger_id == "btn-sel-remove-all":
+                _ = btn_remove_all
+                row_fig_tput = C.PLACEHOLDER
+                row_fig_lat = C.PLACEHOLDER
+                row_table = C.PLACEHOLDER
+                row_btn_dwnld = C.PLACEHOLDER
+                row_card_sel_tests = C.STYLE_DISABLED
+                row_btns_sel_tests = C.STYLE_DISABLED
+                store_sel = list()
+                ctrl_panel.set({"cl-selected-options": list()})
+            elif trigger_id == "btn-sel-remove":
+                _ = btn_remove
+                if list_sel:
+                    new_store_sel = list()
+                    for item in store_sel:
+                        if item["id"] not in list_sel:
+                            new_store_sel.append(item)
+                    store_sel = new_store_sel
+            elif trigger_id == "url":
+                if url_params:
+                    try:
+                        store_sel = literal_eval(url_params["store_sel"][0])
+                        norm = literal_eval(url_params["norm"][0])
+                    except (KeyError, IndexError):
+                        pass
+                    if store_sel:
+                        row_card_sel_tests = C.STYLE_ENABLED
+                        row_btns_sel_tests = C.STYLE_ENABLED
+                        last_test = store_sel[-1]
+                        test = self.spec_tbs[last_test["rls"]]\
+                            [last_test["dut"]][last_test["dutver"]]\
+                                [last_test["phy"]][last_test["area"]]\
+                                    [last_test["test"]]
+                        ctrl_panel.set({
+                            "dd-rls-value": last_test["rls"],
+                            "dd-dut-value": last_test["dut"],
+                            "dd-dut-options": generate_options(sorted(
+                                self.spec_tbs[last_test["rls"]].keys())),
+                            "dd-dut-disabled": False,
+                            "dd-dutver-value": last_test["dutver"],
+                            "dd-dutver-options": generate_options(sorted(
+                                self.spec_tbs[last_test["rls"]]\
+                                    [last_test["dut"]].keys())),
+                            "dd-dutver-disabled": False,
+                            "dd-phy-value": last_test["phy"],
+                            "dd-phy-options": generate_options(sorted(
+                                self.spec_tbs[last_test["rls"]]\
+                                    [last_test["dut"]]\
+                                        [last_test["dutver"]].keys())),
+                            "dd-phy-disabled": False,
+                            "dd-area-value": last_test["area"],
+                            "dd-area-options": [
+                                {"label": label(v), "value": v} for v in \
+                                    sorted(self.spec_tbs[last_test["rls"]]\
+                                        [last_test["dut"]][last_test["dutver"]]\
+                                            [last_test["phy"]].keys())
+                            ],
+                            "dd-area-disabled": False,
+                            "dd-test-value": last_test["test"],
+                            "dd-test-options": generate_options(sorted(
+                                self.spec_tbs[last_test["rls"]]\
+                                    [last_test["dut"]][last_test["dutver"]]\
+                                        [last_test["phy"]]\
+                                            [last_test["area"]].keys())),
+                            "dd-test-disabled": False,
+                            "cl-core-options": generate_options(sorted(
+                                test["core"])),
+                            "cl-core-value": [last_test["core"].upper(), ],
+                            "cl-core-all-value": list(),
+                            "cl-core-all-options": C.CL_ALL_ENABLED,
+                            "cl-framesize-options": generate_options(
+                                sorted(test["frame-size"])),
+                            "cl-framesize-value": \
+                                [last_test["framesize"].upper(), ],
+                            "cl-framesize-all-value": list(),
+                            "cl-framesize-all-options": C.CL_ALL_ENABLED,
+                            "cl-testtype-options": generate_options(sorted(
+                                test["test-type"])),
+                            "cl-testtype-value": \
+                                [last_test["testtype"].upper(), ],
+                            "cl-testtype-all-value": list(),
+                            "cl-testtype-all-options": C.CL_ALL_ENABLED
+                        })
+
+            if trigger_id in ("btn-ctrl-add", "url", "btn-sel-remove",
+                    "cl-ctrl-normalize"):
+                if store_sel:
+                    row_fig_tput, row_fig_lat, row_table, row_btn_dwnld = \
+                        _generate_plotting_area(
+                            graph_iterative(
+                                self.data, store_sel, self.layout, bool(norm)
+                            ),
+                            table_comparison(
+                                self.data, store_sel, bool(norm)
+                            ),
+                            gen_new_url(
+                                parsed_url,
+                                {"store_sel": store_sel, "norm": norm}
+                            )
+                        )
+                    ctrl_panel.set({
+                        "cl-selected-options": list_tests(store_sel)
+                    })
+                else:
+                    row_fig_tput = C.PLACEHOLDER
+                    row_fig_lat = C.PLACEHOLDER
+                    row_table = C.PLACEHOLDER
+                    row_btn_dwnld = C.PLACEHOLDER
+                    row_card_sel_tests = C.STYLE_DISABLED
+                    row_btns_sel_tests = C.STYLE_DISABLED
+                    store_sel = list()
+                    ctrl_panel.set({"cl-selected-options": list()})
+
+            if ctrl_panel.get("cl-core-value") and \
+                    ctrl_panel.get("cl-framesize-value") and \
+                    ctrl_panel.get("cl-testtype-value"):
+                disabled = False
+            else:
+                disabled = True
+            ctrl_panel.set({
+                "btn-add-disabled": disabled,
+                "cl-normalize-value": norm
+            })
+
+            ret_val = [
+                ctrl_panel.panel, store_sel,
+                row_fig_tput, row_fig_lat, row_table, row_btn_dwnld,
+                row_card_sel_tests, row_btns_sel_tests
+            ]
+            ret_val.extend(ctrl_panel.values())
+            return ret_val
+
+        @app.callback(
+            Output("download-data", "data"),
+            State("selected-tests", "data"),
+            Input("btn-download-data", "n_clicks"),
+            prevent_initial_call=True
+        )
+        def _download_data(store_sel, n_clicks):
+            """Download the data
+
+            :param store_sel: List of tests selected by user stored in the
+                browser.
+            :param n_clicks: Number of clicks on the button "Download".
+            :type store_sel: list
+            :type n_clicks: int
+            :returns: dict of data frame content (base64 encoded) and meta data
+                used by the Download component.
+            :rtype: dict
+            """
+
+            if not n_clicks:
+                raise PreventUpdate
+
+            if not store_sel:
+                raise PreventUpdate
+
+            df = pd.DataFrame()
+            for itm in store_sel:
+                sel_data = select_iterative_data(self.data, itm)
+                if sel_data is None:
+                    continue
+                df = pd.concat([df, sel_data], ignore_index=True)
+
+            return dcc.send_data_frame(df.to_csv, C.REPORT_DOWNLOAD_FILE_NAME)
diff --git a/csit.infra.dash/app/cdash/report/layout.yaml b/csit.infra.dash/app/cdash/report/layout.yaml
new file mode 100644
index 0000000000..c4ef13bf8b
--- /dev/null
+++ b/csit.infra.dash/app/cdash/report/layout.yaml
@@ -0,0 +1,127 @@
+plot-throughput:
+  xaxis:
+    title: "Test Cases [Index]"
+    autorange: True
+    fixedrange: False
+    gridcolor: "rgb(230, 230, 230)"
+    linecolor: "rgb(220, 220, 220)"
+    linewidth: 1
+    showgrid: True
+    showline: True
+    showticklabels: True
+    tickcolor: "rgb(220, 220, 220)"
+    tickmode: "array"
+    zeroline: False
+  yaxis:
+    title: "Packet Throughput [pps]"
+    gridcolor: "rgb(230, 230, 230)"
+    hoverformat: ".3s"
+    tickformat: ".3s"
+    linecolor: "rgb(220, 220, 220)"
+    linewidth: 1
+    showgrid: True
+    showline: True
+    showticklabels: True
+    tickcolor: "rgb(220, 220, 220)"
+    zeroline: False
+    range: [0, 50]
+  autosize: False
+  margin:
+    t: 50
+    b: 0
+    l: 80
+    r: 20
+  showlegend: True
+  legend:
+    orientation: "h"
+    font:
+      size: 10
+  width: 700
+  height: 900
+  paper_bgcolor: "#fff"
+  plot_bgcolor: "#fff"
+  hoverlabel:
+    namelength: -1
+
+plot-latency:
+  xaxis:
+    title: "Test Cases [Index]"
+    autorange: True
+    fixedrange: False
+    gridcolor: "rgb(230, 230, 230)"
+    linecolor: "rgb(220, 220, 220)"
+    linewidth: 1
+    showgrid: True
+    showline: True
+    showticklabels: True
+    tickcolor: "rgb(220, 220, 220)"
+    tickmode: "array"
+    zeroline: False
+  yaxis:
+    title: "Average Latency at 50% PDR [us]"
+    gridcolor: "rgb(230, 230, 230)"
+    hoverformat: ".3s"
+    tickformat: ".3s"
+    linecolor: "rgb(220, 220, 220)"
+    linewidth: 1
+    showgrid: True
+    showline: True
+    showticklabels: True
+    tickcolor: "rgb(220, 220, 220)"
+    zeroline: False
+    range: [0, 50]
+  autosize: False
+  margin:
+    t: 50
+    b: 0
+    l: 80
+    r: 20
+  showlegend: True
+  legend:
+    orientation: "h"
+    font:
+      size: 10
+  width: 700
+  height: 900
+  paper_bgcolor: "#fff"
+  plot_bgcolor: "#fff"
+  hoverlabel:
+    namelength: -1
+
+plot-hdrh-latency:
+  showlegend: True
+  legend:
+    traceorder: "normal"
+    orientation: "h"
+    xanchor: "left"
+    yanchor: "top"
+    x: 0
+    y: -0.25
+    bgcolor: "rgba(255, 255, 255, 0)"
+    bordercolor: "rgba(255, 255, 255, 0)"
+  xaxis:
+    type: "log"
+    title: "Percentile [%]"
+    autorange: False
+    fixedrange: True
+    gridcolor: "rgb(230, 230, 230)"
+    linecolor: "rgb(220, 220, 220)"
+    linewidth: 1
+    showgrid: True
+    showline: True
+    showticklabels: True
+    tickcolor: "rgb(220, 220, 220)"
+    tickvals: [1, 2, 1e1, 20, 1e2, 1e3, 1e4, 1e5, 1e6]
+    ticktext: [0, 50, 90, 95, 99, 99.9, 99.99, 99.999, 99.9999]
+  yaxis:
+    title: "One-Way Latency per Direction [us]"
+    gridcolor: "rgb(230, 230, 230)"
+    linecolor: "rgb(220, 220, 220)"
+    linewidth: 1
+    showgrid: True
+    showline: True
+    showticklabels: True
+    tickcolor: "rgb(220, 220, 220)"
+  autosize: True
+  paper_bgcolor: "white"
+  plot_bgcolor: "white"
diff --git a/csit.infra.dash/app/cdash/report/report.py b/csit.infra.dash/app/cdash/report/report.py
new file mode 100644
index 0000000000..28fced433e
--- /dev/null
+++ b/csit.infra.dash/app/cdash/report/report.py
@@ -0,0 +1,49 @@
+# Copyright (c) 2022 Cisco and/or its affiliates.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at:
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Instantiate the Report Dash application.
+"""
+import dash
+
+from ..utils.constants import Constants as C
+from .layout import Layout
+
+
+def init_report(server, releases):
+    """Create a Plotly Dash dashboard.
+
+    :param server: Flask server.
+    :type server: Flask
+    :returns: Dash app server.
+    :rtype: Dash
+    """
+
+    dash_app = dash.Dash(
+        server=server,
+        routes_pathname_prefix=C.REPORT_ROUTES_PATHNAME_PREFIX,
+        external_stylesheets=C.EXTERNAL_STYLESHEETS,
+        title=C.REPORT_TITLE
+    )
+
+    layout = Layout(
+        app=dash_app,
+        releases=releases,
+        html_layout_file=C.HTML_LAYOUT_FILE,
+        graph_layout_file=C.REPORT_GRAPH_LAYOUT_FILE,
+        data_spec_file=C.DATA_SPEC_FILE,
+        tooltip_file=C.TOOLTIP_FILE,
+    )
+    dash_app.index_string = layout.html_layout
+    dash_app.layout = layout.add_content()
+
+    return dash_app.server