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