Add multi-repo Git support per task with Gitea custom ports, auto-clone, and isolated restarts

This commit is contained in:
Dev Core
2026-10-29 00:52:40 +04:00
parent 63af9fe12f
commit e170141376
6 changed files with 384 additions and 110 deletions
+27 -1
View File
@@ -99,7 +99,7 @@ tasks:
| `start-all` | Запустить все незапущенные задачи |
| `stop-all` | Остановить все задачи |
| `restart-all` | Перезапустить все активные задачи |
| `update` (или `git-pull`) | Принудительно проверить и подтянуть свежий код из Git-репозитория |
| `update [имя]` (или `git-pull [имя]`) | Проверить и подтянуть обновления из Git (для конкретной задачи или всех сразу) |
| `logs <имя> [строк]` | Показать последние строки логов stdout и stderr (по умолчанию 25) |
| `tail <имя>` | Трансляция логов задачи в реальном времени (выход: `Ctrl+C`) |
| `info <имя>` | Подробная диагностика задачи (пути, интерпретатор, окружение, лимиты, ошибки) |
@@ -178,6 +178,18 @@ tasks:
stable_uptime: 60.0 # Время стабильной работы (сек) для сброса счетчика рестартов
cwd: "" # Рабочая папка задачи (если пусто — папка скрипта)
# --- Персональный Git задачи (Gitea, GitHub, GitLab, кастомные SSH порты) ---
# Репозиторий автоматически клонируется с сервера при первом старте, если его еще нет!
git:
enabled: true # Включить Git-синхронизацию для этой задачи
repo_url: "ssh://git@git.dev-core.me:2222/dev-core/my-gitea-bot.git" # URL (поддерживает Gitea, кастомные порты и др.)
branch: "main" # Ветка репозитория
path: "bots/tg_bot" # Локальная папка для клонирования кода бота
ssh_key_path: "keys/id_ed25519" # Путь к SSH-ключу (Deploy Key) для доступа к репозиторию
check_interval: 300 # Интервал проверки обновлений в секундах
auto_restart: true # Перезапускать ТОЛЬКО этого бота при появлении новых коммитов
auto_install_reqs: true # Автоматически обновлять зависимости pip при изменениях
# --- Виртуальное окружение и версии Python ---
venv: "bots/tg_bot/.venv" # Папка для venv (создастся сама, если отсутствует)
python_version: "3.10" # Нужная версия Python ("3.10", "3.11", "3.12"...)
@@ -216,6 +228,20 @@ tasks:
---
## 🐙 Мульти-репозитории и поддержка Gitea / GitHub / GitLab
Каждая задача может иметь свой собственный независимый репозиторий:
- **Разные источники:** Один бот может обновляться из вашей собственной **Gitea** (с кастомным SSH-портом `2222`), второй — из приватного **GitHub**, третий — из **GitLab**.
- **Разные SSH-ключи (Deploy Keys):** Для каждого бота в `ssh_key_path` можно указать свой приватный ключ (например, `keys/bot1_key`, `keys/bot2_key`), или использовать общий.
- **Поддержка нестандартных SSH-портов Gitea:** Поддерживаются URL любого формата:
- `ssh://git@git.dev-core.me:2222/username/bot-repo.git`
- `git@github.com:username/bot-repo.git`
- `https://git.dev-core.me/username/bot-repo.git`
- **Автоматический клон (Zero-Touch):** Если вы добавили задачу в `config.yaml`, но папка бота еще пуста — менеджер при первом запуске сам сделает `git clone`, создаст виртуальное окружение, установит `requirements.txt` и запустит бота.
- **Изолированный перезапуск:** При появлении нового коммита в репозитории бота `my-bot`, менеджер подтянет код и перезапустит **только** `my-bot`, не прерывая работу остальных скриптов.
---
## 🥚 Настройка в яйце Pterodactyl (Pterodactyl Egg)
1. **Файлы в контейнере:** Загрузите файлы репозитория в корневую папку вашего сервера Pterodactyl.
+12
View File
@@ -62,6 +62,18 @@ tasks:
# stable_uptime: 60.0 # Время стабильной работы (сек) для сброса счетчика рестартов
# cwd: "" # Рабочая директория (если пусто — папка скрипта)
#
# # --- Персональный Git задачи (Gitea, GitHub, GitLab, кастомные порты) ---
# # Код автоматически клонируется с сервера при первом запуске, если папка еще не создана!
# git:
# enabled: false # Включить Git для этой задачи
# repo_url: "ssh://git@git.dev-core.me:2222/dev-core/bot.git" # URL (Gitea с портом 2222, GitHub и др.)
# branch: "main" # Ветка
# path: "bots/tg_bot" # Локальная папка репозитория задачи
# ssh_key_path: "id_ed25519" # Путь к приватному SSH-ключу (Deploy Key)
# check_interval: 300 # Интервал проверки новых коммитов (в секундах)
# auto_restart: true # Автоматически перезапускать бота при обновлении кода
# auto_install_reqs: true # Автоматически обновлять pip requirements при изменениях
#
# # --- Изолированное окружение (Venv / Python) ---
# venv: "bots/tg_bot/.venv" # Папка с venv (создается автоматически, если нет)
# python_version: "3.10" # Нужная версия Python ("3.10", "3.11", "3.12"...)
+33 -6
View File
@@ -173,18 +173,38 @@ class InteractiveConsole(Cmd):
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)
"""Проверить и подтянуть обновления из Git: update [name] (алиас: git-pull)"""
arg_clean = arg.strip()
target_task = None
if arg_clean:
target_task = self._match_task_name(arg_clean)
if not target_task:
return
print(Fore.CYAN + f"Проверка обновлений Git{' для ' + target_task if target_task else ''}...")
results = self.manager.pull_git(task_name=target_task, manual=True)
if not results:
print(Fore.YELLOW + "Нет активных Git-репозиториев для проверки.")
return
for name, (updated, msg) in results.items():
prefix = f"[{name}] " if name != target_task else ""
if updated:
print(Fore.GREEN + f"✓ {msg}")
print(Fore.GREEN + f"✓ {prefix}{msg}")
else:
print(Fore.YELLOW + f"ℹ️ {msg}")
print(Fore.YELLOW + f"ℹ️ {prefix}{msg}")
def do_git_pull(self, arg):
"""Алиас для update"""
"""Алиас для update [name]"""
self.do_update(arg)
def complete_update(self, text, line, begidx, endidx):
return [t for t in self._get_task_names() if t.startswith(text)]
def complete_git_pull(self, text, line, begidx, endidx):
return [t for t in self._get_task_names() if t.startswith(text)]
def do_logs(self, arg):
"""Показать логи задачи: logs <name> [lines]"""
parts = arg.strip().split()
@@ -292,6 +312,13 @@ class InteractiveConsole(Cmd):
print(f" Изолир. venv: {cfg.venv or 'Системный / родительский'} (автосоздание: {'Вкл' if cfg.auto_create_venv else 'Выкл'})")
print(f" Скрипт: {cfg.script}")
print(f" Рабочая папка: {cfg.cwd or 'По умолчанию (папка скрипта)'}")
if cfg.git.enabled:
print(f" Git Repo: {cfg.git.repo_url} (ветка: {cfg.git.branch})")
if cfg.git.ssh_key_path:
print(f" Git SSH Key: {cfg.git.ssh_key_path}")
print(f" Git Авторестарт: {'Вкл' if cfg.git.auto_restart else 'Выкл'} (интервал: {cfg.git.check_interval}с)")
else:
print(f" Git Repo: Отключен")
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 'Без ограничений'}")
+245 -86
View File
@@ -5,25 +5,34 @@ import subprocess
import threading
import time
from pathlib import Path
from typing import Optional, Tuple, Dict, Any
from typing import Optional, Tuple, Dict, Any, List
from core.models import GitConfig
from core.logger import log_info, log_warn, log_err, log_debug
from core.models import GitConfig, TaskGitConfig
from core.logger import log_info, log_warn, log_err, log_debug, log_setup
class GitUpdater:
"""Управление синхронизацией с Git-репозиторием и поддержкой SSH-ключей"""
"""
Модуль управления Git-репозиториями:
- Поддержка индивидуального Git для КАЖДОЙ задачи (Gitea, GitHub, GitLab, кастомные SSH порты).
- Поддержка глобального Git-репозитория проекта.
- Автоматическое клонирование (если папки задачи еще нет на сервере).
- Автоматическая проверка обновлений, pull, обновление зависимостей и рестарт конкретного бота.
- Безопасная работа с приватными SSH-ключами (chmod 0600 на Linux, StrictHostKeyChecking=no, BatchMode).
"""
def __init__(self, config: GitConfig, notifier, manager):
self.cfg = config
def __init__(self, global_config: GitConfig, notifier, manager):
self.global_cfg = global_config
self.notifier = notifier
self.manager = manager
self.shutdown_event = threading.Event()
self._thread: Optional[threading.Thread] = None
self._lock = threading.Lock()
self._task_last_check: Dict[str, float] = {}
self._global_last_check: float = 0.0
def update_config(self, new_cfg: GitConfig):
self.cfg = new_cfg
def update_config(self, new_global_cfg: GitConfig):
self.global_cfg = new_global_cfg
def start(self):
if self._thread and self._thread.is_alive():
@@ -31,160 +40,310 @@ class GitUpdater:
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-ключа"""
def get_git_env(self, ssh_key_path: Optional[str] = None) -> Dict[str, str]:
"""
Формирует окружение для Git с настройкой OpenSSH.
Поддерживает Gitea / нестандартные порты (например, ssh://...:2222) и приватные ключи.
"""
env = os.environ.copy()
target_key = ssh_key_path or self.global_cfg.ssh_key_path
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}")
if target_key:
key_file = Path(target_key).resolve()
if not key_file.exists():
alt_path = Path.cwd() / target_key
if alt_path.exists():
key_file = alt_path.resolve()
if not key_file.exists():
log_warn(f"[Git] Приватный SSH-ключ не найден: {key_file}")
else:
# На Unix/Linux системах (включая Pterodactyl яйца) выставляем права 0600
# На Unix / Linux / Pterodactyl контейнерах выставляем 0600
if sys.platform != "win32":
try:
os.chmod(key_path, stat.S_IRUSR | stat.S_IWUSR)
os.chmod(key_file, stat.S_IRUSR | stat.S_IWUSR)
except Exception as e:
log_debug(f"[Git] Не удалось установить chmod 0600 на ключ: {e}")
log_debug(f"[Git] Не удалось установить chmod 0600 на ключ {key_file}: {e}")
# Настройка команды SSH: игнорируем подтверждение хоста и используем ключ
devnull = "NUL" if sys.platform == "win32" else "/dev/null"
# BatchMode=yes не позволяет SSH зависать на интерактивных запросах пароля
ssh_cmd = (
f"ssh -i \"{key_path}\" "
f"ssh -i \"{key_file.as_posix()}\" "
"-o StrictHostKeyChecking=no "
f"-o UserKnownHostsFile={devnull} "
"-o IdentitiesOnly=yes "
"-o BatchMode=yes"
)
env["GIT_SSH_COMMAND"] = ssh_cmd
return env
def _run_git_cmd(self, args: list, cwd: str = ".") -> Tuple[int, str, str]:
"""Безопасный вызов команды git"""
def run_git_cmd(
self,
args: List[str],
cwd: str = ".",
ssh_key_path: Optional[str] = None
) -> Tuple[int, str, str]:
"""Безопасный вызов команды git в указанной рабочей директории"""
try:
env = self._get_git_env()
env = self.get_git_env(ssh_key_path)
res = subprocess.run(
["git"] + args,
cwd=cwd,
cwd=str(cwd),
env=env,
capture_output=True,
text=True,
timeout=60
timeout=120
)
return res.returncode, res.stdout.strip(), res.stderr.strip()
except subprocess.TimeoutExpired:
return -1, "", "Таймаут выполнения команды git (60 сек)"
return -1, "", "Таймаут выполнения команды git (120 сек)"
except Exception as e:
return -1, "", str(e)
def check_and_pull(self, manual: bool = False) -> Tuple[bool, str]:
def determine_repo_dir(self, task_cfg) -> Path:
"""Определяет директорию репозитория для задачи"""
if task_cfg.git.path:
return Path(task_cfg.git.path).resolve()
if task_cfg.cwd:
return Path(task_cfg.cwd).resolve()
if task_cfg.script:
script_path = Path(task_cfg.script)
if script_path.parent != Path("."):
return script_path.parent.resolve()
return Path(f"bots/{task_cfg.name}").resolve()
def ensure_task_repo_cloned(self, task) -> bool:
"""
Проверка обновлений и выполнение 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])
git_cfg: TaskGitConfig = task.cfg.git
if not git_cfg.enabled or not git_cfg.repo_url:
return True
repo_dir = self.determine_repo_dir(task.cfg)
dot_git = repo_dir / ".git"
if dot_git.exists():
return True
log_setup(f"[Git] Клонирование репозитория для '{task.cfg.name}' из {git_cfg.repo_url} в {repo_dir}...")
repo_dir.mkdir(parents=True, exist_ok=True)
branch = git_cfg.branch or "main"
# Если папка пуста — клонируем в нее
is_empty = not any(repo_dir.iterdir())
if is_empty:
clone_args = ["clone", "--branch", branch, git_cfg.repo_url, "."]
cwd = str(repo_dir)
else:
msg = "Текущая папка не является git-репозиторием, и repo_url не указан."
if manual:
log_warn(f"[Git] {msg}")
return False, msg
clone_args = ["clone", "--branch", branch, git_cfg.repo_url, str(repo_dir)]
cwd = "."
branch = self.cfg.branch or "main"
code, out, err = self.run_git_cmd(clone_args, cwd=cwd, ssh_key_path=git_cfg.ssh_key_path)
if code == 0:
log_setup(f"[Git] Репозиторий задачи '{task.cfg.name}' успешно склонирован!")
self.notifier.send(
f"📥 <b>Репозиторий склонирован:</b> <code>{task.cfg.name}</code>\n"
f"• <b>URL:</b> <code>{git_cfg.repo_url}</code>\n"
f"• <b>Ветка:</b> <code>{branch}</code>",
title="Git Clone",
level="success",
fields={"Задача": task.cfg.name, "Ветка": branch}
)
return True
else:
log_err(f"[Git] Ошибка клонирования '{task.cfg.name}': {err}")
return False
# 1. Проверяем / обновляем URL origin, если задан
if self.cfg.repo_url:
code_remote, origin_url, _ = self._run_git_cmd(["remote", "get-url", "origin"])
def sync_task_repo(self, task, manual: bool = False) -> Tuple[bool, str]:
"""
Проверка и подтягивание обновлений для конкретной задачи.
Возвращает: (было_ли_обновление: bool, сообщение: str)
"""
git_cfg: TaskGitConfig = task.cfg.git
if not git_cfg.enabled or not git_cfg.repo_url:
return False, f"Git не настроен для задачи '{task.cfg.name}'"
repo_dir = self.determine_repo_dir(task.cfg)
dot_git = repo_dir / ".git"
# 1. Если репозиторий еще не склонирован
if not dot_git.exists():
success = self.ensure_task_repo_cloned(task)
if success:
return True, "Репозиторий успешно склонирован"
return False, "Не удалось склонировать репозиторий"
branch = git_cfg.branch or "main"
ssh_key = git_cfg.ssh_key_path
with self._lock:
# 2. Проверяем / обновляем URL origin
code_remote, origin_url, _ = self.run_git_cmd(
["remote", "get-url", "origin"],
cwd=str(repo_dir),
ssh_key_path=ssh_key
)
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])
self.run_git_cmd(["remote", "add", "origin", git_cfg.repo_url], cwd=str(repo_dir), ssh_key_path=ssh_key)
elif origin_url != git_cfg.repo_url:
self.run_git_cmd(["remote", "set-url", "origin", git_cfg.repo_url], cwd=str(repo_dir), ssh_key_path=ssh_key)
# 2. Выполняем fetch
# 3. Fetch
if manual:
log_info(f"[Git] Проверка обновлений (ветка: {branch})...")
fetch_code, _, fetch_err = self._run_git_cmd(["fetch", "origin", branch])
log_info(f"[Git] Проверка обновлений '{task.cfg.name}' (ветка: {branch})...")
fetch_code, _, fetch_err = self.run_git_cmd(
["fetch", "origin", branch],
cwd=str(repo_dir),
ssh_key_path=ssh_key
)
if fetch_code != 0:
err_msg = f"Ошибка git fetch: {fetch_err}"
err_msg = f"Ошибка git fetch ({task.cfg.name}): {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}"])
# 4. Сравнение локального HEAD и origin/branch
code_head, local_head, _ = self.run_git_cmd(["rev-parse", "HEAD"], cwd=str(repo_dir), ssh_key_path=ssh_key)
code_remote, remote_head, _ = self.run_git_cmd(["rev-parse", f"origin/{branch}"], cwd=str(repo_dir), ssh_key_path=ssh_key)
if code_head != 0 or code_remote != 0:
# Возможно, ветка новая
err_msg = "Не удалось определить ревизии веток"
return False, err_msg
return False, f"Не удалось прочесть ревизии веток для '{task.cfg.name}'"
if local_head == remote_head:
if manual:
log_info("[Git] Репозиторий уже в актуальном состоянии.")
return False, "Репозиторий уже актуален"
log_info(f"[Git] '{task.cfg.name}' уже в актуальном состоянии.")
return False, f"Задача '{task.cfg.name}' уже актуальна"
log_info(f"[Git] Обнаружены новые коммиты! Локальный: {local_head[:7]} -> Удаленный: {remote_head[:7]}")
log_info(f"[Git] '{task.cfg.name}' новые коммиты: {local_head[:7]} -> {remote_head[:7]}")
# 4. Выполняем pull
pull_code, pull_out, pull_err = self._run_git_cmd(["pull", "origin", branch])
# 5. Git Pull
pull_code, _, pull_err = self.run_git_cmd(
["pull", "origin", branch],
cwd=str(repo_dir),
ssh_key_path=ssh_key
)
if pull_code != 0:
err_msg = f"Ошибка git pull: {pull_err}"
err_msg = f"Ошибка git pull ({task.cfg.name}): {pull_err}"
log_err(f"[Git] {err_msg}")
self.notifier.send(
f"❌ <b>Ошибка обновления Git:</b>\n<pre>{pull_err}</pre>",
f"❌ <b>Ошибка обновления Git:</b> <code>{task.cfg.name}</code>\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)"])
# 6. Информация о последнем коммите
_, commit_info, _ = self.run_git_cmd(
["log", "-1", "--pretty=format:%h - %s (%an)"],
cwd=str(repo_dir),
ssh_key_path=ssh_key
)
success_msg = f"Репозиторий успешно обновлен: {commit_info}"
log_info(f"[Git] {success_msg}")
msg = f"Задача '{task.cfg.name}' успешно обновлена: {commit_info}"
log_info(f"[Git] {msg}")
# Уведомление
# Уведомление в Telegram и Discord
self.notifier.send(
f"🔄 <b>Git репозиторий обновлен!</b>\n"
f"🔄 <b>Бот обновлен из Git!</b>\n"
f"• <b>Задача:</b> <code>{task.cfg.name}</code>\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}
fields={"Задача": task.cfg.name, "Ветка": branch, "Коммит": commit_info}
)
# 6. Обновление зависимостей задач при необходимости
if self.cfg.auto_install_reqs:
for task in self.manager.get_all_tasks().values():
if task.cfg.requirements_enabled:
# 7. Обновление зависимостей задачи при необходимости
if git_cfg.auto_install_reqs and task.cfg.requirements_enabled:
task.check_and_install_requirements(force=False)
# 7. Автоматический перезапуск ботов
if self.cfg.auto_restart:
log_info("[Git] Перезапуск запущенных задач после обновления кода...")
self.manager.restart_all()
# 8. Авторестарт только этой конкретной задачи
if git_cfg.auto_restart and task.is_running():
log_info(f"[Git] Перезапуск '{task.cfg.name}' после обновления кода...")
self.manager.restart_task(task.cfg.name)
return True, success_msg
return True, msg
def sync_global_repo(self, manual: bool = False) -> Tuple[bool, str]:
"""Синхронизация глобального репозитория менеджера (если включено в config.yaml)"""
if not self.global_cfg.enabled or not self.global_cfg.repo_url:
return False, "Глобальный Git не настроен"
branch = self.global_cfg.branch or "main"
ssh_key = self.global_cfg.ssh_key_path
with self._lock:
code, _, _ = self.run_git_cmd(["rev-parse", "--is-inside-work-tree"])
if code != 0:
self.run_git_cmd(["init"])
self.run_git_cmd(["remote", "add", "origin", self.global_cfg.repo_url], ssh_key_path=ssh_key)
fetch_code, _, fetch_err = self.run_git_cmd(["fetch", "origin", branch], ssh_key_path=ssh_key)
if fetch_code != 0:
return False, f"Ошибка fetch глобального репо: {fetch_err}"
code_head, local_head, _ = self.run_git_cmd(["rev-parse", "HEAD"], ssh_key_path=ssh_key)
code_remote, remote_head, _ = self.run_git_cmd(["rev-parse", f"origin/{branch}"], ssh_key_path=ssh_key)
if code_head == 0 and code_remote == 0 and local_head != remote_head:
pull_code, _, pull_err = self.run_git_cmd(["pull", "origin", branch], ssh_key_path=ssh_key)
if pull_code == 0:
_, commit_info, _ = self.run_git_cmd(["log", "-1", "--pretty=format:%h - %s (%an)"], ssh_key_path=ssh_key)
if self.global_cfg.auto_restart:
self.manager.restart_all()
return True, f"Глобальный репозиторий обновлен: {commit_info}"
return False, f"Ошибка pull глобального репо: {pull_err}"
return False, "Глобальный репозиторий уже актуален"
def sync_all(self, manual: bool = False) -> Dict[str, Tuple[bool, str]]:
"""Обновление всех задач с включенным Git, а также глобального репозитория"""
results = {}
# 1. Глобальный репо
if self.global_cfg.enabled and self.global_cfg.repo_url:
results["[global]"] = self.sync_global_repo(manual=manual)
# 2. Задачи
for name, task in self.manager.get_all_tasks().items():
if task.cfg.git.enabled and task.cfg.git.repo_url:
results[name] = self.sync_task_repo(task, manual=manual)
return results
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)
self.shutdown_event.wait(timeout=10.0)
now = time.time()
if not self.cfg.enabled:
# Проверка задач
for name, task in self.manager.get_all_tasks().items():
if not task.cfg.git.enabled or not task.cfg.git.repo_url:
continue
interval = task.cfg.git.check_interval if task.cfg.git.check_interval >= 10 else 300.0
last_time = self._task_last_check.get(name, 0.0)
if now - last_time >= interval:
self._task_last_check[name] = now
try:
self.check_and_pull(manual=False)
self.sync_task_repo(task, manual=False)
except Exception as e:
log_err(f"[Git] Ошибка в цикле автообновления: {e}")
log_err(f"[Git] Ошибка автообновления задачи '{name}': {e}")
# Проверка глобального репо
if self.global_cfg.enabled and self.global_cfg.repo_url:
g_interval = self.global_cfg.check_interval if self.global_cfg.check_interval >= 10 else 300.0
if now - self._global_last_check >= g_interval:
self._global_last_check = now
try:
self.sync_global_repo(manual=False)
except Exception as e:
log_err(f"[Git] Ошибка глобального автообновления: {e}")
def shutdown(self):
self.shutdown_event.set()
+26 -7
View File
@@ -38,7 +38,10 @@ class ProcessManager:
self._monitor_thread.start()
self._watcher_thread.start()
if self.app_config.git.enabled:
has_git = self.app_config.git.enabled or any(
t.cfg.git.enabled for t in self._tasks.values()
)
if has_git:
self.git_updater.start()
def get_all_tasks(self) -> Dict[str, ManagedTask]:
@@ -60,6 +63,10 @@ class ProcessManager:
log_warn(f"Задача '{name}' уже запущена")
return False
# Если для задачи включен Git, проверяем/клонируем репозиторий перед стартом
if task.cfg.git.enabled:
self.git_updater.ensure_task_repo_cloned(task)
success = task.start()
if success:
self.notifier.send(
@@ -127,9 +134,16 @@ class ProcessManager:
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 pull_git(self, task_name: Optional[str] = None, manual: bool = True) -> Dict[str, Tuple[bool, str]]:
"""Ручной запуск проверки и обновления из Git (для конкретной задачи или всех)"""
with self._lock:
if task_name:
task = self._tasks.get(task_name)
if not task:
return {task_name: (False, f"Задача '{task_name}' не найдена")}
return {task_name: self.git_updater.sync_task_repo(task, manual=manual)}
else:
return self.git_updater.sync_all(manual=manual)
def apply_config(self, new_config: AppConfig, initial: bool = False):
"""Применение новой конфигурации"""
@@ -138,9 +152,6 @@ class ProcessManager:
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())
@@ -158,6 +169,8 @@ class ProcessManager:
managed = ManagedTask(task_cfg, logs_dir=new_config.logging.dir)
self._tasks[name] = managed
if (initial or task_cfg.autostart) and task_cfg.autostart:
if task_cfg.git.enabled:
self.git_updater.ensure_task_repo_cloned(managed)
managed.start()
if managed.is_running():
self.notifier.send(
@@ -167,6 +180,12 @@ class ProcessManager:
fields={"Задача": name, "PID": str(managed.proc.pid)}
)
has_git = new_config.git.enabled or any(
t.cfg.git.enabled for t in self._tasks.values()
)
if has_git:
self.git_updater.start()
def _monitor_loop(self):
"""Фоновый цикл проверки состояния процессов, памяти, ротации логов и расписания"""
while not self.shutdown_event.is_set():
+31
View File
@@ -13,6 +13,33 @@ class TaskStatus(str, Enum):
SCHEDULED = "SCHEDULED"
@dataclass
class TaskGitConfig:
enabled: bool = False
repo_url: str = ""
branch: str = "main"
path: Optional[str] = None # Путь к локальной папке репозитория (по умолч. папка скрипта)
ssh_key_path: Optional[str] = None # Персональный SSH-ключ для этого репозитория (Gitea/GitHub)
check_interval: float = 300.0 # Интервал проверки новых коммитов (в секундах)
auto_restart: bool = True # Авторестарт задачи при появлении новых коммитов
auto_install_reqs: bool = True # Обновление зависимостей при pull
@classmethod
def from_dict(cls, data: dict) -> "TaskGitConfig":
if not data or not isinstance(data, dict):
return cls()
return cls(
enabled=bool(data.get("enabled", False)),
repo_url=str(data.get("repo_url", "")).strip(),
branch=str(data.get("branch", "main")).strip() or "main",
path=str(data.get("path", "")).strip() or None,
ssh_key_path=str(data.get("ssh_key_path", "")).strip() or None,
check_interval=float(data.get("check_interval", 300.0)),
auto_restart=bool(data.get("auto_restart", True)),
auto_install_reqs=bool(data.get("auto_install_reqs", True))
)
@dataclass
class TaskConfig:
name: str
@@ -26,6 +53,9 @@ class TaskConfig:
cwd: Optional[str] = None
env: Dict[str, str] = field(default_factory=dict)
# Git-репозиторий задачи (Gitea, GitHub, GitLab...)
git: TaskGitConfig = field(default_factory=TaskGitConfig)
# Виртуальное окружение / интерпретатор
venv: Optional[str] = None
python_path: Optional[str] = None
@@ -60,6 +90,7 @@ class TaskConfig:
stable_uptime=float(data.get("stable_uptime", 60.0)),
cwd=data.get("cwd") or None,
env=data.get("env") or {},
git=TaskGitConfig.from_dict(data.get("git") 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,