- Surface a topbar indicator with a live count of active tasks - Propagate exceptions from Proxmox LXC container creation instead of swallowing them, and validate minimum password length - Replace the Fedora catalog icon with the official logo artwork
919 lines
46 KiB
Python
919 lines
46 KiB
Python
"""
|
||
M0 PoC install-пайплайн: clone (create from golden vztmpl) → push → exec → health-check.
|
||
|
||
Ядро переиспользует существующую инфраструктуру панели:
|
||
- `_get_proxmox_client()` / `create_lxc_container()` / `wait_for_task()` /
|
||
`start_container()` / `stop_container()` / `delete_container()` — Proxmox API;
|
||
- `SSHClient` (root@node, тот же паттерн, что в proxmox/mixins/cluster.py) — для
|
||
`pct exec` / `pct push` с полным выводом (нужно для логов и наблюдаемости шагов).
|
||
|
||
Это seed будущего services/appstore_engine.py. Прогресс отдаётся через callback
|
||
`on_step(step, progress)` — в реальном движке он станет WS-broadcast'ом.
|
||
|
||
Безопасность (S-4): содержимое docker-compose.yml и .env НЕ конкатенируется в
|
||
shell-строку. Файлы доставляются на ноду через base64→файл→`pct push`, поэтому
|
||
произвольный ввод не может вырваться в шелл. Имя приложения валидируется regex.
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import base64
|
||
import re
|
||
import secrets
|
||
import time
|
||
from dataclasses import dataclass, field
|
||
from typing import Callable, Dict, Optional
|
||
|
||
import yaml
|
||
from loguru import logger
|
||
from sqlalchemy.orm import Session
|
||
|
||
from ..api.proxmox._helpers import _get_proxmox_client, get_next_vmid
|
||
from ..config import settings
|
||
from ..models import ProxmoxServer
|
||
from ..ssh_client import SSHClient
|
||
|
||
# Docker-сеть, на которую ссылаются compose-файлы Runtipi как external.
|
||
TIPI_NETWORK = "tipi_main_network"
|
||
APP_DIR = "/opt/app" # сюда кладём docker-compose.yml + .env
|
||
APP_DATA_DIR = "/opt/app-data" # значение APP_DATA_DIR для приложений
|
||
|
||
# Имя = hostname LXC: буквы/цифры/дефис, 1..63.
|
||
_NAME_RE = re.compile(r"^[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$")
|
||
|
||
StepCb = Callable[[str, int], None]
|
||
|
||
|
||
class PocError(RuntimeError):
|
||
"""Ошибка пайплайна с человекочитаемым шагом, на котором упали."""
|
||
|
||
|
||
@dataclass
|
||
class InstallSpec:
|
||
server_id: int
|
||
ostemplate: str # golden vztmpl, напр. local:vztmpl/golden-docker_12_amd64.tar.zst
|
||
name: str # hostname / имя приложения
|
||
compose_yaml: str # содержимое docker-compose.yml
|
||
port: int = 3001 # порт для health-check
|
||
# Порт выбран пользователем явно (форма мастера), а не взят из каталога.
|
||
# Влияет на нормализацию compose: явный порт публикуется как есть (в т.ч.
|
||
# 80), а каталожные 0/80 считаются «не задано» → публикуем внутренний.
|
||
port_explicit: bool = False
|
||
env_vars: Dict[str, str] = field(default_factory=dict)
|
||
node: Optional[str] = None # если None — выбирается автоматически
|
||
vmid: Optional[int] = None # если задан — использовать его (идемпотентный повтор)
|
||
cores: int = 2
|
||
memory: int = 2048 # МБ
|
||
swap: int = 512 # МБ
|
||
disk: int = 8 # ГБ
|
||
storage: str = "local-lvm"
|
||
bridge: str = "vmbr0"
|
||
features: str = "nesting=1,keyctl=1" # обязательно для Docker в unprivileged LXC
|
||
health_timeout: int = 300 # сек
|
||
ip_timeout: int = 60 # сек ожидания IP после старта
|
||
# IPAM: статическая конфигурация сети. Если ip_config задан — используется
|
||
# вместо ip=dhcp при создании net0; static_ip — заранее известный адрес
|
||
# (тогда не ждём выдачи по DHCP).
|
||
ip_config: Optional[str] = None # напр. "ip=10.0.0.5/24,gw=10.0.0.1"
|
||
static_ip: Optional[str] = None # напр. "10.0.0.5"
|
||
source: str = "runtipi" # источник каталога: runtipi | umbrel
|
||
# Явный DNS для контейнера (через пробел). None → settings.APPSTORE_NAMESERVER —
|
||
# без этого CT наследует резолвер ноды, который может быть недоступен из сети
|
||
# контейнера (напр. Tailscale-адрес), и `docker compose up` падает на pull образов.
|
||
nameserver: Optional[str] = None
|
||
# Вспомогательные файлы приложения из репозитория каталога
|
||
# ({relpath: {"b64": ..., "exec": bool}}, см. CatalogApp.data_files) —
|
||
# доставляются в ${APP_DATA_DIR}/<relpath> ДО compose up, иначе bind-mount'ы
|
||
# на них получают пустышки и приложение падает (пустой entrypoint.sh/конфиг).
|
||
data_files: Dict[str, dict] = field(default_factory=dict)
|
||
|
||
|
||
@dataclass
|
||
class InstallResult:
|
||
vmid: int
|
||
node: str
|
||
ip: Optional[str]
|
||
url: Optional[str]
|
||
status: str
|
||
|
||
|
||
def _noop(step: str, progress: int) -> None:
|
||
logger.info(f"[appstore-poc] {progress:3d}% {step}")
|
||
|
||
|
||
# ── SSH-хелперы (root@node), идентичный паттерн cluster.py ────────────────────
|
||
|
||
def _node_ssh(server: ProxmoxServer, client) -> SSHClient:
|
||
ssh_host = (server.ip_address or server.hostname or "").split(":")[0]
|
||
return SSHClient(
|
||
hostname=ssh_host,
|
||
username="root",
|
||
password=getattr(client, "_password", None),
|
||
timeout=30, # запас на подключение; per-command таймаут задаётся в _run
|
||
)
|
||
|
||
|
||
# Таймаут по умолчанию для быстрых команд на ноде (pct exec/push, mkdir и т.п.).
|
||
# Долгие шаги (docker compose pull/up) передают увеличенный таймаут явно.
|
||
_CMD_TIMEOUT = 60
|
||
_DOCKER_TIMEOUT = 600
|
||
# Ожидание завершения задачи Proxmox на удаление CT. Долгий таймаут — при
|
||
# wipe_after_delete на LVM-хранилищах затирание диска нулями может занимать
|
||
# много минут; если сдаться раньше, VMID можно ошибочно счесть свободным и
|
||
# словить гонку блокировки конфига при немедленном пересоздании.
|
||
_TEARDOWN_WAIT_TIMEOUT = 1800
|
||
|
||
|
||
_LAYER_PROGRESS_RE = re.compile(
|
||
r"^\s*[0-9a-f]{12}\s+(Pulling|Waiting|Downloading|Verifying Checksum|"
|
||
r"Download complete|Extracting|Pull complete|Already exists)\b"
|
||
)
|
||
|
||
|
||
def _strip_pull_noise(output: str) -> str:
|
||
"""Убрать построчный progress-шум `docker compose pull/up` (на каждый слой
|
||
образа своя строка Downloading/Extracting и т.п., перерисовывающаяся много
|
||
раз). На тяжёлых многослойных образах этот шум может занять весь хвост
|
||
вывода, вытеснив из среза саму причину падения (см. _run).
|
||
"""
|
||
lines = [ln for ln in output.splitlines() if not _LAYER_PROGRESS_RE.match(ln)]
|
||
return "\n".join(lines)
|
||
|
||
|
||
def _run(ssh: SSHClient, cmd: str, *, what: str, timeout: int = _CMD_TIMEOUT) -> str:
|
||
"""Выполнить команду на ноде, вернуть stdout. Бросить PocError при exit!=0.
|
||
|
||
При таймауте execute() вернёт exit_code=-1 → бросаем PocError (установка
|
||
завершается с ошибкой, а не зависает бесконечно).
|
||
"""
|
||
output, exit_code = ssh.execute(cmd, return_exit_code=True, timeout=timeout)
|
||
if exit_code == -1:
|
||
raise PocError(f"{what}: таймаут (>{timeout}с) или обрыв SSH")
|
||
if exit_code != 0:
|
||
# Хвост, а не голова: для многословных команд (docker compose pull/up)
|
||
# реальная причина падения — последние строки, а не progress-шум
|
||
# "Pulling/Downloading" в начале. Раньше срез [:2000] обрезал именно
|
||
# причину, оставляя в UI один прогресс-бар без объяснения. Но и хвост
|
||
# может целиком утонуть в построчном progress-шуме на тяжёлых образах
|
||
# (много слоёв) — поэтому сначала вычищаем его, если после этого
|
||
# что-то остаётся.
|
||
text = (output or "").strip()
|
||
filtered = _strip_pull_noise(text).strip()
|
||
tail = filtered or text
|
||
raise PocError(f"{what}: exit={exit_code}: {tail[-4000:]}")
|
||
return output or ""
|
||
|
||
|
||
def _pct(vmid: int, inner: str) -> str:
|
||
"""pct exec в контейнере через bash -lc (inner фиксированный, без польз. ввода)."""
|
||
return f"pct exec {vmid} -- /bin/bash -lc {_shq(inner)}"
|
||
|
||
|
||
def _shq(s: str) -> str:
|
||
"""Одинарные кавычки для shell (безопасно для фиксированных строк)."""
|
||
return "'" + s.replace("'", "'\"'\"'") + "'"
|
||
|
||
|
||
def _to_int(v) -> Optional[int]:
|
||
"""Аккуратно привести значение к int (int или строка-число), иначе None."""
|
||
if isinstance(v, bool):
|
||
return None
|
||
if isinstance(v, int):
|
||
return v
|
||
if isinstance(v, str) and v.strip().isdigit():
|
||
return int(v.strip())
|
||
return None
|
||
|
||
|
||
def _find_main_service(services: Dict) -> Optional[str]:
|
||
"""Определить главный сервис Runtipi-compose.
|
||
|
||
Приоритет: сервис с `x-runtipi.is_main: true`. Если такого нет, но сервис
|
||
единственный — берём его. Иначе None (не можем однозначно определить).
|
||
"""
|
||
for name, svc in services.items():
|
||
if isinstance(svc, dict):
|
||
rt = svc.get("x-runtipi")
|
||
if isinstance(rt, dict) and rt.get("is_main"):
|
||
return name
|
||
if len(services) == 1:
|
||
return next(iter(services))
|
||
return None
|
||
|
||
|
||
def _compose_env_get(env, key: str) -> Optional[str]:
|
||
"""Достать значение переменной из секции environment (dict или list-формат)."""
|
||
if isinstance(env, dict):
|
||
v = env.get(key)
|
||
return str(v) if v is not None else None
|
||
if isinstance(env, list):
|
||
pref = key + "="
|
||
for item in env:
|
||
s = str(item)
|
||
if s.startswith(pref):
|
||
return s[len(pref):]
|
||
return None
|
||
|
||
|
||
# Сервисы рантайма Umbrel, которые не запустятся вне Umbrel и должны быть
|
||
# вырезаны из compose перед standalone-запуском в LXC.
|
||
def _is_umbrel_infra_service(name: str) -> bool:
|
||
low = name.lower()
|
||
return low == "app_proxy" or low == "tor" or low.endswith("_tor") or low.endswith("-tor")
|
||
|
||
|
||
def _strip_dangling_depends(services: Dict, removed: set) -> None:
|
||
"""Убрать depends_on-ссылки на удалённые сервисы (иначе compose up падает)."""
|
||
for svc in services.values():
|
||
if not isinstance(svc, dict):
|
||
continue
|
||
dep = svc.get("depends_on")
|
||
if isinstance(dep, list):
|
||
new = [d for d in dep if d not in removed]
|
||
if new:
|
||
svc["depends_on"] = new
|
||
else:
|
||
svc.pop("depends_on", None)
|
||
elif isinstance(dep, dict):
|
||
for r in removed:
|
||
dep.pop(r, None)
|
||
if not dep:
|
||
svc.pop("depends_on", None)
|
||
|
||
|
||
def _umbrel_main_service(services: Dict, app_host: Optional[str]) -> Optional[str]:
|
||
"""Определить главный сервис Umbrel-compose.
|
||
|
||
Приоритет — сервис, на который указывает app_proxy (APP_HOST). Затем —
|
||
единственный сервис, затем первый с образом.
|
||
"""
|
||
if not services:
|
||
return None
|
||
if app_host:
|
||
for name in services:
|
||
if name == app_host or name in app_host.split("_") or name in app_host:
|
||
return name
|
||
if len(services) == 1:
|
||
return next(iter(services))
|
||
for name, svc in services.items():
|
||
if isinstance(svc, dict) and svc.get("image"):
|
||
return name
|
||
return next(iter(services))
|
||
|
||
|
||
def _prepare_umbrel(doc: dict) -> tuple[Optional[str], Optional[int], bool]:
|
||
"""Адаптировать Umbrel-compose: снять порт из app_proxy, вырезать рантайм
|
||
Umbrel, определить главный сервис.
|
||
|
||
Возвращает (main_service, internal_port, changed).
|
||
"""
|
||
services = doc.get("services")
|
||
if not isinstance(services, dict):
|
||
return None, None, False
|
||
|
||
# Порт контейнера и целевой сервис задаёт app_proxy Umbrel.
|
||
ap = services.get("app_proxy")
|
||
internal: Optional[int] = None
|
||
app_host: Optional[str] = None
|
||
if isinstance(ap, dict):
|
||
env = ap.get("environment")
|
||
internal = _to_int(_compose_env_get(env, "APP_PORT"))
|
||
app_host = _compose_env_get(env, "APP_HOST")
|
||
|
||
# Вырезать app_proxy/tor — их образов у нас нет, они завесят/уронят up.
|
||
removed = {n for n in list(services.keys()) if _is_umbrel_infra_service(n)}
|
||
for n in removed:
|
||
services.pop(n, None)
|
||
if removed:
|
||
_strip_dangling_depends(services, removed)
|
||
|
||
main = _umbrel_main_service(services, app_host)
|
||
return main, internal, bool(removed)
|
||
|
||
|
||
def _resolve_main_and_port(doc: dict, services: Dict, source: str
|
||
) -> tuple[Optional[str], Optional[int], bool]:
|
||
"""Определить (главный_сервис, внутренний_порт, changed) по источнику."""
|
||
if source == "umbrel":
|
||
return _prepare_umbrel(doc)
|
||
# runtipi: главный сервис и порт объявлены через x-runtipi.
|
||
main = _find_main_service(services)
|
||
internal = None
|
||
if main is not None:
|
||
svc = services.get(main)
|
||
rt = svc.get("x-runtipi") if isinstance(svc, dict) else None
|
||
internal = _to_int(rt.get("internal_port")) if isinstance(rt, dict) else None
|
||
return main, internal, False
|
||
|
||
|
||
def _published_host_port(entry, host_port: Optional[int]) -> Optional[int]:
|
||
"""Хост-порт из записи `ports:` compose.
|
||
|
||
Понимает short-syntax ('8080:80', '${APP_PORT:-3001}:3001',
|
||
'127.0.0.1:8080:80') и long-syntax ({published: ..., target: ...}).
|
||
Переменную APP_PORT подставляем значением host_port — именно его кладём
|
||
в .env, т.е. так её раскроет и docker compose. Раньше '${APP_PORT...'
|
||
парсился как не-число → health-check шёл на внутренний порт, который
|
||
наружу не опубликован, и установка ложно помечалась unhealthy.
|
||
"""
|
||
env = {"APP_PORT": str(host_port)} if host_port else {}
|
||
if isinstance(entry, dict):
|
||
pub = entry.get("published")
|
||
return _to_int(_subst_env(str(pub), env)) if pub is not None else None
|
||
parts = _subst_env(str(entry), env).split(":")
|
||
return _to_int(parts[-2]) if len(parts) >= 2 else None
|
||
|
||
|
||
def _normalize_compose(compose_yaml: str, host_port: Optional[int] = None,
|
||
*, source: str = "runtipi",
|
||
port_explicit: bool = False) -> tuple[str, Optional[int]]:
|
||
"""Привести compose к самодостаточному виду для standalone-запуска в LXC.
|
||
|
||
Делает то, что в родном рантайме (Runtipi/Umbrel) выполняет их оркестратор:
|
||
|
||
1. Объявляет упомянутые, но необъявленные сети (напр. `tipi_main_network`)
|
||
как external — иначе `docker compose up` падает с «refers to undefined
|
||
network …». Сеть создаётся заранее на ноде (`docker network create`).
|
||
|
||
2. Для Umbrel: вырезает сервисы рантайма (app_proxy, tor) — их образов у нас
|
||
нет, а порт контейнера берётся из `app_proxy.environment.APP_PORT`.
|
||
|
||
3. Публикует порт главного сервиса на хост LXC. И Runtipi (порт в
|
||
`x-runtipi.internal_port`), и Umbrel (порт в app_proxy) обычно НЕ имеют
|
||
секции `ports:` — наружу его пробрасывал бы их прокси, которого у нас нет.
|
||
Без публикации приложение недоступно по IP контейнера (health-check не
|
||
проходит). Поэтому главному сервису добавляем `ports: ["<host>:<internal>"]`.
|
||
|
||
Возвращает `(normalized_yaml, published_port)`. При любой ошибке разбора —
|
||
`(compose_yaml, None)` (используем исходный compose как есть).
|
||
"""
|
||
try:
|
||
doc = yaml.safe_load(compose_yaml)
|
||
if not isinstance(doc, dict):
|
||
return compose_yaml, None
|
||
|
||
services = doc.get("services")
|
||
if not isinstance(services, dict):
|
||
return compose_yaml, None
|
||
|
||
# Источнико-специфичная подготовка (для Umbrel мутирует services).
|
||
main, internal, changed = _resolve_main_and_port(doc, services, source)
|
||
services = doc.get("services")
|
||
if not isinstance(services, dict):
|
||
return compose_yaml, None
|
||
|
||
# (1) Необъявленные сети → external.
|
||
referenced: set[str] = set()
|
||
for svc in services.values():
|
||
if not isinstance(svc, dict):
|
||
continue
|
||
nets = svc.get("networks")
|
||
if isinstance(nets, list):
|
||
referenced.update(str(n) for n in nets)
|
||
elif isinstance(nets, dict):
|
||
referenced.update(str(n) for n in nets.keys())
|
||
|
||
if referenced:
|
||
top = doc.get("networks")
|
||
if not isinstance(top, dict):
|
||
top = {}
|
||
for net in referenced:
|
||
if net not in top:
|
||
top[net] = {"external": True}
|
||
changed = True
|
||
if changed:
|
||
doc["networks"] = top
|
||
|
||
# Для Umbrel, если порт контейнера не удалось снять из app_proxy, но
|
||
# известен порт из каталога — используем его как внутренний.
|
||
if source == "umbrel" and internal is None and host_port:
|
||
internal = host_port
|
||
|
||
# (2) Публикация порта главного сервиса на хост LXC.
|
||
published_port: Optional[int] = None
|
||
svc = services.get(main) if main is not None else None
|
||
if isinstance(svc, dict):
|
||
if internal:
|
||
# Уважаем уже объявленную публикацию (не переопределяем).
|
||
if not svc.get("ports"):
|
||
# host_port из каталога, если задан и не дефолтные 80/0; иначе
|
||
# публикуем на том же номере, что слушает контейнер. Порт,
|
||
# явно выбранный пользователем в мастере, уважаем всегда
|
||
# (в т.ч. 80 — для каталога это «не задано», для юзера нет).
|
||
pub = host_port if (host_port and (port_explicit or host_port not in (0, 80))) else internal
|
||
svc["ports"] = [f"{pub}:{internal}"]
|
||
published_port = pub
|
||
changed = True
|
||
else:
|
||
ports = svc.get("ports")
|
||
if isinstance(ports, list) and ports:
|
||
published_port = _published_host_port(ports[0], host_port) or internal
|
||
elif svc.get("ports"):
|
||
# Внутренний порт неизвестен, но публикация уже есть в compose.
|
||
ports = svc.get("ports")
|
||
if isinstance(ports, list) and ports:
|
||
published_port = _published_host_port(ports[0], host_port)
|
||
|
||
if not changed:
|
||
return compose_yaml, published_port
|
||
|
||
return yaml.safe_dump(doc, sort_keys=False, allow_unicode=True), published_port
|
||
except Exception as e:
|
||
logger.warning(f"[appstore-poc] normalize compose failed, using raw: {e}")
|
||
return compose_yaml, None
|
||
|
||
|
||
def _platform_env(env: Dict[str, str], ip: str, source: str) -> Dict[str, str]:
|
||
"""Заполнить IP-зависимые платформенные переменные окружения (ТЗ 5.3).
|
||
|
||
Общие: APP_DOMAIN/APP_HOST/APP_IP. runtipi → LOCAL_DOMAIN. umbrel →
|
||
DEVICE_DOMAIN_NAME/DEVICE_HOSTNAME/APP_SEED (частые ссылки в их compose).
|
||
"""
|
||
env.setdefault("APP_DOMAIN", ip)
|
||
env.setdefault("APP_HOST", ip)
|
||
env["APP_IP"] = ip
|
||
env.setdefault("APP_DATA_DIR", APP_DATA_DIR) # некоторые compose ссылаются на неё в volumes:
|
||
if source == "umbrel":
|
||
env.setdefault("DEVICE_DOMAIN_NAME", f"{ip}.local")
|
||
env.setdefault("DEVICE_HOSTNAME", "umbrel")
|
||
env.setdefault("APP_SEED", "pvemanager")
|
||
# Umbrel генерирует APP_PASSWORD сам (deterministic app password) —
|
||
# compose-файлы ссылаются на неё для паролей/ключей. Обычно её задаёт
|
||
# build_env движка (чтобы значение сохранилось и показалось
|
||
# пользователю); здесь — страховка для standalone-запуска пайплайна.
|
||
env.setdefault("APP_PASSWORD", secrets.token_hex(16))
|
||
else:
|
||
env.setdefault("LOCAL_DOMAIN", "tipi.local") # стандартная переменная Runtipi
|
||
return env
|
||
|
||
|
||
_VAR_RE = re.compile(
|
||
r"\$\{([A-Za-z_][A-Za-z0-9_]*)(?::?-([^}]*))?\}|\$([A-Za-z_][A-Za-z0-9_]*)"
|
||
)
|
||
|
||
|
||
def _subst_env(value: str, env: Dict[str, str]) -> str:
|
||
"""Мини-версия подстановки переменных docker compose:
|
||
${VAR}, ${VAR-def}, ${VAR:-def}, $VAR → env[VAR] | default | ''.
|
||
"""
|
||
def _rep(m: re.Match) -> str:
|
||
var = m.group(1) or m.group(3)
|
||
val = env.get(var)
|
||
if val:
|
||
return val
|
||
return m.group(2) or ""
|
||
return _VAR_RE.sub(_rep, value)
|
||
|
||
|
||
def _bind_mount_hosts(compose_yaml: str, app_dir: str, env: Dict[str, str]) -> list:
|
||
"""Хост-пути bind-mount'ов из `volumes:` всех сервисов (без именованных volume).
|
||
|
||
Официальные образы (mariadb, postgres и т.п.) в контейнере обычно пишут в
|
||
точку монтирования от имени непривилегированного пользователя (напр.
|
||
mysql, uid 999). Docker при первом `up` создаёт отсутствующую хост-директорию
|
||
сам — но от root, с 0755, поэтому такой пользователь получает Permission
|
||
denied. Возвращаем список путей, чтобы pre-create их с правами 777 (ТЗ:
|
||
изоляция на уровне LXC, разграничение владельца внутри контейнера не
|
||
требуется — важна лишь возможность писать).
|
||
"""
|
||
try:
|
||
doc = yaml.safe_load(compose_yaml)
|
||
except Exception:
|
||
return []
|
||
if not isinstance(doc, dict):
|
||
return []
|
||
services = doc.get("services")
|
||
if not isinstance(services, dict):
|
||
return []
|
||
|
||
hosts: list = []
|
||
for svc in services.values():
|
||
if not isinstance(svc, dict):
|
||
continue
|
||
vols = svc.get("volumes")
|
||
if not isinstance(vols, list):
|
||
continue
|
||
for v in vols:
|
||
if not isinstance(v, str) or ":" not in v:
|
||
continue
|
||
# Именованный volume ("dbdata:/var/lib/mysql") — без '/', '.', '~', '$'
|
||
# в начале; управляется Docker'ом, пропускаем.
|
||
if not (v.startswith(("/", ".", "~", "$"))):
|
||
continue
|
||
# Подстановка ДО split(':'): внутри ${VAR:-default} есть ':',
|
||
# который иначе рвёт строку не на границе source:target.
|
||
resolved = _subst_env(v, env).split(":", 1)[0]
|
||
if not resolved:
|
||
continue
|
||
if not resolved.startswith("/"):
|
||
resolved = f"{app_dir}/{resolved.lstrip('./')}"
|
||
hosts.append(resolved)
|
||
# uniq, сохраняя порядок
|
||
return list(dict.fromkeys(hosts))
|
||
|
||
|
||
def _is_file_mount(source: str) -> bool:
|
||
"""Эвристика: source похож на файл, а не директорию (по имени — есть точка,
|
||
напр. `.env`, `config.yml`, `db.sqlite`). Docker при отсутствующем source
|
||
создаёт директорию — для файловых bind-mount'ов (напр. AnythingLLM монтирует
|
||
`.env` как файл) это ломает `docker compose up` ошибкой "not a directory:
|
||
Are you trying to mount a directory onto a file?".
|
||
|
||
Скрытые имена (`.config`, `.n8n`, `.ssh`) — почти всегда ДИРЕКТОРИИ:
|
||
ведущая точка не считается расширением. Файлы среди них — только `.env*`.
|
||
"""
|
||
name = source.rsplit("/", 1)[-1]
|
||
if name.startswith("."):
|
||
return name.lower().startswith(".env")
|
||
return "." in name
|
||
|
||
|
||
def _prepare_bind_mounts(ssh: SSHClient, vmid: int, compose_yaml: str,
|
||
app_dir: str, env: Dict[str, str]) -> None:
|
||
"""Pre-create хост-путей bind-mount'ов с правами 777/666 (см. _bind_mount_hosts).
|
||
|
||
Директории — `mkdir -p`; файлоподобные source (см. _is_file_mount) — `touch`
|
||
родительский путь как файл, иначе Docker создаст там директорию сам.
|
||
"""
|
||
hosts = _bind_mount_hosts(compose_yaml, app_dir, env)
|
||
if not hosts:
|
||
return
|
||
dirs = [h for h in hosts if not _is_file_mount(h)]
|
||
files = [h for h in hosts if _is_file_mount(h)]
|
||
cmds = []
|
||
if dirs:
|
||
q = " ".join(_shq(h) for h in dirs)
|
||
cmds.append(f"mkdir -p {q} && chmod -R 777 {q}")
|
||
for f in files:
|
||
parent = f.rsplit("/", 1)[0] if "/" in f else "."
|
||
qf, qp = _shq(f), _shq(parent)
|
||
# rmdir — самовосстановление после старого бага: если source уже был
|
||
# ошибочно создан Docker'ом как ПУСТАЯ директория в прошлой попытке,
|
||
# убираем её перед touch; иначе Docker не может смонтировать файл поверх
|
||
# директории ("not a directory: ... mount a directory onto a file").
|
||
# Непустую директорию не трогаем (там могут быть данные приложения —
|
||
# ошибка эвристики не должна приводить к потере данных).
|
||
# chmod 777, а не 666: доставленные из каталога скрипты (entrypoint.sh
|
||
# и т.п.) должны сохранить/получить exec-бит, иначе контейнер падает
|
||
# с "permission denied" на entrypoint.
|
||
cmds.append(
|
||
f"mkdir -p {qp}; if [ -d {qf} ]; then rmdir {qf} 2>/dev/null || true; fi; "
|
||
f"[ -e {qf} ] || touch {qf}; [ -d {qf} ] || chmod 777 {qf}"
|
||
)
|
||
_run(ssh, _pct(vmid, " && ".join(cmds)), what="prepare bind-mount dirs")
|
||
|
||
|
||
def _push_file(ssh: SSHClient, vmid: int, content, dest: str, *,
|
||
perms: Optional[str] = None) -> None:
|
||
"""Доставить файл в контейнер без shell-инъекций: base64 → файл на ноде → pct push.
|
||
|
||
content — str (utf-8) или bytes (бинарные файлы каталога).
|
||
"""
|
||
raw = content.encode("utf-8") if isinstance(content, str) else content
|
||
b64 = base64.b64encode(raw).decode("ascii")
|
||
tmp = f"/tmp/appstore_{vmid}_{abs(hash(dest)) % 100000}"
|
||
# b64 состоит из [A-Za-z0-9+/=], безопасно внутри одинарных кавычек.
|
||
_run(ssh, f"printf '%s' '{b64}' | base64 -d > {tmp}", what=f"write {dest} on node")
|
||
perms_arg = f" --perms {perms}" if perms else ""
|
||
_run(ssh, f"pct push {vmid} {tmp} {dest}{perms_arg}", what=f"pct push {dest}")
|
||
_run(ssh, f"rm -f {tmp}", what="cleanup temp")
|
||
|
||
|
||
# Имя relpath data-файла: только безопасные символы (dest не квотируется в
|
||
# `pct push`), без '..' и ведущих '/' — защита от path traversal и инъекций.
|
||
_DATA_RELPATH_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._/\-@]*$")
|
||
|
||
|
||
# Плейсхолдер Runtipi-шаблона: {{VAR}} / {{ VAR }} в файлах data/*.template.
|
||
_TPL_VAR_RE = re.compile(r"\{\{\s*([A-Za-z_][A-Za-z0-9_]*)\s*\}\}")
|
||
|
||
|
||
def _render_template(blob: bytes, env: Dict[str, str]) -> bytes:
|
||
"""Рендер Runtipi-шаблона: {{VAR}} → env[VAR] (отсутствующие → '')."""
|
||
text = blob.decode("utf-8", "replace")
|
||
text = _TPL_VAR_RE.sub(lambda m: str(env.get(m.group(1), "")), text)
|
||
return text.encode("utf-8")
|
||
|
||
|
||
def _push_data_files(ssh: SSHClient, vmid: int, data_files: Dict[str, dict],
|
||
env: Dict[str, str]) -> None:
|
||
"""Доставить файлы приложения из каталога в ${APP_DATA_DIR}/<relpath>.
|
||
|
||
Compose bind-mount'ит их (напр. ${APP_DATA_DIR}/data/nginx.conf,
|
||
${APP_DATA_DIR}/entrypoint.sh) — без доставки на их месте оказались бы
|
||
пустые файлы-заглушки, и приложение падает на старте. Exec-бит
|
||
сохраняется (скрипты); прочим файлам даём 666 (владелец внутри
|
||
контейнера не разграничивается — см. _bind_mount_hosts).
|
||
|
||
Файлы `*.template` (конвенция Runtipi) рендерятся ({{VAR}} → env) и
|
||
кладутся под именем без суффикса — именно его монтирует compose.
|
||
"""
|
||
safe: Dict[str, bytes] = {}
|
||
execs: Dict[str, bool] = {}
|
||
for relpath, meta in (data_files or {}).items():
|
||
if not isinstance(meta, dict) or not meta.get("b64"):
|
||
continue
|
||
if not _DATA_RELPATH_RE.match(relpath) or ".." in relpath:
|
||
logger.warning(f"[appstore-poc] skip data file with unsafe path: {relpath!r}")
|
||
continue
|
||
try:
|
||
blob = base64.b64decode(meta["b64"])
|
||
except Exception:
|
||
logger.warning(f"[appstore-poc] skip data file {relpath}: битый base64")
|
||
continue
|
||
if relpath.endswith(".template"):
|
||
relpath = relpath[: -len(".template")]
|
||
blob = _render_template(blob, env)
|
||
safe[relpath] = blob
|
||
execs[relpath] = bool(meta.get("exec"))
|
||
if not safe:
|
||
return
|
||
|
||
# Заранее создаём все родительские директории одним pct exec.
|
||
dirs = sorted({f"{APP_DATA_DIR}/{rp}".rsplit("/", 1)[0] for rp in safe})
|
||
_run(ssh, _pct(vmid, "mkdir -p " + " ".join(_shq(d) for d in dirs)),
|
||
what="mkdir data-file dirs")
|
||
|
||
for relpath, blob in safe.items():
|
||
_push_file(ssh, vmid, blob, f"{APP_DATA_DIR}/{relpath}",
|
||
perms="0777" if execs[relpath] else "0666")
|
||
|
||
|
||
def _env_file_value(v) -> str:
|
||
"""Значение для строки .env: одна строка на переменную + кавычение.
|
||
|
||
dotenv-парсер docker compose считает ` #` в незакавыченном значении началом
|
||
inline-комментария и обрезает хвост — пароль вида "pa#ss" молча превращался
|
||
в "pa". Такие значения (а также с ведущими/хвостовыми пробелами) оборачиваем
|
||
в двойные кавычки. Остальные оставляем как есть, чтобы не менять поведение
|
||
подстановки ($VAR) для существующих приложений.
|
||
"""
|
||
s = str(v).replace("\r", " ").replace("\n", " ")
|
||
if "#" in s or s != s.strip():
|
||
return '"' + s.replace("\\", "\\\\").replace('"', '\\"') + '"'
|
||
return s
|
||
|
||
|
||
def _env_file_content(env: Dict[str, str]) -> str:
|
||
return "".join(f"{k}={_env_file_value(v)}\n" for k, v in env.items())
|
||
|
||
|
||
def _wait_ip(ssh: SSHClient, vmid: int, timeout: int) -> Optional[str]:
|
||
deadline = time.time() + timeout
|
||
while time.time() < deadline:
|
||
out, code = ssh.execute(f"pct exec {vmid} -- hostname -I", return_exit_code=True)
|
||
if code == 0 and out and out.strip():
|
||
ip = out.strip().split()[0]
|
||
if ip and not ip.startswith("127."):
|
||
return ip
|
||
time.sleep(3)
|
||
return None
|
||
|
||
|
||
# ── Выбор ноды (как в _do_lxc_deploy) ─────────────────────────────────────────
|
||
|
||
def _resolve_node(client, requested: Optional[str]) -> str:
|
||
if requested:
|
||
return requested
|
||
nodes = client.get_nodes()
|
||
if not nodes:
|
||
raise PocError("Не найдено нод Proxmox")
|
||
for n in nodes:
|
||
try:
|
||
for s in client.proxmox.nodes(n["node"]).storage.get():
|
||
if "vztmpl" in s.get("content", ""):
|
||
return n["node"]
|
||
except Exception:
|
||
pass
|
||
return nodes[0]["node"]
|
||
|
||
|
||
# ── Основной пайплайн ─────────────────────────────────────────────────────────
|
||
|
||
def poc_install(db: Session, spec: InstallSpec, on_step: StepCb = _noop) -> InstallResult:
|
||
if not _NAME_RE.match(spec.name):
|
||
raise PocError(f"Недопустимое имя приложения: {spec.name!r} (a-z, 0-9, дефис)")
|
||
|
||
server = db.query(ProxmoxServer).filter(ProxmoxServer.id == spec.server_id).first()
|
||
if not server:
|
||
raise PocError(f"Proxmox сервер id={spec.server_id} не найден")
|
||
|
||
on_step("Подключение к Proxmox...", 5)
|
||
client = _get_proxmox_client(server)
|
||
if not client.is_connected():
|
||
raise PocError("Не удалось подключиться к Proxmox")
|
||
|
||
node = _resolve_node(client, spec.node)
|
||
vmid = spec.vmid or get_next_vmid(db, server.id)
|
||
|
||
# Идемпотентность повтора (ТЗ 6.1): если контейнер с этим vmid уже создан —
|
||
# не пересоздаём, продолжаем с доставки/запуска compose.
|
||
already_exists = False
|
||
if spec.vmid:
|
||
try:
|
||
already_exists = bool(client.get_container_status(node, vmid))
|
||
except Exception:
|
||
already_exists = False
|
||
|
||
if already_exists:
|
||
on_step(f"Контейнер VMID {vmid} уже существует — повтор без пересоздания", 40)
|
||
else:
|
||
on_step(f"Создание LXC VMID {vmid} на ноде {node}...", 20)
|
||
ip_cfg = spec.ip_config or "ip=dhcp"
|
||
net0 = f"name=eth0,bridge={spec.bridge},{ip_cfg},firewall=1"
|
||
try:
|
||
upid = client.create_lxc_container(
|
||
node=node,
|
||
vmid=vmid,
|
||
ostemplate=spec.ostemplate,
|
||
hostname=spec.name,
|
||
cores=spec.cores,
|
||
memory=spec.memory,
|
||
swap=spec.swap,
|
||
storage=spec.storage,
|
||
rootfs_size=spec.disk,
|
||
net0=net0,
|
||
features=spec.features, # nesting=1,keyctl=1 — критично для Docker
|
||
unprivileged=True,
|
||
start_after_create=False,
|
||
description=f"pvemanager-appstore: {spec.name}",
|
||
nameserver=spec.nameserver or settings.APPSTORE_NAMESERVER,
|
||
)
|
||
except Exception as e:
|
||
raise PocError(f"Ошибка создания контейнера: {e}") from e
|
||
if not upid:
|
||
raise PocError("Proxmox не вернул UPID создания контейнера")
|
||
|
||
on_step("Ожидание завершения создания...", 35)
|
||
if not client.wait_for_task(node, upid, timeout=300):
|
||
raise PocError("Таймаут создания контейнера (>5 мин)")
|
||
|
||
on_step("Запуск контейнера...", 45)
|
||
client.start_container(node, vmid)
|
||
|
||
ssh = _node_ssh(server, client)
|
||
if not ssh.connect():
|
||
raise PocError("SSH к ноде не установлен (нужен root-доступ к ноде для pct exec/push)")
|
||
try:
|
||
on_step("Ожидание IP-адреса...", 55)
|
||
# Статический IP из IPAM известен заранее — подтверждаем через контейнер,
|
||
# но при таймауте всё равно используем выделенный адрес.
|
||
ip = _wait_ip(ssh, vmid, spec.ip_timeout) or spec.static_ip
|
||
if not ip:
|
||
raise PocError(f"Контейнер не получил IP за {spec.ip_timeout}с")
|
||
|
||
on_step("Подготовка каталогов и Docker-сети...", 65)
|
||
_run(ssh, _pct(vmid, f"mkdir -p {APP_DIR} {APP_DATA_DIR}"), what="mkdir app dirs")
|
||
_run(
|
||
ssh,
|
||
_pct(vmid, f"docker network inspect {TIPI_NETWORK} >/dev/null 2>&1 || "
|
||
f"docker network create {TIPI_NETWORK}"),
|
||
what="ensure docker network",
|
||
)
|
||
|
||
on_step("Доставка docker-compose.yml и .env (pct push)...", 75)
|
||
normalized, pub_port = _normalize_compose(spec.compose_yaml, spec.port,
|
||
source=spec.source,
|
||
port_explicit=spec.port_explicit)
|
||
if pub_port:
|
||
# Порт, реально опубликованный на хосте LXC → на нём и проверяем/URL.
|
||
spec.port = pub_port
|
||
_push_file(ssh, vmid, normalized, f"{APP_DIR}/docker-compose.yml")
|
||
# IP-зависимые платформенные переменные (ТЗ 5.3) заполняем здесь — IP уже известен.
|
||
env = _platform_env(dict(spec.env_vars), ip, spec.source)
|
||
_push_file(ssh, vmid, _env_file_content(env), f"{APP_DIR}/.env")
|
||
# Файлы приложения из репозитория каталога (конфиги/скрипты) — ДО
|
||
# подготовки bind-mount'ов, чтобы на их местах не появились пустышки.
|
||
_push_data_files(ssh, vmid, spec.data_files, env)
|
||
# Bind-mount директории заранее и с правами 777 — иначе Docker создаст
|
||
# их сам от root при первом `up`, и процессы в контейнере (напр.
|
||
# mariadb от uid mysql) получат Permission denied на запись.
|
||
_prepare_bind_mounts(ssh, vmid, normalized, APP_DIR, env)
|
||
|
||
on_step("Запуск docker compose up -d...", 85)
|
||
_run(
|
||
ssh,
|
||
_pct(vmid, f"cd {APP_DIR} && docker compose --env-file .env up -d 2>&1"),
|
||
what="docker compose up",
|
||
timeout=_DOCKER_TIMEOUT, # тянет образы — может идти минуты
|
||
)
|
||
|
||
on_step(f"Health-check http://{ip}:{spec.port} ...", 92)
|
||
ok = _health_check(ip, spec.port, spec.health_timeout)
|
||
status = "running" if ok else "unhealthy"
|
||
url = f"http://{ip}:{spec.port}"
|
||
on_step(f"Готово ({status}): {url}", 100)
|
||
return InstallResult(vmid=vmid, node=node, ip=ip, url=url, status=status)
|
||
finally:
|
||
ssh.close()
|
||
|
||
|
||
def _health_check(ip: str, port: int, timeout: int) -> bool:
|
||
"""Успех = любой HTTP-ответ (включая 3xx/401). Ретраи каждые 5с до timeout."""
|
||
import httpx
|
||
|
||
deadline = time.time() + timeout
|
||
url = f"http://{ip}:{port}"
|
||
while time.time() < deadline:
|
||
try:
|
||
r = httpx.get(url, timeout=5, follow_redirects=False)
|
||
logger.info(f"[appstore-poc] health {url} -> HTTP {r.status_code}")
|
||
return True
|
||
except Exception:
|
||
time.sleep(5)
|
||
return False
|
||
|
||
|
||
def poc_update(server, client, vmid: int, node: str, compose_yaml: str,
|
||
env_vars: Dict[str, str], port: int, ip: str,
|
||
on_step: StepCb = _noop, health_timeout: int = 300,
|
||
source: str = "runtipi",
|
||
data_files: Optional[Dict[str, dict]] = None,
|
||
port_explicit: bool = False) -> tuple[str, int]:
|
||
"""Обновление приложения в существующем контейнере (M4): доставка нового
|
||
docker-compose.yml → docker compose pull && up -d → health-check.
|
||
|
||
Возвращает ('running' | 'unhealthy', эффективный_порт). Порт возвращаем,
|
||
потому что нормализация compose может опубликовать порт, отличный от
|
||
сохранённого в БД (ia.port), — иначе URL/health в БД укажут не туда.
|
||
"""
|
||
ssh = _node_ssh(server, client)
|
||
if not ssh.connect():
|
||
raise PocError("SSH к ноде не установлен (нужен root-доступ для pct exec/push)")
|
||
try:
|
||
on_step("Доставка нового docker-compose.yml...", 45)
|
||
_run(ssh, _pct(vmid, f"mkdir -p {APP_DIR} {APP_DATA_DIR}"), what="mkdir app dirs")
|
||
_run(
|
||
ssh,
|
||
_pct(vmid, f"docker network inspect {TIPI_NETWORK} >/dev/null 2>&1 || "
|
||
f"docker network create {TIPI_NETWORK}"),
|
||
what="ensure docker network",
|
||
)
|
||
normalized, pub_port = _normalize_compose(compose_yaml, port, source=source,
|
||
port_explicit=port_explicit)
|
||
if pub_port:
|
||
port = pub_port
|
||
_push_file(ssh, vmid, normalized, f"{APP_DIR}/docker-compose.yml")
|
||
env = _platform_env(dict(env_vars), ip, source)
|
||
_push_file(ssh, vmid, _env_file_content(env), f"{APP_DIR}/.env")
|
||
_push_data_files(ssh, vmid, data_files or {}, env)
|
||
_prepare_bind_mounts(ssh, vmid, normalized, APP_DIR, env)
|
||
|
||
on_step("docker compose pull && up -d...", 65)
|
||
_run(
|
||
ssh,
|
||
_pct(vmid, f"cd {APP_DIR} && docker compose --env-file .env pull 2>&1 && "
|
||
f"docker compose --env-file .env up -d 2>&1"),
|
||
what="docker compose pull/up",
|
||
timeout=_DOCKER_TIMEOUT, # pull больших образов — может идти минуты
|
||
)
|
||
|
||
on_step(f"Health-check http://{ip}:{port} ...", 88)
|
||
return ("running" if _health_check(ip, port, health_timeout) else "unhealthy"), port
|
||
finally:
|
||
ssh.close()
|
||
|
||
|
||
def poc_teardown(db: Session, server_id: int, vmid: int, node: Optional[str] = None,
|
||
on_step: StepCb = _noop) -> None:
|
||
"""Остановить и удалить контейнер PoC (для повторяемого прогона)."""
|
||
server = db.query(ProxmoxServer).filter(ProxmoxServer.id == server_id).first()
|
||
if not server:
|
||
raise PocError(f"Proxmox сервер id={server_id} не найден")
|
||
client = _get_proxmox_client(server)
|
||
node = node or _resolve_node(client, None)
|
||
|
||
on_step(f"Остановка LXC {vmid}...", 30)
|
||
try:
|
||
upid = client.stop_container(node, vmid, force=True)
|
||
if upid:
|
||
client.wait_for_task(node, upid, timeout=120)
|
||
except Exception as e:
|
||
logger.warning(f"stop_container: {e}")
|
||
|
||
on_step(f"Удаление LXC {vmid}...", 70)
|
||
try:
|
||
upid = client.delete_container(node, vmid, force=True)
|
||
except Exception as e:
|
||
# CT уже отсутствует (удалён вручную в Proxmox / статус orphaned) —
|
||
# считаем teardown успешным, иначе запись в БД нельзя удалить никогда:
|
||
# каждый повтор удаления падал бы на этом же месте.
|
||
msg = str(e).lower()
|
||
if "does not exist" in msg or "no such" in msg:
|
||
on_step(f"LXC {vmid} уже отсутствует в Proxmox — пропускаем", 100)
|
||
return
|
||
raise
|
||
if upid:
|
||
# Ждём реального завершения задачи, а не просто отдаём таймаут наверх:
|
||
# иначе caller решит, что ресурсы освобождены, пока нода ещё занята
|
||
# (напр. wipe диска) — и следующая установка с тем же VMID словит
|
||
# "can't lock file ... got timeout" (см. инцидент с VMID 102).
|
||
done = client.wait_for_task(node, upid, timeout=_TEARDOWN_WAIT_TIMEOUT)
|
||
if not done:
|
||
raise PocError(
|
||
f"Удаление LXC {vmid}: Proxmox не подтвердил завершение задачи "
|
||
f"за {_TEARDOWN_WAIT_TIMEOUT}с (нода может ещё выполнять wipe "
|
||
f"диска) — ресурсы не считаются освобождёнными, повторите позже"
|
||
)
|
||
on_step("Удалено", 100)
|