Archived
snowy-yang
70ca21974b
为什么：auth_system 的 11 个子模块此前构成一个强连通分量——db.py 与 backup.py
为了「动态读取路径常量」而在模块级 `import auth_system`（包自身），而包 __init__
又再导出这两个子模块的全部符号，互相指成环。
这个环当前并不崩（实测 8/8 种导入姿势全通过），它的代价是**双绑定**：
`auth_system.DB_PATH is auth_system.db.DB_PATH` 初始为 True，但只 patch 其一
另一处不跟随。于是测试不得不把 4 个路径常量**两处都 patch**
（setattr(auth,...) + setattr(db,...)）——而漏 patch 的后果是静默写生产库，
commit fc7fc21 修的那次「黄金测试写进生产库」正是这么来的。
改法：让路径常量回归**模块属性单一来源**。
- db.py：删掉 `import auth_system`，内部改用本模块常量（DATA_DIR / DB_PATH /
SECRET_KEY_PATH）。这些常量本就定义在本模块，绕道包属性纯属多余。
- backup.py：改用 `import auth_system.db as db` 做模块限定访问，路径走
db.BACKUP_DIR / db.DB_PATH——保留动态读取能力，来源从「包属性」换成
「db 模块」，与唯一来源一致。
注意**不能**写成 `from . import db`：该形式在静态图里同时指向包本身与子模块，
会把这个环重新连上（实测确实如此，SCC 从 11 降到 2 就卡住了）。
- admin_site.py：5 处 `auth.DB_PATH` / `auth.BACKUP_DIR`（auth 是包别名）同样
改为经 db 模块访问。**这处不修就会出事**——它读的是包属性快照，而测试已改为
patch db 模块，于是备份上传会静默落到生产 data/backups/（本次实测真的发生了，
2 个 upload_*.db 已清理，副本留在临时目录）。
- 测试：7 个文件的 patch 目标从包属性迁到 auth_system.db.*。
- __init__.py：补注释说明这些常量在此只是 import 快照，禁止经包属性重定向。
验证：
- Tarjan 重算：非平凡强连通分量 11 → **0**（import 图已是 DAG）
- AST 全仓扫描：经包属性访问路径常量的点 **0 处残留**
- 行为：子进程内 patch auth_system.db.* 后，get_conn 连的库 / create_backup
落盘目录 / get_secret_key 目标路径**三者全部跟随**
- 导入姿势回归 8/8 通过
- 门禁：ruff 0 · pyright 0 errors 0 warnings · pytest 175 passed
238 lines
8.8 KiB
Python
238 lines
8.8 KiB
Python
# -*- coding: utf-8 -*-
|
|
"""数据库备份、恢复与自动备份线程。
|
|
|
|
（自 auth_system.py 拆出，行为与原实现一致。）
|
|
"""
|
|
|
|
import math
|
|
import os
|
|
import shutil
|
|
import sqlite3
|
|
import sys
|
|
import threading
|
|
import time
|
|
from pathlib import Path
|
|
from typing import Any
|
|
|
|
import auth_system.db as db # 绝对导入子模块：不经过包属性，避免与包 __init__ 互指成环
|
|
|
|
from .settings import (
|
|
get_setting,
|
|
set_setting,
|
|
)
|
|
|
|
# ============ 数据库备份 ============
|
|
|
|
|
|
# 备份命名专用锁：create_backup 不再持有全局 _DB_LOCK（不阻塞写请求），
|
|
# 但同秒并发的两次备份仍需保证文件名唯一
|
|
_BACKUP_NAME_LOCK = threading.Lock()
|
|
|
|
|
|
def create_backup() -> str:
|
|
"""创建备份（唯一文件名——同秒冲突自动追加序号，不再互相覆盖）。
|
|
|
|
WAL 模式下用独立只读连接走 SQLite 在线备份 API：拿到的是一致性快照，
|
|
且不持有 _DB_LOCK——原实现备份期间阻塞全站写请求，大库时会卡住所有用户。"""
|
|
db.BACKUP_DIR.mkdir(parents=True, exist_ok=True)
|
|
with _BACKUP_NAME_LOCK:
|
|
base = 'backup_' + time.strftime('%Y%m%d_%H%M%S')
|
|
name = base + '.db'
|
|
k = 1
|
|
while (db.BACKUP_DIR / name).exists():
|
|
name = f'{base}-{k}.db'
|
|
k += 1
|
|
# 占位创建目标文件（锁内），保证并发下同秒命名仍唯一
|
|
dest = sqlite3.connect(str(db.BACKUP_DIR / name))
|
|
conn = db.get_conn()
|
|
try:
|
|
try:
|
|
conn.backup(dest)
|
|
finally:
|
|
dest.close()
|
|
# 任何备份产生后统一裁剪（手动/自动/上传同配额）
|
|
try:
|
|
prune_backups(20, 5)
|
|
except Exception:
|
|
pass
|
|
return name
|
|
except Exception:
|
|
# 备份失败：清掉占位文件，不留半个坏备份
|
|
try:
|
|
(db.BACKUP_DIR / name).unlink(missing_ok=True)
|
|
except OSError:
|
|
pass
|
|
raise
|
|
finally:
|
|
conn.close()
|
|
|
|
|
|
def list_backups() -> list[dict[str, Any]]:
|
|
"""备份列表（按文件修改时间倒序——按名字排序会让 upload_ 永远排前，误删新自动备份）"""
|
|
if not db.BACKUP_DIR.exists():
|
|
return []
|
|
out = []
|
|
for p in db.BACKUP_DIR.glob('*.db'):
|
|
st = p.stat()
|
|
out.append({'name': p.name, 'size': st.st_size,
|
|
'time': time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(st.st_mtime)),
|
|
'_mtime': st.st_mtime})
|
|
out.sort(key=lambda x: x['_mtime'], reverse=True)
|
|
for o in out:
|
|
o.pop('_mtime', None)
|
|
return out
|
|
|
|
|
|
def backup_path(name: str) -> Path | None:
|
|
name = Path(name).name # 防目录穿越
|
|
p = db.BACKUP_DIR / name
|
|
return p if p.exists() and p.suffix == '.db' else None
|
|
|
|
|
|
def _backup_is_valid_db(src: Path) -> bool:
|
|
"""深度校验备份文件：SQLite 头 + 能真正打开 + 含 users 表，三者缺一不可"""
|
|
try:
|
|
with open(src, 'rb') as f:
|
|
if f.read(16) != b'SQLite format 3\x00'[:16]:
|
|
return False
|
|
probe = sqlite3.connect(f'file:{src}?mode=ro', uri=True)
|
|
try:
|
|
tables = {r[0] for r in probe.execute("SELECT name FROM sqlite_master WHERE type='table'")}
|
|
return 'users' in tables
|
|
finally:
|
|
probe.close()
|
|
except Exception:
|
|
return False
|
|
|
|
|
|
# 恢复前静止钩子——由应用层注册（取消全部在途下载任务），避免 worker 按旧库账目结算
|
|
_before_restore_hook = None
|
|
|
|
|
|
def register_before_restore_hook(fn) -> None:
|
|
global _before_restore_hook
|
|
_before_restore_hook = fn
|
|
|
|
|
|
def restore_backup(name: str) -> None:
|
|
"""恢复备份（先验证、留回滚、后替换、失败自动回滚，源备份文件保留不移动）
|
|
恢复前先通过钩子取消全部在途任务（worker 不再引用旧库用户结算）"""
|
|
src = backup_path(name)
|
|
if not src:
|
|
raise ValueError('备份文件不存在')
|
|
if not _backup_is_valid_db(src):
|
|
raise ValueError('不是有效的站点数据库备份（校验失败，未做任何修改）')
|
|
if _before_restore_hook is not None:
|
|
try:
|
|
_before_restore_hook()
|
|
except Exception:
|
|
pass
|
|
safety = db.BACKUP_DIR / ('pre_restore_' + time.strftime('%Y%m%d_%H%M%S') + '.db')
|
|
with db._DB_LOCK:
|
|
# 0) 先尽力清 WAL 并合并进主库（被占用导致 checkpoint 忙时明确失败，不假装成功）；
|
|
# 必须在留安全副本之前做——否则副本缺 WAL 里未合并的最近提交，回滚点不完整
|
|
conn = db.get_conn()
|
|
try:
|
|
row = conn.execute('PRAGMA wal_checkpoint(TRUNCATE)').fetchone()
|
|
busy = bool(row and row[0] == 1) # 1 = busy
|
|
finally:
|
|
conn.close()
|
|
if busy:
|
|
raise RuntimeError('数据库当前有其他读写在途（checkpoint 忙），请稍后重试恢复')
|
|
# 1) checkpoint 后留安全副本（包含全部已提交数据，可回滚）
|
|
shutil.copy2(str(db.DB_PATH), str(safety))
|
|
# 2) 源备份复制到临时文件（不动源备份本身）
|
|
tmp = db.DB_PATH.with_suffix('.db.restore_tmp')
|
|
shutil.copy2(str(src), str(tmp))
|
|
# 3) 原子替换 + 立即校验
|
|
os.replace(str(tmp), str(db.DB_PATH))
|
|
try:
|
|
db.init_db()
|
|
except Exception:
|
|
# 替换后初始化失败：回滚安全副本，恢复原库
|
|
shutil.copy2(str(safety), str(db.DB_PATH))
|
|
db.init_db()
|
|
raise RuntimeError('恢复后数据库初始化失败，已自动回滚到恢复前状态') from None
|
|
# 裁剪移出 _DB_LOCK——glob/unlink 的 I/O 不阻塞全站写
|
|
try:
|
|
prune_backups(20, 5)
|
|
except Exception:
|
|
pass
|
|
|
|
|
|
def delete_backup(name: str) -> bool:
|
|
p = backup_path(name)
|
|
# 允许删除 pre_restore_ 安全副本（配额裁剪已保证至少保留
|
|
# 最近 5 份；原实现一刀切拒删导致恢复频繁时无界累积且管理员手动也删不掉）
|
|
if p:
|
|
p.unlink()
|
|
return True
|
|
return False
|
|
|
|
|
|
# 自动备份线程
|
|
_backup_thread_started = False
|
|
|
|
_BACKUP_ERR_TS = {'ts': 0.0, 'n': 0} # 备份失败限频记录（失败不能零痕迹）
|
|
|
|
|
|
def prune_backups(keep_normal: int = 20, keep_pre_restore: int = 5) -> None:
|
|
"""备份配额裁剪（从自动备份循环抽出为独立函数）——
|
|
非pre_restore 保留最近 N 份、pre_restore_ 安全副本保留最近 M 份。
|
|
在 create_backup/上传备份/恢复备份后统一调用（原实现只在自动备份循环里
|
|
裁剪，手动备份/上传/恢复会让 data/backups 无界累积）。"""
|
|
baks = [b for b in list_backups() if not b['name'].startswith('pre_restore_')]
|
|
for b in baks[keep_normal:]:
|
|
try:
|
|
delete_backup(b['name'])
|
|
except Exception:
|
|
pass
|
|
pre = [b for b in list_backups() if b['name'].startswith('pre_restore_')]
|
|
for b in pre[keep_pre_restore:]:
|
|
try:
|
|
(db.BACKUP_DIR / b['name']).unlink()
|
|
except OSError:
|
|
pass
|
|
|
|
|
|
def _auto_backup_loop() -> None:
|
|
while True:
|
|
try:
|
|
interval = float(get_setting('backup_interval_hours', '0') or 0)
|
|
# 非有限值（NaN/inf）或负数一律视为关闭
|
|
if not math.isfinite(interval):
|
|
interval = 0
|
|
set_setting('backup_interval_hours', '0')
|
|
if interval > 0:
|
|
last = float(get_setting('last_backup_ts', '0') or 0)
|
|
if not math.isfinite(last):
|
|
last = 0
|
|
if time.time() - last >= interval * 3600:
|
|
create_backup()
|
|
set_setting('last_backup_ts', str(time.time()))
|
|
# 仅保留最近 20 份（按修改时间，不按文件名）
|
|
# pre_restore_* 安全副本不计入 20 份配额，仅各自保留最近 5 份
|
|
prune_backups(20, 5)
|
|
except Exception:
|
|
# 定时备份失败绝不能静默（磁盘满/权限问题时 owner 以为有备份、
|
|
# 出事时没有）——限频告警，每 10 分钟最多一条（对齐监控线程口径）
|
|
import traceback as _tb
|
|
_now = time.time()
|
|
_BACKUP_ERR_TS['n'] += 1
|
|
if _now - _BACKUP_ERR_TS['ts'] > 600:
|
|
print(f'[警告] 自动备份失败（近 10 分钟累计 {_BACKUP_ERR_TS["n"]} 次）: '
|
|
f'{_tb.format_exc()[-400:]}', file=sys.stderr)
|
|
_BACKUP_ERR_TS['ts'] = _now
|
|
_BACKUP_ERR_TS['n'] = 0
|
|
time.sleep(600)
|
|
|
|
|
|
def start_auto_backup() -> None:
|
|
global _backup_thread_started
|
|
if _backup_thread_started:
|
|
return
|
|
t = threading.Thread(target=_auto_backup_loop, daemon=True)
|
|
t.start()
|
|
# 仅在真实启动成功后置位，失败可重试
|
|
_backup_thread_started = True
|