async def marathon_mesos_status(service: str, instance: str,
verbose: int) -> MutableMapping[str, Any]:
mesos_status: MutableMapping[str, Any] = {}
job_id = marathon_tools.format_job_id(service, instance)
job_id_filter_string = f"{job_id}{marathon_tools.MESOS_TASK_SPACER}"
try:
running_and_active_tasks = select_tasks_by_id(
await get_cached_list_of_running_tasks_from_frameworks(),
job_id=job_id_filter_string,
)
except (ReadTimeout, asyncio.TimeoutError):
return {
"error_message":
"Talking to Mesos timed out. It may be overloaded."
}
mesos_status["running_task_count"] = len(running_and_active_tasks)
if verbose > 0:
num_tail_lines = calculate_tail_lines(verbose)
running_task_dict_futures = []
for task in running_and_active_tasks:
running_task_dict_futures.append(
asyncio.ensure_future(
get_mesos_running_task_dict(task, num_tail_lines)))
non_running_tasks = select_tasks_by_id(
await get_cached_list_of_not_running_tasks_from_frameworks(),
job_id=job_id_filter_string,
)
non_running_tasks.sort(
key=lambda task: get_first_status_timestamp(task) or 0)
non_running_tasks = list(reversed(non_running_tasks[-10:]))
non_running_task_dict_futures = []
for task in non_running_tasks:
non_running_task_dict_futures.append(
asyncio.ensure_future(
get_mesos_non_running_task_dict(task, num_tail_lines)))
all_task_dict_futures = (running_task_dict_futures +
non_running_task_dict_futures)
if len(all_task_dict_futures):
await asyncio.wait(all_task_dict_futures)
mesos_status["running_tasks"] = [
task_future.result() for task_future in running_task_dict_futures
]
mesos_status["non_running_tasks"] = [
task_future.result()
for task_future in non_running_task_dict_futures
]
return mesos_status
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
async def get_mesos_non_running_task_dict(
task: Task, num_tail_lines: int) -> MutableMapping[str, Any]:
if num_tail_lines > 0:
tail_lines = await get_tail_lines_for_mesos_task(
task, get_short_task_id, num_tail_lines)
else:
tail_lines = {}
task_dict = {
"id": get_short_task_id(task["id"]),
"hostname": await
results_or_unknown(get_short_hostname_from_task(task)),
"state": task["state"],
"tail_lines": tail_lines,
}
task_start_time = get_first_status_timestamp(task)
if task_start_time is not None:
task_dict["deployed_timestamp"] = task_start_time
return task_dict
