def test_not_verbose(
self, mock_get_cached_list_of_running_tasks_from_frameworks):
mock_task1 = Task(master=mock.Mock(),
items={"id": "fake--service.fake--instance.1"})
mock_task2 = Task(master=mock.Mock(),
items={"id": "fake--service.fake--instance.2"})
mock_get_cached_list_of_running_tasks_from_frameworks.return_value = [
mock_task1,
mock_task2,
]
mesos_status = instance.marathon_mesos_status("fake_service",
"fake_instance",
verbose=0)
assert mesos_status == {"running_task_count": 2}
async def get_mesos_running_task_dict(
task: Task, num_tail_lines: int
) -> MutableMapping[str, Any]:
short_hostname_future = asyncio.ensure_future(
results_or_unknown(get_short_hostname_from_task(task))
)
mem_limit_future = asyncio.ensure_future(_task_result_or_error(task.mem_limit()))
rss_future = asyncio.ensure_future(_task_result_or_error(task.rss()))
cpu_shares_future = asyncio.ensure_future(
_task_result_or_error(get_cpu_shares(task))
)
cpu_time_future = asyncio.ensure_future(_task_result_or_error(task.cpu_time()))
futures = [
short_hostname_future,
mem_limit_future,
rss_future,
cpu_shares_future,
cpu_time_future,
]
if num_tail_lines > 0:
tail_lines_future = asyncio.ensure_future(
get_tail_lines_for_mesos_task(task, get_short_task_id, num_tail_lines)
)
futures.append(tail_lines_future)
else:
tail_lines_future = None
await asyncio.wait(futures)
task_dict = {
"id": get_short_task_id(task["id"]),
"hostname": short_hostname_future.result(),
"mem_limit": mem_limit_future.result(),
"rss": rss_future.result(),
"cpu_shares": cpu_shares_future.result(),
"cpu_used_seconds": cpu_time_future.result(),
"tail_lines": tail_lines_future.result() if tail_lines_future else {},
}
task_start_time = get_first_status_timestamp(task)
if task_start_time is not None:
task_dict["deployed_timestamp"] = task_start_time
current_time = int(datetime.datetime.now().strftime("%s"))
task_dict["duration_seconds"] = current_time - round(task_start_time)
return task_dict
def mock_task(self):
mock_slave = MesosSlave(config=mock.Mock(), items={"hostname": "abc.def"})
mock_task = Task(
master=mock.Mock(),
items={
"id": "fake--service.fake--instance.2",
"state": "TASK_LOST",
"statuses": [{"timestamp": 1560888200}],
},
)
with asynctest.patch.object(mock_task, "slave", autospec=True):
mock_task.slave.return_value = mock_slave
yield mock_task
def test_verbose(self,
mock_get_cached_list_of_running_tasks_from_frameworks):
with asynctest.patch(
"paasta_tools.api.views.instance.get_cached_list_of_not_running_tasks_from_frameworks",
autospec=True,
) as mock_get_cached_list_of_not_running_tasks_from_frameworks, asynctest.patch(
"paasta_tools.api.views.instance.get_mesos_running_task_dict",
autospec=True
) as mock_get_mesos_running_task_dict, asynctest.patch(
"paasta_tools.api.views.instance.get_mesos_non_running_task_dict",
autospec=True,
) as mock_get_mesos_non_running_task_dict:
running_task_1 = Task(
master=mock.Mock(),
items={"id": "fake--service.fake--instance.1"})
running_task_2 = Task(
master=mock.Mock(),
items={"id": "fake--service.fake--instance.2"})
non_running_task = Task(
master=mock.Mock(),
items={
"id": "fake--service.fake--instance.3",
"statuses": [{
"timestamp": 1560888500
}],
},
)
mock_get_cached_list_of_running_tasks_from_frameworks.return_value = [
running_task_1,
running_task_2,
]
mock_get_cached_list_of_not_running_tasks_from_frameworks.return_value = [
non_running_task
]
mock_get_mesos_running_task_dict.side_effect = lambda task, nlines: {
"id": task["id"]
}
mock_get_mesos_non_running_task_dict.side_effect = lambda task, nlines: {
"id": task["id"],
"state": "TASK_LOST",
}
mesos_status = instance.marathon_mesos_status("fake_service",
"fake_instance",
verbose=2)
assert mesos_status == {
"running_task_count":
2,
"running_tasks": [
{
"id": "fake--service.fake--instance.1"
},
{
"id": "fake--service.fake--instance.2"
},
],
"non_running_tasks": [{
"id": "fake--service.fake--instance.3",
"state": "TASK_LOST"
}],
}
assert mock_get_mesos_running_task_dict.call_count == 2
mock_get_mesos_running_task_dict.assert_has_calls(
[mock.call(running_task_1, 10),
mock.call(running_task_2, 10)],
any_order=True,
)
mock_get_mesos_non_running_task_dict.assert_called_once_with(
non_running_task, 10)
