425 lines
19 KiB
Python
425 lines
19 KiB
Python
import os
|
||
import sys
|
||
import time
|
||
from cmd import Cmd
|
||
from typing import List, Optional
|
||
from colorama import Fore, Style
|
||
from rapidfuzz import process as rf_process, fuzz
|
||
|
||
from core.manager import ProcessManager
|
||
from core.models import TaskStatus
|
||
from core.logger import log_info, log_warn, log_err
|
||
|
||
|
||
class InteractiveConsole(Cmd):
|
||
prompt = Fore.CYAN + "ptera-manager> " + Style.RESET_ALL
|
||
intro = Fore.GREEN + "\nВведите 'help' для списка доступных команд\n"
|
||
|
||
def __init__(self, manager: ProcessManager):
|
||
super().__init__()
|
||
self.manager = manager
|
||
self._command_names = [
|
||
"status", "list", "start", "stop", "restart",
|
||
"start-all", "stop-all", "restart-all",
|
||
"logs", "tail", "info", "install", "clean-logs",
|
||
"update", "git-pull",
|
||
"reload", "clear", "exit", "quit", "help"
|
||
]
|
||
|
||
def _get_task_names(self) -> List[str]:
|
||
return list(self.manager.get_all_tasks().keys())
|
||
|
||
def _match_task_name(self, name: str) -> Optional[str]:
|
||
tasks = self._get_task_names()
|
||
if name in tasks:
|
||
return name
|
||
if tasks:
|
||
best_match = rf_process.extractOne(name, tasks, scorer=fuzz.ratio)
|
||
if best_match and best_match[1] > 60:
|
||
print(Fore.YELLOW + f"ℹ️ Задача '{name}' не найдена. Использовано совпадение '{best_match[0]}'")
|
||
return best_match[0]
|
||
return None
|
||
|
||
def default(self, line: str):
|
||
cmd_entered = line.strip().split()[0] if line.strip() else ""
|
||
if not cmd_entered:
|
||
return
|
||
|
||
best_match = rf_process.extractOne(cmd_entered, self._command_names, scorer=fuzz.ratio)
|
||
if best_match and best_match[1] > 60:
|
||
print(Fore.YELLOW + f"Неизвестная команда '{cmd_entered}'. Возможно, вы имели в виду: '{best_match[0]}'?")
|
||
else:
|
||
print(Fore.RED + f"Команда '{cmd_entered}' не найдена. Введите 'help' для справки.")
|
||
|
||
def emptyline(self):
|
||
pass
|
||
|
||
# ================= COMMANDS =================
|
||
|
||
def do_status(self, arg):
|
||
"""Показать статус и метрики всех задач (алиас: ps)"""
|
||
tasks = self.manager.get_all_tasks()
|
||
if not tasks:
|
||
print(Fore.YELLOW + "Нет настроенных задач. Проверьте config.yaml")
|
||
return
|
||
|
||
header = f"{Fore.CYAN}{'Задача':<24} {'PID':<8} {'Статус':<12} {'CPU':<8} {'RAM':<14} {'Uptime':<12} {'Рестартов':<10}{Style.RESET_ALL}"
|
||
print("\n" + header)
|
||
print("-" * 92)
|
||
|
||
for name, task in tasks.items():
|
||
metrics = task.collect_metrics()
|
||
|
||
if metrics.status == TaskStatus.RUNNING:
|
||
status_str = Fore.GREEN + "RUNNING" + Style.RESET_ALL
|
||
elif metrics.status == TaskStatus.SCHEDULED:
|
||
status_str = Fore.BLUE + "SCHEDULED" + Style.RESET_ALL
|
||
elif metrics.status == TaskStatus.BACKOFF:
|
||
status_str = Fore.YELLOW + "BACKOFF" + Style.RESET_ALL
|
||
elif metrics.status == TaskStatus.CRASHED:
|
||
status_str = Fore.RED + "CRASHED" + Style.RESET_ALL
|
||
elif metrics.status == TaskStatus.STOPPING:
|
||
status_str = Fore.YELLOW + "STOPPING" + Style.RESET_ALL
|
||
else:
|
||
status_str = Style.DIM + "STOPPED" + Style.RESET_ALL
|
||
|
||
pid_str = str(metrics.pid) if metrics.pid else "-"
|
||
cpu_str = f"{metrics.cpu_percent:.1f}%" if metrics.pid else "-"
|
||
|
||
ram_limit_str = f"/{task.cfg.max_memory_mb:.0f}" if task.cfg.max_memory_mb else ""
|
||
ram_str = f"{metrics.memory_mb:.1f}{ram_limit_str} MB" if metrics.pid else "-"
|
||
|
||
uptime_min = metrics.uptime_sec / 60
|
||
uptime_str = f"{uptime_min:.1f} мин" if metrics.pid else "-"
|
||
|
||
restarts_str = str(metrics.restart_count)
|
||
|
||
print(f"{name:<24} {pid_str:<8} {status_str:<21} {cpu_str:<8} {ram_str:<14} {uptime_str:<12} {restarts_str:<10}")
|
||
print()
|
||
|
||
def do_ps(self, arg):
|
||
"""Алиас для команды status"""
|
||
self.do_status(arg)
|
||
|
||
def do_list(self, arg):
|
||
"""Показать список задач и их настройки"""
|
||
tasks = self.manager.get_all_tasks()
|
||
if not tasks:
|
||
print(Fore.YELLOW + "Список задач пуст")
|
||
return
|
||
|
||
print(Fore.CYAN + "\n📋 Задачи в конфигурации:")
|
||
for name, task in tasks.items():
|
||
cfg = task.cfg
|
||
auto_s = Fore.GREEN + "✓" if cfg.autostart else Fore.RED + "✗"
|
||
auto_r = Fore.GREEN + "✓" if cfg.autorestart else Fore.RED + "✗"
|
||
sched = f" | Расписание: {cfg.schedule_interval}с" if cfg.schedule_type == "interval" else ""
|
||
venv_str = f" | venv: {cfg.venv}" if cfg.venv else ""
|
||
quota_str = f" | RAM квота: {cfg.max_memory_mb}MB" if cfg.max_memory_mb else ""
|
||
|
||
print(
|
||
f" • {Fore.WHITE}{name:<22}{Style.RESET_ALL} "
|
||
f"Скрипт: {cfg.script:<28} "
|
||
f"[Автостарт: {auto_s}{Style.RESET_ALL} | Рестарт: {auto_r}{Style.RESET_ALL}{sched}{venv_str}{quota_str}]"
|
||
)
|
||
print()
|
||
|
||
def do_start(self, arg):
|
||
"""Запустить задачу: start <name>"""
|
||
if not arg.strip():
|
||
print(Fore.YELLOW + "Укажите имя задачи. Пример: start bot1")
|
||
return
|
||
target = self._match_task_name(arg.strip())
|
||
if target:
|
||
self.manager.start_task(target)
|
||
|
||
def complete_start(self, text, line, begidx, endidx):
|
||
return [t for t in self._get_task_names() if t.startswith(text)]
|
||
|
||
def do_stop(self, arg):
|
||
"""Остановить задачу: stop <name>"""
|
||
if not arg.strip():
|
||
print(Fore.YELLOW + "Укажите имя задачи. Пример: stop bot1")
|
||
return
|
||
target = self._match_task_name(arg.strip())
|
||
if target:
|
||
self.manager.stop_task(target)
|
||
|
||
def complete_stop(self, text, line, begidx, endidx):
|
||
return [t for t in self._get_task_names() if t.startswith(text)]
|
||
|
||
def do_restart(self, arg):
|
||
"""Перезапустить задачу: restart <name>"""
|
||
if not arg.strip():
|
||
print(Fore.YELLOW + "Укажите имя задачи. Пример: restart bot1")
|
||
return
|
||
target = self._match_task_name(arg.strip())
|
||
if target:
|
||
self.manager.restart_task(target)
|
||
|
||
def complete_restart(self, text, line, begidx, endidx):
|
||
return [t for t in self._get_task_names() if t.startswith(text)]
|
||
|
||
def do_start_all(self, arg):
|
||
"""Запустить все незапущенные задачи"""
|
||
self.manager.start_all()
|
||
|
||
def do_stop_all(self, arg):
|
||
"""Остановить все запущенные задачи"""
|
||
self.manager.stop_all()
|
||
|
||
def do_restart_all(self, arg):
|
||
"""Перезапустить все задачи"""
|
||
self.manager.restart_all()
|
||
|
||
def do_update(self, arg):
|
||
"""Проверить и подтянуть обновления из Git: update [name] (алиас: git-pull)"""
|
||
arg_clean = arg.strip()
|
||
target_task = None
|
||
if arg_clean:
|
||
target_task = self._match_task_name(arg_clean)
|
||
if not target_task:
|
||
return
|
||
|
||
print(Fore.CYAN + f"Проверка обновлений Git{' для ' + target_task if target_task else ''}...")
|
||
results = self.manager.pull_git(task_name=target_task, manual=True)
|
||
|
||
if not results:
|
||
print(Fore.YELLOW + "Нет активных Git-репозиториев для проверки.")
|
||
return
|
||
|
||
for name, (updated, msg) in results.items():
|
||
prefix = f"[{name}] " if name != target_task else ""
|
||
if updated:
|
||
print(Fore.GREEN + f"✓ {prefix}{msg}")
|
||
else:
|
||
print(Fore.YELLOW + f"ℹ️ {prefix}{msg}")
|
||
|
||
def do_git_pull(self, arg):
|
||
"""Алиас для update [name]"""
|
||
self.do_update(arg)
|
||
|
||
def complete_update(self, text, line, begidx, endidx):
|
||
return [t for t in self._get_task_names() if t.startswith(text)]
|
||
|
||
def complete_git_pull(self, text, line, begidx, endidx):
|
||
return [t for t in self._get_task_names() if t.startswith(text)]
|
||
|
||
def do_logs(self, arg):
|
||
"""Показать логи задачи: logs <name> [lines]"""
|
||
parts = arg.strip().split()
|
||
if not parts:
|
||
print(Fore.YELLOW + "Укажите имя задачи. Пример: logs bot1 30")
|
||
return
|
||
target = self._match_task_name(parts[0])
|
||
if not target:
|
||
return
|
||
|
||
lines = int(parts[1]) if len(parts) > 1 and parts[1].isdigit() else 25
|
||
task = self.manager.get_task(target)
|
||
if not task:
|
||
return
|
||
|
||
data = task.read_logs(max_lines=lines)
|
||
|
||
print(Fore.CYAN + f"\n=== STDOUT: {target} (последние {lines} строк) ===")
|
||
if data["stdout"]:
|
||
for line in data["stdout"]:
|
||
print(Fore.WHITE + line)
|
||
else:
|
||
print(Style.DIM + "(лог stdout пуст)")
|
||
|
||
print(Fore.YELLOW + f"\n=== STDERR: {target} (последние {lines} строк) ===")
|
||
if data["stderr"]:
|
||
for line in data["stderr"]:
|
||
print(Fore.RED + line)
|
||
else:
|
||
print(Fore.GREEN + "(нет ошибок в stderr)")
|
||
print()
|
||
|
||
def complete_logs(self, text, line, begidx, endidx):
|
||
return [t for t in self._get_task_names() if t.startswith(text)]
|
||
|
||
def do_tail(self, arg):
|
||
"""Следить за логами задачи в реальном времени (Ctrl+C для выхода): tail <name>"""
|
||
parts = arg.strip().split()
|
||
if not parts:
|
||
print(Fore.YELLOW + "Укажите имя задачи. Пример: tail bot1")
|
||
return
|
||
target = self._match_task_name(parts[0])
|
||
if not target:
|
||
return
|
||
|
||
task = self.manager.get_task(target)
|
||
if not task:
|
||
return
|
||
|
||
print(Fore.CYAN + f"Трансляция логов '{target}' (нажмите Ctrl+C для выхода)...")
|
||
last_stdout_pos = 0
|
||
last_stderr_pos = 0
|
||
|
||
try:
|
||
while True:
|
||
if task.stdout_path.exists():
|
||
with open(task.stdout_path, "r", encoding="utf-8", errors="ignore") as f:
|
||
f.seek(last_stdout_pos)
|
||
new_content = f.read()
|
||
if new_content:
|
||
sys.stdout.write(Fore.WHITE + new_content)
|
||
sys.stdout.flush()
|
||
last_stdout_pos = f.tell()
|
||
|
||
if task.stderr_path.exists():
|
||
with open(task.stderr_path, "r", encoding="utf-8", errors="ignore") as f:
|
||
f.seek(last_stderr_pos)
|
||
new_err = f.read()
|
||
if new_err:
|
||
sys.stdout.write(Fore.RED + new_err)
|
||
sys.stdout.flush()
|
||
last_stderr_pos = f.tell()
|
||
|
||
time.sleep(0.5)
|
||
except KeyboardInterrupt:
|
||
print(Fore.YELLOW + "\nОстановка трансляции логов.")
|
||
|
||
def complete_tail(self, text, line, begidx, endidx):
|
||
return [t for t in self._get_task_names() if t.startswith(text)]
|
||
|
||
def do_info(self, arg):
|
||
"""Подробная диагностика задачи: info <name>"""
|
||
if not arg.strip():
|
||
print(Fore.YELLOW + "Укажите имя задачи. Пример: info bot1")
|
||
return
|
||
target = self._match_task_name(arg.strip())
|
||
if not target:
|
||
return
|
||
|
||
task = self.manager.get_task(target)
|
||
if not task:
|
||
return
|
||
|
||
m = task.collect_metrics()
|
||
cfg = task.cfg
|
||
|
||
py_bin, _ = task.get_python_executable()
|
||
|
||
print(Fore.CYAN + f"\nℹ️ Детальная информация: {target}")
|
||
print("-" * 55)
|
||
print(f" Статус: {m.status.value}")
|
||
print(f" PID процесса: {m.pid or 'Не запущен'}")
|
||
print(f" Интерпретатор: {py_bin}")
|
||
print(f" Версия Python: {cfg.python_version or 'Системная/по умолчанию'} (докачка: {'Вкл' if cfg.allow_download_python else 'Выкл'})")
|
||
print(f" Изолир. venv: {cfg.venv or 'Системный / родительский'} (автосоздание: {'Вкл' if cfg.auto_create_venv else 'Выкл'})")
|
||
print(f" Скрипт: {cfg.script}")
|
||
print(f" Рабочая папка: {cfg.cwd or 'По умолчанию (папка скрипта)'}")
|
||
if cfg.git.enabled:
|
||
print(f" Git Repo: {cfg.git.repo_url} (ветка: {cfg.git.branch})")
|
||
if cfg.git.ssh_key_path:
|
||
print(f" Git SSH Key: {cfg.git.ssh_key_path}")
|
||
print(f" Git Авторестарт: {'Вкл' if cfg.git.auto_restart else 'Выкл'} (интервал: {cfg.git.check_interval}с)")
|
||
else:
|
||
print(f" Git Repo: Отключен")
|
||
print(f" Аргументы: {cfg.args}")
|
||
print(f" Тип запуска: {cfg.schedule_type} (интервал: {cfg.schedule_interval}с)")
|
||
print(f" Квота памяти: {f'{cfg.max_memory_mb} MB (действие: {cfg.memory_limit_action})' if cfg.max_memory_mb else 'Без ограничений'}")
|
||
print(f" Автостарт: {cfg.autostart}")
|
||
print(f" Авторестарт: {cfg.autorestart} (задержка: {cfg.restart_delay}с)")
|
||
print(f" Рестартов: {m.restart_count} / {cfg.max_restarts or '∞'}")
|
||
print(f" Uptime: {m.uptime_sec / 60:.2f} минут")
|
||
print(f" CPU / RAM: {m.cpu_percent}% / {m.memory_mb} MB")
|
||
print(f" Файл stdout: {task.stdout_path}")
|
||
print(f" Файл stderr: {task.stderr_path}")
|
||
if m.last_exit_code is not None:
|
||
print(f" Последний код: {m.last_exit_code}")
|
||
if m.last_error:
|
||
print(Fore.RED + f" Ошибка: {m.last_error}")
|
||
print()
|
||
|
||
def complete_info(self, text, line, begidx, endidx):
|
||
return [t for t in self._get_task_names() if t.startswith(text)]
|
||
|
||
def do_install(self, arg):
|
||
"""Принудительно установить зависимости задачи: install <name>"""
|
||
if not arg.strip():
|
||
print(Fore.YELLOW + "Укажите имя задачи. Пример: install bot1")
|
||
return
|
||
target = self._match_task_name(arg.strip())
|
||
if not target:
|
||
return
|
||
task = self.manager.get_task(target)
|
||
if task:
|
||
task.check_and_install_requirements(force=True)
|
||
|
||
def complete_install(self, text, line, begidx, endidx):
|
||
return [t for t in self._get_task_names() if t.startswith(text)]
|
||
|
||
def do_clean_logs(self, arg):
|
||
"""Очистить файлы логов задачи: clean_logs <name>"""
|
||
if not arg.strip():
|
||
print(Fore.YELLOW + "Укажите имя задачи. Пример: clean_logs bot1")
|
||
return
|
||
target = self._match_task_name(arg.strip())
|
||
if not target:
|
||
return
|
||
task = self.manager.get_task(target)
|
||
if task:
|
||
task.clear_logs()
|
||
|
||
def complete_clean_logs(self, text, line, begidx, endidx):
|
||
return [t for t in self._get_task_names() if t.startswith(text)]
|
||
|
||
def do_reload(self, arg):
|
||
"""Перезагрузить config.yaml вручную"""
|
||
cfg = self.manager.config_mgr.load(exit_on_fail=False)
|
||
if cfg:
|
||
self.manager.apply_config(cfg)
|
||
log_info("Конфиг успешно перезагружен вручную!")
|
||
else:
|
||
log_err("Не удалось перезагрузить конфиг. Проверьте синтаксис YAML.")
|
||
|
||
def do_clear(self, arg):
|
||
"""Очистить экран терминала (алиас: cls)"""
|
||
os.system("cls" if os.name == "nt" else "clear")
|
||
|
||
def do_cls(self, arg):
|
||
"""Алиас для команды clear"""
|
||
self.do_clear(arg)
|
||
|
||
def do_exit(self, arg):
|
||
"""Выход из менеджера процессов и остановка всех задач"""
|
||
print(Fore.YELLOW + "Завершение работы менеджера...")
|
||
self.manager.shutdown()
|
||
return True
|
||
|
||
def do_quit(self, arg):
|
||
return self.do_exit(arg)
|
||
|
||
def do_q(self, arg):
|
||
return self.do_exit(arg)
|
||
|
||
def do_help(self, arg):
|
||
"""Показать справку по командам"""
|
||
print(Fore.CYAN + "\nДоступные команды:")
|
||
commands = [
|
||
("status / ps", "Показать статус, ресурсы (CPU/RAM/Квоты) и аптайм всех задач"),
|
||
("list", "Список задач, расписания, venv и параметров из config.yaml"),
|
||
("start <name>", "Запустить задачу"),
|
||
("stop <name>", "Остановить задачу (graceful termination дерева процессов)"),
|
||
("restart <name>", "Перезапустить задачу"),
|
||
("start-all", "Запустить все незапущенные задачи"),
|
||
("stop-all", "Остановить все задачи"),
|
||
("restart-all", "Перезапустить все задачи"),
|
||
("update / git-pull", "Проверить и подтянуть обновления из Git-репозитория"),
|
||
("logs <name> [lines]", "Показать последние строки stdout и stderr"),
|
||
("tail <name>", "Следить за выводом логов в режиме реального времени"),
|
||
("info <name>", "Подробная диагностика задачи (пути, venv, квоты, ошибки)"),
|
||
("install <name>", "Установить requirements.txt для указанной задачи"),
|
||
("clean-logs <name>", "Очистить файлы логов выбранной задачи"),
|
||
("reload", "Вручную перечитать config.yaml"),
|
||
("clear / cls", "Очистить консоль"),
|
||
("exit / quit / q", "Остановить все задачи и выйти"),
|
||
]
|
||
for cmd_name, desc in commands:
|
||
print(f" {Fore.GREEN}{cmd_name:<22}{Style.RESET_ALL} {desc}")
|
||
print()
|