350 lines
16 KiB
Python
350 lines
16 KiB
Python
import time
|
|
import threading
|
|
from typing import Dict, Optional, List, Tuple
|
|
from core.models import AppConfig, TaskConfig, TaskStatus, TaskMetrics
|
|
from core.config import ConfigManager
|
|
from core.notifier import Notifier
|
|
from core.process import ManagedTask
|
|
from core.git_updater import GitUpdater
|
|
from core.logger import log_info, log_warn, log_err, log_debug
|
|
|
|
|
|
class ProcessManager:
|
|
"""Главный оркестратор задач, процессов, квот и автообновлений"""
|
|
|
|
def __init__(self, config_manager: ConfigManager, notifier: Notifier):
|
|
self.config_mgr = config_manager
|
|
self.notifier = notifier
|
|
self.app_config = AppConfig()
|
|
|
|
self._tasks: Dict[str, ManagedTask] = {}
|
|
self._lock = threading.RLock()
|
|
self.shutdown_event = threading.Event()
|
|
|
|
self.git_updater = GitUpdater(self.app_config.git, self.notifier, self)
|
|
|
|
self._monitor_thread: Optional[threading.Thread] = None
|
|
self._watcher_thread: Optional[threading.Thread] = None
|
|
|
|
def initialize(self):
|
|
"""Первоначальная загрузка конфигурации и старт фоновых потоков"""
|
|
cfg = self.config_mgr.load(exit_on_fail=True)
|
|
if cfg:
|
|
self.apply_config(cfg, initial=True)
|
|
|
|
self._monitor_thread = threading.Thread(target=self._monitor_loop, daemon=True, name="MonitorThread")
|
|
self._watcher_thread = threading.Thread(target=self._watcher_loop, daemon=True, name="ConfigWatcherThread")
|
|
|
|
self._monitor_thread.start()
|
|
self._watcher_thread.start()
|
|
|
|
has_git = self.app_config.git.enabled or any(
|
|
t.cfg.git.enabled for t in self._tasks.values()
|
|
)
|
|
if has_git:
|
|
self.git_updater.start()
|
|
|
|
def get_all_tasks(self) -> Dict[str, ManagedTask]:
|
|
with self._lock:
|
|
return dict(self._tasks)
|
|
|
|
def get_task(self, name: str) -> Optional[ManagedTask]:
|
|
with self._lock:
|
|
return self._tasks.get(name)
|
|
|
|
def start_task(self, name: str) -> bool:
|
|
with self._lock:
|
|
task = self._tasks.get(name)
|
|
if not task:
|
|
log_err(f"Задача '{name}' не найдена в менеджере")
|
|
return False
|
|
|
|
if task.is_running():
|
|
log_warn(f"Задача '{name}' уже запущена")
|
|
return False
|
|
|
|
# Если для задачи включен Git, проверяем/клонируем репозиторий перед стартом
|
|
if task.cfg.git.enabled:
|
|
self.git_updater.ensure_task_repo_cloned(task)
|
|
|
|
success = task.start()
|
|
if success:
|
|
self.notifier.send(
|
|
f"🚀 <b>Задача запущена:</b> <code>{name}</code> (PID: {task.proc.pid})",
|
|
title="Задача запущена",
|
|
level="success",
|
|
fields={"Задача": name, "PID": str(task.proc.pid)}
|
|
)
|
|
return success
|
|
|
|
def stop_task(self, name: str, force: bool = False) -> bool:
|
|
with self._lock:
|
|
task = self._tasks.get(name)
|
|
if not task:
|
|
log_warn(f"Задача '{name}' не найдена")
|
|
return False
|
|
|
|
if not task.is_running():
|
|
log_warn(f"Задача '{name}' уже остановлена")
|
|
return True
|
|
|
|
success = task.stop(force=force)
|
|
if success:
|
|
self.notifier.send(
|
|
f"🛑 <b>Задача остановлена:</b> <code>{name}</code>",
|
|
title="Задача остановлена",
|
|
level="warning",
|
|
fields={"Задача": name}
|
|
)
|
|
return success
|
|
|
|
def restart_task(self, name: str, force: bool = True) -> bool:
|
|
with self._lock:
|
|
task = self._tasks.get(name)
|
|
if not task:
|
|
log_err(f"Задача '{name}' не найдена")
|
|
return False
|
|
|
|
task.stop(force=force)
|
|
task.restart_count += 1
|
|
success = task.start()
|
|
if success:
|
|
self.notifier.send(
|
|
f"🔄 <b>Задача перезапущена:</b> <code>{name}</code> (PID: {task.proc.pid})",
|
|
title="Задача перезапущена",
|
|
level="info",
|
|
fields={"Задача": name, "PID": str(task.proc.pid), "Рестарт №": str(task.restart_count)}
|
|
)
|
|
return success
|
|
|
|
def start_all(self):
|
|
with self._lock:
|
|
for name, task in self._tasks.items():
|
|
if not task.is_running():
|
|
self.start_task(name)
|
|
|
|
def stop_all(self, force: bool = False):
|
|
with self._lock:
|
|
for name, task in self._tasks.items():
|
|
if task.is_running():
|
|
self.stop_task(name, force=force)
|
|
|
|
def restart_all(self):
|
|
with self._lock:
|
|
for name in list(self._tasks.keys()):
|
|
self.restart_task(name)
|
|
|
|
def pull_git(self, task_name: Optional[str] = None, manual: bool = True) -> Dict[str, Tuple[bool, str]]:
|
|
"""Ручной запуск проверки и обновления из Git (для конкретной задачи или всех)"""
|
|
with self._lock:
|
|
if task_name:
|
|
task = self._tasks.get(task_name)
|
|
if not task:
|
|
return {task_name: (False, f"Задача '{task_name}' не найдена")}
|
|
return {task_name: self.git_updater.sync_task_repo(task, manual=manual)}
|
|
else:
|
|
return self.git_updater.sync_all(manual=manual)
|
|
|
|
def apply_config(self, new_config: AppConfig, initial: bool = False):
|
|
"""Применение новой конфигурации"""
|
|
with self._lock:
|
|
self.app_config = new_config
|
|
self.notifier.update_configs(new_config.telegram, new_config.discord)
|
|
self.git_updater.update_config(new_config.git)
|
|
|
|
existing_names = set(self._tasks.keys())
|
|
new_names = set(new_config.tasks.keys())
|
|
|
|
# 1. Задачи, которых больше нет в конфиге
|
|
for name in (existing_names - new_names):
|
|
log_info(f"Задача '{name}' удалена из конфига. Остановка...")
|
|
task = self._tasks.pop(name)
|
|
task.stop(force=True)
|
|
|
|
# 2. Обновление или создание задач
|
|
for name, task_cfg in new_config.tasks.items():
|
|
if name in self._tasks:
|
|
self._tasks[name].update_config(task_cfg)
|
|
else:
|
|
managed = ManagedTask(task_cfg, logs_dir=new_config.logging.dir)
|
|
self._tasks[name] = managed
|
|
if (initial or task_cfg.autostart) and task_cfg.autostart:
|
|
if task_cfg.git.enabled:
|
|
self.git_updater.ensure_task_repo_cloned(managed)
|
|
managed.start()
|
|
if managed.is_running():
|
|
self.notifier.send(
|
|
f"🚀 <b>Автозапуск задачи:</b> <code>{name}</code> (PID: {managed.proc.pid})",
|
|
title="Автозапуск задачи",
|
|
level="success",
|
|
fields={"Задача": name, "PID": str(managed.proc.pid)}
|
|
)
|
|
|
|
has_git = new_config.git.enabled or any(
|
|
t.cfg.git.enabled for t in self._tasks.values()
|
|
)
|
|
if has_git:
|
|
self.git_updater.start()
|
|
|
|
def _monitor_loop(self):
|
|
"""Фоновый цикл проверки состояния процессов, памяти, ротации логов и расписания"""
|
|
while not self.shutdown_event.is_set():
|
|
interval = self.app_config.monitoring.interval if self.app_config.monitoring else 5.0
|
|
self.shutdown_event.wait(timeout=interval)
|
|
|
|
if not self.app_config.monitoring.enabled:
|
|
continue
|
|
|
|
with self._lock:
|
|
tasks_snapshot = list(self._tasks.values())
|
|
|
|
max_log_bytes = int(self.app_config.logging.max_size_mb * 1024 * 1024)
|
|
backup_count = self.app_config.logging.backup_count
|
|
|
|
now = time.time()
|
|
|
|
for task in tasks_snapshot:
|
|
# 1. Ротация логов при необходимости
|
|
task.rotate_logs_if_needed(max_log_bytes, backup_count)
|
|
|
|
# 2. Проверка задач по расписанию (Interval)
|
|
if task.status == TaskStatus.SCHEDULED:
|
|
if now >= task.next_run_time:
|
|
log_info(f"[{task.cfg.name}] Запуск запланированной задачи по расписанию...")
|
|
task.start()
|
|
continue
|
|
|
|
# 3. Сброс счетчика рестартов при стабильной работе
|
|
task.check_stable_run()
|
|
|
|
# 4. Проверка превышения квоты памяти (RAM limit)
|
|
over_mem = task.check_memory_limit()
|
|
if over_mem is not None:
|
|
limit = task.cfg.max_memory_mb
|
|
action = task.cfg.memory_limit_action
|
|
log_warn(
|
|
f"⚠️ Задача '{task.cfg.name}' превысила лимит RAM: {over_mem} MB > {limit} MB. Действие: {action}"
|
|
)
|
|
self.notifier.send(
|
|
f"⚠️ <b>Превышение квоты памяти!</b>\n"
|
|
f"• <b>Задача:</b> <code>{task.cfg.name}</code>\n"
|
|
f"• <b>Использование:</b> {over_mem} MB (Лимит: {limit} MB)\n"
|
|
f"• <b>Действие:</b> {action.upper()}",
|
|
title="Превышение лимита памяти",
|
|
level="warning",
|
|
fields={"Задача": task.cfg.name, "RAM": f"{over_mem} MB", "Лимит": f"{limit} MB"}
|
|
)
|
|
|
|
if action == "restart":
|
|
self.restart_task(task.cfg.name)
|
|
continue
|
|
elif action == "kill":
|
|
self.stop_task(task.cfg.name, force=True)
|
|
continue
|
|
|
|
# 5. Проверка завершения процесса
|
|
exit_code = task.poll_exit()
|
|
if exit_code is not None and task.status != TaskStatus.STOPPED and task.status != TaskStatus.STOPPING:
|
|
self._handle_task_exit(task, exit_code)
|
|
|
|
# 6. Логирование метрик (если включено в конфиге)
|
|
if self.app_config.monitoring.log_metrics and task.is_running():
|
|
m = task.collect_metrics()
|
|
log_debug(
|
|
f"[{task.cfg.name}] CPU: {m.cpu_percent}% | RAM: {m.memory_mb} MB | "
|
|
f"Uptime: {m.uptime_sec / 60:.1f} мин | Restarts: {m.restart_count}"
|
|
)
|
|
|
|
def _handle_task_exit(self, task: ManagedTask, exit_code: int):
|
|
uptime = round(time.time() - task.start_time, 1) if task.start_time else 0
|
|
|
|
# Если это задача по расписанию и завершилась успешно (код 0)
|
|
if task.cfg.schedule_type == "interval" and exit_code == 0:
|
|
log_info(f"[{task.cfg.name}] Периодическая задача успешно выполнена. Следующий запуск через {task.cfg.schedule_interval} сек.")
|
|
task.status = TaskStatus.SCHEDULED
|
|
task.next_run_time = time.time() + task.cfg.schedule_interval
|
|
return
|
|
|
|
err_snippet = task.read_last_error(max_lines=8)
|
|
|
|
log_err(
|
|
f"Задача '{task.cfg.name}' завершилась с кодом {exit_code} (Uptime: {uptime} сек)"
|
|
)
|
|
if err_snippet:
|
|
log_err(f"Последняя ошибка '{task.cfg.name}':\n{err_snippet}")
|
|
|
|
# Alert
|
|
tg_text = (
|
|
f"⚠️ <b>Задача завершилась аварийно!</b>\n"
|
|
f"• <b>Задача:</b> <code>{task.cfg.name}</code>\n"
|
|
f"• <b>Код выхода:</b> {exit_code}\n"
|
|
f"• <b>Время работы:</b> {uptime}s\n"
|
|
)
|
|
if err_snippet:
|
|
clean_err = err_snippet[:400].replace("<", "<").replace(">", ">")
|
|
tg_text += f"\n<pre>{clean_err}</pre>"
|
|
|
|
self.notifier.send(
|
|
tg_text,
|
|
title="Аварийное завершение задачи",
|
|
level="error",
|
|
fields={"Задача": task.cfg.name, "Код выхода": str(exit_code), "Uptime": f"{uptime}s"}
|
|
)
|
|
|
|
# Автоперезапуск с задержкой (backoff)
|
|
if task.cfg.autorestart:
|
|
if 0 < task.cfg.max_restarts <= task.restart_count:
|
|
task.status = TaskStatus.CRASHED
|
|
log_err(
|
|
f"Задача '{task.cfg.name}' превысила лимит рестартов ({task.cfg.max_restarts}). "
|
|
f"Автоперезапуск остановлен."
|
|
)
|
|
self.notifier.send(
|
|
f"❌ <b>Лимит рестартов исчерпан:</b> <code>{task.cfg.name}</code> ({task.cfg.max_restarts})",
|
|
title="Лимит рестартов исчерпан",
|
|
level="error",
|
|
fields={"Задача": task.cfg.name, "Попыток": str(task.cfg.max_restarts)}
|
|
)
|
|
return
|
|
|
|
task.status = TaskStatus.BACKOFF
|
|
log_warn(
|
|
f"Автоперезапуск '{task.cfg.name}' через {task.cfg.restart_delay} сек... "
|
|
f"(Попытка {task.restart_count + 1}/{task.cfg.max_restarts or '∞'})"
|
|
)
|
|
|
|
def _delayed_restart():
|
|
time.sleep(task.cfg.restart_delay)
|
|
if not self.shutdown_event.is_set() and task.status == TaskStatus.BACKOFF:
|
|
task.restart_count += 1
|
|
task.start()
|
|
|
|
threading.Thread(target=_delayed_restart, daemon=True, name=f"Restart-{task.cfg.name}").start()
|
|
else:
|
|
task.status = TaskStatus.STOPPED
|
|
|
|
def _watcher_loop(self):
|
|
"""Отслеживание изменений файла config.yaml без падений процесса"""
|
|
while not self.shutdown_event.is_set():
|
|
self.shutdown_event.wait(timeout=2.0)
|
|
|
|
if self.config_mgr.check_modified():
|
|
log_info("Обнаружено изменение конфигурационного файла. Применение...")
|
|
new_cfg = self.config_mgr.load(exit_on_fail=False)
|
|
if new_cfg is not None:
|
|
self.apply_config(new_cfg)
|
|
log_info("Конфигурация успешно обновлена на лету!")
|
|
else:
|
|
log_warn("Конфигурация не была применена из-за ошибок валидации.")
|
|
|
|
def shutdown(self):
|
|
"""Полная остановка всех процессов, git-апдейтера и менеджера"""
|
|
log_info("Остановка всех задач и завершение работы менеджера...")
|
|
self.shutdown_event.set()
|
|
self.git_updater.shutdown()
|
|
with self._lock:
|
|
for task in self._tasks.values():
|
|
task.stop(force=True, timeout=3.0)
|
|
self.notifier.shutdown()
|
|
log_info("Все задачи завершены.")
|