Files
astrbot_plugin_tixing/services/storage.py
T

320 lines
13 KiB
Python

"""Transactional SQLite persistence outside the installed plugin directory."""
import asyncio
import json
import sqlite3
import time
from contextlib import closing
from pathlib import Path
def scope_key(platform_id, group_id, user_id):
# Group UMO may include the sender when unique-session is enabled.
return json.dumps([platform_id, "group" if group_id else "private", group_id or user_id])
class ReminderStore:
def __init__(self, path):
self.path = Path(path)
self._lock = asyncio.Lock()
async def _run(self, operation):
def run():
with closing(sqlite3.connect(self.path, timeout=10)) as db, db:
db.row_factory = sqlite3.Row
return operation(db)
async with self._lock:
# Wait for the worker before releasing the lock even during unload.
worker = asyncio.create_task(asyncio.to_thread(run))
try:
return await asyncio.shield(worker)
except asyncio.CancelledError:
await worker
raise
async def initialize(self):
self.path.parent.mkdir(parents=True, exist_ok=True)
def create(db):
db.executescript("""
PRAGMA journal_mode=WAL;
CREATE TABLE IF NOT EXISTS reminders (
id INTEGER PRIMARY KEY AUTOINCREMENT,
scope TEXT NOT NULL, platform_id TEXT NOT NULL,
platform_name TEXT NOT NULL, destination TEXT NOT NULL,
scene TEXT NOT NULL, umo TEXT NOT NULL,
creator_id TEXT NOT NULL, creator_name TEXT NOT NULL DEFAULT '',
target_id TEXT NOT NULL, target_name TEXT NOT NULL DEFAULT '',
content TEXT NOT NULL, remind_at REAL NOT NULL,
timezone TEXT NOT NULL, repeat_type TEXT NOT NULL
CHECK(repeat_type IN ('none','daily','weekly')),
status TEXT NOT NULL DEFAULT 'active'
CHECK(status IN ('active','done','cancelled')),
failure_count INTEGER NOT NULL DEFAULT 0,
last_error TEXT NOT NULL DEFAULT '',
retry_at REAL NOT NULL DEFAULT 0,
lease_owner TEXT NOT NULL DEFAULT '', lease_until REAL NOT NULL DEFAULT 0,
created_at REAL NOT NULL
);
CREATE INDEX IF NOT EXISTS reminders_due ON reminders(status, remind_at);
CREATE INDEX IF NOT EXISTS reminders_scope ON reminders(scope, creator_id);
CREATE TABLE IF NOT EXISTS members (
scope TEXT NOT NULL, user_id TEXT NOT NULL,
nickname TEXT NOT NULL DEFAULT '', seen_at REAL NOT NULL,
PRIMARY KEY(scope, user_id)
);
CREATE TABLE IF NOT EXISTS reply_contexts (
platform_id TEXT NOT NULL, scene TEXT NOT NULL, destination TEXT NOT NULL,
msg_id TEXT NOT NULL, received_at REAL NOT NULL,
used INTEGER NOT NULL DEFAULT 0, blocked INTEGER NOT NULL DEFAULT 0,
PRIMARY KEY(platform_id, scene, destination)
);
""")
columns = {row[1] for row in db.execute("PRAGMA table_info(reminders)")}
if "waiting_reason" not in columns:
db.execute(
"ALTER TABLE reminders ADD COLUMN waiting_reason TEXT NOT NULL DEFAULT ''"
)
await self._run(create)
async def observe(self, scope, user_id, nickname=""):
await self._run(
lambda db: (
db.execute(
"INSERT INTO members VALUES (?,?,?,?) ON CONFLICT(scope,user_id) DO UPDATE SET "
"nickname=CASE WHEN excluded.nickname!='' THEN excluded.nickname ELSE members.nickname END, "
"seen_at=excluded.seen_at",
(scope, user_id, nickname or "", time.time()),
).rowcount
)
)
async def member(self, scope, value):
def read(db):
rows = db.execute(
"SELECT * FROM members WHERE scope=? AND (user_id=? OR nickname=?)",
(scope, value, value),
).fetchall()
exact = [r for r in rows if r["user_id"] == value]
if exact:
return dict(exact[0])
if len(rows) > 1:
raise ValueError("本群有重名用户,请使用真实 @ 或 /tx identity 获取的用户标识。")
return dict(rows[0]) if rows else None
return await self._run(read)
async def add(self, record, limit):
def insert(db):
db.execute("BEGIN IMMEDIATE")
count = db.execute(
"SELECT COUNT(*) FROM reminders WHERE scope=? AND creator_id=? AND status='active'",
(record["scope"], record["creator_id"]),
).fetchone()[0]
if count >= limit:
raise ValueError(f"你在当前会话最多只能设置 {limit} 个提醒,请先取消一些。")
columns = (
"scope",
"platform_id",
"platform_name",
"destination",
"scene",
"umo",
"creator_id",
"creator_name",
"target_id",
"target_name",
"content",
"remind_at",
"timezone",
"repeat_type",
)
cursor = db.execute(
f"INSERT INTO reminders ({','.join(columns)},created_at) "
f"VALUES ({','.join('?' for _ in range(len(columns) + 1))})",
tuple(record[c] for c in columns) + (time.time(),),
)
return cursor.lastrowid
return await self._run(insert)
async def list(self, scope, creator_id=None, history=False):
def read(db):
sql, params = "SELECT * FROM reminders WHERE scope=?", [scope]
if creator_id is not None:
sql += " AND creator_id=?"
params.append(creator_id)
if not history:
sql += " AND status='active'"
sql += " ORDER BY remind_at,id"
return [dict(r) for r in db.execute(sql, params).fetchall()]
return await self._run(read)
async def get(self, reminder_id, scope):
def read(db):
row = db.execute(
"SELECT * FROM reminders WHERE id=? AND scope=?", (reminder_id, scope)
).fetchone()
return dict(row) if row else None
return await self._run(read)
async def cancel(self, scope, creator_id, reminder_id=None):
def write(db):
sql = "UPDATE reminders SET status='cancelled', waiting_reason='', lease_owner='', lease_until=0 WHERE scope=? AND status='active'"
params = [scope]
if creator_id is not None:
sql += " AND creator_id=?"
params.append(creator_id)
if reminder_id is not None:
sql += " AND id=?"
params.append(reminder_id)
return db.execute(sql, params).rowcount
return await self._run(write)
async def due(self, now):
return await self._run(
lambda db: [
dict(r)
for r in db.execute(
"SELECT * FROM reminders WHERE status='active' AND remind_at<=? "
"AND retry_at<=? AND lease_until<=? ORDER BY remind_at,id",
(now, now, now),
)
]
)
async def claim(self, reminder_id, owner, now):
# One lease per send prevents overlapping hot reloads from sending twice.
return await self._run(
lambda db: (
db.execute(
"UPDATE reminders SET lease_owner=?,lease_until=? WHERE id=? AND status='active' "
"AND lease_until<=? AND remind_at<=? AND retry_at<=?",
(owner, now + 120, reminder_id, now, now, now),
).rowcount
== 1
)
)
async def success(self, reminder_id, owner, next_time=None):
return await self._run(
lambda db: (
db.execute(
"UPDATE reminders SET status=?,remind_at=COALESCE(?,remind_at),failure_count=0,"
"last_error='',waiting_reason='',retry_at=0,lease_owner='',lease_until=0 WHERE id=? AND lease_owner=? AND status='active'",
("active" if next_time is not None else "done", next_time, reminder_id, owner),
).rowcount
)
)
async def failure(self, reminder_id, owner, error, maximum, retry_at):
def write(db):
db.execute(
"UPDATE reminders SET failure_count=failure_count+1,last_error=?,retry_at=?,waiting_reason='',"
"status=CASE WHEN failure_count+1>=? THEN 'cancelled' ELSE 'active' END,"
"lease_owner='',lease_until=0 WHERE id=? AND lease_owner=? AND status='active'",
(str(error)[:500], retry_at, maximum, reminder_id, owner),
)
await self._run(write)
async def release(self, reminder_id, owner):
await self._run(
lambda db: (
db.execute(
"UPDATE reminders SET lease_owner='',lease_until=0 WHERE id=? AND lease_owner=?",
(reminder_id, owner),
).rowcount
)
)
async def remember_reply(self, platform_id, scene, destination, msg_id, received_at):
# Duplicate/replayed events must not renew expiry or refill reply quota.
await self._run(
lambda db: (
db.execute(
"INSERT INTO reply_contexts(platform_id,scene,destination,msg_id,received_at) VALUES (?,?,?,?,?) "
"ON CONFLICT(platform_id,scene,destination) DO UPDATE SET "
"msg_id=excluded.msg_id,received_at=excluded.received_at,used=0,blocked=0 "
"WHERE reply_contexts.msg_id!=excluded.msg_id AND excluded.received_at>=reply_contexts.received_at",
(platform_id, scene, destination, msg_id, received_at),
).rowcount
)
)
async def reserve_reply(self, platform_id, scene, destination, now, window):
def reserve(db):
db.execute("BEGIN IMMEDIATE")
row = db.execute(
"SELECT * FROM reply_contexts WHERE platform_id=? AND scene=? AND destination=?",
(platform_id, scene, destination),
).fetchone()
# Reserve two of QQ's five replies for command responses/other plugins.
if (
not row
or row["blocked"]
or row["used"] >= 3
or not 0 <= now - row["received_at"] < window
):
return None
db.execute(
"UPDATE reply_contexts SET used=used+1 WHERE platform_id=? AND scene=? AND destination=?",
(platform_id, scene, destination),
)
# AstrBot's official event sender uses random sequences in 1..10000.
return {"msg_id": row["msg_id"], "msg_seq": 20001 + row["used"]}
return await self._run(reserve)
async def block_reply(self, platform_id, scene, destination, msg_id):
await self._run(
lambda db: (
db.execute(
"UPDATE reply_contexts SET blocked=1 WHERE platform_id=? AND scene=? AND destination=? AND msg_id=?",
(platform_id, scene, destination, msg_id),
).rowcount
)
)
async def wait_for_reply(self, reminder_id, owner, reason):
await self._run(
lambda db: (
db.execute(
"UPDATE reminders SET waiting_reason=?,retry_at=0,lease_owner='',lease_until=0 "
"WHERE id=? AND lease_owner=? AND status='active'",
(reason[:500], reminder_id, owner),
).rowcount
)
)
async def resume(self, scope, creator_id, reminder_id, limit):
def write(db):
db.execute("BEGIN IMMEDIATE")
row = db.execute(
"SELECT * FROM reminders WHERE scope=? AND id=?", (scope, reminder_id)
).fetchone()
if not row or (creator_id is not None and row["creator_id"] != creator_id):
raise ValueError("当前会话中找不到该提醒,或你没有操作权限。")
if row["status"] == "done" or (row["status"] == "cancelled" and not row["last_error"]):
raise ValueError("只能重试投递失败或正在等待的提醒。")
if row["lease_until"] > time.time():
raise ValueError("该提醒正在投递,请稍后重试。")
count = db.execute(
"SELECT COUNT(*) FROM reminders WHERE scope=? AND creator_id=? AND status='active' AND id!=?",
(scope, row["creator_id"], reminder_id),
).fetchone()[0]
if count >= limit:
raise ValueError(f"最多只能设置 {limit} 个活跃提醒,请先取消一些。")
db.execute(
"UPDATE reminders SET status='active',failure_count=0,last_error='',waiting_reason='',"
"retry_at=0,lease_owner='',lease_until=0 WHERE id=?",
(reminder_id,),
)
await self._run(write)