lockbot 2.9.3__tar.gz → 2.9.4__tar.gz

{lockbot-2.9.3/python/lockbot.egg-info → lockbot-2.9.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lockbot
-Version: 2.9.3
+Version: 2.9.4
 Summary: Cluster resource management bot for IM platforms
 Author-email: Jianbang Yang <yangjianbang112@gmail.com>
 License: MIT

{lockbot-2.9.3 → lockbot-2.9.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lockbot"
-version = "2.9.3"
+version = "2.9.4"
 description = "Cluster resource management bot for IM platforms"
 readme = "README.md"
 license = {text = "MIT"}

{lockbot-2.9.3 → lockbot-2.9.4}/python/lockbot/backend/app/admin/router.py

@@ -3,16 +3,10 @@ Admin API routes.
 """
 
 import contextlib
-import io
-import json
 import os
-import shutil
-import tempfile
-import zipfile
-from datetime import datetime
 
-from fastapi import APIRouter, Depends, HTTPException, Request
-from fastapi.responses import FileResponse, Response
+from fastapi import APIRouter, Depends, File, Form, HTTPException, Request, UploadFile
+from fastapi.responses import FileResponse
 from sqlalchemy.orm import Session
 from starlette.background import BackgroundTask
 
@@ -300,78 +294,108 @@ def download_backup(
     _admin: User = Depends(require_super_admin),
     db: Session = Depends(get_db),
 ):
-    """Download full SQLite database backup (super_admin only)."""
-    from lockbot.backend.app.config import DATABASE_URL
+    """Download full backup archive (DB + bot states + manifest) as zip (super_admin only)."""
+    from lockbot.backend.app.backup.service import create_backup_archive
 
-    db_url = DATABASE_URL
-    if not db_url.startswith("sqlite:///"):
-        raise HTTPException(status_code=400, detail="Backup only supported for SQLite")
-
-    db_path = db_url[len("sqlite:///") :]
-    if not os.path.exists(db_path):
-        raise HTTPException(status_code=404, detail="Database file not found")
-
-    # Copy to temp file to avoid sending a mid-write database
-    fd, tmp_path = tempfile.mkstemp(suffix=".db")
-    os.close(fd)
     try:
-        shutil.copy2(db_path, tmp_path)
-    except BaseException:
-        with contextlib.suppress(OSError):
-            os.unlink(tmp_path)
-        raise
+        zip_path = create_backup_archive(password=None)
+    except RuntimeError as e:
+        raise HTTPException(status_code=400, detail=str(e)) from None
 
     write_audit_log(db, _admin, "admin.backup", ip=request.client.host if request.client else None)
     db.commit()
 
-    filename = f"lockbot_backup_{datetime.now().strftime('%Y%m%d_%H%M%S')}.db"
+    filename = zip_path.name
     return FileResponse(
-        path=tmp_path,
+        path=str(zip_path),
         filename=filename,
-        media_type="application/x-sqlite3",
-        background=BackgroundTask(os.unlink, tmp_path),
+        media_type="application/zip",
+        background=BackgroundTask(_cleanup_backup_tmp, zip_path),
     )
 
 
-_DEFAULT_DATA_DIR = os.environ.get("DATA_DIR", "/data")
+def _cleanup_backup_tmp(zip_path):
 
+    with contextlib.suppress(OSError):
+        zip_path.unlink(missing_ok=True)
+    with contextlib.suppress(OSError):
+        zip_path.parent.rmdir()
+
+
+@router.post("/backup/restore/preview")
+async def preview_restore_backup(
+    file: UploadFile = File(...),
+    password: str | None = Form(default=None),
+    source_secret_key: str | None = Form(default=None),
+    _admin: User = Depends(require_super_admin),
+    db: Session = Depends(get_db),
+):
+    """Preview restoring bots from a unified backup zip (super_admin only)."""
+    from lockbot.backend.app.backup.service import restore_preview
 
-@router.get("/bot-states")
-def download_all_bot_states(
+    content = await file.read()
+    if not content:
+        raise HTTPException(status_code=400, detail="Backup file is empty")
+    try:
+        return restore_preview(content, password or None, source_secret_key or None, _admin.id, db)
+    except ValueError as e:
+        err = str(e)
+        if err == "BACKUP_PASSWORD_REQUIRED":
+            raise HTTPException(status_code=422, detail="BACKUP_PASSWORD_REQUIRED") from None
+        if err == "BACKUP_PASSWORD_WRONG":
+            raise HTTPException(status_code=422, detail="BACKUP_PASSWORD_WRONG") from None
+        raise HTTPException(status_code=400, detail=err) from None
+
+
+@router.post("/backup/restore/apply")
+async def apply_restore_backup(
     request: Request,
+    file: UploadFile = File(...),
+    password: str | None = Form(default=None),
+    source_secret_key: str | None = Form(default=None),
+    selected_uuids: str = Form(...),
     _admin: User = Depends(require_super_admin),
     db: Session = Depends(get_db),
 ):
-    """Download all bot state files as a zip archive (super_admin only)."""
-    bots = db.query(Bot).filter(Bot.is_deleted.is_(False)).all()
+    """Apply restore for selected bots from a backup zip (super_admin only).
 
-    buf = io.BytesIO()
-    with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as zf:
-        for bot in bots:
-            # Determine data dir from config_overrides or default
-            data_dir = _DEFAULT_DATA_DIR
-            try:
-                overrides = json.loads(bot.config_overrides or "{}")
-                data_dir = overrides.get("DATA_DIR") or _DEFAULT_DATA_DIR
-            except (json.JSONDecodeError, AttributeError):
-                pass
-            state_file = os.path.join(data_dir, "bots", str(bot.id), "bot_state.json")
-            folder_name = f"bot_{bot.id}_{bot.name}"
-            if os.path.exists(state_file):
-                zf.write(state_file, f"{folder_name}/bot_state.json")
-            else:
-                # Create an empty placeholder so the admin knows the bot has no state
-                zf.writestr(f"{folder_name}/bot_state.json", "{}")
-
-    buf.seek(0)
-    content = buf.read()
-
-    write_audit_log(db, _admin, "admin.bot_states", ip=request.client.host if request.client else None)
-    db.commit()
+    selected_uuids: JSON array of bot UUIDs to restore, e.g. '["uuid1","uuid2"]'
+    """
+    import json as _json
 
-    filename = f"lockbot_states_{datetime.now().strftime('%Y%m%d_%H%M%S')}.zip"
-    return Response(
-        content=content,
-        media_type="application/zip",
-        headers={"Content-Disposition": f'attachment; filename="{filename}"'},
+    from lockbot.backend.app.backup.service import restore_apply
+
+    content = await file.read()
+    if not content:
+        raise HTTPException(status_code=400, detail="Backup file is empty")
+
+    try:
+        uuids = _json.loads(selected_uuids)
+    except (ValueError, TypeError):
+        raise HTTPException(status_code=422, detail="selected_uuids must be a JSON array") from None
+
+    if not isinstance(uuids, list) or not uuids:
+        raise HTTPException(status_code=422, detail="selected_uuids must be a non-empty array")
+
+    try:
+        result = restore_apply(content, password or None, source_secret_key or None, uuids, _admin.id, db)
+    except ValueError as e:
+        err = str(e)
+        if err == "BACKUP_PASSWORD_REQUIRED":
+            raise HTTPException(status_code=422, detail="BACKUP_PASSWORD_REQUIRED") from None
+        if err == "BACKUP_PASSWORD_WRONG":
+            raise HTTPException(status_code=422, detail="BACKUP_PASSWORD_WRONG") from None
+        raise HTTPException(status_code=400, detail=err) from None
+
+    write_audit_log(
+        db,
+        _admin,
+        "admin.restore",
+        detail={"created": result["created"], "overwritten": result["overwritten"]},
+        ip=request.client.host if request.client else None,
     )
+    db.commit()
+    return result
+
+
+_DEFAULT_DATA_DIR = os.environ.get("DATA_DIR", "/data")