6:36 a.m.
From: Ondrej Lichtner <olichtne(a)redhat.com>
This commit reimplements the result serializer so that it doesn't
automatically create a DOM tree out of the supplied results. Instead
results are stored in a nice dictionary hierarchy.
This changed combined with moving the res_data formatting done on slaves
makes it very easy to print the summary. And at the same time be able to
easily create an xml file.
Signed-off-by: Ondrej Lichtner <olichtne(a)redhat.com>
---
lnst-ctl | 2 +-
lnst/Controller/NetTestController.py | 2 +
lnst/Controller/NetTestResultSerializer.py | 265 ++++++++++-------------------
3 files changed, 91 insertions(+), 178 deletions(-)
diff --git a/lnst-ctl b/lnst-ctl
index 55e2dd1..43770b2 100755
--- a/lnst-ctl
+++ b/lnst-ctl
@@ -183,7 +183,7 @@ def main():
if result_path:
result_path = os.path.expanduser(result_path)
handle = open(result_path, "w")
- handle.write(str(res_serializer))
+ handle.write(res_serializer.get_result_xml())
handle.close()
if __name__ == "__main__":
diff --git a/lnst/Controller/NetTestController.py b/lnst/Controller/NetTestController.py
index c7d1fab..8045aa7 100644
--- a/lnst/Controller/NetTestController.py
+++ b/lnst/Controller/NetTestController.py
@@ -495,6 +495,8 @@ class NetTestController:
command["seconds"]),
"msg": "",
"res_data": None}
+ if self._res_serializer:
+ self._res_serializer.add_cmd_result(command, cmd_res)
return cmd_res
machine_id = command["machine"]
diff --git a/lnst/Controller/NetTestResultSerializer.py
b/lnst/Controller/NetTestResultSerializer.py
index d245568..514988b 100644
--- a/lnst/Controller/NetTestResultSerializer.py
+++ b/lnst/Controller/NetTestResultSerializer.py
@@ -44,213 +44,71 @@ def get_node_val(node):
class NetTestResultSerializer:
def __init__(self):
- impl = getDOMImplementation()
- self._dom = impl.createDocument(None, "results", None)
- self._top_el = self._dom.documentElement
- self._cur_recipe_el = None
- self._cur_cmd_seq_el = None
-
- def __str__(self):
- return self._dom.toprettyxml()
+ self._results = []
def add_recipe(self, name):
- recipe_el = self._dom.createElement("recipe")
- recipe_el.setAttribute("name", name)
- recipe_el.setAttribute("result", "FAIL")
- self._top_el.appendChild(recipe_el)
- self._cur_recipe_el = recipe_el
- self._cur_cmd_seq_el = None
+ recipe_result = {"name": name,
+ "result": "FAIL",
+ "tasks": []}
+ self._results.append(recipe_result)
def set_recipe_result(self, result):
if result and result["passed"]:
- self._cur_recipe_el.setAttribute("result", "PASS")
+ self._results[-1]["result"] = "PASS"
else:
- self._cur_recipe_el.setAttribute("result", "FAIL")
+ self._results[-1]["result"] = "FAIL"
+
if "err_msg" in result:
- err_el = self._dom.createElement("error_message")
- err_text = self._dom.createTextNode(result["err_msg"])
- err_el.appendChild(err_text)
- self._cur_recipe_el.appendChild(err_el)
+ self._results[-1]["err_msg"] = result["err_msg"]
def add_task(self):
- cmd_seq_el = self._dom.createElement("command_sequence")
- self._cur_recipe_el.appendChild(cmd_seq_el)
- self._cur_cmd_seq_el = cmd_seq_el
+ self._results[-1]["tasks"].append([])
def add_cmd_result(self, command, cmd_res):
- command_el = self._dom.createElement("command")
- self._cur_cmd_seq_el.appendChild(command_el)
-
- for key in command:
- if key == "options":
- continue
- command_el.setAttribute(key, str(command[key]))
-
- result_el = self._dom.createElement("result")
- command_el.appendChild(result_el)
-
- if cmd_res["passed"]:
- res = "PASS"
- else:
- res = "FAIL"
- result_el.setAttribute("result", res)
-
- if "err_msg" in cmd_res:
- err_el = self._dom.createElement("error_message")
- err_text = self._dom.createTextNode(cmd_res["err_msg"])
- err_el.appendChild(err_text)
- result_el.appendChild(err_el)
-
- if "res_data" in cmd_res:
- res_data_el = self._dom.createElement("result_data")
- serialize_obj(cmd_res["res_data"], self._dom, res_data_el)
- command_el.appendChild(res_data_el)
+ self._results[-1]["tasks"][-1].append((command, cmd_res))
def print_summary(self):
output_pairs = []
- for recipe in self._top_el.getElementsByTagName("recipe"):
- recipe_name = recipe.getAttribute("name")
- recipe_res = recipe.getAttribute("result")
- output_pairs.append((recipe_name, recipe_res))
-
- if recipe_res == "FAIL":
- err_node = None
- for child in recipe.childNodes:
- if child.nodeName == "error_message":
- err_node = child
- break
- if err_node:
- text = get_node_val(err_node)
- output_pairs.append((4*" "+"error message:
"+text, ""))
+ for recipe in self._results:
+ output_pairs.append((recipe["name"], recipe["result"]))
+
+ if recipe["result"] == "FAIL" and \
+ "err_msg" in recipe and recipe["err_msg"] !=
"":
+ err_msg = recipe["err_msg"]
+ output_pairs.append((4*" " + "error message:" +
err_msg, ""))
seq_num = 1
- for cmd_seq in recipe.getElementsByTagName("command_sequence"):
- command_sequence = 4*" "+"task: %s" % seq_num
- output_pairs.append((command_sequence, ""))
+ for task in recipe["tasks"]:
+ output_pairs.append((4*" " + "task: %s" %
seq_num,""))
- seq_num = seq_num + 1
+ seq_num += 1
- for command in cmd_seq.getElementsByTagName("command"):
- self._format_command(command, output_pairs)
+ for cmd, cmd_res in task:
+ self._format_command(cmd, cmd_res, output_pairs)
self._print_pairs(output_pairs)
- def _format_command(self, command, output_pairs):
- cmd_type = command.getAttribute("type")
- if cmd_type == "test":
- self._format_test_command(command, output_pairs)
- elif cmd_type == "wait":
- self._format_wait_command(command, output_pairs)
- elif cmd_type == "intr":
- self._format_intr_command(command, output_pairs)
- elif cmd_type == "kill":
- self._format_kill_command(command, output_pairs)
- elif cmd_type == "ctl_wait":
- self._format_ctl_wait_command(command, output_pairs)
- elif cmd_type == "exec":
- self._format_exec_command(command, output_pairs)
- elif cmd_type == "config":
- self._format_config(command, output_pairs)
-
- result_node = command.getElementsByTagName("result")[0]
- cmd_res = result_node.getAttribute("result")
-
- if cmd_res == "FAIL":
- err_node = result_node.getElementsByTagName("error_message")
- if len(err_node) != 0:
- err_node = err_node[0]
- text = get_node_val(err_node)
- output_pairs.append((12*" "+"error message: "+text,
""))
-
- def _format_test_command(self, command, output_pairs):
- result_node = command.getElementsByTagName("result")[0]
- cmd_res = result_node.getAttribute("result")
-
- cmd_val = command.getAttribute("module")
- cmd_type = command.getAttribute("type")
- if command.hasAttribute("bg_id"):
- bg_id = " bg_id: %s" % command.getAttribute("bg_id")
- else:
- bg_id = ""
- cmd = 8*" "+"%-14s%s%s" %(cmd_type, cmd_val, bg_id)
- output_pairs.append((cmd, cmd_res))
-
- def _format_wait_command(self, command, output_pairs):
- result_node = command.getElementsByTagName("result")[0]
- cmd_res = result_node.getAttribute("result")
-
- cmd_val = command.getAttribute("proc_id")
- cmd_type = command.getAttribute("type")
- if command.hasAttribute("bg_id"):
- bg_id = " bg_id: %s" % command.getAttribute("bg_id")
+ def _format_command(self, command, cmd_res, output_pairs):
+ if cmd_res["passed"]:
+ res = "PASS"
else:
- bg_id = ""
- cmd = 8*" "+"%-13s id: %s%s" %(cmd_type, cmd_val, bg_id)
- output_pairs.append((cmd, cmd_res))
-
- def _format_intr_command(self, command, output_pairs):
- self._format_wait_command(command, output_pairs)
-
- def _format_kill_command(self, command, output_pairs):
- self._format_wait_command(command, output_pairs)
+ res = "FAIL"
+ output_pairs.append((8*" " + cmd_res["res_header"], res))
- def _format_exec_command(self, command, output_pairs):
- result_node = command.getElementsByTagName("result")[0]
- cmd_res = result_node.getAttribute("result")
+ if "msg" in cmd_res and cmd_res["msg"] != "":
+ output_pairs.append((12*" " + "message: " +
cmd_res["msg"], ""))
- cmd_val = command.getAttribute("command")
- cmd_type = command.getAttribute("type")
- if command.hasAttribute("bg_id"):
- bg_id = " bg_id: %s" % command.getAttribute("bg_id")
- else:
- bg_id = ""
- cmd = 8*" "+"%-14s%s%s" %(cmd_type, cmd_val, bg_id)
- output_pairs.append((cmd, cmd_res))
-
- def _format_ctl_wait_command(self, command, output_pairs):
- result_node = command.getElementsByTagName("result")[0]
- cmd_res = result_node.getAttribute("result")
-
- cmd_val = command.getAttribute("seconds")
- cmd_type = command.getAttribute("type")
- cmd = 8*" "+"%-14s%ss" %(cmd_type, cmd_val)
- output_pairs.append((cmd, cmd_res))
-
- def _format_config(self, command, output_pairs):
- result_node = command.getElementsByTagName("result")[0]
- cmd_res = result_node.getAttribute("result")
-
- cmd_type = command.getAttribute("type")
- if command.hasAttribute("bg_id"):
- bg_id = " bg_id: %s" % command.getAttribute("bg_id")
- else:
- bg_id = ""
- cmd = 8*" "+"%-14s%s" %(cmd_type, bg_id)
- output_pairs.append((cmd, cmd_res))
-
- result_data_nodes = command.getElementsByTagName("result_data")
- if len(result_data_nodes) != 0:
- result_data_node = result_data_nodes[0]
- options_nodes = result_data_node.getElementsByTagName("options")
- for options_node in options_nodes:
- for option in
options_node.getElementsByTagName("options_item"):
- previous_node =
option.getElementsByTagName("previous_val")[0]
- current_node =
option.getElementsByTagName("current_val")[0]
- name_node = option.getElementsByTagName("name")[0]
- previous_val = get_node_val(previous_node)
- current_val = get_node_val(current_node)
- name = get_node_val(name_node)
- opt_left = 12*" "+"%s" % name
- opt_right = "previous: %s current: %s" \
- % (previous_val, current_val)
- output_pairs.append((opt_left, opt_right))
+ if "report" in cmd_res and cmd_res["report"] !=
"":
+ for line in cmd_res["report"].splitlines():
+ out = decorate_with_preset(line, "faded")
+ output_pairs.append((12*" " + out, ""))
def _print_pairs(self, output_pairs):
max_left = 0
max_right = 0
for left, right in output_pairs:
- if len(left) > max_left and right != "":
+ if len(left) > max_left:
max_left = len(left)
if len(right) > max_right:
max_right = len(right)
@@ -282,3 +140,56 @@ class NetTestResultSerializer:
output = left + " "
logging.info(" %s " % output)
logging.info("="*(full_length))
+
+ def get_result_xml(self):
+ impl = getDOMImplementation()
+ doc = impl.createDocument(None, "results", None)
+ top_el = doc.documentElement
+
+ for recipe in self._results:
+ recipe_el = doc.createElement("recipe")
+ recipe_el.setAttribute("name", recipe["name"])
+ recipe_el.setAttribute("result", recipe["result"])
+
+ top_el.appendChild(recipe_el)
+
+ if recipe["result"] == "FAIL" and \
+ "err_msg" in recipe and recipe["err_msg"] !=
"":
+ err_el = doc.createElement("error_message")
+ err_text = doc.createTextNode(recipe["err_msg"])
+ err_el.appendChild(err_text)
+ recipe_el.appendChild(err_el)
+
+ for task in recipe["tasks"]:
+ cmd_seq_el = doc.createElement("command_sequence")
+ recipe_el.appendChild(cmd_seq_el)
+
+ for cmd, cmd_res in task:
+ command_el = doc.createElement("command")
+ cmd_seq_el.appendChild(command_el)
+
+ for key in cmd:
+ if key == "options":
+ continue
+ command_el.setAttribute(key, str(cmd[key]))
+
+ result_el = doc.createElement("result")
+ command_el.appendChild(result_el)
+
+ if cmd_res["passed"]:
+ res = "PASS"
+ else:
+ res = "FAIL"
+ result_el.setAttribute("result", res)
+
+ if "msg" in cmd_res and cmd_res["msg"]:
+ msg_el = doc.createElement("message")
+ msg_text = doc.createTextNode(cmd_res["msg"])
+ msg_el.appendChild(msg_text)
+ result_el.appendChild(msg_el)
+
+ if "res_data" in cmd_res and
cmd_res["res_data"]:
+ res_data_el = doc.createElement("result_data")
+ serialize_obj(cmd_res["res_data"], doc, res_data_el)
+ command_el.appendChild(res_data_el)
+ return doc.toprettyxml()
--
1.8.3.1