sync from GitHub 7b6cdc8: fix(v5后端): 修复管理面板加载不出数据-HF Space重建后从Hub恢复manifest

app/api/admin_data.py

@@ -388,6 +388,17 @@ async def list_backups_v5(
     返回字段：set_id, user_id, alias, total_size, blob_count,
     created_at, is_latest, prev_set_id。
     """
+    # 本地 DB 为空时尝试从 Hub 同步（HF Space 重建后 DB 丢失）
+    with get_conn() as conn:
+        cnt = conn.execute("SELECT COUNT(*) AS c FROM backup_sets").fetchone()["c"]
+    if cnt == 0:
+        try:
+            import asyncio
+            from ..services import backup_v5_store
+            asyncio.create_task(backup_v5_store._sync_manifests_background())
+        except Exception:
+            pass
+
     where = ""
     args: list = []
     if q:

app/api/user_backups_v5.py

@@ -59,6 +59,9 @@ async def list_sets(request: Request):
         offset = int(request.query_params.get("offset") or "0")
     except Exception:
         limit, offset = 20, 0
+    # 本地 DB 为空时触发 Hub 同步（HF Space 重建后 DB 丢失，Hub 上 manifest 仍在）
+    if backup_v5_store.count_sets(user_id) == 0:
+        asyncio.create_task(backup_v5_store._sync_manifests_background())
     items = backup_v5_store.list_sets(user_id, limit=limit, offset=offset)
     return ok_with_cors({"items": items, "count": len(items), "total": len(items)})
 

app/main.py

@@ -147,6 +147,9 @@ async def lifespan(app: FastAPI):
     # 启动 v5 备份 GC 任务（清理 refs=0 的 blob，每小时一次）
     from .services import backup_v5_store
     backup_v5_store.start_gc_task()
+    # v5 备份：从 Hub 同步 manifest 元数据回本地 DB（HF Space 重建后本地 DB 丢失，
+    # 但 Hub 上 backup_sets_v5/<user_id>/<set_id>.json 仍存在，需恢复否则管理面板和列表为空）
+    asyncio.create_task(backup_v5_store._sync_manifests_background())
     # 启动用户文件 Hub 定时同步任务
     s = get_settings()
     if is_hub_enabled():

app/services/backup_v5_store.py

@@ -24,6 +24,7 @@ from ..hf_storage import (
     delete_from_hub,
     download_bytes,
     is_hub_enabled,
+    list_hub_keys,
     push_to_hub,
     upload_bytes,
 )
@@ -323,6 +324,16 @@ def batch_check_blobs(prev_set_id: Optional[str], paths: list[dict]) -> dict:
 
 # ===== 备份集管理 =====
 
+def count_sets(user_id: str) -> int:
+    """统计指定用户的备份集数量（用于判断是否需要触发 Hub 同步）。"""
+    with get_conn() as conn:
+        row = conn.execute(
+            "SELECT COUNT(*) AS c FROM backup_sets WHERE user_id = ?",
+            (user_id,),
+        ).fetchone()
+    return int(row["c"]) if row else 0
+
+
 def list_sets(user_id: str, limit: int = 20, offset: int = 0) -> list[dict]:
     with get_conn() as conn:
         rows = conn.execute(
@@ -788,3 +799,159 @@ async def _gc_loop() -> None:
                 await asyncio.sleep(GC_INTERVAL_SEC)
             except asyncio.CancelledError:
                 break
+
+
+def sync_manifests_from_hub() -> dict:
+    """从 Hub 同步 manifest 元数据回本地 backup_sets 表。
+
+    HF Space 重建后本地 DB（ephemeral）被清空，但 Hub 上 backup_sets_v5/<user_id>/<set_id>.json
+    仍然存在。此函数列出 Hub 上所有 manifest JSON，对本地 DB 缺失的 set 补录元数据，
+    并恢复 blob refs 计数。
+
+    幂等：已存在的 set 跳过，不重复插入。
+
+    返回 {"synced": N, "skipped": M, "failed": K}
+    """
+    if not is_hub_enabled():
+        logger.warning("[v5_sync] hub disabled, skip sync")
+        return {"synced": 0, "skipped": 0, "failed": 0}
+
+    # 列出 Hub 上所有 manifest key（格式：<user_id>/<set_id>.json）
+    try:
+        hub_keys = list_hub_keys(NS_MANIFESTS)
+    except Exception as e:
+        logger.warning("[v5_sync] list_hub_keys failed: %s", e)
+        return {"synced": 0, "skipped": 0, "failed": 0}
+
+    if not hub_keys:
+        logger.info("[v5_sync] no manifests on hub")
+        return {"synced": 0, "skipped": 0, "failed": 0}
+
+    synced = 0
+    skipped = 0
+    failed = 0
+
+    for sub_key in hub_keys:
+        # sub_key 格式：<user_id>/<set_id>.json
+        parts = sub_key.rsplit("/", 1)
+        if len(parts) != 2 or not parts[1].endswith(".json"):
+            continue
+        user_id = parts[0]
+        set_id = parts[1][:-5]  # 去掉 .json
+        if not user_id or not set_id:
+            continue
+
+        # 检查本地 DB 是否已有此 set
+        try:
+            with get_conn() as conn:
+                row = conn.execute(
+                    "SELECT set_id FROM backup_sets WHERE set_id = ?",
+                    (set_id,),
+                ).fetchone()
+            if row:
+                skipped += 1
+                continue
+        except Exception:
+            pass
+
+        # 从 Hub 下载 manifest JSON
+        try:
+            data = download_bytes(NS_MANIFESTS, sub_key)
+            if not data:
+                failed += 1
+                continue
+            manifest = json.loads(data.decode("utf-8"))
+            if not isinstance(manifest, dict):
+                failed += 1
+                continue
+            if int(manifest.get("version") or 0) != 5:
+                failed += 1
+                continue
+
+            # 写 manifest 到本地缓存（与 _write_manifest_to_local 一致）
+            _write_manifest_to_local(user_id, set_id, manifest)
+
+            # 解析 manifest 字段，写入 backup_sets 表
+            blobs = manifest.get("blobs")
+            if not isinstance(blobs, list):
+                blobs = []
+            keys = [str(b.get("key") or "") for b in blobs if isinstance(b, dict) and b.get("key")]
+            total_size = sum(int(b.get("size") or 0) for b in blobs if isinstance(b, dict))
+            blob_count = len(blobs)
+            checksum = manifest.get("checksum") or hashlib.sha256(
+                json.dumps({k: v for k, v in manifest.items() if k != "checksum"},
+                           sort_keys=True, ensure_ascii=False).encode("utf-8")
+            ).hexdigest()
+            created_at = int(manifest.get("exportedAt") or _now())
+            prev_set_id = str(manifest.get("prevSetId") or "")
+            alias = str(manifest.get("alias") or "")[:200]
+
+            with get_conn() as conn:
+                # INSERT OR IGNORE 避免并发同步重复插入
+                conn.execute(
+                    "INSERT OR IGNORE INTO backup_sets(set_id, user_id, manifest, manifest_sha256, "
+                    "total_size, blob_count, created_at, is_latest, prev_set_id, alias) "
+                    "VALUES(?, ?, ?, ?, ?, ?, ?, 0, ?, ?)",
+                    (
+                        set_id, user_id, json.dumps(manifest, ensure_ascii=False), checksum,
+                        total_size, blob_count, created_at, prev_set_id, alias,
+                    ),
+                )
+                # 恢复 blob refs（每个 set 引用的 blob refs +1）
+                for k in keys:
+                    # 先确保 blob 记录存在（可能本地 DB 也丢了 blob 元数据）
+                    existing = conn.execute(
+                        "SELECT key FROM backup_blobs WHERE key = ?", (k,)
+                    ).fetchone()
+                    if existing:
+                        conn.execute(
+                            "UPDATE backup_blobs SET refs = refs + 1 WHERE key = ?",
+                            (k,),
+                        )
+                    else:
+                        # blob 元数据丢失，从 manifest 补录（size 来自 manifest）
+                        blob_info = next((b for b in blobs if isinstance(b, dict) and b.get("key") == k), {})
+                        conn.execute(
+                            "INSERT OR IGNORE INTO backup_blobs(key, size, mime, refs, first_uploaded_at, first_uploaded_by) "
+                            "VALUES(?, ?, ?, 1, ?, ?)",
+                            (k, int(blob_info.get("size") or 0), str(blob_info.get("type") or ""),
+                             created_at, user_id),
+                        )
+
+            # 标记 is_latest：每个用户最新的 set（按 created_at 降序第一个）
+            synced += 1
+        except Exception as e:
+            logger.warning("[v5_sync] sync set=%s failed: %s", set_id[:8], e)
+            failed += 1
+
+    # 修正每个用户的 is_latest 标记：最新 set（按 created_at 降序）置 1，其余置 0
+    try:
+        with get_conn() as conn:
+            users = conn.execute("SELECT DISTINCT user_id FROM backup_sets").fetchall()
+            for u in users:
+                uid = str(u["user_id"])
+                latest = conn.execute(
+                    "SELECT set_id FROM backup_sets WHERE user_id = ? ORDER BY created_at DESC LIMIT 1",
+                    (uid,),
+                ).fetchone()
+                if latest:
+                    conn.execute(
+                        "UPDATE backup_sets SET is_latest = CASE WHEN set_id = ? THEN 1 ELSE 0 END WHERE user_id = ?",
+                        (str(latest["set_id"]), uid),
+                    )
+    except Exception as e:
+        logger.warning("[v5_sync] fix is_latest failed: %s", e)
+
+    logger.info("[v5_sync] done: synced=%d skipped=%d failed=%d", synced, skipped, failed)
+    return {"synced": synced, "skipped": skipped, "failed": failed}
+
+
+async def _sync_manifests_background() -> None:
+    """后台同步 manifests（在 startup 中异步调用，不阻塞启动）。"""
+    try:
+        # 放到线程池执行（list_hub_keys 和 download_bytes 是同步 IO）
+        result = await asyncio.to_thread(sync_manifests_from_hub)
+        if result["synced"] > 0:
+            logger.info("[v5_sync] background sync recovered %d sets", result["synced"])
+    except Exception as e:
+        logger.warning("[v5_sync] background sync failed: %s", e)