unis-oa/backend/scripts/check_embed_moved.py

467 lines
25 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.

#!/usr/bin/env python3
"""嵌页面那一屏问的第二句:我打开的那一环、那条待办,现在还在原地吗。
PYTHONPATH=. python3 scripts/check_embed_moved.py
用户那句原话是在生产上试出来的:「在嵌入的报销页面里点了提交,OA 这一页没反应,我以为没
提交成功。」链路是这样断的:人在对面点下提交,对面自己的后端过一两秒才把结论送到 OA;而
那一屏上 ``POST /embed/state`` 原本只答一句"这一趟变成单了没"(``started``),挂在单据上开出
来的那些趟问这一句永远得到 null —— 会话就是挂在这张单上开出来的,"这一趟发起出去了没"根本
不成其为问题(:func:`app.api.embeds._started_of` 因此直接回 null)。于是那一屏连一句可轮询的
话都没有,那两秒里它和提交前一模一样,人看到的仍然是"没反应"。
修法是在同一条轻路上补第二句:拿会话**打开那一刻的快照**(work / job / activity / task 四列)
去对此刻,任一条对不上就算"动了"(判据 :func:`app.api.embeds.work_moved`)。这一条钉的就是那
句判据本身,十二句里每一句都对得上一种看得见的坏法:
1. 一切还在原地 → 没动。这一条是"不许界面白刷"那半边,缺了它,前面几条怎么过都没意义;
2. 单据走去了别的环节 → 动了(人在对面提交成功,OA 这一步已经交棒);
3. 那条待办不再挂在待办表里 → 动了,**无论谁办的**:他自己、抢先的人、会签凑够了数、还是第
三方服务端代点的那一路 —— 后者正是生产上等的那一句;
4. 这张单落定了(办结 / 终止 / 作废)→ 动了,而且 ``state.status`` 说得出是哪一种;
5. 这张单整个不在了(连归档行都没有)→ 动了:这一屏没有东西可以留着看了;
6. 挂在开始环节、手上根本没有待办的那些趟(第三方接管开始环节建的那一单,见 engine.start 的
hold_at_begin)不能因为"待办查不到"就被判成已经动了;
7. 并行环节时 ``work.activity`` 是逗号串,认自己那一环要用串里的成员,不能用整串相等;
8. **回看一张早就办结的单**(会话上环节与待办都是空的)→ 没动:那种屏没有可比的东西,判成
动了就是每点开一次白刷一次整屏,而前端那道 movedOut 闸一次装载只挡得住一次;
9. 认不出那一趟(假预受理号)→ found=false 且 moved=false、state=null,不抛异常;
10. 挂在单据上的那一趟,``started`` 照旧是 null 而 ``moved`` 答得出话 —— 两句互不顶替,这一条
就是这次改动存在的全部理由;
11. 发起页那些还没变成单的趟 → 第二句答不出(state=null、moved=false),归 started 那一路管;
12. 问这一句**一行都不写**:不发短码、不记"打开"留痕、连会话自己的 update_time 都不许挪 ——
这一条是成串追问的轮询,写一行就是往台账里掺一条假的"他打开了那个页面"。
判据本身(1-8)收在一个纯函数里;现场那四个键的内容(含 11、含"一句问话发几条语句")收在
:func:`_moved_of` 里,配一条按表名回话的假库;9 还走一次真路由(把 get_db / current_user 两个
依赖换掉就行)。这三段**都不需要数据库**,MySQL 不可达的机器跑的就是它们。10 与第 12 句要
一张真单、一条真待办与一趟真会话;连不上库时脚本自己说清跳过了什么,不含糊过去。跑完连自己
造的那条源、那张单、那条待办与那几趟会话一起删干净(清场口径照 ``check_write_payload.py``)。
"""
from __future__ import annotations
import logging
import time
from datetime import datetime
from sqlalchemy import delete, select
from sqlalchemy.exc import OperationalError
from starlette.testclient import TestClient
from app import models
from app.api.embeds import _moved_of, work_moved
from app.db import SessionLocal
from app.main import app
from app.security import create_access_token
from app.service import embed_session
#: 这一趟专用的源编码:会话、短码、留痕与这条源本身都按它清场,别人的行一条不碰
SOURCE = f"check_embed_moved_{int(time.time())}"
FIELD = "approve_page"
#: 会话都挂在管理员身上:接口那一路按"打开这一页的那个人"认趟(match_prekey),用 1 号就是一
#: 个 token 走到底,不必为流程里的审批人再凑一个能登录的账号
PERSON = "1"
FAILS: list[str] = []
PASSED = 0
def check(label: str, condition, detail="") -> None:
global PASSED
if condition:
PASSED += 1
print(f"[通过] {label}")
else:
FAILS.append(label)
print(f"[FAIL] {label}{f' -> {detail}' if detail else ''}")
def same(label, got, want) -> None:
"""比值的一句:不等就把两边都念出来,光说"条件不成立"看不出差在哪一格。"""
check(label, got == want, f"期望 {want!r},实得 {got!r}")
def verdict(**over) -> bool:
"""一句判据:默认那份"全都在原地"的现场,按需要改一样。"""
args = dict(snapshot_activity="a-dept", snapshot_task="t-1",
now_status="running", now_activity="a-dept", task_open=True)
args.update(over)
return work_moved(**args)
class _Reply:
"""假库的回话:first() 与 scalar() 两个口子,够把 _moved_of 走一遍。"""
def __init__(self, value):
self._value = value
def first(self):
return self._value
def scalar(self):
return self._value
class _FakeDb:
"""只按语句里那张表名回话的假库。
为的是把 ``state`` 那四个键的**内容**也钉进不连库的这一半:真表上要凑出"归档行还在、运行
行没了"这种现场,得真跑一张流程再把它办结,代价与这一条要钉的东西不成比例。顺带把"一句
问话发几条语句"数下来 —— 那正是"必须还是一条便宜的读路"这句话唯一的抓手。
"""
def __init__(self, *, work=None, archived=None, task_open=True):
self.work = work
self.archived = archived
self.task_open = task_open
self.statements: list = []
def execute(self, statement):
text = str(statement)
self.statements.append(text)
if "oa_work_completed" in text:
return _Reply(self.archived)
if "oa_task" in text:
return _Reply("t-1" if self.task_open else None)
return _Reply(self.work)
def _running(job="FYBX0001", activity="a-dept", status="running"):
"""假库里那一行还在跑的单据:只带 _moved_of 要读的那三列。"""
return type("Row", (), {"job": job, "status": status, "activity": activity})()
def _trip(**over):
"""一趟挂在单据上的会话,默认"打开时看的是 a-dept 那一环、手上那条待办叫 t-1"。"""
args = dict(prekey="PRE-MOVED-1", source=SOURCE, person=PERSON, field=FIELD,
work="w-1", job="FYBX0001", activity="a-dept", task="t-1")
args.update(over)
return models.EmbedSession(**args)
def pure_checks() -> None:
"""判据本身。这一整段不碰数据库 —— MySQL 不可达的机器跑的就是它。"""
print("--- 判据(不连库)")
check("1 一切还在原地 → 没动", verdict() is False, verdict())
check("2 单据走去别的环节 → 动了", verdict(now_activity="a-finance"))
check("3 那条待办不挂着了 → 动了", verdict(task_open=False))
check("4 单据已办结 → 动了", verdict(now_status="completed"))
check("4 单据已终止 → 动了", verdict(now_status="terminated"))
check("4 单据已作废 → 动了", verdict(now_status="canceled"))
check("5 这张单两张表里都没有了 → 动了", verdict(now_status=""))
# 6 与 8 是同一种坏法的两面:手上没有可比的东西时,"查不到"不等于"已经动了"。那种趟
# (停在开始环节、第三方接管开始环节建的那一单,见 engine.start 的 hold_at_begin,以及
# 回看一张早就办结的单)压根没有待办可查,一问就永远是"不在了"
check("6 开始环节那趟本来没待办:不许误判成动了",
verdict(snapshot_task="", task_open=False) is False,
verdict(snapshot_task="", task_open=False))
check("6 同一档,环节一走就真的动了", verdict(snapshot_task="", now_activity="a-finance"))
check("8 回看一张早就办结的单(环节与待办都没快照)→ 没动",
verdict(snapshot_activity="", snapshot_task="", now_status="",
task_open=None) is False,
verdict(snapshot_activity="", snapshot_task="", now_status="", task_open=None))
check("7 并行逗号串里认得出自己那一环",
verdict(snapshot_activity="a-b", now_activity="a-b,a-c") is False,
verdict(snapshot_activity="a-b", now_activity="a-b,a-c"))
check("7 并行逗号串里没有自己那一环 → 动了",
verdict(snapshot_activity="a-b", now_activity="a-c,a-d"))
check("待办被办掉而环节没变 → 仍算动了(第三方服务端代点就是这一种)",
verdict(snapshot_activity="a-dept", task_open=False))
# --- 现场那四个键的内容:假库按表名回话,同样不连库 ---
moved, state = _moved_of(_FakeDb(work=_running()), _trip())
same("1 现场说的就是此刻:job / activity / status / task_open 四格齐全且都是此刻的值",
(moved, state and state.model_dump()),
(False, {"job": "FYBX0001", "activity": "a-dept", "status": "running",
"task_open": True}))
moved, state = _moved_of(_FakeDb(work=_running()), _trip(task=""))
same("会话没带待办号时 task_open 是 null,不猜一个 false",
(moved, state and state.task_open), (False, None))
moved, state = _moved_of(_FakeDb(work=_running(activity="a-finance")), _trip())
same("2 环节走了:说得出动了,也说得出走去哪一环",
(moved, state and state.activity), (True, "a-finance"))
moved, state = _moved_of(_FakeDb(work=_running(), task_open=False), _trip())
same("3 待办没了:动了,且 task_open=false",
(moved, state and state.task_open), (True, False))
# 归档那一行还在、运行那一行没了 = 这张单落定了。状态要照念,只报一个空串说不出为什么
moved, state = _moved_of(_FakeDb(archived="completed"), _trip())
same("4 单已归档:动了,state.status 念得出 completed(activity 是空串,归档行没这一列)",
(moved, state and (state.status, state.activity)), (True, ("completed", "")))
moved, state = _moved_of(_FakeDb(), _trip())
same("5 两张表里都没有:动了,state.status=gone",
(moved, state and state.status), (True, "gone"))
# 会话上的主键查不到(办结得飞快、归档行又被删)时按单号再问一次,别说成 gone
moved, state = _moved_of(_FakeDb(archived="terminated"), _trip(work="没有这个主键"))
same("5 主键查不到时按单号再问归档表,终止就说终止",
(moved, state and state.status), (True, "terminated"))
# 快照是空的那一趟挂在一张不存在的单上:判据要说"没动",不是硬写 True
moved, state = _moved_of(_FakeDb(), _trip(activity="", task=""))
same("8 快照为空 + 单没了 → 没动(这里判据没被绕过去)",
(moved, state and state.status), (False, "gone"))
# 认不出那一趟、以及那一趟压根没挂在单据上:都不碰库就答"没动 + 现场留空"。传进去的库
# 是 None —— 判据只要敢碰一下就当场崩,等于顺手钉死了"不碰库"
same("9 认不出那一趟 → 说没动、现场留空", _moved_of(None, None), (False, None))
same("11 发起页那些还没变成单的趟 → 这一句答不出,算没动",
_moved_of(None, _trip(work="", job="", activity="", task="")), (False, None))
# --- 那条读路真的便宜吗:一句问话最多两条语句 ---
full = _FakeDb(work=_running())
_moved_of(full, _trip())
same("12 挂在待办上的一趟:一句问话两条按主键的读(单据 + 待办),不多不少",
len(full.statements), 2)
plain = _FakeDb(work=_running())
_moved_of(plain, _trip(task=""))
same("12 会话没带待办号时那一条待办语句根本不发", len(plain.statements), 1)
gone_db = _FakeDb()
_moved_of(gone_db, _trip())
same("12 单没了那一档不再追问待办(判据已定,何必多问一条)",
any("oa_task" in text for text in gone_db.statements), False)
def state_of(client, headers, prekey):
"""问一句,把 data 那一层原样交回来(HTTP 状态码塞进 _status 一起比)。"""
response = client.post("/api/v1/embed/state", headers=headers,
json={"code": SOURCE, "field": FIELD, "prekey": prekey})
body = dict((response.json() or {}).get("data") or {})
body["_status"] = response.status_code
return body
def counts(db):
"""这一趟专用的那本账:留痕条数与短码条数(与 check_embed_api.py 同一个口径)。"""
from sqlalchemy import func
logs = db.execute(select(func.count()).select_from(models.DataSourceLog)
.where(models.DataSourceLog.source == SOURCE)).scalar() or 0
tickets = db.execute(select(func.count()).select_from(models.EmbedTicket)
.where(models.EmbedTicket.source == SOURCE)).scalar() or 0
return int(logs), int(tickets)
def stamp_of(db, prekey):
"""这一趟自己的 update_time —— "有没有人动过这一行"最硬的一句证据。"""
return db.execute(select(models.EmbedSession.update_time)
.where(models.EmbedSession.prekey == prekey)).scalar()
def dml_during(call):
"""跑那一句的时候,引擎上到底发出去几条写语句(INSERT / UPDATE / DELETE)。
按语句数而不是按"台账里多没多一行"来算:留痕与短码那两张表只数得出一笔**已经 commit
的**写,而这一条要钉的是"轮询压根不该发写语句"——多一条没提交的 UPDATE 也一样把
oa_embed_session 那一行锁住,成串追问时正是它把提交那一头挡在锁外面。
只数这三张表的写:监听挂在共享 engine 上,同一进程里调度线程(发件箱投递、超时扫描)
随时可能在别的表上落一笔,把它们算进来会让这一句变成随机失败。这三张正是这一条接口
**有可能**动到的全部:会话行、打开留痕、免登短码。
"""
from sqlalchemy import event
from app.db import engine
tables = ("oa_embed_session", "oa_data_source_log", "oa_embed_ticket")
seen: list = []
def _note(_conn, _cursor, statement, _params, _context, _executemany):
text = str(statement)
head = text.lstrip()[:8].upper()
if head.startswith(("INSERT", "UPDATE", "DELETE")) and any(n in text for n in tables):
seen.append(text[:80])
event.listen(engine, "before_cursor_execute", _note)
try:
call()
finally:
event.remove(engine, "before_cursor_execute", _note)
return seen
class _NoRows:
"""一条什么都不查得到的库:每个口子都回 None,够把"认不出那一趟"那一路走到底。"""
def execute(self, statement):
return self
def scalars(self):
return self
def first(self):
return None
def scalar(self):
return None
class _Who:
"""够认趟用的一个人:接口那一路只读 person_id。"""
person_id = PERSON
is_admin = True
def route_checks() -> None:
"""第 9 句走真接口、**不碰库**:把 get_db 与 current_user 两个依赖换掉就够了。
生产上这一句是成串追问的轮询,预受理号过期、被人放弃、前端拿着上一趟的号重来一次,
都是"认不出那一趟"。那一路必须安静:200 加三句假话,不是一句异常——界面 catch 之后
只是"当没变",而 5xx 会把一次正常的轮询变成一次值得报警的失败。
"""
from app.db import get_db
from app.deps import current_user
# 安静一下:CSP 那位中间件自己开一条 SessionLocal 问可嵌入来源(不吃这里的依赖替换),
# 库不可达时它打一坨 traceback 才继续,看着像这一条挂了;httpx 那句访问日志同理
quiet = [logging.getLogger("app.service.embed"), logging.getLogger("httpx")]
saved_levels = [item.level for item in quiet]
for item in quiet:
item.setLevel(logging.CRITICAL)
saved = dict(app.dependency_overrides)
app.dependency_overrides[get_db] = lambda: _NoRows()
app.dependency_overrides[current_user] = lambda: _Who()
try:
client = TestClient(app, raise_server_exceptions=False)
# 令牌那一格只要过 current_user 那一道(已经换成假的),值本身不参与判定;写 ASCII
# 是因为 httpx 按 ASCII 编请求头,中文字在这里会当场炸
body = state_of(client, {"Authorization": "Bearer probe-token"}, "PRE-没这个号")
same("9 认不出那一趟(真路由、不碰库):200 + found=false + moved=false + state=null",
(body.get("_status"), body.get("found"), body.get("started"),
body.get("moved"), body.get("state")),
(200, False, None, False, None))
same("9 报文的键就是那四个,一个不多一个不少(started / found 一个都没动)",
sorted(body), ["_status", "found", "moved", "started", "state"])
finally:
for item, level in zip(quiet, saved_levels):
item.setLevel(level)
app.dependency_overrides.clear()
app.dependency_overrides.update(saved)
def db_checks(job):
"""要真表的那几条:走一次真接口,看报文,也看它是不是一行都没写。
这里不跑真流程 —— 这一条要钉的是"读出来的那份现场对不对、读的时候动没动手",与流转无
关,所以摆一张假单、一条真待办、一趟真会话就够,跑完连自己造的一起删干净。
"""
print("--- 真表(要一个连得上的库)")
db = SessionLocal()
try:
db.execute(select(models.User.id).limit(1))
except Exception as exc:
line = (str(exc).splitlines() or [type(exc).__name__])[0][:110]
print("[跳过] 库连不上(" + type(exc).__name__ + ":" + line + ")")
print(" 真表那九条本轮未跑;连上 MySQL 后原样再跑一次即可。判据那一段照算")
db.close()
return
try:
row = models.DataSource(code=SOURCE, name="嵌页面第二句校验源", kind="fetch",
provider="embed", url="https://erp.invalid/approve?no={arg.no}",
page_mode="ticket", auth_secret="check-embed-moved-key")
work = models.Work(job=job, serial=job, title="嵌页面第二句校验单 " + job,
process="p-check-embed-moved", process_name="嵌页面第二句校验",
status="running", activity="a-dept", activity_name="部门审批",
creator=PERSON, creator_person="校验", creator_identity="admin")
db.add_all([row, work])
db.flush()
task = models.Task(job=job, work=work.id, title=work.title, status="pending",
process=work.process, process_name=work.process_name,
activity="a-dept", activity_name="部门审批", person=PERSON,
identity="admin", identity_name="校验")
db.add(task)
db.flush()
session = embed_session.open_session(
db, row=row, field_key=FIELD,
field={"key": FIELD, "embed": {"actions": {"enabled": True, "allow": ["decide"]}}},
person=PERSON, work=work.id, job=job, activity="a-dept", task=task)[0]
db.commit()
prekey = str(session.prekey)
client = TestClient(app, raise_server_exceptions=False)
headers = {"Authorization": "Bearer " + create_access_token(PERSON)[0]}
# 会话就挂在这张单上:"成单了没"那一句问不出来(这正是改之前那一屏什么都没有的时
# 刻),而第二句答得出话。两句互不顶替 —— 这一条就是这次改动存在的全部理由
first = state_of(client, headers, prekey)
same("10 挂在单据上的那一趟:started 照旧是空的,moved 与 state 答得出话",
(first.get("_status"), first.get("found"), first.get("started"), first.get("moved")),
(200, True, None, False))
same("10 现场念的是真表里的此刻:环节、状态、那条待办都还在原地",
first.get("state"), {"job": job, "activity": "a-dept",
"status": "running", "task_open": True})
# 对面那一刀落下来:引擎把待办整行删掉(_complete_task),单还停在这一环。这正是生
# 产上等的那一秒 —— 第三方服务端替人办完,OA 这一屏当场听得见
db.execute(delete(models.Task).where(models.Task.id == task.id))
db.commit()
after = state_of(client, headers, prekey)
same("3 第三方服务端把这条待办办掉之后,这一句当场答得出动了",
(after.get("moved"), (after.get("state") or {}).get("task_open")), (True, False))
# 单整个没了:连行带号从运行表里抹掉(delete_unstarted 那一路)。快照还在,所以判据
# 该说动了;现场也念得出"这张单不在了",而不只是一个空串
db.execute(delete(models.Work).where(models.Work.id == work.id))
db.commit()
gone = state_of(client, headers, prekey)
same("5 那张单整个不在了:动了,现场念得出 gone",
(gone.get("moved"), (gone.get("state") or {}).get("status")), (True, "gone"))
# 回看那一屏:另一趟挂在一张不存在的单上,而会话上环节与待办都是空的 —— 没有可比的
# 东西就不许说动了,否则那一屏每切回来一次白刷一次整屏
back = embed_session.open_session(
db, row=row, field_key=FIELD, field={"key": FIELD, "embed": {}},
person=PERSON, work="w-没了", job=job, activity="", task=None)[0]
db.commit()
again = state_of(client, headers, str(back.prekey))
same("8 快照是空的(回看一屏)而单又没了 → 说没动,不许白刷",
(again.get("found"), again.get("moved")), (True, False))
# 认不出那一趟:found 与 moved 一起 false、state 留空,而且不抛异常(还是 200)
ghost = state_of(client, headers, "PRE-没这个号")
same("9 号认不出来:found=false、moved=false、state=null,200 不抛异常",
(ghost.get("_status"), ghost.get("found"), ghost.get("moved"), ghost.get("state")),
(200, False, False, None))
# 一行都不写:留痕、短码,连这一趟自己的 update_time 都不许挪
db.expire_all()
base, seen = counts(db), stamp_of(db, prekey)
writes = dml_during(lambda: [state_of(client, headers, prekey) for _ in range(5)])
db.expire_all()
same("12 连问五句:引擎上一条写语句都没发(INSERT/UPDATE/DELETE 全零)", writes, [])
same("12 连问五句:不发短码、不记打开留痕", counts(db), base)
same("12 连问五句:连这一趟自己的 update_time 都没挪(真的一行都不写)",
stamp_of(db, prekey), seen)
except OperationalError as exc:
line = (str(exc).splitlines() or ["库断了"])[0][:110]
print("[跳过] 跑到一半库断了(" + line + "),这一段以判据那半为准")
finally:
purge(db, job)
db.close()
def purge(db, job):
"""删掉自己造的那几张行:按这一趟专用的编码与单号删,别人的会话一条不碰。"""
for model in (models.Task, models.Work, models.WorkCompleted):
db.execute(delete(model).where(model.job == job))
db.execute(delete(models.EmbedSession).where(models.EmbedSession.source == SOURCE))
db.execute(delete(models.EmbedTicket).where(models.EmbedTicket.source == SOURCE))
db.execute(delete(models.DataSourceLog).where(models.DataSourceLog.source == SOURCE))
db.execute(delete(models.DataSource).where(models.DataSource.code == SOURCE))
db.commit()
def main() -> int:
pure_checks()
route_checks()
db_checks("MOVED" + datetime.now().strftime("%m%d%H%M%S"))
for line in FAILS:
print("[FAIL] " + line)
if FAILS:
print("共 " + str(len(FAILS)) + " 条不对")
return 1
print("通过:那一屏第二句判得准、读得便宜,问一句一行都不写(" + str(PASSED) + " 项)")
return 0
if __name__ == "__main__":
raise SystemExit(main())