Initial commit: PteraPyManager v2.5 with modular architecture, auto venv, python downloader, and resource quotas
This commit is contained in:
@@ -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"
|
||||
@@ -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
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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
@@ -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("<", "<").replace(">", ">")
|
||||
tg_text += f"\n<pre>{clean_err}</pre>"
|
||||
|
||||
self.notifier.send(
|
||||
tg_text,
|
||||
title="Аварийное завершение задачи",
|
||||
level="error",
|
||||
fields={"Задача": task.cfg.name, "Код выхода": str(exit_code), "Uptime": f"{uptime}s"}
|
||||
)
|
||||
|
||||
# Автоперезапуск с задержкой (backoff)
|
||||
if task.cfg.autorestart:
|
||||
if 0 < task.cfg.max_restarts <= task.restart_count:
|
||||
task.status = TaskStatus.CRASHED
|
||||
log_err(
|
||||
f"Задача '{task.cfg.name}' превысила лимит рестартов ({task.cfg.max_restarts}). "
|
||||
f"Автоперезапуск остановлен."
|
||||
)
|
||||
self.notifier.send(
|
||||
f"❌ <b>Лимит рестартов исчерпан:</b> <code>{task.cfg.name}</code> ({task.cfg.max_restarts})",
|
||||
title="Лимит рестартов исчерпан",
|
||||
level="error",
|
||||
fields={"Задача": task.cfg.name, "Попыток": str(task.cfg.max_restarts)}
|
||||
)
|
||||
return
|
||||
|
||||
task.status = TaskStatus.BACKOFF
|
||||
log_warn(
|
||||
f"Автоперезапуск '{task.cfg.name}' через {task.cfg.restart_delay} сек... "
|
||||
f"(Попытка {task.restart_count + 1}/{task.cfg.max_restarts or '∞'})"
|
||||
)
|
||||
|
||||
def _delayed_restart():
|
||||
time.sleep(task.cfg.restart_delay)
|
||||
if not self.shutdown_event.is_set() and task.status == TaskStatus.BACKOFF:
|
||||
task.restart_count += 1
|
||||
task.start()
|
||||
|
||||
threading.Thread(target=_delayed_restart, daemon=True, name=f"Restart-{task.cfg.name}").start()
|
||||
else:
|
||||
task.status = TaskStatus.STOPPED
|
||||
|
||||
def _watcher_loop(self):
|
||||
"""Отслеживание изменений файла config.yaml без падений процесса"""
|
||||
while not self.shutdown_event.is_set():
|
||||
self.shutdown_event.wait(timeout=2.0)
|
||||
|
||||
if self.config_mgr.check_modified():
|
||||
log_info("Обнаружено изменение конфигурационного файла. Применение...")
|
||||
new_cfg = self.config_mgr.load(exit_on_fail=False)
|
||||
if new_cfg is not None:
|
||||
self.apply_config(new_cfg)
|
||||
log_info("Конфигурация успешно обновлена на лету!")
|
||||
else:
|
||||
log_warn("Конфигурация не была применена из-за ошибок валидации.")
|
||||
|
||||
def shutdown(self):
|
||||
"""Полная остановка всех процессов, git-апдейтера и менеджера"""
|
||||
log_info("Остановка всех задач и завершение работы менеджера...")
|
||||
self.shutdown_event.set()
|
||||
self.git_updater.shutdown()
|
||||
with self._lock:
|
||||
for task in self._tasks.values():
|
||||
task.stop(force=True, timeout=3.0)
|
||||
self.notifier.shutdown()
|
||||
log_info("Все задачи завершены.")
|
||||
+183
@@ -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 = ""
|
||||
@@ -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
@@ -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}")
|
||||
@@ -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
|
||||
Reference in New Issue
Block a user