astrbot_plugin_private_comp.../ops_migration.py

252 行
9.7 KiB
Python

此文件含有模棱两可的 Unicode 字符

此文件含有可能会与其他字符混淆的 Unicode 字符。 如果您是想特意这样的,可以安全地忽略该警告。 使用 Escape 按钮显示他们。

from __future__ import annotations
import hashlib
import json
import os
import shutil
import sqlite3
import tempfile
from dataclasses import asdict, dataclass, field
from datetime import datetime, timezone
from pathlib import Path
from typing import Any
SOURCE_PLUGIN_NAMES = (
"astrbot_plugin_private_companion",
"astrbot_plugin_private_companion-main",
)
TARGET_PLUGIN_NAME = "astrbot_plugin_private_companion_ops"
MIGRATION_VERSION = 1
MARKER_NAME = "ops_migration_v1.json"
SUPPORTED_JSON = "companions.json"
SUPPORTED_SQLITE = "companions.db"
@dataclass(frozen=True)
class MigrationFile:
source: str
target: str
kind: str
bytes: int
sha256: str
@dataclass
class MigrationReport:
ok: bool
mode: str
source_dir: str
target_dir: str
source_plugin: str = SOURCE_PLUGIN_NAMES[0]
target_plugin: str = TARGET_PLUGIN_NAME
source_format: str = ""
source_files: list[MigrationFile] = field(default_factory=list)
retained_fields: list[str] = field(default_factory=list)
flagged_fields: list[str] = field(default_factory=list)
skipped_fields: list[str] = field(default_factory=list)
errors: list[str] = field(default_factory=list)
warnings: list[str] = field(default_factory=list)
marker: str = ""
def to_dict(self) -> dict[str, Any]:
result = asdict(self)
result["source_files"] = [asdict(item) for item in self.source_files]
return result
def _sha256(path: Path) -> str:
digest = hashlib.sha256()
with path.open("rb") as handle:
for chunk in iter(lambda: handle.read(1024 * 1024), b""):
digest.update(chunk)
return digest.hexdigest()
def _file(path: Path, target_name: str, kind: str) -> MigrationFile:
return MigrationFile(str(path), target_name, kind, path.stat().st_size, _sha256(path))
def _read_json_store(path: Path) -> dict[str, Any]:
with path.open("r", encoding="utf-8") as handle:
payload = json.load(handle)
if not isinstance(payload, dict):
raise ValueError("companions.json 顶层必须是对象")
return payload
def _validate_sqlite(path: Path) -> tuple[list[str], dict[str, int]]:
connection = sqlite3.connect(f"file:{path.resolve()}?mode=ro", uri=True, timeout=3)
try:
result = connection.execute("PRAGMA integrity_check").fetchone()
if not result or str(result[0]).lower() != "ok":
raise ValueError(f"SQLite integrity_check 失败: {result[0] if result else 'unknown'}")
tables = [row[0] for row in connection.execute("SELECT name FROM sqlite_master WHERE type='table'")]
if "store_sections" not in tables:
raise ValueError("companions.db 缺少 store_sections 表")
counts = {name: int(connection.execute(f"SELECT COUNT(*) FROM {name}").fetchone()[0]) for name in tables}
return tables, counts
finally:
connection.close()
def _candidate_files(source: Path) -> tuple[Path | None, Path | None]:
json_path = source / SUPPORTED_JSON
sqlite_path = source / SUPPORTED_SQLITE
return (json_path if json_path.is_file() else None, sqlite_path if sqlite_path.is_file() else None)
def _empty_target(target: Path) -> tuple[bool, str]:
if not target.exists():
return True, ""
if not target.is_dir():
return False, "目标路径不是目录"
entries = list(target.iterdir())
if not entries:
return True, ""
if (target / MARKER_NAME).is_file():
return False, "目标目录已有迁移标记,拒绝重复迁移"
return False, "目标目录非空,拒绝覆盖"
def preview(source_dir: str | Path, target_dir: str | Path) -> dict[str, Any]:
source = Path(source_dir).expanduser().resolve()
target = Path(target_dir).expanduser().resolve()
report = MigrationReport(ok=False, mode="preview", source_dir=str(source), target_dir=str(target))
report.marker = str(target / MARKER_NAME)
if not source.is_dir():
report.errors.append("源数据目录不存在")
return report.to_dict()
empty, reason = _empty_target(target)
if not empty:
report.errors.append(reason)
return report.to_dict()
json_path, sqlite_path = _candidate_files(source)
if not json_path and not sqlite_path:
report.errors.append("未找到 companions.json 或 companions.db")
return report.to_dict()
if sqlite_path:
try:
tables, counts = _validate_sqlite(sqlite_path)
report.source_format = "sqlite"
report.source_files.append(_file(sqlite_path, SUPPORTED_SQLITE, "sqlite"))
report.retained_fields.extend(f"sqlite.table:{name}" for name in tables)
report.warnings.append(f"SQLite 表记录数:{counts}")
except Exception as exc:
report.errors.append(f"SQLite 校验失败:{exc}")
return report.to_dict()
if json_path:
try:
payload = _read_json_store(json_path)
report.source_files.append(_file(json_path, SUPPORTED_JSON, "json-mirror"))
report.retained_fields.extend(f"json:{key}" for key in sorted(payload))
except Exception as exc:
report.warnings.append(f"JSON 镜像无法读取,将只迁移 SQLite:{exc}")
else:
try:
payload = _read_json_store(json_path)
report.source_format = "json"
report.source_files.append(_file(json_path, SUPPORTED_JSON, "json"))
report.retained_fields.extend(f"json:{key}" for key in sorted(payload))
except Exception as exc:
report.errors.append(f"JSON 校验失败:{exc}")
return report.to_dict()
flagged = {"news_integration", "web_exploration", "qzone_integration", "bilibili_integration"}
report.flagged_fields = sorted(
field_name.split(":", 1)[1]
for field_name in report.retained_fields
if field_name.startswith("json:") and field_name.split(":", 1)[1] in flagged
)
report.ok = not report.errors
return report.to_dict()
def _backup_sqlite(source: Path, target: Path) -> None:
source_conn = sqlite3.connect(f"file:{source.resolve()}?mode=ro", uri=True, timeout=3)
try:
target_conn = sqlite3.connect(str(target), timeout=3)
try:
source_conn.backup(target_conn)
target_conn.commit()
finally:
target_conn.close()
finally:
source_conn.close()
def _report_from_dict(payload: dict[str, Any]) -> MigrationReport:
fields = {key: value for key, value in payload.items() if key in MigrationReport.__dataclass_fields__}
fields["source_files"] = [MigrationFile(**item) for item in fields.get("source_files", [])]
return MigrationReport(**fields)
def execute(source_dir: str | Path, target_dir: str | Path) -> dict[str, Any]:
report = _report_from_dict(preview(source_dir, target_dir))
report.mode = "execute"
if not report.ok:
return report.to_dict()
source = Path(report.source_dir)
target = Path(report.target_dir)
target.mkdir(parents=True, exist_ok=True)
staging = Path(tempfile.mkdtemp(prefix=".ops-migration-", dir=str(target.parent)))
moved: list[Path] = []
try:
json_path, sqlite_path = _candidate_files(source)
if sqlite_path:
_backup_sqlite(sqlite_path, staging / SUPPORTED_SQLITE)
if json_path and any(item.target == SUPPORTED_JSON and item.kind in {"json", "json-mirror"} for item in report.source_files):
shutil.copy2(json_path, staging / SUPPORTED_JSON)
marker_payload = {
"migration_version": MIGRATION_VERSION,
"source_plugin": SOURCE_PLUGIN_NAMES[0],
"target_plugin": TARGET_PLUGIN_NAME,
"source_dir": str(source),
"target_dir": str(target),
"source_format": report.source_format,
"created_at": datetime.now(timezone.utc).isoformat(),
"files": [asdict(item) for item in report.source_files],
}
(staging / MARKER_NAME).write_text(
json.dumps(marker_payload, ensure_ascii=False, indent=2), encoding="utf-8"
)
for item in staging.iterdir():
destination = target / item.name
if destination.exists():
raise FileExistsError(f"目标文件已存在:{destination}")
os.replace(item, destination)
moved.append(destination)
report.marker = str(target / MARKER_NAME)
report.warnings.append("迁移完成;源目录保持不变,删除旧目录前请先做 VM 验收")
return report.to_dict()
except Exception as exc:
for destination in reversed(moved):
try:
destination.unlink()
except OSError:
pass
report.ok = False
report.errors.append(f"迁移失败,源目录未修改:{exc}")
return report.to_dict()
finally:
shutil.rmtree(staging, ignore_errors=True)
def format_report(report: dict[str, Any]) -> str:
lines = [
f"迁移状态:{'可执行' if report.get('ok') else '拒绝/失败'}",
f"模式:{report.get('mode')}",
f"来源:{report.get('source_dir')}",
f"目标:{report.get('target_dir')}",
f"格式:{report.get('source_format') or '-'}",
]
if report.get("retained_fields"):
lines.append(f"保留字段/表:{len(report['retained_fields'])} 项")
if report.get("flagged_fields"):
lines.append("待后续清理字段:" + ", ".join(report["flagged_fields"]))
for error in report.get("errors", []):
lines.append("错误:" + str(error))
for warning in report.get("warnings", []):
lines.append("提示:" + str(warning))
return "\n".join(lines)