1 # Copyright (c) 2023 Cisco and/or its affiliates.
2 # Licensed under the Apache License, Version 2.0 (the "License");
3 # you may not use this file except in compliance with the License.
4 # You may obtain a copy of the License at:
6 # http://www.apache.org/licenses/LICENSE-2.0
8 # Unless required by applicable law or agreed to in writing, software
9 # distributed under the License is distributed on an "AS IS" BASIS,
10 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 # See the License for the specific language governing permissions and
12 # limitations under the License.
14 """Plotly Dash HTML layout override.
19 import dash_bootstrap_components as dbc
21 from flask import Flask
24 from dash import callback_context, no_update
25 from dash import Input, Output, State
26 from dash.exceptions import PreventUpdate
27 from yaml import load, FullLoader, YAMLError
29 from ..utils.constants import Constants as C
30 from ..utils.control_panel import ControlPanel
31 from ..utils.utils import show_tooltip, gen_new_url, get_ttypes, get_cadences, \
32 get_test_beds, get_job, generate_options, set_job_params
33 from ..utils.url_processing import url_decode
34 from .graphs import graph_statistics, select_data
38 """The layout of the dash app and the callbacks.
44 data_stats: pd.DataFrame,
45 data_trending: pd.DataFrame,
46 html_layout_file: str,
47 graph_layout_file: str,
51 - save the input parameters,
52 - read and pre-process the data,
53 - prepare data for the control panel,
54 - read HTML layout file,
55 - read tooltips from the tooltip file.
57 :param app: Flask application running the dash application.
58 :param data_stats: Pandas dataframe with staistical data.
59 :param data_trending: Pandas dataframe with trending data.
60 :param html_layout_file: Path and name of the file specifying the HTML
61 layout of the dash application.
62 :param graph_layout_file: Path and name of the file with layout of
64 :param tooltip_file: Path and name of the yaml file specifying the
67 :type data_stats: pandas.DataFrame
68 :type data_trending: pandas.DataFrame
69 :type html_layout_file: str
70 :type graph_layout_file: str
71 :type tooltip_file: str
76 self._html_layout_file = html_layout_file
77 self._graph_layout_file = graph_layout_file
78 self._tooltip_file = tooltip_file
80 # Pre-process the data:
81 data_stats = data_stats[~data_stats.job.str.contains("-verify-")]
82 data_stats = data_stats[~data_stats.job.str.contains("-coverage-")]
83 data_stats = data_stats[~data_stats.job.str.contains("-iterative-")]
84 data_stats = data_stats[["job", "build", "start_time", "duration"]]
86 jobs = sorted(list(data_stats["job"].unique()))
95 lst_job = job.split("-")
96 d_job_info["job"].append(job)
97 d_job_info["dut"].append(lst_job[1])
98 d_job_info["ttype"].append(lst_job[3])
99 d_job_info["cadence"].append(lst_job[4])
100 d_job_info["tbed"].append("-".join(lst_job[-2:]))
101 self._job_info = pd.DataFrame.from_dict(d_job_info)
103 self._default = set_job_params(self._job_info, C.STATS_DEFAULT_JOB)
109 "dut_version": list(),
116 df_job = data_trending.loc[(data_trending["job"] == job)]
117 builds = df_job["build"].unique()
119 df_build = df_job.loc[(df_job["build"] == build)]
120 tst_info["job"].append(job)
121 tst_info["build"].append(build)
122 tst_info["dut_type"].append(df_build["dut_type"].iloc[-1])
123 tst_info["dut_version"].append(df_build["dut_version"].iloc[-1])
124 tst_info["hosts"].append(df_build["hosts"].iloc[-1])
126 passed = df_build.value_counts(subset="passed")[True]
130 failed = df_build.value_counts(subset="passed")[False]
131 failed_tests = df_build.loc[(df_build["passed"] == False)]\
132 ["test_id"].to_list()
134 for tst in failed_tests:
135 lst_tst = tst.split(".")
136 suite = lst_tst[-2].replace("2n1l-", "").\
137 replace("1n1l-", "").replace("2n-", "")
138 l_failed.append(f"{suite.split('-')[0]}-{lst_tst[-1]}")
142 tst_info["passed"].append(passed)
143 tst_info["failed"].append(failed)
144 tst_info["lst_failed"].append(sorted(l_failed))
146 self._data = data_stats.merge(pd.DataFrame.from_dict(tst_info))
149 self._html_layout = str()
150 self._graph_layout = None
151 self._tooltips = dict()
154 with open(self._html_layout_file, "r") as file_read:
155 self._html_layout = file_read.read()
156 except IOError as err:
158 f"Not possible to open the file {self._html_layout_file}\n{err}"
162 with open(self._graph_layout_file, "r") as file_read:
163 self._graph_layout = load(file_read, Loader=FullLoader)
164 except IOError as err:
166 f"Not possible to open the file {self._graph_layout_file}\n"
169 except YAMLError as err:
171 f"An error occurred while parsing the specification file "
172 f"{self._graph_layout_file}\n{err}"
176 with open(self._tooltip_file, "r") as file_read:
177 self._tooltips = load(file_read, Loader=FullLoader)
178 except IOError as err:
180 f"Not possible to open the file {self._tooltip_file}\n{err}"
182 except YAMLError as err:
184 f"An error occurred while parsing the specification file "
185 f"{self._tooltip_file}\n{err}"
188 # Control panel partameters and their default values.
190 "ri-ttypes-options": self._default["ttypes"],
191 "ri-cadences-options": self._default["cadences"],
192 "dd-tbeds-options": self._default["tbeds"],
193 "ri-duts-value": self._default["dut"],
194 "ri-ttypes-value": self._default["ttype"],
195 "ri-cadences-value": self._default["cadence"],
196 "dd-tbeds-value": self._default["tbed"],
197 "al-job-children": html.A(
198 self._default["job"],
199 href=f"{C.URL_JENKINS}{self._default['job']}",
205 if self._app is not None and hasattr(self, "callbacks"):
206 self.callbacks(self._app)
209 def html_layout(self) -> dict:
210 return self._html_layout
212 def add_content(self):
213 """Top level method which generated the web page.
216 - Store for user input data,
218 - Main area with control panel and ploting area.
220 If no HTML layout is provided, an error message is displayed instead.
222 :returns: The HTML div with the whole page.
231 dcc.Store(id="control-panel"),
232 dcc.Location(id="url", refresh=False),
243 id="offcanvas-metadata",
244 title="Detailed Information",
248 dbc.Row(id="row-metadata")
256 self._add_ctrl_col(),
257 self._add_plotting_col()
262 id="offcanvas-documentation",
263 title="Documentation",
266 children=html.Iframe(
267 src=C.URL_DOC_TRENDING,
287 def _add_navbar(self):
288 """Add nav element with navigation panel. It is placed on the top.
290 :returns: Navigation bar.
291 :rtype: dbc.NavbarSimple
293 return dbc.NavbarSimple(
294 id="navbarsimple-main",
296 dbc.NavItem(dbc.NavLink(
301 dbc.NavItem(dbc.NavLink(
306 dbc.NavItem(dbc.NavLink(
312 dbc.NavItem(dbc.NavLink(
314 id="btn-documentation",
319 brand_external_link=True,
324 def _add_ctrl_col(self) -> dbc.Col:
325 """Add column with controls. It is placed on the left side.
327 :returns: Column with the control panel.
332 children=self._add_ctrl_panel(),
333 className="sticky-top"
337 def _add_plotting_col(self) -> dbc.Col:
338 """Add column with plots and tables. It is placed on the right side.
340 :returns: Column with tables.
344 id="col-plotting-area",
350 class_name="g-0 p-0",
361 def _add_ctrl_panel(self) -> dbc.Row:
362 """Add control panel.
364 :returns: Control panel.
369 class_name="g-0 p-1",
374 children=show_tooltip(
383 value=self._default["dut"],
384 options=self._default["duts"],
385 class_name="form-control"
393 class_name="g-0 p-1",
398 children=show_tooltip(
407 value=self._default["ttype"],
408 options=self._default["ttypes"],
409 class_name="form-control"
417 class_name="g-0 p-1",
422 children=show_tooltip(
431 value=self._default["cadence"],
432 options=self._default["cadences"],
433 class_name="form-control"
441 class_name="g-0 p-1",
446 children=show_tooltip(
454 placeholder="Select a test bed...",
455 value=self._default["tbed"],
456 options=self._default["tbeds"]
464 class_name="g-0 p-1",
469 children=self._default["job"]
475 def _get_plotting_area(
480 """Generate the plotting area with all its content.
482 :param job: The job which data will be displayed.
483 :param url: URL to be displayed in the modal window.
486 :returns: List of rows with elements to be displayed in the plotting
491 figs = graph_statistics(self._data, job, self._graph_layout)
498 id="row-graph-passed",
499 class_name="g-0 p-1",
508 id="row-graph-duration",
509 class_name="g-0 p-1",
527 "text-transform": "none",
528 "padding": "0rem 1rem"
533 dbc.ModalHeader(dbc.ModalTitle("URL")),
542 id="plot-btn-download",
543 children="Download Data",
547 "text-transform": "none",
548 "padding": "0rem 1rem"
551 dcc.Download(id="download-stats-data")
554 "d-grid gap-0 d-md-flex justify-content-md-end"
561 def callbacks(self, app):
562 """Callbacks for the whole application.
564 :param app: The application.
569 Output("control-panel", "data"), # Store
570 Output("plotting-area", "children"),
571 Output("ri-ttypes", "options"),
572 Output("ri-cadences", "options"),
573 Output("dd-tbeds", "options"),
574 Output("ri-duts", "value"),
575 Output("ri-ttypes", "value"),
576 Output("ri-cadences", "value"),
577 Output("dd-tbeds", "value"),
578 Output("al-job", "children"),
579 State("control-panel", "data"), # Store
580 Input("ri-duts", "value"),
581 Input("ri-ttypes", "value"),
582 Input("ri-cadences", "value"),
583 Input("dd-tbeds", "value"),
586 def _update_ctrl_panel(cp_data: dict, dut: str, ttype: str, cadence:str,
587 tbed: str, href: str) -> tuple:
588 """Update the application when the event is detected.
590 :param cp_data: Current status of the control panel stored in
592 :param dut: Input - DUT name.
593 :param ttype: Input - Test type.
594 :param cadence: Input - The cadence of the job.
595 :param tbed: Input - The test bed.
596 :param href: Input - The URL provided by the browser.
603 :returns: New values for web page elements.
607 ctrl_panel = ControlPanel(self._cp_default, cp_data)
610 parsed_url = url_decode(href)
612 url_params = parsed_url["params"]
616 trigger_id = callback_context.triggered[0]["prop_id"].split(".")[0]
617 if trigger_id == "ri-duts":
618 ttype_opts = generate_options(get_ttypes(self._job_info, dut))
619 ttype_val = ttype_opts[0]["value"]
620 cad_opts = generate_options(get_cadences(
621 self._job_info, dut, ttype_val))
622 cad_val = cad_opts[0]["value"]
623 tbed_opts = generate_options(get_test_beds(
624 self._job_info, dut, ttype_val, cad_val))
625 tbed_val = tbed_opts[0]["value"]
627 "ri-duts-value": dut,
628 "ri-ttypes-options": ttype_opts,
629 "ri-ttypes-value": ttype_val,
630 "ri-cadences-options": cad_opts,
631 "ri-cadences-value": cad_val,
632 "dd-tbeds-options": tbed_opts,
633 "dd-tbeds-value": tbed_val
635 elif trigger_id == "ri-ttypes":
636 cad_opts = generate_options(get_cadences(
637 self._job_info, ctrl_panel.get("ri-duts-value"), ttype))
638 cad_val = cad_opts[0]["value"]
639 tbed_opts = generate_options(get_test_beds(
640 self._job_info, ctrl_panel.get("ri-duts-value"), ttype,
642 tbed_val = tbed_opts[0]["value"]
644 "ri-ttypes-value": ttype,
645 "ri-cadences-options": cad_opts,
646 "ri-cadences-value": cad_val,
647 "dd-tbeds-options": tbed_opts,
648 "dd-tbeds-value": tbed_val
650 elif trigger_id == "ri-cadences":
651 tbed_opts = generate_options(get_test_beds(
652 self._job_info, ctrl_panel.get("ri-duts-value"),
653 ctrl_panel.get("ri-ttypes-value"), cadence))
654 tbed_val = tbed_opts[0]["value"]
656 "ri-cadences-value": cadence,
657 "dd-tbeds-options": tbed_opts,
658 "dd-tbeds-value": tbed_val
660 elif trigger_id == "dd-tbeds":
662 "dd-tbeds-value": tbed
664 elif trigger_id == "url":
666 new_job = url_params.get("job", list())[0]
668 job_params = set_job_params(self._job_info, new_job)
669 ctrl_panel = ControlPanel(
671 "ri-ttypes-options": job_params["ttypes"],
672 "ri-cadences-options": job_params["cadences"],
673 "dd-tbeds-options": job_params["tbeds"],
674 "ri-duts-value": job_params["dut"],
675 "ri-ttypes-value": job_params["ttype"],
676 "ri-cadences-value": job_params["cadence"],
677 "dd-tbeds-value": job_params["tbed"],
678 "al-job-children": html.A(
679 self._default["job"],
682 f"{self._default['job']}"
690 ctrl_panel = ControlPanel(self._cp_default, cp_data)
694 ctrl_panel.get("ri-duts-value"),
695 ctrl_panel.get("ri-ttypes-value"),
696 ctrl_panel.get("ri-cadences-value"),
697 ctrl_panel.get("dd-tbeds-value")
702 "al-job-children": html.A(
704 href=f"{C.URL_JENKINS}{job}",
709 plotting_area = self._get_plotting_area(
711 gen_new_url(parsed_url, {"job": job})
718 ret_val.extend(ctrl_panel.values)
722 Output("plot-mod-url", "is_open"),
723 [Input("plot-btn-url", "n_clicks")],
724 [State("plot-mod-url", "is_open")],
726 def toggle_plot_mod_url(n, is_open):
727 """Toggle the modal window with url.
734 Output("download-stats-data", "data"),
735 State("control-panel", "data"), # Store
736 Input("plot-btn-download", "n_clicks"),
737 prevent_initial_call=True
739 def _download_data(cp_data: dict, n_clicks: int):
742 :param cp_data: Current status of the control panel stored in
744 :param n_clicks: Number of clicks on the button "Download".
747 :returns: dict of data frame content (base64 encoded) and meta data
748 used by the Download component.
754 ctrl_panel = ControlPanel(self._cp_default, cp_data)
758 ctrl_panel.get("ri-duts-value"),
759 ctrl_panel.get("ri-ttypes-value"),
760 ctrl_panel.get("ri-cadences-value"),
761 ctrl_panel.get("dd-tbeds-value")
764 data = select_data(self._data, job)
765 data = data.drop(columns=["job", ])
767 return dcc.send_data_frame(
768 data.T.to_csv, f"{job}-{C.STATS_DOWNLOAD_FILE_NAME}")
771 Output("row-metadata", "children"),
772 Output("offcanvas-metadata", "is_open"),
773 Input("graph-passed", "clickData"),
774 Input("graph-duration", "clickData"),
775 prevent_initial_call=True
777 def _show_metadata_from_graphs(
778 passed_data: dict, duration_data: dict) -> tuple:
779 """Generates the data for the offcanvas displayed when a particular
780 point in a graph is clicked on.
782 :param passed_data: The data from the clicked point in the graph
783 displaying the pass/fail data.
784 :param duration_data: The data from the clicked point in the graph
785 displaying the duration data.
786 :type passed_data: dict
787 :type duration data: dict
788 :returns: The data to be displayed on the offcanvas (job statistics
789 and the list of failed tests) and the information to show the
791 :rtype: tuple(list, bool)
794 if not (passed_data or duration_data):
799 title = "Job Statistics"
800 trigger_id = callback_context.triggered[0]["prop_id"].split(".")[0]
801 if trigger_id == "graph-passed":
802 graph_data = passed_data["points"][0].get("hovertext", "")
803 elif trigger_id == "graph-duration":
804 graph_data = duration_data["points"][0].get("text", "")
806 lst_graph_data = graph_data.split("<br>")
808 # Prepare list of failed tests:
811 for itm in lst_graph_data:
812 if "csit-ref:" in itm:
813 job, build = itm.split(" ")[-1].split("/")
816 fail_tests = self._data.loc[
817 (self._data["job"] == job) &
818 (self._data["build"] == build)
819 ]["lst_failed"].values[0]
825 # Create the content of the offcanvas:
826 list_group_items = list()
827 for itm in lst_graph_data:
828 lst_itm = itm.split(": ")
829 if lst_itm[0] == "csit-ref":
830 list_group_item = dbc.ListGroupItem([
831 dbc.Badge(lst_itm[0]),
834 href=f"{C.URL_JENKINS}{lst_itm[1]}",
839 list_group_item = dbc.ListGroupItem([
840 dbc.Badge(lst_itm[0]),
843 list_group_items.append(list_group_item)
846 class_name="gy-2 p-0",
850 target_id="metadata",
852 style={"display": "inline-block"}
857 dbc.ListGroup(list_group_items, flush=True),
865 if fail_tests is not None:
868 class_name="gy-2 p-0",
871 f"List of Failed Tests ({len(fail_tests)})"
876 children=[dbc.ListGroup(
878 dbc.ListGroupItem(x) \
890 return metadata, open_canvas
893 Output("offcanvas-documentation", "is_open"),
894 Input("btn-documentation", "n_clicks"),
895 State("offcanvas-documentation", "is_open")
897 def toggle_offcanvas_documentation(n_clicks, is_open):