#!/usr/bin/env python3 """守住"报文在提交之前拼"这一层(``api/runtime.py::_commit``)。 ``SessionLocal`` 开着 ``expire_on_commit``:先提交再序列化,刚改过的那几行全被标记过期, 序列化就得逐行回库刷回来——一次审批白问两条 SELECT(当值待办 + 这张单子),发起、 改派、抄送、评论每一处同一笔。现在这些接口统一走"flush → 拼报文 → 提交"。 这一层动的是**写路径的收尾顺序**,``perf_guard.py`` 那套只读扫描看不见它,所以这里 单独钉三件事:: PYTHONPATH=. python3 scripts/check_write_payload.py 1. **写完不再回读**:发起、打开待办、审批三趟请求,最后一条写语句之后不许再有任何 SELECT——报文要么在提交前从身份映射里拼好,要么就得回库刷(改动前审批末尾正好 挂着 ``SELECT oa_task.id AS ...`` 与 ``SELECT oa_work.id AS ...`` 两条); 2. **报文对得上库**:接口回的那份单据字段与每一条待办,与请求结束后另起快照、从库里 重新查出来再序列化的一份,必须逐字段一致——这是"改了顺序、没改报文"的正证。唯一 容差是时间那一秒:``DATETIME`` 落库四舍五入到整秒,内存里那份还带着微秒 (``serializers.dt`` 抹微秒),所以内存值最多比库里早一秒; 3. **拼不出来就别提交**:故意把序列化打坏,这次操作必须整个回滚。宁可让人重试, 也不要"报了错、单子却已经在库里走完了"那种两头不靠的状态。 库里跑真流程再自己删干净(同 ``check_log_timeline.py``)。 """ from __future__ import annotations import re from datetime import datetime from sqlalchemy import delete, or_, select from starlette.testclient import TestClient import perf_guard as pg # noqa: F401 顺带把语句计数监听器挂上(pg.ROWS) from app import models, serializers from app.api import runtime from app.db import SessionLocal from app.main import app from app.security import create_access_token #: 要驱动的那张流程与一份能过必填校验的表单(与 ``check_log_timeline.py`` 同一份) PROCESS_NAME = "备用金申请流程" DATA = { "loanType": "personalLoan", "loanReason": "校验收尾顺序", "loanItems": [{"loanNote": "校验", "loanType": "personalLoan", "loanTypeName": "校验", "loanAmount": 3000, "returnDate": "2099-12-31"}], "loanAmountTotal": 3000, "payItems": [{"payee": "康文靖", "bankName": "校验银行", "bankAccount": "6222020200009999", "payAmount": 3000, "payWay": "bank"}], } #: 写语句;"最后一条写之后还有没有语句"就是这一层的判据 WRITE = re.compile(r'^\s*(INSERT|UPDATE|DELETE)\b', re.I) #: ``serializers.dt`` 那种 "YYYY-MM-DD HH:MM:SS" TIMESTAMP = re.compile(r'^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$') FAILS: list[str] = [] PASSED = 0 def check(label: str, ok: bool, detail: str = "") -> None: """报一条结果;``ok`` 为假就记进失败清单,最后决定退出码。""" global PASSED if ok: PASSED += 1 print(f"[通过] {label}") else: FAILS.append(label) print(f"[FAIL] {label}{f' -> {detail}' if detail else ''}") def _at(label: str, call) -> tuple[object, list[str]]: """打一次接口,顺带把这一次问过的语句摘出来。""" start = len(pg.ROWS) response = call() return response, pg.ROWS[start:] def _tail(stmts: list[str]) -> list[str]: """最后一条写语句之后的那些语句——报文若是提交之后才拼,就多在这里。""" last_write = max((i for i, s in enumerate(stmts) if WRITE.match(s)), default=-1) return stmts[last_write + 1:] def _check_quiet(label: str, stmts: list[str]) -> None: tail = _tail(stmts) check(label, not tail, f"最后一条写之后还问了 {len(tail)} 条:{tail[0][:110] if tail else ''}") def _as_time(value: object) -> datetime | None: return datetime.strptime(value, "%Y-%m-%d %H:%M:%S") if isinstance(value, str) and TIMESTAMP.match(value) else None def _payload_diff(sent: dict, fresh: dict) -> list[str]: """逐字段比接口回的那份与重新查库拼的那份;时间字段只放行一秒以内的取整差。""" bad: list[str] = [] for key, want in fresh.items(): got = sent.get(key) if got == want: continue left, right = _as_time(got), _as_time(want) if left is not None and right is not None and abs((right - left).total_seconds()) <= 1: continue # 内存里那份带着微秒,落库四舍五入,最多差一秒 bad.append(f"{key}: 接口回 {got!r} / 库里是 {want!r}") return bad def main() -> int: db = SessionLocal() process = db.execute( select(models.Process).where(models.Process.name == PROCESS_NAME, models.Process.enabled.is_(True)) ).scalars().first() if process is None: print(f"[跳过] 没有已发布的「{PROCESS_NAME}」,这一项校不了") db.close() return 0 # 同 check_cc_reads.py:写死 id=1 在这台库上可能没有那一行,整条门会空跑成「跳过」, # 看着是绿的那一格其实一个字没校;挑一个在职管理员,挑不到照旧报跳过。 starter = db.execute( select(models.User) .where(models.User.status == models.UserStatus.ACTIVE, models.User.role == models.ROLE_ADMIN) .order_by(models.User.id) ).scalars().first() if starter is None: print("[跳过] 库里没有在职的管理员账号,发起与拼报文这一路校不了") db.close() return 0 client = TestClient(app, raise_server_exceptions=False) token, _ = create_access_token(str(starter.id)) # 管理员:代跑各环节不会被权限挡 headers = {"Authorization": f"Bearer {token}"} stamp = datetime.now().strftime("%m%d%H%M%S") titles = [f"提交前拼报文校验单 {stamp}", f"拼报文失败回滚校验单 {stamp}"] jobs: list[str] = [] try: # 1) 发起:报文里的 job / work / serial 与那几条新建待办,全来自刚 flush 的对象 created, stmts = _at("create", lambda: client.post( "/api/v1/job", headers=headers, json={"process": process.id, "data": DATA, "title": titles[0]})) if created.status_code >= 400: print(f"[跳过] 发起这张流程没成功({created.status_code}),这一项校不了:{created.text[:160]}") return 0 body = created.json().get("data") or {} jobs.append(str(body.get("job") or "")) _check_quiet("发起的收尾不再回读刚写的东西", stmts) check("发起回了报文", bool(body.get("job")), str(sorted(body))[:160]) db.rollback() # 换快照,下面的对账才算"从库里重新查" work = db.execute(select(models.Work).where(models.Work.job == body.get("job"))).scalar_one_or_none() check("单据确实落在库里", work is not None, f"job={body.get('job')}") if work is None: return 1 check("发起回的 job / work / serial / title / status 与库里一致", body.get("job") == work.job and body.get("work") == work.id and body.get("serial") == work.serial and body.get("title") == work.title and body.get("status") in (work.status, ""), f"{body.get('serial')}/{body.get('status')} vs {work.serial}/{work.status}") sent_tasks = body.get("tasks") or [] check("发起回了新建的待办(一条都没有就比不出报文)", bool(sent_tasks), "0 条") rows = {row.id: row for row in db.execute( select(models.Task).where(models.Task.id.in_( [str(t.get("id") or "") for t in sent_tasks] or ["-1"]))).scalars().all()} check("发起回的每一条待办都真在库里", len(rows) == len(sent_tasks), f"回了 {len(sent_tasks)} 条,库里有 {len(rows)} 条") bad = [f"{row.get('activity_name') or row.get('activity')}: " + ";".join( _payload_diff(row, serializers.task(rows[row['id']]))) for row in sent_tasks if row.get("id") in rows and _payload_diff(row, serializers.task(rows[row['id']]))] check("发起回的每一条待办与库里逐字段一致(时间只容一秒取整差)", not bad, ";".join(bad[:3])) # 2) 打开待办:只写一个 view_time,顺手把整条待办的报文再对一遍 task_id = str(sent_tasks[0].get("id") or "") viewed, stmts = _at("view", lambda: client.post(f"/api/v1/task/{task_id}/view", headers=headers)) _check_quiet("打开待办的收尾不再回读那条待办", stmts) db.rollback() sent_view = viewed.json().get("data") or {} row = db.get(models.Task, task_id) check("打开待办回的报文与库里逐字段一致", row is not None and not _payload_diff(sent_view, serializers.task(row)), ";".join(_payload_diff(sent_view, serializers.task(row))[:3]) if row is not None else "待办不见了") check("已阅时间确实写进去了", row is not None and row.view_time is not None, "view_time 还是空") # 3) 审批:这一步之后单子办结归档,报文里的 work 指向归档件 detail = client.get(f"/api/v1/job/{jobs[0]}", headers=headers).json().get("data") or {} open_tasks = [t for t in (detail.get("tasks") or []) if not t.get("finish_time")] if not open_tasks: check("跑出了一条待办(没有就校不了审批的收尾)", False, "这张单一步就走完了") return 1 route = (open_tasks[0].get("route_name_list") or open_tasks[0].get("route_list") or ["submit"])[0] done, stmts = _at("execute", lambda: client.post( f"/api/v1/task/{open_tasks[0]['id']}/execute", headers=headers, json={"route_name": route, "opinion": "同意"})) check("审批跑起来了", done.status_code < 400, f"{done.status_code} {done.text[:120]}") _check_quiet("审批的收尾不再回读待办与单据", stmts) check("审批这趟问过库(一条都没有就说明探针没挂上)", bool(stmts), "0 条") step = done.json().get("data") or {} db.rollback() running = db.execute(select(models.Work).where(models.Work.job == jobs[0])).scalar_one_or_none() archived = db.execute(select(models.WorkCompleted).where(models.WorkCompleted.job == jobs[0])).scalar_one_or_none() holder = running or archived check("办结之后报文里的 work / status 与库里(跑着的或归档的)一致", holder is not None and step.get("work") == holder.id and step.get("status") == holder.status and step.get("job") == holder.job, f"{step.get('work')}/{step.get('status')} vs " f"{holder.id if holder else '无'}/{holder.status if holder else '无'}") sent_next = step.get("tasks") or [] rows = {row.id: row for row in db.execute( select(models.Task).where(models.Task.id.in_( [str(t.get("id") or "") for t in sent_next] or ["-1"]))).scalars().all()} bad = [f"{row.get('activity_name') or row.get('activity')}: " + ";".join( _payload_diff(row, serializers.task(rows[row['id']]))) for row in sent_next if row.get("id") in rows and _payload_diff(row, serializers.task(rows[row['id']]))] check("审批回的每一条新待办与库里逐字段一致", len(rows) == len(sent_next) and not bad, f"回 {len(sent_next)} 条 / 库里 {len(rows)} 条;" + ";".join(bad[:2])) # 4) 拼不出报文就不该提交:把序列化打坏,这张单必须整个回滚 real = runtime._create_payload def boom(_result): raise RuntimeError("故意打坏发起的报文") runtime._create_payload = boom try: broken, _ = _at("boom", lambda: client.post( "/api/v1/job", headers=headers, json={"process": process.id, "data": DATA, "title": titles[1]})) finally: runtime._create_payload = real db.rollback() leaked = db.execute(select(models.Work.job).where(models.Work.title == titles[1])).scalars().all() leaked += db.execute(select(models.WorkCompleted.job).where( models.WorkCompleted.title == titles[1])).scalars().all() check("报文拼不出来时整笔回滚(库里没留下半张单)", broken.status_code >= 500 and not leaked, f"状态 {broken.status_code},库里留下 {len(leaked)} 张") return 1 if FAILS else 0 finally: try: purge(db, jobs, titles) finally: db.close() def purge(db, jobs: list[str], titles: list[str]) -> None: """删掉自己跑出来的那几张单:按 job / 标题精确删,别的单据一律不碰。""" found = [job for job in jobs if job] found += [row[0] for row in db.execute(select(models.Work.job).where( models.Work.title.in_(titles or ["-1"]))).all()] found += [row[0] for row in db.execute(select(models.WorkCompleted.job).where( models.WorkCompleted.title.in_(titles or ["-1"]))).all()] if not found: return ids = list(found) ids += [row[0] for row in db.execute(select(models.Work.id).where(models.Work.job.in_(found))).all()] ids += [row[0] for row in db.execute( select(models.WorkCompleted.id).where(models.WorkCompleted.job.in_(found))).all()] for model in (models.WorkComment, models.Attachment, models.Notification, models.NotifyDelivery, models.OutboundMessage, models.OpenEvent, models.DataSourceLog, models.ReadCompleted, models.Read, models.WorkLog, models.TaskCompleted, models.Task, models.WorkCompleted, models.Work): columns = [getattr(model, name) for name in ("job", "work", "work_completed") if hasattr(model, name)] if columns: db.execute(delete(model).where(or_(*[column.in_(ids) for column in columns]))) db.commit() print(f" 已清掉这几张校验单({len(found)} 张 / work_id {len(ids)} 个)") if __name__ == "__main__": raise SystemExit(main())