Files
ptera-py-manager/core/manager.py
T

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("<", "&lt;").replace(">", "&gt;")
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("Все задачи завершены.")