unis-oa/backend/scripts/check_write_payload.py

276 lines
14 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
"""守住"报文在提交之前拼"这一层(``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())