unis-oa/backend/app/readcache.py

191 lines
8.2 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

"""只读结果在**同一个 Session 内**的复用:按"这一条结果读过哪几张表"作废。
为什么加这一层
==============
库在另一台机器上,一条 SQL 无论多轻都要一趟十几毫秒,快慢只取决于一个请求排几次队。
量一次审批(``POST /task/{id}/execute``,101 条语句)里,**同一条 SQL、同一份参数**被反复问:
``users`` 11 次、``oa_form`` 5 次、``oa_role`` 4 次、``oa_unit`` / ``oa_group`` 各 3 次,
而这一次请求对这些表一条都没写。流程引擎每到一个环节都把审批人重解析一遍、表单重读
一遍,同一个人、同一个角色因此在一次点击里被问好几遍。接完之后同一条路径 78 条
(``python3 scripts/check_readcache.py`` 守着它不作废错东西,``/tmp`` 下没有:口径见那脚本)。
规则(宁可少缓存,不能读旧值)
==============================
* 只活在**一个 Session** 里:请求结束 Session 关掉,缓存跟着没,绝不通到下一个请求。
* 每条结果记下它依赖哪几张表;**任何一个 Session** 写了其中任何一张,这一条立刻作废
(每张表一个进程级代号,取的时候比一份)。写是在连接层看的(见 :func:`app.db` 里那个
``before_cursor_execute``),ORM 刷的、bulk 的、裸 SQL 的统统算数。
* 认不清的写(不知道是哪张表,或者根本不在某个 Session 上)→ 全局代号 +1,
所有 Session 的缓存一律作废。
* 取回的是拷贝:调用方拿去改,不会污染缓存里那一份。ORM 对象按原样给(本来就该是
Session 身份映射里那一个,拷一份反而是错的)。
* 本 Session **回滚过**就把这一份整体清空:未提交的值只有写的人自己读得到,回滚之后
它就成了旧值。只读请求收尾那条 ROLLBACK 牵连不到任何人。
* 不缓存写、不缓存流程数据(单据、待办、日志那些一直在变),调用方自己挑哪条值得复用。
* 整层可以关掉:起进程时带 ``OA_READCACHE=off``,行为退回没有这一层的样子。
"""
from __future__ import annotations
import os
import threading
from collections.abc import Callable, Iterable
from typing import Any
from sqlalchemy.orm import Session
_INFO_KEY = "readcache"
#: 这一层整体开关:``OA_READCACHE=off`` 起进程就关掉(A/B 与临时止损都用它)。
#: 只在起进程时读一次——每一万次取值都去翻环境变量不叫省时间。
ENABLED = os.environ.get("OA_READCACHE", "").strip().lower() not in ("0", "false", "no", "off")
_lock = threading.Lock()
#: 说不清道不明的写(比如启动期建表那些跑在连接上的裸 SQL)会把代号推一格,
#: 所有 Session 的缓存于是全部重来——这类写只发生在启动与运维脚本里,代价可以忽略。
_generation = 1
#: 每张表一个代号。**作废是进程级的事**:后台的 Hub 同步、别的请求写掉 users /
#: oa_unit 之后,正在跑的这一次请求下一回读就得看到新值,不能只清写的那个 Session。
_table_gen: dict[str, int] = {}
def generation() -> int:
return _generation
def _stamp(names: tuple[str, ...]) -> tuple[int, ...]:
"""这一组依赖表现在的代号;命中时要与存下来的那份一字不差。"""
return tuple(_table_gen.get(name, 0) for name in names)
def _copy(value: Any) -> Any:
"""容器逐层拷一份(缓存里那份就此与调用方脱钩);ORM 对象与标量原样给。"""
if isinstance(value, list):
return [_copy(item) for item in value]
if isinstance(value, tuple):
return tuple(_copy(item) for item in value)
if isinstance(value, set):
return {_copy(item) for item in value}
if isinstance(value, dict):
return {key: _copy(item) for key, item in value.items()}
return value
class _Store:
"""挂在 ``Session.info`` 上的一小张表:``key -> (依赖表, 取时的代号, 值)``。"""
__slots__ = ("entries", "gen", "dirty")
def __init__(self) -> None:
self.entries: dict[tuple, tuple[tuple[str, ...], tuple[int, ...], Any]] = {}
self.gen = _generation
#: 这个 Session 写过东西:一旦回滚,读进去的那些**未提交值**就成了旧值。
self.dirty = False
def fresh(self) -> None:
if self.gen != _generation:
self.entries.clear()
self.gen = _generation
def drop_table(self, table: str) -> None:
for key in [key for key, (tables, _, _) in self.entries.items() if table in tables]:
del self.entries[key]
def _store(db: Session) -> _Store:
store = db.info.get(_INFO_KEY)
if store is None:
store = db.info[_INFO_KEY] = _Store()
store.fresh()
return store
def peek(db: Session, tables: Iterable[str], key: tuple) -> tuple[bool, Any]:
"""看过没有:``(命中?, 值)``。依赖表被写过就不算命中,条目就地丢掉。
单独给这一口是为了让调用方"只补缺的那几个":一批人要问姓名时,先把缓存里有的挑出来,
剩下的一次 ``IN`` 查完,而不是退回一个一个问库。
"""
names = tuple(sorted({str(table) for table in tables if table}))
if not ENABLED or not names:
return False, None
store = _store(db)
stamp = _stamp(names)
if key in store.entries:
tables_of, stamp_of, value = store.entries[key]
if tables_of == names and stamp_of == stamp:
return True, _copy(value)
# 依赖表被人写过了(谁写的都一样):丢掉重取。
del store.entries[key]
return False, None
def put(db: Session, tables: Iterable[str], key: tuple, value: Any) -> Any:
"""把一份结果连同"取的时候这几张表的代号"存进本 Session,交出去的是拷贝。"""
names = tuple(sorted({str(table) for table in tables if table}))
if not ENABLED or not names:
return value
store = _store(db)
store.entries[key] = (names, _stamp(names), value)
return _copy(value)
def get(db: Session, tables: Iterable[str], key: tuple, loader: Callable[[], Any]) -> Any:
"""``loader()`` 的结果按 ``(依赖表, key)`` 在本 Session 内复用。
``key`` 必须自带调用点标签(如 ``("personref.resolve", 值)``),不同调用点不许共用一个键。
没查到过的键会调 ``loader`` 并把结果存下——**包括 ``None`` 与空表**:认不出人这件事
在一次请求里也不会突然变成认得出,而"认不出的那一串"恰恰是最爱被反复问的。
"""
found, value = peek(db, tables, key)
if found:
return value
return put(db, tables, key, loader())
def note_write(db: Session, table: str) -> None:
"""有人写了 ``table``:全进程依赖这张表的结果就此作废。
代号推一格是进程级的事(不只清本 Session 那一份),本 Session 的条目顺手就地删掉,
省得留在表里等下一次比对才发现已经过期。
"""
name = str(table)
with _lock:
_table_gen[name] = _table_gen.get(name, 0) + 1
store = db.info.get(_INFO_KEY)
if store is not None:
store.dirty = True
store.drop_table(name)
def note_rollback(db: Session) -> None:
"""本 Session 回滚:写过东西就把这一份缓存清空。
未提交的值只有写的那个 Session 自己读得到,所以只清自己;一个只读请求收尾时
那条 ROLLBACK 不该牵连别人——按这个口径,纯读的请求推不动任何人的缓存。
"""
store = db.info.get(_INFO_KEY)
if store is not None and store.dirty:
store.entries.clear()
store.dirty = False
def invalidate_everywhere(db: Session | None = None) -> None:
"""说不清写了哪张表 / 不是哪个 Session 干的:全场作废。
顺带把 ``db`` 标成"写过东西":它随后要是回滚,那一版读进缓存的未提交值也得跟着丢。
"""
global _generation
with _lock:
_generation += 1
if db is not None:
store = db.info.get(_INFO_KEY)
if store is not None:
store.dirty = True
__all__ = [
"ENABLED", "get", "generation", "invalidate_everywhere",
"note_rollback", "note_write", "peek", "put",
]