276 lines
14 KiB
Python
276 lines
14 KiB
Python
#!/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())
|