Initial commit: PteraPyManager v2.5 with modular architecture, auto venv, python downloader, and resource quotas

This commit is contained in:
Dev Core
2026-10-29 00:39:00 +04:00
commit 3f8b0c1022
15 changed files with 2719 additions and 0 deletions
+46
View File
@@ -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
+261
View File
@@ -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**. Распространяется свободно для личного и коммерческого использования.
+85
View File
@@ -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" # Путь к файлу зависимостей
+7
View File
@@ -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"
+88
View File
@@ -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
+397
View File
@@ -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 <name>"""
if not arg.strip():
print(Fore.YELLOW + "Укажите имя задачи. Пример: start bot1")
return
target = self._match_task_name(arg.strip())
if target:
self.manager.start_task(target)
def complete_start(self, text, line, begidx, endidx):
return [t for t in self._get_task_names() if t.startswith(text)]
def do_stop(self, arg):
"""Остановить задачу: stop <name>"""
if not arg.strip():
print(Fore.YELLOW + "Укажите имя задачи. Пример: stop bot1")
return
target = self._match_task_name(arg.strip())
if target:
self.manager.stop_task(target)
def complete_stop(self, text, line, begidx, endidx):
return [t for t in self._get_task_names() if t.startswith(text)]
def do_restart(self, arg):
"""Перезапустить задачу: restart <name>"""
if not arg.strip():
print(Fore.YELLOW + "Укажите имя задачи. Пример: restart bot1")
return
target = self._match_task_name(arg.strip())
if target:
self.manager.restart_task(target)
def complete_restart(self, text, line, begidx, endidx):
return [t for t in self._get_task_names() if t.startswith(text)]
def do_start_all(self, arg):
"""Запустить все незапущенные задачи"""
self.manager.start_all()
def do_stop_all(self, arg):
"""Остановить все запущенные задачи"""
self.manager.stop_all()
def do_restart_all(self, arg):
"""Перезапустить все задачи"""
self.manager.restart_all()
def do_update(self, arg):
"""Проверить и подтянуть обновления из Git: update (алиас: 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 <name> [lines]"""
parts = arg.strip().split()
if not parts:
print(Fore.YELLOW + "Укажите имя задачи. Пример: logs bot1 30")
return
target = self._match_task_name(parts[0])
if not target:
return
lines = int(parts[1]) if len(parts) > 1 and parts[1].isdigit() else 25
task = self.manager.get_task(target)
if not task:
return
data = task.read_logs(max_lines=lines)
print(Fore.CYAN + f"\n=== STDOUT: {target} (последние {lines} строк) ===")
if data["stdout"]:
for line in data["stdout"]:
print(Fore.WHITE + line)
else:
print(Style.DIM + "(лог stdout пуст)")
print(Fore.YELLOW + f"\n=== STDERR: {target} (последние {lines} строк) ===")
if data["stderr"]:
for line in data["stderr"]:
print(Fore.RED + line)
else:
print(Fore.GREEN + "(нет ошибок в stderr)")
print()
def complete_logs(self, text, line, begidx, endidx):
return [t for t in self._get_task_names() if t.startswith(text)]
def do_tail(self, arg):
"""Следить за логами задачи в реальном времени (Ctrl+C для выхода): tail <name>"""
parts = arg.strip().split()
if not parts:
print(Fore.YELLOW + "Укажите имя задачи. Пример: tail bot1")
return
target = self._match_task_name(parts[0])
if not target:
return
task = self.manager.get_task(target)
if not task:
return
print(Fore.CYAN + f"Трансляция логов '{target}' (нажмите Ctrl+C для выхода)...")
last_stdout_pos = 0
last_stderr_pos = 0
try:
while True:
if task.stdout_path.exists():
with open(task.stdout_path, "r", encoding="utf-8", errors="ignore") as f:
f.seek(last_stdout_pos)
new_content = f.read()
if new_content:
sys.stdout.write(Fore.WHITE + new_content)
sys.stdout.flush()
last_stdout_pos = f.tell()
if task.stderr_path.exists():
with open(task.stderr_path, "r", encoding="utf-8", errors="ignore") as f:
f.seek(last_stderr_pos)
new_err = f.read()
if new_err:
sys.stdout.write(Fore.RED + new_err)
sys.stdout.flush()
last_stderr_pos = f.tell()
time.sleep(0.5)
except KeyboardInterrupt:
print(Fore.YELLOW + "\nОстановка трансляции логов.")
def complete_tail(self, text, line, begidx, endidx):
return [t for t in self._get_task_names() if t.startswith(text)]
def do_info(self, arg):
"""Подробная диагностика задачи: info <name>"""
if not arg.strip():
print(Fore.YELLOW + "Укажите имя задачи. Пример: info bot1")
return
target = self._match_task_name(arg.strip())
if not target:
return
task = self.manager.get_task(target)
if not task:
return
m = task.collect_metrics()
cfg = task.cfg
py_bin, _ = task.get_python_executable()
print(Fore.CYAN + f"\nℹ️ Детальная информация: {target}")
print("-" * 55)
print(f" Статус: {m.status.value}")
print(f" PID процесса: {m.pid or 'Не запущен'}")
print(f" Интерпретатор: {py_bin}")
print(f" Версия Python: {cfg.python_version or 'Системная/по умолчанию'} (докачка: {'Вкл' if cfg.allow_download_python else 'Выкл'})")
print(f" Изолир. venv: {cfg.venv or 'Системный / родительский'} (автосоздание: {'Вкл' if cfg.auto_create_venv else 'Выкл'})")
print(f" Скрипт: {cfg.script}")
print(f" Рабочая папка: {cfg.cwd or 'По умолчанию (папка скрипта)'}")
print(f" Аргументы: {cfg.args}")
print(f" Тип запуска: {cfg.schedule_type} (интервал: {cfg.schedule_interval}с)")
print(f" Квота памяти: {f'{cfg.max_memory_mb} MB (действие: {cfg.memory_limit_action})' if cfg.max_memory_mb else 'Без ограничений'}")
print(f" Автостарт: {cfg.autostart}")
print(f" Авторестарт: {cfg.autorestart} (задержка: {cfg.restart_delay}с)")
print(f" Рестартов: {m.restart_count} / {cfg.max_restarts or '∞'}")
print(f" Uptime: {m.uptime_sec / 60:.2f} минут")
print(f" CPU / RAM: {m.cpu_percent}% / {m.memory_mb} MB")
print(f" Файл stdout: {task.stdout_path}")
print(f" Файл stderr: {task.stderr_path}")
if m.last_exit_code is not None:
print(f" Последний код: {m.last_exit_code}")
if m.last_error:
print(Fore.RED + f" Ошибка: {m.last_error}")
print()
def complete_info(self, text, line, begidx, endidx):
return [t for t in self._get_task_names() if t.startswith(text)]
def do_install(self, arg):
"""Принудительно установить зависимости задачи: install <name>"""
if not arg.strip():
print(Fore.YELLOW + "Укажите имя задачи. Пример: install bot1")
return
target = self._match_task_name(arg.strip())
if not target:
return
task = self.manager.get_task(target)
if task:
task.check_and_install_requirements(force=True)
def complete_install(self, text, line, begidx, endidx):
return [t for t in self._get_task_names() if t.startswith(text)]
def do_clean_logs(self, arg):
"""Очистить файлы логов задачи: clean_logs <name>"""
if not arg.strip():
print(Fore.YELLOW + "Укажите имя задачи. Пример: clean_logs bot1")
return
target = self._match_task_name(arg.strip())
if not target:
return
task = self.manager.get_task(target)
if task:
task.clear_logs()
def complete_clean_logs(self, text, line, begidx, endidx):
return [t for t in self._get_task_names() if t.startswith(text)]
def do_reload(self, arg):
"""Перезагрузить config.yaml вручную"""
cfg = self.manager.config_mgr.load(exit_on_fail=False)
if cfg:
self.manager.apply_config(cfg)
log_info("Конфиг успешно перезагружен вручную!")
else:
log_err("Не удалось перезагрузить конфиг. Проверьте синтаксис YAML.")
def do_clear(self, arg):
"""Очистить экран терминала (алиас: cls)"""
os.system("cls" if os.name == "nt" else "clear")
def do_cls(self, arg):
"""Алиас для команды clear"""
self.do_clear(arg)
def do_exit(self, arg):
"""Выход из менеджера процессов и остановка всех задач"""
print(Fore.YELLOW + "Завершение работы менеджера...")
self.manager.shutdown()
return True
def do_quit(self, arg):
return self.do_exit(arg)
def do_q(self, arg):
return self.do_exit(arg)
def do_help(self, arg):
"""Показать справку по командам"""
print(Fore.CYAN + "\nДоступные команды:")
commands = [
("status / ps", "Показать статус, ресурсы (CPU/RAM/Квоты) и аптайм всех задач"),
("list", "Список задач, расписания, venv и параметров из config.yaml"),
("start <name>", "Запустить задачу"),
("stop <name>", "Остановить задачу (graceful termination дерева процессов)"),
("restart <name>", "Перезапустить задачу"),
("start-all", "Запустить все незапущенные задачи"),
("stop-all", "Остановить все задачи"),
("restart-all", "Перезапустить все задачи"),
("update / git-pull", "Проверить и подтянуть обновления из Git-репозитория"),
("logs <name> [lines]", "Показать последние строки stdout и stderr"),
("tail <name>", "Следить за выводом логов в режиме реального времени"),
("info <name>", "Подробная диагностика задачи (пути, venv, квоты, ошибки)"),
("install <name>", "Установить requirements.txt для указанной задачи"),
("clean-logs <name>", "Очистить файлы логов выбранной задачи"),
("reload", "Вручную перечитать config.yaml"),
("clear / cls", "Очистить консоль"),
("exit / quit / q", "Остановить все задачи и выйти"),
]
for cmd_name, desc in commands:
print(f" {Fore.GREEN}{cmd_name:<22}{Style.RESET_ALL} {desc}")
print()
+190
View File
@@ -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"❌ <b>Ошибка обновления Git:</b>\n<pre>{pull_err}</pre>",
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"🔄 <b>Git репозиторий обновлен!</b>\n"
f"• <b>Ветка:</b> <code>{branch}</code>\n"
f"• <b>Коммит:</b> <code>{commit_info}</code>",
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()
+78
View File
@@ -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)
+330
View File
@@ -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"🚀 <b>Задача запущена:</b> <code>{name}</code> (PID: {task.proc.pid})",
title="Задача запущена",
level="success",
fields={"Задача": name, "PID": str(task.proc.pid)}
)
return success
def stop_task(self, name: str, force: bool = False) -> bool:
with self._lock:
task = self._tasks.get(name)
if not task:
log_warn(f"Задача '{name}' не найдена")
return False
if not task.is_running():
log_warn(f"Задача '{name}' уже остановлена")
return True
success = task.stop(force=force)
if success:
self.notifier.send(
f"🛑 <b>Задача остановлена:</b> <code>{name}</code>",
title="Задача остановлена",
level="warning",
fields={"Задача": name}
)
return success
def restart_task(self, name: str, force: bool = True) -> bool:
with self._lock:
task = self._tasks.get(name)
if not task:
log_err(f"Задача '{name}' не найдена")
return False
task.stop(force=force)
task.restart_count += 1
success = task.start()
if success:
self.notifier.send(
f"🔄 <b>Задача перезапущена:</b> <code>{name}</code> (PID: {task.proc.pid})",
title="Задача перезапущена",
level="info",
fields={"Задача": name, "PID": str(task.proc.pid), "Рестарт №": str(task.restart_count)}
)
return success
def start_all(self):
with self._lock:
for name, task in self._tasks.items():
if not task.is_running():
self.start_task(name)
def stop_all(self, force: bool = False):
with self._lock:
for name, task in self._tasks.items():
if task.is_running():
self.stop_task(name, force=force)
def restart_all(self):
with self._lock:
for name in list(self._tasks.keys()):
self.restart_task(name)
def pull_git(self, 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"🚀 <b>Автозапуск задачи:</b> <code>{name}</code> (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"⚠️ <b>Превышение квоты памяти!</b>\n"
f"• <b>Задача:</b> <code>{task.cfg.name}</code>\n"
f"• <b>Использование:</b> {over_mem} MB (Лимит: {limit} MB)\n"
f"• <b>Действие:</b> {action.upper()}",
title="Превышение лимита памяти",
level="warning",
fields={"Задача": task.cfg.name, "RAM": f"{over_mem} MB", "Лимит": f"{limit} MB"}
)
if action == "restart":
self.restart_task(task.cfg.name)
continue
elif action == "kill":
self.stop_task(task.cfg.name, force=True)
continue
# 5. Проверка завершения процесса
exit_code = task.poll_exit()
if exit_code is not None and task.status != TaskStatus.STOPPED and task.status != TaskStatus.STOPPING:
self._handle_task_exit(task, exit_code)
# 6. Логирование метрик (если включено в конфиге)
if self.app_config.monitoring.log_metrics and task.is_running():
m = task.collect_metrics()
log_debug(
f"[{task.cfg.name}] CPU: {m.cpu_percent}% | RAM: {m.memory_mb} MB | "
f"Uptime: {m.uptime_sec / 60:.1f} мин | Restarts: {m.restart_count}"
)
def _handle_task_exit(self, task: ManagedTask, exit_code: int):
uptime = round(time.time() - task.start_time, 1) if task.start_time else 0
# Если это задача по расписанию и завершилась успешно (код 0)
if task.cfg.schedule_type == "interval" and exit_code == 0:
log_info(f"[{task.cfg.name}] Периодическая задача успешно выполнена. Следующий запуск через {task.cfg.schedule_interval} сек.")
task.status = TaskStatus.SCHEDULED
task.next_run_time = time.time() + task.cfg.schedule_interval
return
err_snippet = task.read_last_error(max_lines=8)
log_err(
f"Задача '{task.cfg.name}' завершилась с кодом {exit_code} (Uptime: {uptime} сек)"
)
if err_snippet:
log_err(f"Последняя ошибка '{task.cfg.name}':\n{err_snippet}")
# Alert
tg_text = (
f"⚠️ <b>Задача завершилась аварийно!</b>\n"
f"• <b>Задача:</b> <code>{task.cfg.name}</code>\n"
f"• <b>Код выхода:</b> {exit_code}\n"
f"• <b>Время работы:</b> {uptime}s\n"
)
if err_snippet:
clean_err = err_snippet[:400].replace("<", "&lt;").replace(">", "&gt;")
tg_text += f"\n<pre>{clean_err}</pre>"
self.notifier.send(
tg_text,
title="Аварийное завершение задачи",
level="error",
fields={"Задача": task.cfg.name, "Код выхода": str(exit_code), "Uptime": f"{uptime}s"}
)
# Автоперезапуск с задержкой (backoff)
if task.cfg.autorestart:
if 0 < task.cfg.max_restarts <= task.restart_count:
task.status = TaskStatus.CRASHED
log_err(
f"Задача '{task.cfg.name}' превысила лимит рестартов ({task.cfg.max_restarts}). "
f"Автоперезапуск остановлен."
)
self.notifier.send(
f"❌ <b>Лимит рестартов исчерпан:</b> <code>{task.cfg.name}</code> ({task.cfg.max_restarts})",
title="Лимит рестартов исчерпан",
level="error",
fields={"Задача": task.cfg.name, "Попыток": str(task.cfg.max_restarts)}
)
return
task.status = TaskStatus.BACKOFF
log_warn(
f"Автоперезапуск '{task.cfg.name}' через {task.cfg.restart_delay} сек... "
f"(Попытка {task.restart_count + 1}/{task.cfg.max_restarts or '∞'})"
)
def _delayed_restart():
time.sleep(task.cfg.restart_delay)
if not self.shutdown_event.is_set() and task.status == TaskStatus.BACKOFF:
task.restart_count += 1
task.start()
threading.Thread(target=_delayed_restart, daemon=True, name=f"Restart-{task.cfg.name}").start()
else:
task.status = TaskStatus.STOPPED
def _watcher_loop(self):
"""Отслеживание изменений файла config.yaml без падений процесса"""
while not self.shutdown_event.is_set():
self.shutdown_event.wait(timeout=2.0)
if self.config_mgr.check_modified():
log_info("Обнаружено изменение конфигурационного файла. Применение...")
new_cfg = self.config_mgr.load(exit_on_fail=False)
if new_cfg is not None:
self.apply_config(new_cfg)
log_info("Конфигурация успешно обновлена на лету!")
else:
log_warn("Конфигурация не была применена из-за ошибок валидации.")
def shutdown(self):
"""Полная остановка всех процессов, git-апдейтера и менеджера"""
log_info("Остановка всех задач и завершение работы менеджера...")
self.shutdown_event.set()
self.git_updater.shutdown()
with self._lock:
for task in self._tasks.values():
task.stop(force=True, timeout=3.0)
self.notifier.shutdown()
log_info("Все задачи завершены.")
+183
View File
@@ -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 = ""
+150
View File
@@ -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"• <b>{k}:</b> {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("<b>", "").replace("</b>", "").replace("<code>", "").replace("</code>", "")
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("<b>", "**").replace("</b>", "**")
.replace("<code>", "`").replace("</code>", "`")
.replace("<pre>", "```").replace("</pre>", "```")
)
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()
+435
View File
@@ -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}")
+387
View File
@@ -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-<version>/
"""
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
+77
View File
@@ -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()
+5
View File
@@ -0,0 +1,5 @@
pyyaml>=6.0
psutil>=5.9.0
requests>=2.28.0
colorama>=0.4.6
rapidfuzz>=3.0.0