def test_merge_atomic_actions(self):
atomic_merger = utils.AtomicMerger(self.atomic)
atomic_actions = [{"name": "foo", "started_at": 0, "finished_at": 1.1}]
self.assertEqual(collections.OrderedDict([("foo", 1.1)]),
atomic_merger.merge_atomic_actions(atomic_actions))
atomic_actions = [{
"name": "foo",
"started_at": 0,
"finished_at": 1.1
}, {
"name": "bar",
"started_at": 1.1,
"finished_at": 2.3
}]
self.assertEqual(collections.OrderedDict([("foo", 1.1)]),
atomic_merger.merge_atomic_actions(atomic_actions))
atomic_actions = [{
"name": "foo",
"started_at": 0,
"finished_at": 1.1
}, {
"name": "bar",
"started_at": 1.1,
"finished_at": 2.3
}, {
"name": "bar",
"started_at": 2.3,
"finished_at": 3.5
}]
self.assertEqual(
collections.OrderedDict([("foo", 1.1), ("bar (x2)", 2.4)]),
atomic_merger.merge_atomic_actions(atomic_actions))
def __init__(self, workload_info):
super(AtomicHistogramChart, self).__init__(workload_info)
atomics = self._workload["statistics"]["atomics"]
atomic_merger = utils.AtomicMerger(atomics)
for i, name in enumerate(atomics):
value = atomics[name]
self._data[atomic_merger.get_merged_name(name)] = {
"views": self._init_views(value["min_duration"],
value["max_duration"]),
"disabled": i}
def _merge_atomic_actions(self, atomic_actions):
atomic_merger = utils.AtomicMerger(
self._workload["statistics"]["atomics"])
return atomic_merger.merge_atomic_actions(
atomic_actions)
def _get_atomic_names(self):
atomic_merger = utils.AtomicMerger(
self._workload["statistics"]["atomics"])
return atomic_merger.get_merged_names()
def detailed(self, api, task_id=None, iterations_data=False):
"""Print detailed information about given task.
:param task_id: str, task uuid
:param iterations_data: bool, include results for each iteration
"""
task = api.task.get_detailed(task_id=task_id, extended_results=True)
if not task:
print("The task %s can not be found" % task_id)
return 1
print()
print("-" * 80)
print(
_("Task %(task_id)s: %(status)s") % {
"task_id": task_id,
"status": task["status"]
})
if task["status"] == consts.TaskStatus.CRASHED or task["status"] == (
consts.TaskStatus.VALIDATION_FAILED):
print("-" * 80)
verification = yaml.safe_load(task["verification_log"])
if logging.is_debug():
print(yaml.safe_load(verification["trace"]))
else:
print(verification["etype"])
print(verification["msg"])
print(
_("\nFor more details run:\nrally -d task detailed %s") %
task["uuid"])
return 0
elif task["status"] not in [
consts.TaskStatus.FINISHED, consts.TaskStatus.ABORTED
]:
print("-" * 80)
print(
_("\nThe task %s marked as '%s'. Results "
"available when it is '%s'.") %
(task_id, task["status"], consts.TaskStatus.FINISHED))
return 0
for result in task["results"]:
key = result["key"]
print("-" * 80)
print()
print("test scenario %s" % key["name"])
print("args position %s" % key["pos"])
print("args values:")
print(json.dumps(key["kw"], indent=2))
print()
iterations = []
iterations_headers = ["iteration", "duration"]
iterations_actions = []
output = []
task_errors = []
if iterations_data:
atomic_merger = putils.AtomicMerger(result["info"]["atomic"])
atomic_names = atomic_merger.get_merged_names()
for i, atomic_name in enumerate(atomic_names, 1):
action = "%i. %s" % (i, atomic_name)
iterations_headers.append(action)
iterations_actions.append((atomic_name, action))
for idx, itr in enumerate(result["iterations"], 1):
if iterations_data:
row = {"iteration": idx, "duration": itr["duration"]}
for name, action in iterations_actions:
atomic_actions = (atomic_merger.merge_atomic_actions(
itr["atomic_actions"]))
row[action] = atomic_actions.get(name, 0)
iterations.append(row)
if "output" in itr:
iteration_output = itr["output"]
else:
iteration_output = {"additive": [], "complete": []}
# NOTE(amaretskiy): "scenario_output" is supported
# for backward compatibility
if ("scenario_output" in itr
and itr["scenario_output"]["data"]):
iteration_output["additive"].append({
"data":
itr["scenario_output"]["data"].items(),
"title":
"Scenario output",
"description":
"",
"chart_plugin":
"StackedArea"
})
for idx, additive in enumerate(iteration_output["additive"]):
if len(output) <= idx + 1:
output_table = plot.charts.OutputStatsTable(
result["info"], title=additive["title"])
output.append(output_table)
output[idx].add_iteration(additive["data"])
if itr.get("error"):
task_errors.append(TaskCommands._format_task_error(itr))
self._print_task_errors(task_id, task_errors)
cols = plot.charts.MainStatsTable.columns
float_cols = result["info"]["stat"]["cols"][1:7]
formatters = dict(
zip(float_cols, [
cliutils.pretty_float_formatter(col, 3)
for col in float_cols
]))
rows = [dict(zip(cols, r)) for r in result["info"]["stat"]["rows"]]
cliutils.print_list(rows,
fields=cols,
formatters=formatters,
table_label="Response Times (sec)",
sortby_index=None)
print()
if iterations_data:
formatters = dict(
zip(iterations_headers[1:], [
cliutils.pretty_float_formatter(col, 3)
for col in iterations_headers[1:]
]))
cliutils.print_list(iterations,
fields=iterations_headers,
table_label="Atomics per iteration",
formatters=formatters)
print()
if output:
cols = plot.charts.OutputStatsTable.columns
float_cols = cols[1:7]
formatters = dict(
zip(float_cols, [
cliutils.pretty_float_formatter(col, 3)
for col in float_cols
]))
for out in output:
data = out.render()
rows = [dict(zip(cols, r)) for r in data["data"]["rows"]]
if rows:
# NOTE(amaretskiy): print title explicitly because
# prettytable fails if title length is too long
print(data["title"])
cliutils.print_list(rows,
fields=cols,
formatters=formatters)
print()
print(
_("Load duration: %s") %
rutils.format_float_to_str(result["info"]["load_duration"]))
print(
_("Full duration: %s") %
rutils.format_float_to_str(result["info"]["full_duration"]))
print("\nHINTS:")
print(_("* To plot HTML graphics with this data, run:"))
print("\trally task report %s --out output.html\n" % task["uuid"])
print(_("* To generate a JUnit report, run:"))
print("\trally task report %s --junit --out output.xml\n" %
task["uuid"])
print(_("* To get raw JSON output of task results, run:"))
print("\trally task results %s\n" % task["uuid"])
def _merge_atomic_actions(self, atomic_actions):
atomic_merger = utils.AtomicMerger(self._workload_info["atomic"])
return atomic_merger.merge_atomic_actions(atomic_actions)
def _get_atomic_names(self):
atomic_merger = utils.AtomicMerger(self._workload_info["atomic"])
return atomic_merger.get_merged_names()
def test_get_merged_name(self):
atomic_merger = utils.AtomicMerger(self.atomic)
self.assertEqual("foo", atomic_merger.get_merged_name("foo"))
self.assertEqual("bar (x2)", atomic_merger.get_merged_name("bar"))
def test_get_merged_names(self):
atomic_merger = utils.AtomicMerger(self.atomic)
self.assertEqual(["foo", "bar (x2)"], atomic_merger.get_merged_names())
