Интегрирован wesp в сайт

WESP_REL/app/services/admin_dashboard_service.py

@@ -0,0 +1,386 @@
+"""Вспомогательные функции админ-дашборда: хвост лога, бэкап SQLite, команды службы."""
+
+from __future__ import annotations
+
+import gc
+import io
+import json
+import os
+import shlex
+import shutil
+import time
+import sqlite3
+import subprocess
+import tempfile
+import zipfile
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+from flask import Flask
+from sqlalchemy.engine.url import make_url
+
+
+def tail_text_file(path: Path, max_lines: int = 200, max_bytes: int = 512_000) -> Tuple[List[str], str]:
+    """Читает последние строки текстового файла (ограничение по размеру хвоста)."""
+    if not path.is_file():
+        return [], "Файл не найден"
+    try:
+        size = path.stat().st_size
+        with path.open("rb") as f:
+            if size <= max_bytes:
+                f.seek(0)
+                chunk = f.read()
+            else:
+                f.seek(-max_bytes, os.SEEK_END)
+                chunk = f.read()
+        text = chunk.decode("utf-8", errors="replace")
+        lines = text.splitlines()
+        return lines[-max_lines:], ""
+    except OSError as exc:
+        return [], str(exc)
+
+
+def sqlite_bind_paths(app: Flask) -> Dict[str, Path]:
+    """Имена bind SQLAlchemy → абсолютные пути к файлам SQLite (только файловые URI)."""
+    return dict(_sqlite_paths_from_app(app))
+
+
+def _sqlite_paths_from_app(app: Flask) -> List[Tuple[str, Path]]:
+    out: List[Tuple[str, Path]] = []
+    uris = [app.config.get("SQLALCHEMY_DATABASE_URI", "")]
+    binds = app.config.get("SQLALCHEMY_BINDS") or {}
+    for name, uri in [("recipes", uris[0]), *[(k, v) for k, v in binds.items()]]:
+        if not uri:
+            continue
+        try:
+            url = make_url(uri)
+        except Exception:
+            continue
+        if url.drivername != "sqlite":
+            continue
+        db = url.database
+        if not db or db == ":memory:":
+            continue
+        p = Path(db)
+        if not p.is_absolute():
+            p = Path(app.config.get("BASE_DIR", ".")) / p
+        out.append((name, p.resolve()))
+    return out
+
+
+def _sqlite_snapshot_bytes(fpath: Path) -> bytes:
+    """
+    Согласованный снимок файла SQLite для архива.
+    При journal_mode=WAL простое копирование .db на диске может не включать свежие данные
+    (они в -wal); sqlite3.backup объединяет состояние в один файл.
+    """
+    if not fpath.is_file():
+        raise FileNotFoundError(f"База не найдена: {fpath}")
+    src = sqlite3.connect(str(fpath))
+    try:
+        fd, tmp_name = tempfile.mkstemp(suffix=".db")
+        os.close(fd)
+        try:
+            dst = sqlite3.connect(tmp_name)
+            try:
+                src.backup(dst)
+            finally:
+                dst.close()
+            return Path(tmp_name).read_bytes()
+        finally:
+            try:
+                Path(tmp_name).unlink(missing_ok=True)
+            except OSError:
+                pass
+    finally:
+        src.close()
+
+
+def build_sqlite_backup_zip(app: Flask) -> Tuple[bytes, str]:
+    """Упаковывает файлы SQLite в ZIP; возвращает (bytes, предлагаемое имя файла)."""
+    from datetime import datetime
+
+    pairs = _sqlite_paths_from_app(app)
+    if not pairs:
+        raise ValueError("Нет файловых баз SQLite для резервной копии")
+
+    buf = io.BytesIO()
+    stamp = datetime.utcnow().strftime("%Y%m%d-%H%M%S")
+    used_names: set[str] = set()
+    with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as zf:
+        for bind_name, fpath in pairs:
+            arc = f"{bind_name}-{fpath.name}"
+            if arc in used_names:
+                arc = f"{bind_name}-{fpath.name}-{len(used_names)}"
+            used_names.add(arc)
+            raw = _sqlite_snapshot_bytes(fpath)
+            zf.writestr(arc, raw, compress_type=zipfile.ZIP_DEFLATED)
+    name = f"wesp-sqlite-backup-{stamp}.zip"
+    return buf.getvalue(), name
+
+
+_SQLITE_MAGIC = b"SQLite format 3\x00"
+
+
+def _remove_sqlite_sidecars(db_path: Path) -> None:
+    """Удаляет -wal / -shm / -journal рядом с файлом БД (после подмены файла)."""
+    base = str(db_path)
+    for suffix in ("-wal", "-shm", "-journal"):
+        p = Path(base + suffix)
+        try:
+            if p.is_file():
+                p.unlink()
+        except OSError:
+            pass
+
+
+def _checkpoint_sqlite(db_path: Path) -> None:
+    """Сбрасывает WAL перед подменой файла на диске."""
+    if not db_path.is_file():
+        return
+    try:
+        con = sqlite3.connect(str(db_path))
+        try:
+            con.execute("PRAGMA wal_checkpoint(TRUNCATE)")
+        finally:
+            con.close()
+    except sqlite3.Error:
+        pass
+
+
+def _restore_sqlite_via_backup(dest_path: Path, raw: bytes) -> None:
+    """Вливает снимок SQLite в существующий файл (работает при открытых соединениях)."""
+    fd, tmp_name = tempfile.mkstemp(suffix=".db")
+    os.close(fd)
+    try:
+        Path(tmp_name).write_bytes(raw)
+        src = sqlite3.connect(tmp_name)
+        try:
+            dst = sqlite3.connect(str(dest_path))
+            try:
+                src.backup(dst)
+            finally:
+                dst.close()
+        finally:
+            src.close()
+    finally:
+        try:
+            Path(tmp_name).unlink(missing_ok=True)
+        except OSError:
+            pass
+
+
+def _replace_sqlite_file(tmp_file: Path, dest_path: Path) -> None:
+    """Атомарная подмена файла SQLite; при блокировке — sqlite3.backup в целевой файл."""
+    gc.collect()
+    _checkpoint_sqlite(dest_path)
+    _remove_sqlite_sidecars(dest_path)
+    last_exc: Optional[OSError] = None
+    for attempt in range(8):
+        try:
+            os.replace(str(tmp_file), str(dest_path))
+            _remove_sqlite_sidecars(dest_path)
+            return
+        except OSError as exc:
+            last_exc = exc
+            if attempt >= 7:
+                break
+            gc.collect()
+            _checkpoint_sqlite(dest_path)
+            _remove_sqlite_sidecars(dest_path)
+            time.sleep(0.05 * (attempt + 1))
+    if last_exc is not None:
+        raw = tmp_file.read_bytes()
+        _restore_sqlite_via_backup(dest_path, raw)
+        try:
+            tmp_file.unlink(missing_ok=True)
+        except OSError:
+            pass
+        _remove_sqlite_sidecars(dest_path)
+
+
+def _dispose_sqlalchemy_engines(app: Flask) -> None:
+    """Сбрасывает пулы соединений перед заменой файлов на диске."""
+    from app import db
+
+    with app.app_context():
+        db.session.remove()
+        try:
+            db.engine.dispose()
+        except Exception:
+            pass
+        for bind_key in app.config.get("SQLALCHEMY_BINDS") or {}:
+            try:
+                db.get_engine(app=app, bind=bind_key).dispose()
+            except Exception:
+                pass
+
+
+def restore_sqlite_from_zip(app: Flask, zip_bytes: bytes) -> Dict[str, Any]:
+    """
+    Восстанавливает файлы SQLite из ZIP того же формата, что и build_sqlite_backup_zip
+    (имена внутри: «{bind}-{имя_файла}», например recipes-recipes.db).
+    Текущие файлы копируются в *.restore-bak-{utc_stamp}.
+    """
+    if len(zip_bytes) > 80 * 1024 * 1024:
+        raise ValueError("Архив слишком большой (максимум 80 МБ)")
+
+    pairs = _sqlite_paths_from_app(app)
+    if not pairs:
+        raise ValueError("Нет файловых баз SQLite в конфигурации")
+
+    stamp = datetime.utcnow().strftime("%Y%m%d-%H%M%S")
+    tmp_root = Path(app.config.get("BASE_DIR", ".")).resolve() / "wesp_restore_tmp"
+    tmp_root.mkdir(parents=True, exist_ok=True)
+    pid = os.getpid()
+    restored: List[Dict[str, str]] = []
+
+    _dispose_sqlalchemy_engines(app)
+
+    try:
+        with zipfile.ZipFile(io.BytesIO(zip_bytes)) as zf:
+            members = [
+                n.strip().replace("\\", "/")
+                for n in zf.namelist()
+                if n and not n.endswith("/")
+            ]
+            for bind_name, dest_path in pairs:
+                arc = f"{bind_name}-{dest_path.name}"
+                match = None
+                for m in members:
+                    if m.rsplit("/", 1)[-1] == arc:
+                        match = m
+                        break
+                if not match:
+                    raise ValueError(
+                        f"В архиве нет файла «{arc}» для bind «{bind_name}». "
+                        "Нужен ZIP, скачанный кнопкой «Скачать ZIP»."
+                    )
+
+                raw = zf.read(match)
+                if len(raw) < 16 or not raw.startswith(_SQLITE_MAGIC):
+                    raise ValueError(f"«{arc}» не является корректным файлом SQLite")
+
+                dest_path.parent.mkdir(parents=True, exist_ok=True)
+                if dest_path.is_file():
+                    bak = dest_path.with_name(f"{dest_path.name}.restore-bak-{stamp}")
+                    shutil.copy2(dest_path, bak)
+
+                _remove_sqlite_sidecars(dest_path)
+                tmp_file = tmp_root / f"{arc}.{pid}.tmp"
+                try:
+                    tmp_file.write_bytes(raw)
+                    _replace_sqlite_file(tmp_file, dest_path)
+                finally:
+                    try:
+                        if tmp_file.is_file():
+                            tmp_file.unlink()
+                    except OSError:
+                        pass
+
+                _remove_sqlite_sidecars(dest_path)
+                restored.append({"bind": bind_name, "path": str(dest_path)})
+    except zipfile.BadZipFile as exc:
+        raise ValueError("Некорректный ZIP-архив") from exc
+
+    return {
+        "restored": restored,
+        "message": (
+            "Базы восстановлены из архива. Перезапустите процесс WESP "
+            "(или службу), затем обновите страницу."
+        ),
+    }
+
+
+def run_service_command(app: Flask, action: str) -> Dict[str, Any]:
+    """action: restart | stop — только если задана команда в конфиге."""
+    if action == "restart":
+        from app.services.system_restart_service import resolve_admin_restart_cmd
+
+        cmd = resolve_admin_restart_cmd(app.config)
+    elif action == "stop":
+        cmd = app.config.get("WESP_ADMIN_STOP_CMD") or ""
+    else:
+        return {"ok": False, "code": "bad_action", "message": "Неизвестное действие"}
+
+    cmd = (cmd or "").strip()
+    if not cmd:
+        return {
+            "ok": False,
+            "code": "not_configured",
+            "message": (
+                "Команда не задана. Для перезапуска/остановки укажите в окружении "
+                "WESP_ADMIN_RESTART_CMD или WESP_ADMIN_STOP_CMD (например systemctl …)."
+            ),
+        }
+
+    try:
+        args = shlex.split(cmd)
+        subprocess.Popen(
+            args,
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            start_new_session=True,
+        )
+    except OSError as exc:
+        return {"ok": False, "code": "exec_error", "message": str(exc)}
+
+    return {"ok": True, "code": "started", "message": "Команда запущена в фоне"}
+
+
+def install_state_path(app: Flask) -> Path:
+    raw = (app.config.get("WESP_INSTALL_STATE_PATH") or "").strip()
+    if raw:
+        p = Path(raw).expanduser()
+        if not p.is_absolute():
+            p = Path(str(app.config.get("BASE_DIR", "."))) / p
+        return p.resolve()
+    data_dir = Path(str(app.config.get("DATA_DIR") or "")).expanduser()
+    if not str(data_dir):
+        data_dir = Path(str(app.config.get("BASE_DIR", "."))) / "data"
+    return data_dir.resolve() / "wesp_install_state.json"
+
+
+def get_install_and_warranty(app: Flask) -> Dict[str, Any]:
+    """
+    Дата первого запуска (фиксируется в JSON при первом обращении) и гарантия WESP_WARRANTY_DAYS.
+    Возвращает UTC ISO для first_launch_at, дату окончания гарантии и целые дни до неё (может быть < 0).
+    """
+    path = install_state_path(app)
+    warranty_days = int(app.config.get("WESP_WARRANTY_DAYS", 365))
+    warranty_days = max(1, warranty_days)
+    now = datetime.now(timezone.utc)
+
+    first_launch: Optional[datetime] = None
+    if path.is_file():
+        try:
+            data = json.loads(path.read_text(encoding="utf-8"))
+            raw_ts = data.get("first_launch_at") or data.get("first_started_at")
+            if raw_ts:
+                first_launch = datetime.fromisoformat(str(raw_ts).replace("Z", "+00:00"))
+                if first_launch.tzinfo is None:
+                    first_launch = first_launch.replace(tzinfo=timezone.utc)
+        except (OSError, ValueError, TypeError, json.JSONDecodeError):
+            first_launch = None
+
+    if first_launch is None:
+        first_launch = now
+        try:
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_text(
+                json.dumps({"first_launch_at": first_launch.isoformat()}, indent=2),
+                encoding="utf-8",
+            )
+        except OSError:
+            pass
+
+    warranty_end = first_launch + timedelta(days=warranty_days)
+    days_left = (warranty_end.date() - now.date()).days
+
+    return {
+        "first_launch_at": first_launch.isoformat(),
+        "warranty_until": warranty_end.date().isoformat(),
+        "warranty_days_remaining": int(days_left),
+    }