From 3f8b0c102207abf22646a5f75b46c2f7f30cc89d Mon Sep 17 00:00:00 2001 From: Dev Core <103052766+Dev-Cored@users.noreply.github.com> Date: Thu, 29 Oct 2026 00:39:00 +0400 Subject: [PATCH] Initial commit: PteraPyManager v2.5 with modular architecture, auto venv, python downloader, and resource quotas --- .gitignore | 46 +++++ README.md | 261 ++++++++++++++++++++++++++ config.yaml | 85 +++++++++ core/__init__.py | 7 + core/config.py | 88 +++++++++ core/console.py | 397 ++++++++++++++++++++++++++++++++++++++++ core/git_updater.py | 190 +++++++++++++++++++ core/logger.py | 78 ++++++++ core/manager.py | 330 +++++++++++++++++++++++++++++++++ core/models.py | 183 +++++++++++++++++++ core/notifier.py | 150 +++++++++++++++ core/process.py | 435 ++++++++++++++++++++++++++++++++++++++++++++ core/python_env.py | 387 +++++++++++++++++++++++++++++++++++++++ manager.py | 77 ++++++++ reqs.txt | 5 + 15 files changed, 2719 insertions(+) create mode 100644 .gitignore create mode 100644 README.md create mode 100644 config.yaml create mode 100644 core/__init__.py create mode 100644 core/config.py create mode 100644 core/console.py create mode 100644 core/git_updater.py create mode 100644 core/logger.py create mode 100644 core/manager.py create mode 100644 core/models.py create mode 100644 core/notifier.py create mode 100644 core/process.py create mode 100644 core/python_env.py create mode 100644 manager.py create mode 100644 reqs.txt diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..54019ea --- /dev/null +++ b/.gitignore @@ -0,0 +1,46 @@ +# Virtual Environments +.venv/ +venv/ +ENV/ +env/ +.runtimes/ + +# IDE & Editor settings +.idea/ +.vscode/ +*.swp +*.swo + +# Python cache & build +__pycache__/ +*.py[cod] +*$py.class +*.so +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +*.egg-info/ +.installed.cfg +*.egg + +# Logs & Runtime data +logs/ +*.log +*.log.* + +# Secrets & SSH keys +id_* +*.pem +*.key + +# Local configuration overrides (optional, keep default config.yaml in repo) +# config.local.yaml diff --git a/README.md b/README.md new file mode 100644 index 0000000..892935e --- /dev/null +++ b/README.md @@ -0,0 +1,261 @@ +# ⚡ DevCoded PteraPyManager (v2.5) + +**PteraPyManager** — продвинутый интерактивный супервизор процессов и менеджер Python-ботов. Разработан специально для мультизапуска и контроля нескольких ботов/скриптов в **одном контейнере (яйце) Pterodactyl Panel**, а также на любых Linux/Windows серверах. + +--- + +## 🚀 Основные возможности + +- **Мультипроцессорный супервизор:** Запуск и независимый контроль любого количества Python-скриптов и фоновых воркеров. +- **Интеллектуальный авторестарт:** Автоматический перезапуск упавших ботов с защитой от краш-штормов (`restart_delay`, экспоненциальный бэкофф и сброс счетчика при стабильной работе). +- **Корректное завершение (Tree Kill):** Завершение не только родительского процесса, но и всего дерева дочерних подпроцессов (aiohttp-серверы, воркеры, ffmpeg и др.). +- **Управление версиями Python и автоматический Venv:** + - **Вариант А:** Автопоиск нужной версии Python (3.9, 3.10, 3.11, 3.12, 3.13) среди установленных в системе / контейнере. + - **Резерв Б:** Автоматическая докачка автономного Portable CPython (*python-build-standalone*) без прав `root` / `sudo`. + - **Автосоздание venv:** Автоматическое создание изолированного окружения `.venv`, обновление `pip` и установка зависимостей из `requirements.txt` при первом старте. +- **Квоты ресурсов (Resource Quotas):** Мониторинг RAM каждого скрипта в реальном времени. Автоматический перезапуск (`restart`) или остановка (`kill`) при утечках памяти. +- **Автоматическая ротация логов:** Ограничение размера лог-файлов на диске и автоматическая ротация архивов, предотвращающая переполнение дисковой квоты в контейнере. +- **Планировщик задач (Interval Schedule):** Поддержка периодических задач (парсеров, генераторов бэкапов) с интервальным перезапуском. +- **Двусторонние уведомления (Telegram + Discord):** Асинхронная очередь оповещений о падениях, рестартах, превышении памяти и обновлениях Git с красивыми цветными Embeds. +- **Git Auto-Updater c поддержкой SSH:** Периодическая проверка репозитория, автоматический `git pull`, доустановка новых зависимостей и безопасный рестарт ботов. Полная поддержка Deploy Keys через SSH. +- **Интерактивная CLI-консоль:** Управление через терминал с автодополнением по клавише `Tab`, подсказками при опечатках на базе `RapidFuzz` и живым просмотром логов (`tail`). + +--- + +## 📦 Быстрый старт + +### 1. Требования +- Python 3.9+ (рекомендуется Python 3.10–3.12) +- Git (для работы автообновления) + +### 2. Установка зависимостей +```bash +git clone ssh://git@git.dev-core.me:2222/dev-core/ptera-py-manager.git +cd ptera-py-manager + +# Рекомендуется создать базовый venv менеджера: +python3 -m venv .venv +source .venv/bin/activate # На Windows: .venv\Scripts\activate + +# Установка зависимостей менеджера: +pip install -r reqs.txt +``` + +### 3. Запуск +```bash +python manager.py +``` + +--- + +## 🐍 Интерпретатор по умолчанию и выбор версий Python + +### Какой Python используется по умолчанию? +1. **Для самого менеджера (`manager.py`):** + Используется тот интерпретатор, через который вы запустили менеджер (системный `python3` контейнера или виртуальное окружение `.venv`, в котором выполнен запуск: `sys.executable`). +2. **Для управляемых задач (`tasks`):** + - Если в задаче **не указаны** ни `python_version`, ни `venv`, ни `python_path`: задача выполняется через **тот же интерпретатор по умолчанию**, на котором работает сам менеджер. + - Если указан `venv`, но не указан `python_version`: виртуальное окружение задачи создается на базе **текущего родительского Python**. + - Если указан `python_version`: менеджер автоматически ищет указанную версию в системе (Вариант А) или скачивает автономный переносимый бинарник нужной версии (Резерв Б). + +--- + +### Список поддерживаемых версий для поля `python_version` + +В поле `python_version` в `config.yaml` указывается мажорная версия в формате `"3.X"`. Поддерживаются следующие значения: + +| Значение в конфиге | Ветка CPython | Версия автодокачки (Резерв Б) | Рекомендации по использованию | +|---|---|---|---| +| `"3.12"` | Python 3.12 | 3.12.7+ | ⚡ **Рекомендуется** — высокая производительность, современный синтаксис | +| `"3.11"` | Python 3.11 | 3.11.10+ | Отличная стабильность, ускоренное ядро CPython (Faster CPython) | +| `"3.10"` | Python 3.10 | 3.10.15+ | Максимальная совместимость со старыми библиотеками и ботами | +| `"3.9"` | Python 3.9 | 3.9.20+ | Для легаси-проектов | +| `"3.13"` | Python 3.13 | 3.13.0+ | Новейшая версия (экспериментальные фичи) | + +#### Пример указания в конфиге: +```yaml +tasks: + - name: my-bot + script: "bots/bot.py" + venv: "bots/bot/.venv" + python_version: "3.10" # Достаточно указать "3.10" + auto_create_venv: true # Менеджер сам создаст venv с Python 3.10 + allow_download_python: true # Если в Pterodactyl нет Python 3.10, он скачается автоматически +``` + +--- + +## 🎮 Команды интерактивной консоли + +В консоли менеджера (`ptera-manager>`) доступны следующие команды: + +| Команда | Описание | +|---|---| +| `status` (или `ps`) | Сводная цветная таблица: PID, статус, CPU %, RAM (с учетом квот), Uptime и число рестартов | +| `list` | Список всех настроенных задач, их скрипты, флаги автостарта и расписания | +| `start <имя>` | Запустить выбранную задачу | +| `stop <имя>` | Остановить задачу с graceful-завершением дочерних процессов | +| `restart <имя>` | Перезапустить задачу | +| `start-all` | Запустить все незапущенные задачи | +| `stop-all` | Остановить все задачи | +| `restart-all` | Перезапустить все активные задачи | +| `update` (или `git-pull`) | Принудительно проверить и подтянуть свежий код из Git-репозитория | +| `logs <имя> [строк]` | Показать последние строки логов stdout и stderr (по умолчанию 25) | +| `tail <имя>` | Трансляция логов задачи в реальном времени (выход: `Ctrl+C`) | +| `info <имя>` | Подробная диагностика задачи (пути, интерпретатор, окружение, лимиты, ошибки) | +| `install <имя>` | Принудительно установить/обновить `requirements.txt` для выбранной задачи | +| `clean-logs <имя>` | Очистить файлы логов выбранной задачи | +| `reload` | Перечитать конфигурационный файл `config.yaml` на лету | +| `clear` (или `cls`) | Очистить экран консоли | +| `exit` (или `quit`, `q`) | Корректно остановить все задачи и выйти из программы | + +> 💡 **Автокомплит и поиск опечаток:** Для всех команд и имен задач работает автодополнение по клавише `Tab`. Если вы опечатались (например, ввели `ststus`), система автоматически подскажет правильную команду. + +--- + +## ⚙️ Подробный конфигурационный файл (config.yaml) + +Ниже приведена детальная структура `config.yaml` с построчным описанием каждого параметра: + +```yaml +# ============================================================ +# PyTaskManager Configuration +# ============================================================ + +# ===================== TELEGRAM ===================== +# Настройки оповещений в Telegram о событиях, крашах и рестартах +telegram: + enabled: false # Включить/выключить Telegram-уведомления (true/false) + token: "123456789:ABCdefGhIJKlmNoPQRsTUVw" # Токен Telegram-бота от @BotFather + chat_id: "123456789" # ID чата или пользователя для получения уведомлений + +# ===================== DISCORD ===================== +# Настройки оповещений в Discord через Webhook (с цветными Embeds) +discord: + enabled: false # Включить/выключить Discord-уведомления (true/false) + webhook_url: "https://discord.com/api/webhooks/..." # URL созданного вебхука канала + username: "PyTaskManager" # Отображаемое имя бота в канале + avatar_url: "" # Ссылка на аватарку бота (опционально) + +# ===================== GIT AUTO-UPDATE ===================== +# Автоматическая синхронизация с Git-репозиторием и поддержка SSH-ключей. +# Позволяет обновлять всех ботов на сервере по push в репозиторий. +git: + enabled: false # Включить фоновую автосинхронизацию с Git + repo_url: "ssh://git@git.dev-core.me:2222/dev-core/ptera-py-manager.git" # URL (SSH или HTTPS) + branch: "main" # Отслеживаемая ветка (main / master) + check_interval: 300 # Интервал проверки обновлений в секундах (например, каждые 5 минут) + ssh_key_path: "id_ed25519" # Путь к приватному SSH-ключу (для доступа к закрытым репо) + auto_restart: true # Автоматически перезапустить активных ботов после git pull + auto_install_reqs: true # Автоматически проверить и установить новые requirements.txt + +# ===================== MONITORING ===================== +# Настройки фонового мониторинга процессов и сбора метрик +monitoring: + enabled: true # Включить супервизор и сбор метрик CPU/RAM + interval: 5 # Интервал проверки состояния процессов (в секундах) + log_metrics: false # Спамить ли замерами CPU/RAM в терминал каждые N секунд + +# ===================== LOGGING ===================== +# Хранение логов и автоматическая ротация для экономии дискового пространства +logging: + dir: "logs" # Папка для сохранения логов stdout и stderr + manager_log: "logs/manager.log" # Лог-файл самого менеджера процессов + max_size_mb: 20.0 # Максимальный размер файла лога перед ротацией (в MB) + backup_count: 3 # Сколько ротированных архивов хранить (.log.1, .log.2...) + +# ===================== TASKS ===================== +# Список контролируемых ботов и процессов +tasks: + # Пример постоянного бота (24/7): + - name: my-telegram-bot # Уникальное имя задачи + script: "bots/tg_bot/main.py" # Путь к исполняемому Python-скрипту + args: ["--mode", "production"] # Аргументы командной строки передаваемые скрипту + autostart: true # Запускать ли бота при старте менеджера + autorestart: true # Автоматически перезапускать при падении (exit code != 0) + max_restarts: 5 # Лимит попыток рестарта (0 - без ограничений) + restart_delay: 3.0 # Пауза перед рестартом в секундах (защита от краш-штормов) + stable_uptime: 60.0 # Время стабильной работы (сек) для сброса счетчика рестартов + cwd: "" # Рабочая папка задачи (если пусто — папка скрипта) + + # --- Виртуальное окружение и версии Python --- + venv: "bots/tg_bot/.venv" # Папка для venv (создастся сама, если отсутствует) + python_version: "3.10" # Нужная версия Python ("3.10", "3.11", "3.12"...) + auto_create_venv: true # Автоматически создать venv при первом запуске + allow_download_python: true # Скачать portable Python (Резерв Б), если версии нет в системе + python_path: "" # Прямой путь к интерпретатору (если нужно переопределить) + + # --- Квоты ресурсов (Resource Quotas) --- + max_memory_mb: 500.0 # Лимит оперативной памяти в MB + memory_limit_action: "restart" # Действие при превышении: "restart", "kill" или "alert" + + # --- Тип расписания (Schedule) --- + schedule_type: "continuous" # "continuous" (работа 24/7) или "interval" (периодический запуск) + schedule_interval: 0 # Интервал для типа "interval" (в секундах) + + # --- Переменные окружения и зависимости --- + env: + PYTHONIOENCODING: "utf-8" + MY_CUSTOM_VAR: "example_value" + requirements: + enabled: true # Проверять и устанавливать зависимости + path: "bots/tg_bot/requirements.txt" # Путь к файлу зависимостей + + # Пример периодической задачи (запуск раз в 2 часа): + - name: database-backup + script: "scripts/backup.py" + args: [] + autostart: true + autorestart: false + schedule_type: "interval" + schedule_interval: 7200 # Запуск каждые 7200 секунд (2 часа) + requirements: + enabled: false + path: "" +``` + +--- + +## 🥚 Настройка в яйце Pterodactyl (Pterodactyl Egg) + +1. **Файлы в контейнере:** Загрузите файлы репозитория в корневую папку вашего сервера Pterodactyl. +2. **Команда запуска (Startup Command):** + ```bash + python3 manager.py + ``` +3. **Настройка SSH для приватных репозиториев:** + - Сгенерируйте SSH-ключ: `ssh-keygen -t ed25519 -C "ptera-manager" -f id_ed25519 -N ""` + - Добавьте открытый ключ `id_ed25519.pub` в **Deploy Keys** вашего Git-репозитория (GitHub / GitLab / Gitea). + - Приватный ключ `id_ed25519` оставьте в корне контейнера рядом с `config.yaml`. + - В `config.yaml` укажите `ssh_key_path: "id_ed25519"`. + - Менеджер автоматически установит на ключ права `0600` и настроит `StrictHostKeyChecking=no`. + +--- + +## 🛠 Архитектура проекта + +```text +ptera-py-manager/ +├── core/ +│ ├── __init__.py # Метаданные пакета +│ ├── models.py # Dataclass-модели настроек, квот, метрик и статусов задач +│ ├── logger.py # Потокобезопасный цветной логгер с поддержкой UTF-8 +│ ├── config.py # Безопасный парсер YAML с защитой от сбоев при опечатках +│ ├── notifier.py # Асинхронный диспетчер Telegram и Discord (Embeds) +│ ├── python_env.py # Поиск версий Python (А), автодокачка Portable CPython (Б) и venv +│ ├── process.py # ManagedTask: управление процессами, ротация логов, квоты RAM +│ ├── git_updater.py # Git-синхронизатор с авто-pull и поддержкой SSH Deploy Keys +│ ├── manager.py # ProcessManager: монитор процессов, синхронизация потоков, hot-reload +│ └── console.py # Интерактивная консоль с RapidFuzz и автодополнением Tab +├── config.yaml # Конфигурационный файл +├── manager.py # Точка входа в программу +├── reqs.txt # Зависимости Python +├── .gitignore # Исключения Git (логи, ключи, кэш, .venv) +└── README.md # Документация проекта +``` + +--- + +## 📄 Лицензия + +Разработано **Dev-Cored**. Распространяется свободно для личного и коммерческого использования. diff --git a/config.yaml b/config.yaml new file mode 100644 index 0000000..288a134 --- /dev/null +++ b/config.yaml @@ -0,0 +1,85 @@ +# ============================================================ +# PyTaskManager v2.5 Configuration +# ============================================================ + +# ===================== TELEGRAM ===================== +# Оповещения в Telegram о падениях, рестартах и событиях +telegram: + enabled: false + token: "BOT_TOKEN" + chat_id: "CHAT_ID" + +# ===================== DISCORD ===================== +# Оповещения через Discord Webhook (красивые цветные Embeds) +discord: + enabled: false + webhook_url: "https://discord.com/api/webhooks/YOUR_WEBHOOK_URL" + username: "PyTaskManager" + avatar_url: "" + +# ===================== GIT AUTO-UPDATE ===================== +# Автоматическая синхронизация с Git-репозиторием и поддержка SSH-ключей. +# Идеально для контейнеров Pterodactyl: положите приватный SSH-ключ рядом +# (например, id_ed25519), укажите путь, а публичный ключ добавьте в GitHub Deploy Keys. +git: + enabled: false + repo_url: "" # SSH или HTTPS ссылка (например git@github.com:username/repo.git) + branch: "main" # Ветка для отслеживания + check_interval: 300 # Интервал проверки новых коммитов (в секундах) + ssh_key_path: "" # Путь к приватному SSH-ключу (например "id_ed25519") + auto_restart: true # Авто-рестарт запущенных ботов после обновления кода + auto_install_reqs: true # Проверять и доустанавливать requirements при изменениях + +# ===================== MONITORING ===================== +# Мониторинг процессов, квот ресурсов и сбора метрик (CPU, RAM, Uptime) +monitoring: + enabled: true + interval: 5 # Интервал проверки процессов в секундах + log_metrics: false # Выводить ли метрики процессов в консоль каждые interval секунд + +# ===================== LOGGING ===================== +# Настройки хранения и автоматической ротации логов +logging: + dir: "logs" + manager_log: "logs/manager.log" + max_size_mb: 20.0 # Максимальный размер лог-файла до ротации (в мегабайтах) + backup_count: 3 # Количество сохраняемых архивных файлов логов (.log.1, .log.2...) + +# ===================== TASKS ===================== +# Список управляемых скриптов и задач. +# Раскомментируйте и настройте пример ниже для добавления своих задач. +tasks: + # ──────────────────────────────────────────────────────────── + # ПРИМЕР ШАБЛОНА ЗАДАЧИ: + # ──────────────────────────────────────────────────────────── + # - name: my-telegram-bot # Уникальное имя задачи + # script: "bots/tg_bot/main.py" # Путь к файлу скрипта + # args: ["--mode", "production"] # Аргументы командной строки + # autostart: true # Запускать при старте менеджера + # autorestart: true # Автоматически перезапускать при падении + # max_restarts: 5 # Максимальное число рестартов (0 - бесконечно) + # restart_delay: 3.0 # Пауза перед рестартом (защита от краш-штормов) + # stable_uptime: 60.0 # Время стабильной работы (сек) для сброса счетчика рестартов + # cwd: "" # Рабочая директория (если пусто — папка скрипта) + # + # # --- Изолированное окружение (Venv / Python) --- + # venv: "bots/tg_bot/.venv" # Папка с venv (создается автоматически, если нет) + # python_version: "3.10" # Нужная версия Python ("3.10", "3.11", "3.12"...) + # auto_create_venv: true # Автоматически создать venv при первом запуске + # allow_download_python: true # Резерв Б: автоматически скачать portable Python, если нет в системе + # python_path: "" # Или прямой путь к конкретному интерпретатору + # + # # --- Квоты ресурсов (Resource Quotas) --- + # max_memory_mb: 500.0 # Лимит RAM в MB (restart, kill или alert при превышении) + # memory_limit_action: "restart" # Действие: "restart", "kill" или "alert" + # + # # --- Планировщик запусков (Schedule) --- + # schedule_type: "continuous" # "continuous" (24/7 бот) или "interval" (периодический запуск) + # schedule_interval: 3600 # Интервал между запусками в секундах (для "interval") + # + # # --- Окружение и Зависимости --- + # env: + # PYTHONIOENCODING: "utf-8" + # requirements: + # enabled: false # Проверять и устанавливать зависимости перед запуском + # path: "bots/tg_bot/requirements.txt" # Путь к файлу зависимостей diff --git a/core/__init__.py b/core/__init__.py new file mode 100644 index 0000000..8b8f124 --- /dev/null +++ b/core/__init__.py @@ -0,0 +1,7 @@ +""" +DevCoded PteraPyManager Core Package +A powerful process supervisor and task manager for Python bots and services. +""" + +__version__ = "2.5.0" +__author__ = "Dev-Cored" diff --git a/core/config.py b/core/config.py new file mode 100644 index 0000000..07bda5d --- /dev/null +++ b/core/config.py @@ -0,0 +1,88 @@ +import os +import yaml +from typing import Optional, Dict +from core.models import ( + AppConfig, TelegramConfig, DiscordConfig, GitConfig, + MonitoringConfig, LoggingConfig, TaskConfig +) +from core.logger import log_err, log_warn + + +class ConfigManager: + def __init__(self, config_path: str = "config.yaml"): + self.config_path = config_path + self._last_mtime: float = 0.0 + + def load(self, exit_on_fail: bool = False) -> Optional[AppConfig]: + """Безопасная загрузка конфигурации без падения процесса""" + if not os.path.exists(self.config_path): + log_err(f"Конфиг {self.config_path} не найден!") + if exit_on_fail: + raise FileNotFoundError(f"Config file not found: {self.config_path}") + return None + + try: + with open(self.config_path, "r", encoding="utf-8") as f: + raw_data = yaml.safe_load(f) + + if raw_data is None: + log_warn(f"Конфиг {self.config_path} пуст") + raw_data = {} + + if not isinstance(raw_data, dict): + raise ValueError("Корневой элемент YAML должен быть словарем (dict)") + + telegram = TelegramConfig.from_dict(raw_data.get("telegram") or {}) + discord = DiscordConfig.from_dict(raw_data.get("discord") or {}) + git = GitConfig.from_dict(raw_data.get("git") or {}) + monitoring = MonitoringConfig.from_dict(raw_data.get("monitoring") or {}) + logging_cfg = LoggingConfig.from_dict(raw_data.get("logging") or {}) + + raw_tasks = raw_data.get("tasks") or [] + tasks: Dict[str, TaskConfig] = {} + + if isinstance(raw_tasks, list): + for item in raw_tasks: + if not isinstance(item, dict): + continue + name = str(item.get("name", "")).strip() + if not name: + log_warn("Пропущена задача без указания имени") + continue + if name in tasks: + log_warn(f"Дублирующееся имя задачи '{name}', перезаписываем") + tasks[name] = TaskConfig.from_dict(item) + elif isinstance(raw_tasks, dict): + for name, item in raw_tasks.items(): + if isinstance(item, dict): + item["name"] = name + tasks[name] = TaskConfig.from_dict(item) + + self._last_mtime = os.path.getmtime(self.config_path) + return AppConfig( + telegram=telegram, + discord=discord, + git=git, + monitoring=monitoring, + logging=logging_cfg, + tasks=tasks + ) + + except Exception as e: + log_err(f"Ошибка парсинга конфига {self.config_path}: {e}") + if exit_on_fail: + raise e + return None + + def check_modified(self) -> bool: + """Проверка изменения файла на диске""" + try: + if not os.path.exists(self.config_path): + return False + mtime = os.path.getmtime(self.config_path) + if mtime != self._last_mtime: + self._last_mtime = mtime + return True + except Exception: + pass + return False diff --git a/core/console.py b/core/console.py new file mode 100644 index 0000000..dc6fcfe --- /dev/null +++ b/core/console.py @@ -0,0 +1,397 @@ +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 """ + 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 """ + 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 """ + 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 (алиас: git-pull)""" + print(Fore.CYAN + "Проверка обновлений Git репозитория...") + updated, msg = self.manager.pull_git(manual=True) + if updated: + print(Fore.GREEN + f"✓ {msg}") + else: + print(Fore.YELLOW + f"ℹ️ {msg}") + + def do_git_pull(self, arg): + """Алиас для update""" + self.do_update(arg) + + def do_logs(self, arg): + """Показать логи задачи: logs [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 """ + 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 """ + 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 'По умолчанию (папка скрипта)'}") + 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 """ + 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 """ + 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 ", "Запустить задачу"), + ("stop ", "Остановить задачу (graceful termination дерева процессов)"), + ("restart ", "Перезапустить задачу"), + ("start-all", "Запустить все незапущенные задачи"), + ("stop-all", "Остановить все задачи"), + ("restart-all", "Перезапустить все задачи"), + ("update / git-pull", "Проверить и подтянуть обновления из Git-репозитория"), + ("logs [lines]", "Показать последние строки stdout и stderr"), + ("tail ", "Следить за выводом логов в режиме реального времени"), + ("info ", "Подробная диагностика задачи (пути, venv, квоты, ошибки)"), + ("install ", "Установить requirements.txt для указанной задачи"), + ("clean-logs ", "Очистить файлы логов выбранной задачи"), + ("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() diff --git a/core/git_updater.py b/core/git_updater.py new file mode 100644 index 0000000..b09b99e --- /dev/null +++ b/core/git_updater.py @@ -0,0 +1,190 @@ +import os +import sys +import stat +import subprocess +import threading +import time +from pathlib import Path +from typing import Optional, Tuple, Dict, Any + +from core.models import GitConfig +from core.logger import log_info, log_warn, log_err, log_debug + + +class GitUpdater: + """Управление синхронизацией с Git-репозиторием и поддержкой SSH-ключей""" + + def __init__(self, config: GitConfig, notifier, manager): + self.cfg = config + self.notifier = notifier + self.manager = manager + self.shutdown_event = threading.Event() + self._thread: Optional[threading.Thread] = None + self._lock = threading.Lock() + + def update_config(self, new_cfg: GitConfig): + self.cfg = new_cfg + + def start(self): + if self._thread and self._thread.is_alive(): + return + self._thread = threading.Thread(target=self._run_loop, daemon=True, name="GitUpdaterThread") + self._thread.start() + + def _get_git_env(self) -> Dict[str, str]: + """Подготовка переменных окружения для git с учетом SSH-ключа""" + env = os.environ.copy() + + if self.cfg.ssh_key_path: + key_path = Path(self.cfg.ssh_key_path).resolve() + if not key_path.exists(): + log_warn(f"[Git] Указанный SSH-ключ не найден: {key_path}") + else: + # На Unix/Linux системах (включая Pterodactyl яйца) выставляем права 0600 + if sys.platform != "win32": + try: + os.chmod(key_path, stat.S_IRUSR | stat.S_IWUSR) + except Exception as e: + log_debug(f"[Git] Не удалось установить chmod 0600 на ключ: {e}") + + # Настройка команды SSH: игнорируем подтверждение хоста и используем ключ + devnull = "NUL" if sys.platform == "win32" else "/dev/null" + ssh_cmd = ( + f"ssh -i \"{key_path}\" " + "-o StrictHostKeyChecking=no " + f"-o UserKnownHostsFile={devnull} " + "-o IdentitiesOnly=yes" + ) + env["GIT_SSH_COMMAND"] = ssh_cmd + + return env + + def _run_git_cmd(self, args: list, cwd: str = ".") -> Tuple[int, str, str]: + """Безопасный вызов команды git""" + try: + env = self._get_git_env() + res = subprocess.run( + ["git"] + args, + cwd=cwd, + env=env, + capture_output=True, + text=True, + timeout=60 + ) + return res.returncode, res.stdout.strip(), res.stderr.strip() + except subprocess.TimeoutExpired: + return -1, "", "Таймаут выполнения команды git (60 сек)" + except Exception as e: + return -1, "", str(e) + + def check_and_pull(self, manual: bool = False) -> Tuple[bool, str]: + """ + Проверка обновлений и выполнение pull. + Возвращает: (было_ли_обновление: bool, сообщение_или_ошибка: str) + """ + with self._lock: + # Проверяем, является ли текущая директория git-репозиторием + code, out, _ = self._run_git_cmd(["rev-parse", "--is-inside-work-tree"]) + if code != 0: + if self.cfg.repo_url: + log_info(f"[Git] Инициализация git-репозитория с URL {self.cfg.repo_url}...") + self._run_git_cmd(["init"]) + self._run_git_cmd(["remote", "add", "origin", self.cfg.repo_url]) + else: + msg = "Текущая папка не является git-репозиторием, и repo_url не указан." + if manual: + log_warn(f"[Git] {msg}") + return False, msg + + branch = self.cfg.branch or "main" + + # 1. Проверяем / обновляем URL origin, если задан + if self.cfg.repo_url: + code_remote, origin_url, _ = self._run_git_cmd(["remote", "get-url", "origin"]) + if code_remote != 0: + self._run_git_cmd(["remote", "add", "origin", self.cfg.repo_url]) + elif origin_url != self.cfg.repo_url: + self._run_git_cmd(["remote", "set-url", "origin", self.cfg.repo_url]) + + # 2. Выполняем fetch + if manual: + log_info(f"[Git] Проверка обновлений (ветка: {branch})...") + fetch_code, _, fetch_err = self._run_git_cmd(["fetch", "origin", branch]) + if fetch_code != 0: + err_msg = f"Ошибка git fetch: {fetch_err}" + log_warn(f"[Git] {err_msg}") + return False, err_msg + + # 3. Сравниваем локальный HEAD и origin/branch + code_head, local_head, _ = self._run_git_cmd(["rev-parse", "HEAD"]) + code_remote, remote_head, _ = self._run_git_cmd(["rev-parse", f"origin/{branch}"]) + + if code_head != 0 or code_remote != 0: + # Возможно, ветка новая + err_msg = "Не удалось определить ревизии веток" + return False, err_msg + + if local_head == remote_head: + if manual: + log_info("[Git] Репозиторий уже в актуальном состоянии.") + return False, "Репозиторий уже актуален" + + log_info(f"[Git] Обнаружены новые коммиты! Локальный: {local_head[:7]} -> Удаленный: {remote_head[:7]}") + + # 4. Выполняем pull + pull_code, pull_out, pull_err = self._run_git_cmd(["pull", "origin", branch]) + if pull_code != 0: + err_msg = f"Ошибка git pull: {pull_err}" + log_err(f"[Git] {err_msg}") + self.notifier.send( + f"❌ Ошибка обновления Git:\n
{pull_err}
", + title="Ошибка Git Auto-Update", + level="error" + ) + return False, err_msg + + # 5. Получаем информацию о последнем коммите + _, commit_info, _ = self._run_git_cmd(["log", "-1", "--pretty=format:%h - %s (%an)"]) + + success_msg = f"Репозиторий успешно обновлен: {commit_info}" + log_info(f"[Git] {success_msg}") + + # Уведомление + self.notifier.send( + f"🔄 Git репозиторий обновлен!\n" + f"• Ветка: {branch}\n" + f"• Коммит: {commit_info}", + title="Git Auto-Update", + level="success", + fields={"Ветка": branch, "Коммит": commit_info} + ) + + # 6. Обновление зависимостей задач при необходимости + if self.cfg.auto_install_reqs: + for task in self.manager.get_all_tasks().values(): + if task.cfg.requirements_enabled: + task.check_and_install_requirements(force=False) + + # 7. Автоматический перезапуск ботов + if self.cfg.auto_restart: + log_info("[Git] Перезапуск запущенных задач после обновления кода...") + self.manager.restart_all() + + return True, success_msg + + def _run_loop(self): + """Периодический фоновый цикл проверки обновлений""" + while not self.shutdown_event.is_set(): + interval = self.cfg.check_interval if self.cfg.check_interval > 10 else 300.0 + self.shutdown_event.wait(timeout=interval) + + if not self.cfg.enabled: + continue + + try: + self.check_and_pull(manual=False) + except Exception as e: + log_err(f"[Git] Ошибка в цикле автообновления: {e}") + + def shutdown(self): + self.shutdown_event.set() diff --git a/core/logger.py b/core/logger.py new file mode 100644 index 0000000..f63ff30 --- /dev/null +++ b/core/logger.py @@ -0,0 +1,78 @@ +import os +import sys +import threading +from typing import Optional +from datetime import datetime +from colorama import Fore, Style, init + +if sys.platform == "win32": + try: + if hasattr(sys.stdout, "reconfigure"): + sys.stdout.reconfigure(encoding="utf-8") + if hasattr(sys.stderr, "reconfigure"): + sys.stderr.reconfigure(encoding="utf-8") + except Exception: + pass + +init(autoreset=True) + +_print_lock = threading.Lock() +_log_file: Optional[str] = None + + +def setup_logger(log_file_path: Optional[str] = None): + """Настройка файла логирования для самого менеджера""" + global _log_file + if log_file_path: + os.makedirs(os.path.dirname(os.path.abspath(log_file_path)), exist_ok=True) + _log_file = log_file_path + + +def _format_msg(level_name: str, color: str, msg: str) -> str: + timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") + return f"{color}[{timestamp}] [{level_name}] {msg}{Style.RESET_ALL}" + + +def _write_to_file(level_name: str, msg: str): + if _log_file: + try: + timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") + with open(_log_file, "a", encoding="utf-8") as f: + f.write(f"[{timestamp}] [{level_name}] {msg}\n") + except Exception: + pass + + +def log_info(msg: str): + formatted = _format_msg("ИНФО", Fore.GREEN, msg) + with _print_lock: + print(formatted) + _write_to_file("ИНФО", msg) + + +def log_warn(msg: str): + formatted = _format_msg("ПРЕДУПРЕЖДЕНИЕ", Fore.YELLOW, msg) + with _print_lock: + print(formatted) + _write_to_file("ПРЕДУПРЕЖДЕНИЕ", msg) + + +def log_err(msg: str): + formatted = _format_msg("ОШИБКА", Fore.RED, msg) + with _print_lock: + print(formatted) + _write_to_file("ОШИБКА", msg) + + +def log_setup(msg: str): + formatted = _format_msg("SETUP", Fore.BLUE, msg) + with _print_lock: + print(formatted) + _write_to_file("SETUP", msg) + + +def log_debug(msg: str): + formatted = _format_msg("DEBUG", Fore.MAGENTA, msg) + with _print_lock: + print(formatted) + _write_to_file("DEBUG", msg) diff --git a/core/manager.py b/core/manager.py new file mode 100644 index 0000000..0476dff --- /dev/null +++ b/core/manager.py @@ -0,0 +1,330 @@ +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() + + if self.app_config.git.enabled: + 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 + + success = task.start() + if success: + self.notifier.send( + f"🚀 Задача запущена: {name} (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"🛑 Задача остановлена: {name}", + 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"🔄 Задача перезапущена: {name} (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, manual: bool = True) -> Tuple[bool, str]: + """Ручной запуск проверки и обновления из Git""" + return self.git_updater.check_and_pull(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) + + if new_config.git.enabled: + self.git_updater.start() + + 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: + managed.start() + if managed.is_running(): + self.notifier.send( + f"🚀 Автозапуск задачи: {name} (PID: {managed.proc.pid})", + title="Автозапуск задачи", + level="success", + fields={"Задача": name, "PID": str(managed.proc.pid)} + ) + + 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"⚠️ Превышение квоты памяти!\n" + f"• Задача: {task.cfg.name}\n" + f"• Использование: {over_mem} MB (Лимит: {limit} MB)\n" + f"• Действие: {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"⚠️ Задача завершилась аварийно!\n" + f"• Задача: {task.cfg.name}\n" + f"• Код выхода: {exit_code}\n" + f"• Время работы: {uptime}s\n" + ) + if err_snippet: + clean_err = err_snippet[:400].replace("<", "<").replace(">", ">") + tg_text += f"\n
{clean_err}
" + + 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"❌ Лимит рестартов исчерпан: {task.cfg.name} ({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("Все задачи завершены.") diff --git a/core/models.py b/core/models.py new file mode 100644 index 0000000..36b7262 --- /dev/null +++ b/core/models.py @@ -0,0 +1,183 @@ +from dataclasses import dataclass, field +from enum import Enum +from typing import List, Dict, Optional + + +class TaskStatus(str, Enum): + STOPPED = "STOPPED" + STARTING = "STARTING" + RUNNING = "RUNNING" + CRASHED = "CRASHED" + BACKOFF = "BACKOFF" + STOPPING = "STOPPING" + SCHEDULED = "SCHEDULED" + + +@dataclass +class TaskConfig: + name: str + script: str + args: List[str] = field(default_factory=list) + autostart: bool = True + autorestart: bool = True + max_restarts: int = 5 + restart_delay: float = 3.0 + stable_uptime: float = 60.0 + cwd: Optional[str] = None + env: Dict[str, str] = field(default_factory=dict) + + # Виртуальное окружение / интерпретатор + venv: Optional[str] = None + python_path: Optional[str] = None + python_version: Optional[str] = None # e.g. "3.10", "3.11", "3.12" + auto_create_venv: bool = True # Автоматически создавать venv при отсутствии + allow_download_python: bool = True # Докачивать portable python (резерв Б), если нет в системе + + # Ограничение ресурсов (Квоты) + max_memory_mb: Optional[float] = None + memory_limit_action: str = "restart" # "restart", "kill", "alert" + + # Планировщик задач + schedule_type: str = "continuous" # "continuous", "interval", "once" + schedule_interval: float = 0.0 # в секундах (для интервала) + + # Зависимости + requirements_enabled: bool = False + requirements_path: str = "" + + @classmethod + def from_dict(cls, data: dict) -> "TaskConfig": + req = data.get("requirements") or {} + max_mem = data.get("max_memory_mb") + return cls( + name=str(data.get("name", "")).strip(), + script=str(data.get("script", "")).strip(), + args=[str(a) for a in data.get("args", [])], + autostart=bool(data.get("autostart", True)), + autorestart=bool(data.get("autorestart", True)), + max_restarts=int(data.get("max_restarts", 5)), + restart_delay=float(data.get("restart_delay", 3.0)), + stable_uptime=float(data.get("stable_uptime", 60.0)), + cwd=data.get("cwd") or None, + env=data.get("env") or {}, + venv=data.get("venv") or None, + python_path=data.get("python_path") or None, + python_version=str(data.get("python_version", "")).strip() or None, + auto_create_venv=bool(data.get("auto_create_venv", True)), + allow_download_python=bool(data.get("allow_download_python", True)), + max_memory_mb=float(max_mem) if max_mem is not None else None, + memory_limit_action=str(data.get("memory_limit_action", "restart")).lower(), + schedule_type=str(data.get("schedule_type", "continuous")).lower(), + schedule_interval=float(data.get("schedule_interval", 0.0)), + requirements_enabled=bool(req.get("enabled", False)), + requirements_path=str(req.get("path", "")).strip() + ) + + +@dataclass +class TelegramConfig: + enabled: bool = False + token: str = "" + chat_id: str = "" + + @classmethod + def from_dict(cls, data: dict) -> "TelegramConfig": + return cls( + enabled=bool(data.get("enabled", False)), + token=str(data.get("token", "")).strip(), + chat_id=str(data.get("chat_id", "")).strip() + ) + + +@dataclass +class DiscordConfig: + enabled: bool = False + webhook_url: str = "" + username: str = "PyTaskManager" + avatar_url: str = "" + + @classmethod + def from_dict(cls, data: dict) -> "DiscordConfig": + return cls( + enabled=bool(data.get("enabled", False)), + webhook_url=str(data.get("webhook_url", "")).strip(), + username=str(data.get("username", "PyTaskManager")).strip(), + avatar_url=str(data.get("avatar_url", "")).strip() + ) + + +@dataclass +class GitConfig: + enabled: bool = False + repo_url: str = "" + branch: str = "main" + check_interval: float = 300.0 # Каждые 5 минут + ssh_key_path: str = "" + auto_restart: bool = True + auto_install_reqs: bool = True + + @classmethod + def from_dict(cls, data: dict) -> "GitConfig": + return cls( + enabled=bool(data.get("enabled", False)), + repo_url=str(data.get("repo_url", "")).strip(), + branch=str(data.get("branch", "main")).strip(), + check_interval=float(data.get("check_interval", 300.0)), + ssh_key_path=str(data.get("ssh_key_path", "")).strip(), + auto_restart=bool(data.get("auto_restart", True)), + auto_install_reqs=bool(data.get("auto_install_reqs", True)) + ) + + +@dataclass +class MonitoringConfig: + enabled: bool = True + interval: float = 5.0 + log_metrics: bool = False + + @classmethod + def from_dict(cls, data: dict) -> "MonitoringConfig": + return cls( + enabled=bool(data.get("enabled", True)), + interval=float(data.get("interval", 5.0)), + log_metrics=bool(data.get("log_metrics", False)) + ) + + +@dataclass +class LoggingConfig: + dir: str = "logs" + manager_log: Optional[str] = "logs/manager.log" + max_size_mb: float = 20.0 + backup_count: int = 3 + + @classmethod + def from_dict(cls, data: dict) -> "LoggingConfig": + return cls( + dir=str(data.get("dir", "logs")), + manager_log=data.get("manager_log", "logs/manager.log"), + max_size_mb=float(data.get("max_size_mb", 20.0)), + backup_count=int(data.get("backup_count", 3)) + ) + + +@dataclass +class AppConfig: + telegram: TelegramConfig = field(default_factory=TelegramConfig) + discord: DiscordConfig = field(default_factory=DiscordConfig) + git: GitConfig = field(default_factory=GitConfig) + monitoring: MonitoringConfig = field(default_factory=MonitoringConfig) + logging: LoggingConfig = field(default_factory=LoggingConfig) + tasks: Dict[str, TaskConfig] = field(default_factory=dict) + + +@dataclass +class TaskMetrics: + cpu_percent: float = 0.0 + memory_mb: float = 0.0 + uptime_sec: float = 0.0 + pid: Optional[int] = None + restart_count: int = 0 + status: TaskStatus = TaskStatus.STOPPED + last_exit_code: Optional[int] = None + last_error: str = "" diff --git a/core/notifier.py b/core/notifier.py new file mode 100644 index 0000000..903701e --- /dev/null +++ b/core/notifier.py @@ -0,0 +1,150 @@ +import queue +import threading +from datetime import datetime +from typing import Optional, Dict, Any +import requests + +from core.models import TelegramConfig, DiscordConfig +from core.logger import log_err, log_warn, log_debug + + +class Notifier: + """Асинхронный диспетчер уведомлений для Telegram и Discord Webhook""" + + def __init__(self): + self._tg_cfg = TelegramConfig() + self._dc_cfg = DiscordConfig() + self._queue: queue.Queue = queue.Queue() + self._shutdown_event = threading.Event() + self._worker_thread = threading.Thread( + target=self._worker, daemon=True, name="NotifierWorker" + ) + self._worker_thread.start() + + def update_configs(self, tg_cfg: TelegramConfig, dc_cfg: DiscordConfig): + self._tg_cfg = tg_cfg + self._dc_cfg = dc_cfg + + def send( + self, + text: str, + title: Optional[str] = None, + level: str = "info", + fields: Optional[Dict[str, str]] = None + ): + """ + Помещает уведомление в очередь отправки. + :param text: Основной текст + :param title: Заголовок (для Discord Embed) + :param level: "info", "success", "warning", "error" + :param fields: Словарь дополнительных полей {ключ: значение} + """ + if not self._tg_cfg.enabled and not self._dc_cfg.enabled: + return + + payload = { + "text": text, + "title": title or "PyTaskManager", + "level": level, + "fields": fields or {}, + "timestamp": datetime.utcnow().isoformat() + } + self._queue.put(payload) + + def _worker(self): + while not self._shutdown_event.is_set(): + try: + item = self._queue.get(timeout=1.0) + except queue.Empty: + continue + + try: + if self._tg_cfg.enabled: + self._send_telegram(item) + if self._dc_cfg.enabled: + self._send_discord(item) + except Exception as e: + log_debug(f"Ошибка в Notifier worker: {e}") + finally: + self._queue.task_done() + + def _send_telegram(self, item: dict): + if not self._tg_cfg.token or not self._tg_cfg.chat_id: + return + + url = f"https://api.telegram.org/bot{self._tg_cfg.token}/sendMessage" + + # Преобразуем заголовок и поля в HTML для Telegram + html_msg = item["text"] + if item.get("fields"): + field_lines = [f"• {k}: {v}" for k, v in item["fields"].items()] + html_msg += "\n" + "\n".join(field_lines) + + payload = { + "chat_id": self._tg_cfg.chat_id, + "text": html_msg, + "parse_mode": "HTML" + } + + try: + resp = requests.post(url, json=payload, timeout=8) + if not resp.ok: + # Fallback без разметки + payload.pop("parse_mode", None) + payload["text"] = payload["text"].replace("", "").replace("", "").replace("", "").replace("", "") + requests.post(url, json=payload, timeout=5) + except requests.RequestException as e: + log_err(f"Ошибка отправки Telegram: {e}") + + def _send_discord(self, item: dict): + if not self._dc_cfg.webhook_url: + return + + colors = { + "success": 0x2ECC71, # Зеленый + "error": 0xE74C3C, # Красный + "warning": 0xF1C40F, # Желтый + "info": 0x3498DB # Синий + } + embed_color = colors.get(item.get("level", "info"), 0x3498DB) + + embed_fields = [] + for k, v in item.get("fields", {}).items(): + embed_fields.append({ + "name": str(k), + "value": str(v), + "inline": True + }) + + # Очищаем HTML теги для Discord + clean_desc = ( + item["text"] + .replace("", "**").replace("", "**") + .replace("", "`").replace("", "`") + .replace("
", "```").replace("
", "```") + ) + + embed = { + "title": item.get("title", "Оповещение PyTaskManager"), + "description": clean_desc, + "color": embed_color, + "fields": embed_fields, + "footer": {"text": "PyTaskManager v2.5"} + } + + payload: Dict[str, Any] = { + "username": self._dc_cfg.username or "PyTaskManager", + "embeds": [embed] + } + if self._dc_cfg.avatar_url: + payload["avatar_url"] = self._dc_cfg.avatar_url + + try: + resp = requests.post(self._dc_cfg.webhook_url, json=payload, timeout=8) + if not resp.ok: + log_warn(f"Ошибка отправки Discord Webhook: HTTP {resp.status_code} - {resp.text}") + except requests.RequestException as e: + log_err(f"Ошибка отправки Discord: {e}") + + def shutdown(self): + self._shutdown_event.set() diff --git a/core/process.py b/core/process.py new file mode 100644 index 0000000..6363ab5 --- /dev/null +++ b/core/process.py @@ -0,0 +1,435 @@ +import os +import sys +import time +import hashlib +import subprocess +import threading +from pathlib import Path +from typing import Optional, List, Dict, Tuple +import psutil + +from core.models import TaskConfig, TaskStatus, TaskMetrics +from core.python_env import PythonEnvManager +from core.logger import log_info, log_warn, log_err, log_setup, log_debug + + +class ManagedTask: + """Управление жизненным циклом отдельной задачи/процесса""" + + def __init__(self, config: TaskConfig, logs_dir: str = "logs"): + self.cfg = config + self.logs_dir = Path(logs_dir) + self.logs_dir.mkdir(parents=True, exist_ok=True) + + self.stdout_path = self.logs_dir / f"{self.cfg.name}_stdout.log" + self.stderr_path = self.logs_dir / f"{self.cfg.name}_stderr.log" + + self._stdout_file = None + self._stderr_file = None + + self.proc: Optional[subprocess.Popen] = None + self.psutil_proc: Optional[psutil.Process] = None + + self.status: TaskStatus = TaskStatus.STOPPED + self.start_time: float = 0.0 + self.stop_time: float = 0.0 + self.restart_count: int = 0 + self.last_crash_time: float = 0.0 + self.last_exit_code: Optional[int] = None + self.last_error_message: str = "" + + # Планировщик (Interval / Cron) + self.next_run_time: float = 0.0 + + self._lock = threading.RLock() + self._installed_reqs_hash: Optional[str] = None + + def update_config(self, new_cfg: TaskConfig): + """Обновление конфигурации задачи на лету""" + with self._lock: + self.cfg = new_cfg + + def get_python_executable(self) -> Tuple[str, Optional[str]]: + """ + Определение интерпретатора Python с учетом auto-create venv, + выбора версии Python (Вариант А + Резерв Б) или python_path. + Возвращает: (путь_к_python, путь_к_папке_bin_для_PATH) + """ + # 1. Если указан прямой python_path + if self.cfg.python_path and os.path.exists(self.cfg.python_path): + return self.cfg.python_path, None + + # 2. Использование PythonEnvManager (автосоздание venv, поиск версии, докачка) + req_path = self.cfg.requirements_path if self.cfg.requirements_enabled else None + return PythonEnvManager.ensure_task_environment( + venv_path_str=self.cfg.venv, + python_version=self.cfg.python_version, + auto_create_venv=self.cfg.auto_create_venv, + allow_download=self.cfg.allow_download_python, + requirements_path=req_path, + requirements_enabled=self.cfg.requirements_enabled + ) + + def check_and_install_requirements(self, force: bool = False) -> bool: + """Проверка и установка зависимостей задачи с кэшированием хеша файла""" + if not self.cfg.requirements_enabled and not force: + return True + + req_path = self.cfg.requirements_path + if not req_path: + return True + + candidate_paths = [ + Path(req_path), + Path(self.cfg.cwd or ".") / req_path, + Path(os.path.dirname(os.path.abspath(self.cfg.script))) / os.path.basename(req_path) + ] + target_req = None + for p in candidate_paths: + if p.exists() and p.is_file(): + target_req = p + break + + if not target_req: + log_warn(f"[{self.cfg.name}] Файл зависимостей не найден: {req_path}") + return False + + try: + with open(target_req, "rb") as f: + content_hash = hashlib.md5(f.read()).hexdigest() + except Exception as e: + log_err(f"[{self.cfg.name}] Не удалось прочитать requirements: {e}") + return False + + if not force and self._installed_reqs_hash == content_hash: + log_debug(f"[{self.cfg.name}] Зависимости уже актуальны (хэш совпадает)") + return True + + python_bin, _ = self.get_python_executable() + log_setup(f"[{self.cfg.name}] Установка зависимостей из {target_req} через {python_bin}...") + try: + result = subprocess.run( + [python_bin, "-m", "pip", "install", "-r", str(target_req)], + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + text=True, + timeout=180 + ) + if result.returncode == 0: + self._installed_reqs_hash = content_hash + log_setup(f"[{self.cfg.name}] Зависимости успешно установлены!") + return True + else: + log_err(f"[{self.cfg.name}] Ошибка pip: {result.stderr.strip()}") + return False + except subprocess.TimeoutExpired: + log_err(f"[{self.cfg.name}] Таймаут установки зависимостей (180 сек)") + return False + except Exception as e: + log_err(f"[{self.cfg.name}] Ошибка вызова pip: {e}") + return False + + def rotate_logs_if_needed(self, max_size_bytes: int, backup_count: int = 3): + """Ротация файлов логов при превышении максимального размера""" + with self._lock: + for log_path in [self.stdout_path, self.stderr_path]: + if not log_path.exists(): + continue + + try: + if log_path.stat().st_size >= max_size_bytes: + self._close_log_handles() + + # Ротация существующих бэкапов: .log.3 удаляется, .log.2 -> .3, .log.1 -> .2, .log -> .1 + for i in range(backup_count, 0, -1): + src = Path(f"{log_path}.{i}") + dst = Path(f"{log_path}.{i + 1}") + if i == backup_count and src.exists(): + src.unlink(missing_ok=True) + elif src.exists(): + src.rename(dst) + + if log_path.exists(): + log_path.rename(Path(f"{log_path}.1")) + + log_debug(f"[{self.cfg.name}] Выполнена ротация лога {log_path.name}") + self._reopen_log_handles() + except Exception as e: + log_debug(f"Ошибка ротации лога {log_path}: {e}") + + def _reopen_log_handles(self): + """Переоткрытие дескрипторов после ротации""" + if self.is_running(): + try: + self._stdout_file = open(self.stdout_path, "a", encoding="utf-8", buffering=1) + self._stderr_file = open(self.stderr_path, "a", encoding="utf-8", buffering=1) + except Exception: + pass + + def start(self) -> bool: + """Запуск процесса задачи""" + with self._lock: + if self.is_running(): + log_warn(f"Задача {self.cfg.name} уже выполняется (PID: {self.proc.pid})") + return False + + script_path = Path(self.cfg.script) + if not script_path.exists(): + if self.cfg.cwd: + script_path = Path(self.cfg.cwd) / self.cfg.script + if not script_path.exists(): + log_err(f"[{self.cfg.name}] Скрипт не найден: {self.cfg.script}") + self.status = TaskStatus.CRASHED + self.last_error_message = f"Файл не найден: {self.cfg.script}" + return False + + script_abs = script_path.resolve() + working_dir = Path(self.cfg.cwd).resolve() if self.cfg.cwd else script_abs.parent + + # Установка зависимостей + if self.cfg.requirements_enabled: + self.check_and_install_requirements() + + # Определение интерпретатора Python + python_bin, bin_dir = self.get_python_executable() + + # Подготовка окружения + env = os.environ.copy() + env["PYTHONUNBUFFERED"] = "1" + if bin_dir: + env["PATH"] = bin_dir + os.pathsep + env.get("PATH", "") + env["VIRTUAL_ENV"] = str(Path(bin_dir).parent) + + if self.cfg.env: + env.update({k: str(v) for k, v in self.cfg.env.items()}) + + cmd = [python_bin, str(script_abs)] + list(self.cfg.args) + + try: + self._close_log_handles() + self._stdout_file = open(self.stdout_path, "a", encoding="utf-8", buffering=1) + self._stderr_file = open(self.stderr_path, "a", encoding="utf-8", buffering=1) + + timestamp = time.strftime("%Y-%m-%d %H:%M:%S") + banner = f"\n{'='*20} [START {timestamp}] {'='*20}\n" + self._stdout_file.write(banner) + self._stderr_file.write(banner) + self._stdout_file.flush() + self._stderr_file.flush() + + self.proc = subprocess.Popen( + cmd, + stdout=self._stdout_file, + stderr=self._stderr_file, + cwd=str(working_dir), + env=env + ) + + self.start_time = time.time() + self.status = TaskStatus.RUNNING + try: + self.psutil_proc = psutil.Process(self.proc.pid) + self.psutil_proc.cpu_percent(interval=None) + except Exception: + self.psutil_proc = None + + log_info(f"Задача '{self.cfg.name}' запущена (PID {self.proc.pid})") + return True + + except Exception as e: + self.status = TaskStatus.CRASHED + self.last_error_message = str(e) + log_err(f"Ошибка запуска задачи '{self.cfg.name}': {e}") + self._close_log_handles() + return False + + def stop(self, force: bool = False, timeout: float = 5.0) -> bool: + """Остановка процесса и его дочерних процессов""" + with self._lock: + if not self.proc or self.proc.poll() is not None: + self.status = TaskStatus.STOPPED + self._close_log_handles() + return True + + self.status = TaskStatus.STOPPING + pid = self.proc.pid + + children = [] + try: + if self.psutil_proc and self.psutil_proc.is_running(): + children = self.psutil_proc.children(recursive=True) + except Exception: + pass + + log_info(f"Остановка задачи '{self.cfg.name}' (PID: {pid})...") + + try: + if force: + self._kill_process_tree(children) + else: + self.proc.terminate() + for child in children: + try: + child.terminate() + except Exception: + pass + + try: + self.proc.wait(timeout=timeout) + except subprocess.TimeoutExpired: + log_warn(f"Задача '{self.cfg.name}' не ответила на SIGTERM, принудительное завершение...") + self._kill_process_tree(children) + + except Exception as e: + log_err(f"Исключение при остановке '{self.cfg.name}': {e}") + finally: + self.stop_time = time.time() + self.status = TaskStatus.STOPPED + self._close_log_handles() + + log_info(f"Задача '{self.cfg.name}' остановлена") + return True + + def _kill_process_tree(self, children: List[psutil.Process]): + for child in children: + try: + child.kill() + except Exception: + pass + try: + if self.proc: + self.proc.kill() + self.proc.wait(timeout=2.0) + except Exception: + pass + + def _close_log_handles(self): + """Безопасное закрытие дескрипторов файлов логов""" + if self._stdout_file: + try: + self._stdout_file.flush() + self._stdout_file.close() + except Exception: + pass + self._stdout_file = None + + if self._stderr_file: + try: + self._stderr_file.flush() + self._stderr_file.close() + except Exception: + pass + self._stderr_file = None + + def is_running(self) -> bool: + if self.proc is None: + return False + return self.proc.poll() is None + + def poll_exit(self) -> Optional[int]: + with self._lock: + if self.proc is None: + return None + exit_code = self.proc.poll() + if exit_code is not None: + self._close_log_handles() + self.last_exit_code = exit_code + self.stop_time = time.time() + self.psutil_proc = None + return exit_code + + def check_stable_run(self): + with self._lock: + if self.is_running(): + uptime = time.time() - self.start_time + if uptime > self.cfg.stable_uptime and self.restart_count > 0: + log_debug(f"[{self.cfg.name}] Стабильная работа ({uptime:.0f}с), сброс счетчика рестартов") + self.restart_count = 0 + + def check_memory_limit(self) -> Optional[float]: + """Проверяет превышение лимита памяти. Возвращает текущий объем RAM (MB) при превышении, иначе None""" + if not self.is_running() or not self.cfg.max_memory_mb: + return None + + try: + if self.psutil_proc and self.psutil_proc.is_running(): + mem_mb = self.psutil_proc.memory_info().rss / (1024 * 1024) + if mem_mb > self.cfg.max_memory_mb: + return round(mem_mb, 1) + except Exception: + pass + return None + + def collect_metrics(self) -> TaskMetrics: + with self._lock: + if not self.is_running(): + return TaskMetrics( + status=self.status, + restart_count=self.restart_count, + last_exit_code=self.last_exit_code, + last_error=self.last_error_message + ) + + uptime = time.time() - self.start_time + cpu = 0.0 + mem_mb = 0.0 + + try: + if self.psutil_proc and self.psutil_proc.is_running(): + cpu = self.psutil_proc.cpu_percent(interval=None) + mem_mb = self.psutil_proc.memory_info().rss / (1024 * 1024) + else: + self.psutil_proc = psutil.Process(self.proc.pid) + cpu = self.psutil_proc.cpu_percent(interval=None) + mem_mb = self.psutil_proc.memory_info().rss / (1024 * 1024) + except (psutil.NoSuchProcess, psutil.AccessDenied): + pass + + return TaskMetrics( + cpu_percent=round(cpu, 1), + memory_mb=round(mem_mb, 1), + uptime_sec=round(uptime, 1), + pid=self.proc.pid, + restart_count=self.restart_count, + status=TaskStatus.RUNNING, + last_exit_code=self.last_exit_code, + last_error=self.last_error_message + ) + + def read_last_error(self, max_lines: int = 15) -> str: + if not self.stderr_path.exists(): + return "" + try: + with open(self.stderr_path, "r", encoding="utf-8", errors="ignore") as f: + lines = f.readlines() + return "".join(lines[-max_lines:]).strip() + except Exception as e: + return f"Не удалось прочесть stderr: {e}" + + def read_logs(self, max_lines: int = 30) -> Dict[str, List[str]]: + result = {"stdout": [], "stderr": []} + try: + if self.stdout_path.exists(): + with open(self.stdout_path, "r", encoding="utf-8", errors="ignore") as f: + result["stdout"] = [line.rstrip() for line in f.readlines()[-max_lines:]] + if self.stderr_path.exists(): + with open(self.stderr_path, "r", encoding="utf-8", errors="ignore") as f: + result["stderr"] = [line.rstrip() for line in f.readlines()[-max_lines:]] + except Exception as e: + log_err(f"Ошибка чтения логов {self.cfg.name}: {e}") + return result + + def clear_logs(self): + with self._lock: + self._close_log_handles() + try: + if self.stdout_path.exists(): + self.stdout_path.unlink() + if self.stderr_path.exists(): + self.stderr_path.unlink() + # Удаляем также бэкапы + for p in self.logs_dir.glob(f"{self.cfg.name}_*.log.*"): + p.unlink(missing_ok=True) + log_info(f"Логи задачи '{self.cfg.name}' очищены") + except Exception as e: + log_err(f"Не удалось удалить логи {self.cfg.name}: {e}") diff --git a/core/python_env.py b/core/python_env.py new file mode 100644 index 0000000..6da8ced --- /dev/null +++ b/core/python_env.py @@ -0,0 +1,387 @@ +import os +import sys +import shutil +import tarfile +import platform +import subprocess +from pathlib import Path +from typing import Optional, Tuple, List, Dict +import requests + +from core.logger import log_info, log_warn, log_err, log_debug, log_setup + + +class PythonEnvManager: + """ + Менеджер сред исполнения Python: + - Вариант А: поиск установленных версий Python в системе / контейнере + - Вариант Б (Резерв): автоматическая докачка Portable CPython (python-build-standalone) + - Автоматическое создание изолированных .venv и установка pip/requirements + """ + + DEFAULT_RELEASE_TAG = "20261021" + RUNTIMES_DIR = Path(".runtimes") + + @classmethod + def get_platform_info(cls) -> Tuple[str, str, str]: + """ + Определение параметров платформы: (os_name, arch, libc) + os_name: linux, windows, darwin + arch: x86_64, aarch64 + libc: gnu, musl (только для linux) + """ + # OS + if sys.platform.startswith("linux"): + os_name = "unknown-linux" + elif sys.platform == "win32": + os_name = "pc-windows-msvc" + elif sys.platform == "darwin": + os_name = "apple-darwin" + else: + os_name = sys.platform + + # Arch + machine = platform.machine().lower() + if machine in ("x86_64", "amd64"): + arch = "x86_64" + elif machine in ("aarch64", "arm64"): + arch = "aarch64" + elif machine.startswith("arm"): + arch = "armv7" + else: + arch = machine + + # Libc (для Linux: glibc vs musl/Alpine) + libc = "gnu" + if os_name == "unknown-linux": + try: + lib_path = Path("/lib") + if lib_path.exists() and any(p.name.startswith("ld-musl") for p in lib_path.glob("ld-musl*")): + libc = "musl" + else: + libc_name, _ = platform.libc_ver() + if "musl" in libc_name.lower(): + libc = "musl" + except Exception: + pass + + return os_name, arch, libc + + @classmethod + def find_system_python(cls, target_version: str) -> Optional[str]: + """ + Вариант А: Поиск нужной версии Python в операционной системе / контейнере. + Проверяет PATH, системные папки (/usr/bin/pythonX.Y) и команду py на Windows. + """ + target_version = target_version.strip() + ver_parts = target_version.split(".") + if len(ver_parts) >= 2: + short_ver = f"{ver_parts[0]}.{ver_parts[1]}" + no_dot_ver = f"{ver_parts[0]}{ver_parts[1]}" + else: + short_ver = target_version + no_dot_ver = target_version + + # 1. Проверяем текущий запущенный Python + curr_ver = f"{sys.version_info.major}.{sys.version_info.minor}" + if curr_ver == short_ver: + log_debug(f"[PythonEnv] Текущий интерпретатор соответствует версии {short_ver}") + return sys.executable + + # 2. Список возможных кандидатов на исполнение + candidates = [] + if sys.platform == "win32": + candidates.extend([ + f"python{short_ver}", + f"python{no_dot_ver}", + f"python{ver_parts[0]}", + "python" + ]) + # Windows Python Launcher (py -X.Y) + try: + res = subprocess.run( + ["py", f"-{short_ver}", "-c", "import sys; print(sys.executable)"], + capture_output=True, + text=True, + timeout=5 + ) + if res.returncode == 0 and res.stdout.strip(): + exe_path = res.stdout.strip() + if os.path.exists(exe_path): + log_info(f"[PythonEnv] Найдена версия {short_ver} через Windows Launcher: {exe_path}") + return exe_path + except Exception: + pass + else: + # Linux / Pterodactyl Container + candidates.extend([ + f"/usr/bin/python{short_ver}", + f"/usr/local/bin/python{short_ver}", + f"/usr/bin/python{no_dot_ver}", + f"python{short_ver}", + f"python{no_dot_ver}", + ]) + + for cand in candidates: + resolved = shutil.which(cand) or (cand if os.path.isabs(cand) and os.path.exists(cand) else None) + if resolved: + try: + res = subprocess.run( + [resolved, "-c", "import sys; print(f'{sys.version_info.major}.{sys.version_info.minor}')"], + capture_output=True, + text=True, + timeout=5 + ) + if res.returncode == 0 and res.stdout.strip() == short_ver: + log_info(f"[PythonEnv] Найден системный Python {short_ver}: {resolved}") + return resolved + except Exception: + pass + + return None + + @classmethod + def get_download_url(cls, target_version: str) -> Optional[Tuple[str, str]]: + """ + Поиск ссылки на скачивание нужной версии в python-build-standalone. + Возвращает: (download_url, asset_filename) + """ + os_name, arch, libc = cls.get_platform_info() + target_version = target_version.strip() + short_ver = ".".join(target_version.split(".")[:2]) + + # Формируем паттерн для поиска ассета + if os_name == "unknown-linux": + target_pattern = f"-{arch}-{os_name}-{libc}-install_only" + else: + target_pattern = f"-{arch}-{os_name}-install_only" + + # Пробуем запросить последний релиз через GitHub API + try: + api_url = "https://api.github.com/repos/astral-sh/python-build-standalone/releases/latest" + headers = {"User-Agent": "PyTaskManager"} + r = requests.get(api_url, headers=headers, timeout=8) + if r.status_code == 200: + assets = r.json().get("assets", []) + for a in assets: + name = a.get("name", "") + if f"cpython-{short_ver}." in name and target_pattern in name and not name.endswith(".sha256"): + return a.get("browser_download_url"), name + except Exception as e: + log_debug(f"[PythonEnv] GitHub API request failed: {e}") + + # Fallback: известные ссылки по умолчанию + tag = cls.DEFAULT_RELEASE_TAG + ver_map = { + "3.10": "3.10.15", + "3.11": "3.11.10", + "3.12": "3.12.7", + "3.9": "3.9.20", + "3.13": "3.13.0" + } + patch_ver = ver_map.get(short_ver, f"{short_ver}.0") + filename = f"cpython-{patch_ver}+{tag}{target_pattern}.tar.gz" + fallback_url = f"https://github.com/astral-sh/python-build-standalone/releases/download/{tag}/{filename}" + return fallback_url, filename + + @classmethod + def download_portable_python(cls, target_version: str) -> Optional[str]: + """ + Вариант Б (Резерв): Загрузка и распаковка автономного CPython. + Сохраняется в .runtimes/python-/ + """ + short_ver = ".".join(target_version.split(".")[:2]) + dest_dir = cls.RUNTIMES_DIR / f"python-{short_ver}" + cls.RUNTIMES_DIR.mkdir(parents=True, exist_ok=True) + + # Проверяем, не скачан ли он уже + existing_bin = cls._find_python_in_dir(dest_dir) + if existing_bin: + log_debug(f"[PythonEnv] Использован ранее скачанный Python {short_ver}: {existing_bin}") + return existing_bin + + download_info = cls.get_download_url(short_ver) + if not download_info: + log_err(f"[PythonEnv] Не найдена сборка для скачивания Python {short_ver}") + return None + + url, filename = download_info + log_setup(f"[PythonEnv] Вариант Б: Загрузка переносимого Python {short_ver} ({filename})...") + + temp_archive = cls.RUNTIMES_DIR / filename + try: + with requests.get(url, stream=True, timeout=120) as resp: + if resp.status_code != 200: + log_err(f"[PythonEnv] Ошибка скачивания (HTTP {resp.status_code}) по URL: {url}") + return None + + total_size = int(resp.headers.get("content-length", 0)) + downloaded = 0 + with open(temp_archive, "wb") as f: + for chunk in resp.iter_content(chunk_size=1024 * 1024): + if chunk: + f.write(chunk) + downloaded += len(chunk) + + log_setup(f"[PythonEnv] Распаковка {filename} в {dest_dir}...") + dest_dir.mkdir(parents=True, exist_ok=True) + + with tarfile.open(temp_archive, "r:*") as tar: + # В архиве папка 'python', распакуем ее содержимое + tar.extractall(path=cls.RUNTIMES_DIR) + + extracted_python = cls.RUNTIMES_DIR / "python" + if extracted_python.exists() and extracted_python != dest_dir: + if dest_dir.exists(): + shutil.rmtree(dest_dir, ignore_errors=True) + extracted_python.rename(dest_dir) + + temp_archive.unlink(missing_ok=True) + + py_bin = cls._find_python_in_dir(dest_dir) + if py_bin: + log_info(f"[PythonEnv] Portable Python {short_ver} успешно установлен: {py_bin}") + return py_bin + else: + log_err(f"[PythonEnv] Бинарник Python не найден после распаковки в {dest_dir}") + return None + + except Exception as e: + log_err(f"[PythonEnv] Ошибка при докачке/распаковке Python {short_ver}: {e}") + if temp_archive.exists(): + temp_archive.unlink(missing_ok=True) + return None + + @classmethod + def _find_python_in_dir(cls, directory: Path) -> Optional[str]: + """Поиск бинарника python в папке рантайма""" + if not directory.exists(): + return None + + candidates = [ + directory / "bin" / "python3", + directory / "bin" / "python", + directory / "python.exe", + directory / "bin" / "python.exe" + ] + for c in candidates: + if c.exists() and c.is_file(): + return str(c.resolve()) + return None + + @classmethod + def resolve_python_binary( + cls, + requested_version: Optional[str] = None, + allow_download: bool = True + ) -> str: + """ + Разрешение базового интерпретатора Python: + 1. Если версия не указана -> текущий sys.executable + 2. Вариант А: поиск в системе / контейнере + 3. Вариант Б: резервная докачка Portable Python + 4. Fallback -> sys.executable + """ + if not requested_version: + return sys.executable + + # 1. Вариант А: Системный Python + found = cls.find_system_python(requested_version) + if found: + return found + + # 2. Вариант Б: Докачка + if allow_download: + log_warn(f"[PythonEnv] Python {requested_version} не найден в системе. Переход к Варианту Б (докачка)...") + downloaded = cls.download_portable_python(requested_version) + if downloaded: + return downloaded + + log_warn(f"[PythonEnv] Не удалось найти или скачать Python {requested_version}. Используем текущий: {sys.executable}") + return sys.executable + + @classmethod + def ensure_task_environment( + cls, + venv_path_str: Optional[str], + python_version: Optional[str] = None, + auto_create_venv: bool = True, + allow_download: bool = True, + requirements_path: Optional[str] = None, + requirements_enabled: bool = False + ) -> Tuple[str, Optional[str]]: + """ + Гарантирует готовность среды исполнения для задачи: + - Если venv существует -> возвращает его интерпретатор + - Если venv нет, но включено автосоздание -> находит/докачивает Python, создает venv, ставит pip + - Возвращает: (путь_к_python, путь_к_папке_bin_для_PATH) + """ + # Если venv вообще не настроен + if not venv_path_str: + base_py = cls.resolve_python_binary(python_version, allow_download) + return base_py, None + + venv_path = Path(venv_path_str).resolve() + + # Пути к интерпретатору внутри venv + bin_dir = venv_path / ("Scripts" if sys.platform == "win32" else "bin") + py_name = "python.exe" if sys.platform == "win32" else "python" + py_in_venv = bin_dir / py_name + + # 1. Если venv уже создан и рабочий + if py_in_venv.exists(): + return str(py_in_venv), str(bin_dir) + + # 2. Если venv не существует и автосоздание отключено + if not auto_create_venv: + log_warn(f"[PythonEnv] venv '{venv_path_str}' не найден, а auto_create_venv=false. Используем базовый.") + return cls.resolve_python_binary(python_version, allow_download), None + + # 3. Автоматическое создание venv + log_setup(f"[PythonEnv] Виртуальное окружение {venv_path.name} не найдено. Автоматическое создание...") + + base_python = cls.resolve_python_binary(python_version, allow_download) + log_setup(f"[PythonEnv] Создание venv в '{venv_path}' с использованием базового Python: {base_python}...") + + try: + res = subprocess.run( + [base_python, "-m", "venv", str(venv_path)], + capture_output=True, + text=True, + timeout=120 + ) + if res.returncode != 0: + log_err(f"[PythonEnv] Ошибка создания venv: {res.stderr}") + return base_python, None + + if not py_in_venv.exists(): + log_err(f"[PythonEnv] Интерпретатор не найден внутри созданного venv: {py_in_venv}") + return base_python, None + + log_setup(f"[PythonEnv] venv успешно создан! Обновление pip...") + # Тихо обновляем pip в новом venv + subprocess.run( + [str(py_in_venv), "-m", "pip", "install", "--upgrade", "pip"], + capture_output=True, + timeout=90 + ) + + # Если включены requirements, сразу устанавливаем + if requirements_enabled and requirements_path and os.path.exists(requirements_path): + log_setup(f"[PythonEnv] Первичная установка зависимостей из {requirements_path}...") + req_res = subprocess.run( + [str(py_in_venv), "-m", "pip", "install", "-r", str(requirements_path)], + capture_output=True, + text=True, + timeout=300 + ) + if req_res.returncode == 0: + log_setup(f"[PythonEnv] Зависимости задачи успешно установлены в новый venv!") + else: + log_warn(f"[PythonEnv] Ошибка установки зависимостей: {req_res.stderr.strip()}") + + return str(py_in_venv), str(bin_dir) + + except Exception as e: + log_err(f"[PythonEnv] Исключение при создании виртуального окружения: {e}") + return base_python, None diff --git a/manager.py b/manager.py new file mode 100644 index 0000000..92699c7 --- /dev/null +++ b/manager.py @@ -0,0 +1,77 @@ +#!/usr/bin/env python3 +""" +PyTaskManager v2.5 +Developed by Dev-Cored +Advanced Process Supervisor and Manager with Telegram notifications and interactive CLI. +""" + +import sys +import signal + +if sys.platform == "win32": + try: + if hasattr(sys.stdout, "reconfigure"): + sys.stdout.reconfigure(encoding="utf-8") + if hasattr(sys.stderr, "reconfigure"): + sys.stderr.reconfigure(encoding="utf-8") + except Exception: + pass + +from colorama import Fore, Style, init + +from core.logger import setup_logger, log_warn, log_info, log_err +from core.config import ConfigManager +from core.notifier import Notifier +from core.manager import ProcessManager +from core.console import InteractiveConsole + +init(autoreset=True) + +LOGO = f""" +{Fore.CYAN} + ███╗ ███╗ █████╗ ███╗ ██╗ █████╗ ██████╗ ███████╗██████╗ + ████╗ ████║██╔══██╗████╗ ██║██╔══██╗██╔════╝ ██╔════╝██╔══██╗ + ██╔████╔██║███████║██╔██╗ ██║███████║██║ ███╗█████╗ ██████╔╝ + ██║╚██╔╝██║██╔══██║██║╚██╗██║██╔══██║██║ ██║██╔══╝ ██╔══██╗ + ██║ ╚═╝ ██║██║ ██║██║ ╚████║██║ ██║╚██████╔╝███████╗██║ ██║ + ╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═══╝╚═╝ ╚═╝ ╚═════╝ ╚══════╝╚═╝ ╚═╝ +{Fore.YELLOW}⚡ PyTaskManager v2.5 by Dev-Cored +{Style.DIM}Интерактивный менеджер процессов и ботов с мониторингом и авторестартом +""" + + +def main(): + print(LOGO) + + setup_logger("logs/manager.log") + + config_mgr = ConfigManager("config.yaml") + notifier = Notifier() + manager = ProcessManager(config_mgr, notifier) + + # Регистрация системных сигналов + def signal_handler(signum, frame): + log_warn(f"\nПолучен системный сигнал {signum}. Завершение работы...") + manager.shutdown() + sys.exit(0) + + try: + signal.signal(signal.SIGINT, signal_handler) + signal.signal(signal.SIGTERM, signal_handler) + except Exception: + pass + + try: + manager.initialize() + console = InteractiveConsole(manager) + console.cmdloop() + except KeyboardInterrupt: + log_warn("\nПрервано пользователем") + except Exception as e: + log_err(f"Критическая ошибка: {e}") + finally: + manager.shutdown() + + +if __name__ == "__main__": + main() diff --git a/reqs.txt b/reqs.txt new file mode 100644 index 0000000..b54b806 --- /dev/null +++ b/reqs.txt @@ -0,0 +1,5 @@ +pyyaml>=6.0 +psutil>=5.9.0 +requests>=2.28.0 +colorama>=0.4.6 +rapidfuzz>=3.0.0