- Db::query_json_raw:持 Db.lock、row_to_json 包裹、不做 JSON 键归一(给自带归一语义的厚业务仓) - Db::query_rows:持锁返回原始 pglite::Row(pg_catalog 元数据 / 取首行首列) - Db::lock_owned():与所有 Db::* / DbTransaction 共用同一把锁,guard 内可用裸句柄跑自有 SQL - query_json_inner 拆出共用段 query_json_inner_raw ⇒ SQL 包裹只有一份,query_json* 行为未改 - 闸门 AR20(raw 不归一 / 共用段 / 8 个公开入口全持锁)+ 反自证 14 → 15 项 - 探针 db_raw_it(4 条):raw 不归一 · 归一路径同时成立 · guard 期间 Db::exec 被阻塞 · query_rows 读 pg_catalog - 销掉 known-limitations 的「双锁」条;CHANGELOG / README 版本表升 0.5.0 - 验收:653 passed / 0 failed;verify.sh --smoke 14/14;check-arch 25/25 自证 15/15
1541 lines
72 KiB
Bash
Executable File
1541 lines
72 KiB
Bash
Executable File
#!/usr/bin/env bash
|
||
# sspf 架构边界自检 —— crate 依赖纪律 + 内存红线
|
||
#
|
||
# 目的:把 PLAN.md 判断 ②/⑥ 的架构约束变成**可执行的尺子**。
|
||
# 靠人读 Cargo.toml 守不住 —— 加依赖的人不会想到「这会让所有业务包背锅」。
|
||
#
|
||
# 🔴 **纯静态**:不编译、不启动。只需要 bash + python3(macOS 自带)。
|
||
#
|
||
# 用法:
|
||
# bash scripts/check-arch.sh # 全查
|
||
# bash scripts/check-arch.sh --self-test # 反自证:造已知违规,必须被抓到
|
||
#
|
||
# 退出码:0 全过 / 1 有 ❌ / 2 用法错
|
||
#
|
||
# ── 判据 ──
|
||
# AR1 `crates/sspf-sdk` 依赖只能有 `sspf-contract`
|
||
# —— 业务包只依赖 sdk ⇒ sdk 多一个依赖 = 所有业务包都要背
|
||
# AR2 🔴 平台包零业务:`packs/` 不存在;若出现则业务包依赖 ⊆ {sspf-sdk, serde}
|
||
# —— 业务包必须能整目录搬走 ⇒ 不许挂在 axum / tokio / pglite 上
|
||
# AR3 `crates/sspf-contract` 源码不许 `use axum|tokio|pglite|sqlx`
|
||
# —— 契约层一旦有 IO,业务包就再也不是「轻依赖」
|
||
# AR4 `crates/sspf-contract` 依赖 ⊆ {serde, serde_json, uuid, http}
|
||
# AR5 `crates/sspf-mcp`(若已存在)依赖 ⊆ {sspf-contract, serde, serde_json, tokio, async-trait}
|
||
# —— MCP 层要能同时接「进程内内核」和「远端 Java 后端」⇒ **不许依赖内核内部**
|
||
# —— tokio / async-trait 是协议实现(stdio 异步读写)所需,不是业务依赖
|
||
# AR6 `crates/sspf-adapter-baseline` 依赖 ⊆ {sspf-mcp, sspf-contract, serde, serde_json,
|
||
# tokio, http, hyper, hyper-util, http-body-util, bytes}
|
||
# —— 适配器只认工具契约层;依赖内核 store 就等于把第二种后端钉死在本进程旁
|
||
# AR7 `crates/sspf-lowcode` 依赖 ⊆ {sspf-contract, serde, serde_json}
|
||
# —— 低代码引擎是纯计算;依赖 DB/HTTP 会让它只能在内核里跑,且测试必须起库
|
||
# AR9 平台层(真源 `crates/sspf-core/src/**` + 转发壳 `src/backend/src/platform/**`)
|
||
# 里不许出现 `use sspf_pack_*`
|
||
# —— 平台层不许认识任何业务包(业务知识隔离)
|
||
# AR10 平台层(同上两处,不含 compat/)里不许出现
|
||
# `crate::platform::compat` —— 平台层不许**反向依赖**契约面
|
||
# —— M1 解开的环 A;拆 crate 时它就是循环依赖(编译器当天才报错 ⇒ 必须提前钉住)
|
||
# AR11 `src/backend/src/platform/compat/helper.rs` 里不许 `use super::<别的模块>`
|
||
# —— 契约面底座不许反向依赖契约面业务模块(helper 被 14 个模块依赖 ⇒ 即成环)
|
||
# —— M1 解开的环 B/C
|
||
# MEM1 非注释代码里不许出现 `SELECT *`
|
||
# —— 终端产品内存预算 ≤ 120MB(PLAN.md 判断 ⑥)⇒ 全表读进 Vec 直接爆
|
||
# MEM2 `crates/**` 与 `src/backend/src/**` 里不许出现无界 `HashMap` 缓存
|
||
# (近似检查:`static` + `Mutex<HashMap` 必须有 `MAX` 常量同文件出现)
|
||
# AR14 `crates/sspf-mcp-adapter` 依赖 ⊆ 白名单 + 源码不许 `use sspf_pack_*`
|
||
# —— M6 把 MCP 适配层下沉成独立 crate;它是「全仓唯一知道全部包的汇聚点」
|
||
# ⇒ 依赖面必须锁死,否则它会变成第二个「什么都认识」的黑洞
|
||
# AR15 旧平台路径不许复活:全仓不许 `crate::platform::` / `ssw_platform::platform::`,
|
||
# 且 `src/backend/src/platform/` 目录不许存在
|
||
# —— M7 删掉了 38 个转发壳;重建壳 + 改回 import 会**一切照常编译、测试全绿**
|
||
# ⇒ 没有这条闸门,M2–M7 的架构收益会**静默蒸发**
|
||
# AR16 内核只有 lib(`src/backend/Cargo.toml` 不许 `[[bin]]`)、集成测试不许回流
|
||
# 到 `src/backend/tests/`、`crates/sspf-admin` 必须存在且产出 bin
|
||
# —— 「内核是库、装配是应用、测试是消费者」这三条边界都是**文件位置**
|
||
# ⇒ 没有任何编译错误会提示你踩线,只有结构慢慢退回原样
|
||
# AR17 🔴 平台包零业务:任何 Cargo.toml 里都不许有 `sspf-pack-*` 依赖 / `example-packs`
|
||
# —— `crates/sspf` 是业务仓唯一依赖的**标准平台包**;示例包一硬依赖,
|
||
# `cargo add sspf` 就等于把 asset/demo/shop/books 拖进业务二进制
|
||
# AR18 `crates/sspf/src/**` 不得出现业务字面量(业务仓名 / 业务表名 / `/api/ssw/`)
|
||
# —— 门面是平台与业务的**唯一汇聚点**,两边都碰得到 ⇒ 「顺手写一句业务」
|
||
# 的成本最低,而这类代码**不会让任何测试变红**
|
||
#
|
||
# 🔴 AR1–AR5 是 PLAN.md §3.2 的分层纪律;MEM1–MEM2 是判断 ⑥ 的四条内存红线的静态部分。
|
||
# AR19 唯一装配链:`routes.rs` 只允许一个 `pub fn build_app_with`、一处
|
||
# `.layer(catch_all())` 与恰好 2 处互斥的 fallback 调用;`Extras.router_owned`
|
||
# 注释必须写明「不许自带 fallback」—— 业务自带状态路由若抄第二遍链,
|
||
# 404 兜底会静默错位且测试全绿(S25)。
|
||
# 🔴 AR17/AR18 是「sspf 标准平台包」(2026-11-04 P0)的边界:平台包里零业务。
|
||
# 🔴 AR19 是「业务自带状态的可组合装配」(2026-11-04 P1)的边界:装配链仍然只有一份。
|
||
# 🔴 AR20 是「业务仓库操作共用同一把锁」(2026-11-04 v0.5.0)的边界:raw 入口不归一、不造第二把锁。
|
||
|
||
set -u
|
||
|
||
ROOT="$(cd "$(dirname "$0")/.." && pwd)"
|
||
CRATES="$ROOT/crates"
|
||
KERNEL="$ROOT/src/backend"
|
||
MODULES_DIR="$KERNEL/src/modules"
|
||
|
||
# 🔴 **平台侧真源目录表**(M2/M3/M4 逐步扩):
|
||
# - `sspf-core/src` 平台核心(M2)
|
||
# - `sspf-compat-*/src` 契约面 7 个包(M3 底座 + M4 六个域包)
|
||
# 🔴 **动态收集**(`crates/sspf-compat-*/src`)⇒ 新增契约面包时**不会漏扫** ——
|
||
# 写死列表必然在某次新增包时漏掉 ⇒ 尺子静默失效(实测踩过)。
|
||
# 🔴🔴 **M7 起:`src/backend/src/platform/` 已删除**(38 个转发壳全部清空)⇒
|
||
# 平台层**只有真源**,没有壳 ⇒ 扫描面里**不再有**转发壳目录。
|
||
# ⇒ 旧路径(`crate::platform::…` / `ssw_platform::platform::…`)**必须**由
|
||
# **AR15** 单独钉住(见下)—— 否则删壳之后旧路径无人看管,
|
||
# 哪天有人写回 `crate::platform::sys::` ⇒ 编译不过(好的),
|
||
# 但若同时又建了个壳目录 ⇒ 就等于**复活了被删掉的架构**(坏的)。
|
||
PLAT_SRC_DIRS=()
|
||
[ -d "$CRATES/sspf-core/src" ] && PLAT_SRC_DIRS+=("$CRATES/sspf-core/src")
|
||
for d in "$CRATES"/sspf-compat-*/src; do
|
||
[ -d "$d" ] && PLAT_SRC_DIRS+=("$d")
|
||
done
|
||
|
||
PASS=0
|
||
FAIL=0
|
||
SKIP=0
|
||
|
||
ok() { PASS=$((PASS + 1)); printf '✅ %s\n' "$1"; }
|
||
bad() { FAIL=$((FAIL + 1)); printf '❌ %s\n' "$1"; }
|
||
skip() { SKIP=$((SKIP + 1)); printf '⏭ %s\n' "$1"; }
|
||
|
||
usage() {
|
||
echo "用法: bash scripts/check-arch.sh [--self-test]"
|
||
echo " 静态检查 crate 依赖纪律(AR1–AR20)与内存红线(MEM1–MEM2)"
|
||
echo "退出码: 0 全过 / 1 有 ❌ / 2 用法错"
|
||
}
|
||
|
||
# 取出 Cargo.toml 里 [dependencies] 段的包名(一行一个,已去空白)
|
||
deps_of() {
|
||
awk '
|
||
/^\[dependencies\]/ { f = 1; next }
|
||
/^\[/ { f = 0 }
|
||
f && /^[A-Za-z0-9_-]+[[:space:]]*=/ { sub(/[[:space:]]*=.*/, ""); print }
|
||
' "$1"
|
||
}
|
||
|
||
# 判断集合 A 是否 ⊆ 集合 B(两者都是空格分隔串)
|
||
subset_of() {
|
||
local need="$1" allowed=" $2 "
|
||
local x
|
||
for x in $need; do
|
||
case "$allowed" in
|
||
*" $x "*) : ;;
|
||
*) return 1 ;;
|
||
esac
|
||
done
|
||
return 0
|
||
}
|
||
|
||
# ---------------------------------------------------------------- AR1
|
||
check_ar1() {
|
||
local f="$CRATES/sspf-sdk/Cargo.toml"
|
||
[ -f "$f" ] || { skip "AR1 sspf-sdk 不存在(尚未拆分)"; return; }
|
||
local deps; deps="$(deps_of "$f" | tr '\n' ' ')"
|
||
if subset_of "$deps" "sspf-contract"; then
|
||
ok "AR1 sspf-sdk 依赖干净([$deps])"
|
||
else
|
||
bad "AR1 sspf-sdk 依赖越界:[$deps] —— 只允许 sspf-contract"
|
||
fi
|
||
}
|
||
|
||
# ---------------------------------------------------------------- AR2
|
||
check_ar2() {
|
||
local found=0 n=0
|
||
for f in "$ROOT"/packs/*/Cargo.toml; do
|
||
[ -f "$f" ] || continue
|
||
n=$((n + 1))
|
||
local deps; deps="$(deps_of "$f" | tr '\n' ' ')"
|
||
if subset_of "$deps" "sspf-sdk serde"; then
|
||
ok "AR2 $(basename "$(dirname "$f")") 依赖干净([$deps])"
|
||
else
|
||
bad "AR2 $(basename "$(dirname "$f")") 依赖越界:[$deps] —— 只允许 sspf-sdk / serde"
|
||
found=1
|
||
fi
|
||
done
|
||
if [ "$n" -eq 0 ]; then
|
||
# 🔴 2026-11-04 清理:零包是**合法目标态**,但不能「跳过」(跳过 = 尺子变瞎)。
|
||
# ⇒ 改成正向断言:packs/ 目录必须不存在,谁把业务包塞回来立刻红。
|
||
if [ -d "$ROOT/packs" ]; then
|
||
bad "AR2 平台包零业务:packs/ 目录不该存在(业务包属于业务仓 / 技能仓)"
|
||
found=1
|
||
else
|
||
ok "AR2 平台包零业务:没有 packs/,无任何业务包依赖(出现即红)"
|
||
fi
|
||
fi
|
||
return $found
|
||
}
|
||
|
||
# ---------------------------------------------------------------- AR3
|
||
check_ar3() {
|
||
local dir="$CRATES/sspf-contract/src"
|
||
[ -d "$dir" ] || { skip "AR3 sspf-contract 不存在"; return; }
|
||
local hits
|
||
hits="$(grep -rnE '^[[:space:]]*(pub )?use (axum|tokio|pglite|sqlx)' "$dir" 2>/dev/null || true)"
|
||
if [ -z "$hits" ]; then
|
||
ok "AR3 sspf-contract 无 IO 依赖(无 axum/tokio/pglite/sqlx 的 use)"
|
||
else
|
||
bad "AR3 sspf-contract 出现 IO 依赖:"
|
||
printf '%s\n' "$hits" | sed 's/^/ /'
|
||
fi
|
||
}
|
||
|
||
# ---------------------------------------------------------------- AR4
|
||
check_ar4() {
|
||
local f="$CRATES/sspf-contract/Cargo.toml"
|
||
[ -f "$f" ] || { skip "AR4 sspf-contract 不存在"; return; }
|
||
local deps; deps="$(deps_of "$f" | tr '\n' ' ')"
|
||
if subset_of "$deps" "serde serde_json uuid http"; then
|
||
ok "AR4 sspf-contract 依赖在白名单内([$deps])"
|
||
else
|
||
bad "AR4 sspf-contract 依赖越界:[$deps] —— 白名单 serde/serde_json/uuid/http"
|
||
fi
|
||
}
|
||
|
||
# ---------------------------------------------------------------- AR5
|
||
check_ar5() {
|
||
local f="$CRATES/sspf-mcp/Cargo.toml"
|
||
[ -f "$f" ] || { skip "AR5 sspf-mcp 不存在(P1 才落地)"; return; }
|
||
local deps; deps="$(deps_of "$f" | tr '\n' ' ')"
|
||
if subset_of "$deps" "sspf-contract serde serde_json tokio async-trait"; then
|
||
ok "AR5 sspf-mcp 依赖干净([$deps])"
|
||
else
|
||
bad "AR5 sspf-mcp 依赖越界:[$deps] —— 只允许 sspf-contract/serde/serde_json/tokio/async-trait"
|
||
fi
|
||
}
|
||
|
||
# ---------------------------------------------------------------- AR6
|
||
check_ar6() {
|
||
local f="$CRATES/sspf-adapter-baseline/Cargo.toml"
|
||
[ -f "$f" ] || { skip "AR6 sspf-adapter-baseline 不存在"; return; }
|
||
local deps; deps="$(deps_of "$f" | tr '\n' ' ')"
|
||
# 🔴 适配器只许依赖「工具契约层 + HTTP 客户端」。
|
||
# 一旦依赖 sspf-store / axum,第二种后端就只能跑在同一个内核旁边 —— 双轨失效。
|
||
if subset_of "$deps" "sspf-mcp sspf-contract serde serde_json tokio http hyper hyper-util http-body-util bytes"; then
|
||
ok "AR6 sspf-adapter-baseline 依赖干净([$deps])"
|
||
else
|
||
bad "AR6 sspf-adapter-baseline 依赖越界:[$deps] —— 只许工具契约层 + HTTP 客户端,不许依赖内核 store"
|
||
fi
|
||
}
|
||
|
||
# ---------------------------------------------------------------- AR7
|
||
check_ar7() {
|
||
local f="$CRATES/sspf-lowcode/Cargo.toml"
|
||
[ -f "$f" ] || { skip "AR7 sspf-lowcode 不存在"; return; }
|
||
local deps; deps="$(deps_of "$f" | tr '\n' ' ')"
|
||
# 🔴 低代码引擎必须是**纯计算**:解析 / 校验 / SQL 生成。
|
||
# 一旦依赖 pglite / axum,它就只能在内核里跑 —— CLI、MCP、离线校验工具都用不了,
|
||
# 而且测试必须起数据库(现在 38 个测试 0 依赖、毫秒级)。
|
||
if subset_of "$deps" "sspf-contract serde serde_json"; then
|
||
ok "AR7 sspf-lowcode 依赖干净([$deps])"
|
||
else
|
||
bad "AR7 sspf-lowcode 依赖越界:[$deps] —— 只许契约层 + 序列化,不许 DB / HTTP"
|
||
fi
|
||
}
|
||
|
||
# ---------------------------------------------------------------- AR8
|
||
# 业务包装载器(`crates/sspf-plugin`)的依赖白名单。
|
||
#
|
||
# 🔴 **为什么单列一条**:装载器是「业务包 ⇄ 内核」的唯一中介。
|
||
# 它一旦依赖 axum / tokio / pglite,业务包就**间接背上 web 框架**(AR2 的精神废掉),
|
||
# 而且「包可整目录搬走」这个承诺再也证不了。
|
||
# 装载器只做「读清单 + 校验兼容区间 + 收集 entities/menus/routes」⇒ 纯数据。
|
||
check_ar8() {
|
||
local f="$CRATES/sspf-plugin/Cargo.toml"
|
||
[ -f "$f" ] || { skip "AR8 sspf-plugin 不存在(批次 12 才落地)"; return; }
|
||
local deps; deps="$(deps_of "$f" | tr '\n' ' ')"
|
||
if subset_of "$deps" "sspf-sdk sspf-contract serde serde_json"; then
|
||
ok "AR8 sspf-plugin 依赖干净([$deps])"
|
||
else
|
||
bad "AR8 sspf-plugin 依赖越界:[$deps] —— 只允许 sspf-sdk/sspf-contract/serde/serde_json(不许 axum/tokio/pglite)"
|
||
fi
|
||
}
|
||
|
||
# ---------------------------------------------------------------- AR9
|
||
# **平台层不许认识任何业务包**(业务知识隔离,红线 12)。
|
||
#
|
||
# 🔴 方向是「内核 ⇒ 包」,**不是**「包 ⇒ 内核」:`src/backend/Cargo.toml` 依赖
|
||
# `sspf-pack-<app>` 是**允许**的(装配根要装载它们);
|
||
# 但**平台层**里出现 `use sspf_pack_*` ⇒ 平台层知道了
|
||
# 具体业务 ⇒ 加/删业务包就要改平台层 ⇒ 「链接就好」这个承诺是假的。
|
||
# 🔴 **M2 起平台层的真源在 `crates/sspf-core/src/`**,`src/backend/src/platform/`
|
||
# 只剩转发壳(`pub use sspf_core::*`)+ 尚未搬走的 `compat/`(M3/M4)。
|
||
# ⇒ 闸门必须**两处都扫**:扫真源(管实现)+ 扫转发壳(防有人往壳里塞实现)。
|
||
# 只扫壳 = 尺子量空壳 = 虚假安全感。
|
||
check_ar9() {
|
||
local dirs=()
|
||
[ "${#PLAT_SRC_DIRS[@]}" -gt 0 ] || { skip "AR9 平台层目录不存在"; return; }
|
||
dirs=("${PLAT_SRC_DIRS[@]}")
|
||
local hits
|
||
hits="$(grep -rnE '^[[:space:]]*(pub )?use[[:space:]]+sspf_pack_' "${dirs[@]}" 2>/dev/null || true)"
|
||
if [ -z "$hits" ]; then
|
||
ok "AR9 平台层没有 use sspf_pack_*(业务知识没漏进 sspf-core/ / compat 各包 / platform/)"
|
||
else
|
||
bad "AR9 平台层出现了业务包引用(业务知识漏进平台层 ⇒ 加包要改平台层):"
|
||
printf '%s\n' "$hits" | sed 's/^/ /'
|
||
fi
|
||
}
|
||
|
||
# ---------------------------------------------------------------- AR10
|
||
# **平台层不许反向依赖契约面**(M1 解开的环 A,防回退)。
|
||
#
|
||
# 🔴 **背景**:M1 之前 `platform/auth.rs` 里写着
|
||
# `crate::platform::compat::helper::current_user(...)` —— 平台层反过来调契约面。
|
||
# 同 crate 内这只是「层间倒挂」(能编译),但**拆 crate 时就是循环依赖**,
|
||
# 编译器直接报错 ⇒ 整个迁移(M2–M6)全部卡死。
|
||
# M1 已把分流点上移到装配根(`routes.rs`),平台层不再认识契约面。
|
||
#
|
||
# 🔴 **为什么必须钉住**:拆 crate 是**渐进**的 —— 在拆完之前,加回这一行
|
||
# **照样编译通过、测试照样全绿**,只有到 M2 那天才炸 ⇒ 那时候已经改了一堆东西,
|
||
# 回滚成本高得多。⇒ 现在就把它拦住。
|
||
#
|
||
# 判据:平台层真源(`crates/sspf-core/src/**`)与转发壳(`src/backend/src/platform/**`,
|
||
# **不含 compat/**)里都不许出现 `crate::platform::compat` / `super::compat` / `crate::compat`。
|
||
check_ar10() {
|
||
local dirs=()
|
||
[ "${#PLAT_SRC_DIRS[@]}" -gt 0 ] || { skip "AR10 平台层目录不存在"; return; }
|
||
dirs=("${PLAT_SRC_DIRS[@]}")
|
||
local hits
|
||
# 🔴 **必须排除注释行**(`//` / `//!` / `///`)—— 文档注释里的路径引用是
|
||
# **给人看的**(如 `//! (见 crate::platform::compat::helper::load_menus])`),
|
||
# 不是依赖 ⇒ 不该判红。
|
||
# 🔴 纯 grep 过滤不了:`//!` 前面**没有空格** ⇒ `^\s*//` 漏掉它。
|
||
# 这里用 python3 逐行判(与 MEM1/MEM2 同一套路)。
|
||
hits="$(python3 - "${dirs[@]}" <<'PY'
|
||
import os, re, sys
|
||
pat = re.compile(r'(crate::platform::compat|crate::compat|super::compat)')
|
||
bad = []
|
||
for root in sys.argv[1:]:
|
||
for dirpath, dirnames, files in os.walk(root):
|
||
dirnames[:] = [d for d in dirnames if d != 'compat'] # 契约面自己互引合法
|
||
for fn in files:
|
||
if not fn.endswith('.rs'):
|
||
continue
|
||
p = os.path.join(dirpath, fn)
|
||
try:
|
||
lines = open(p, encoding='utf-8').read().splitlines()
|
||
except OSError:
|
||
continue
|
||
for i, line in enumerate(lines, 1):
|
||
s = line.strip()
|
||
# 整行注释(含 `//!` / `///`)⇒ 跳过
|
||
if s.startswith('//'):
|
||
continue
|
||
# 行尾注释:把 `//` 之后截掉再判(`use x::y; // 说明` 里的说明不算)
|
||
code = line.split('//', 1)[0]
|
||
if pat.search(code):
|
||
bad.append(f'{p}:{i}: {s}')
|
||
for b in bad:
|
||
print(b)
|
||
PY
|
||
)"
|
||
if [ -z "$hits" ]; then
|
||
ok "AR10 平台层没有反向依赖契约面(拆 crate 的前置条件仍成立)"
|
||
else
|
||
bad "AR10 平台层反向依赖契约面(拆 crate 时就是循环依赖 ⇒ 必须把调用点上移到装配根):"
|
||
printf '%s\n' "$hits" | sed 's/^/ /'
|
||
fi
|
||
}
|
||
|
||
# ---------------------------------------------------------------- AR11
|
||
# **契约面底座(helper)不许依赖契约面业务模块**(M1 解开的环 B/C,防回退)。
|
||
#
|
||
# 🔴 **背景**:`compat/helper.rs` 被 **14 个**契约面模块依赖(实测)⇒ 它是底座。
|
||
# 若它反过来 `use super::system` / `use super::permission` ⇒
|
||
# 拆 crate 时 helper ↔ system / helper ↔ permission 都是**循环依赖**。
|
||
# M1 已把 `menu_node` / `official_view_path` / `USER_DETAIL_COLUMNS` /
|
||
# `organize_name_of` 搬进 helper,切断了这两条边。
|
||
#
|
||
# 🔴 **M3 起底座真源在 `crates/sspf-compat-core/src/helper.rs`**(壳只剩 `pub use`)
|
||
# ⇒ 两处都扫(扫真源管实现 + 扫壳防塞私货)。跨 crate 形态的同一纪律 =
|
||
# `sspf-compat-core` 的 Cargo.toml 不许依赖 `sspf-compat-*`(M4 的 6 个包)。
|
||
#
|
||
# 判据(两处):
|
||
# ① `helper.rs`(真源或壳)里不许 `use super::` 指向**非 helper 的模块**,
|
||
# 也不许 `use crate::res`(同 crate 内的反向依赖);
|
||
# ② `crates/sspf-compat-core/Cargo.toml` 不许依赖 `sspf-compat-*`。
|
||
check_ar11() {
|
||
local files=()
|
||
[ -f "$CRATES/sspf-compat-core/src/helper.rs" ] && files+=("$CRATES/sspf-compat-core/src/helper.rs")
|
||
local hits=""
|
||
if [ "${#files[@]}" -gt 0 ]; then
|
||
# 🔴🔴 **必须用 `-H`(强制输出文件名前缀)** —— M7 起文件只有一个,
|
||
# `grep -n` 只输出「行号:内容」⇒ **不含路径** ⇒ 反自证里
|
||
# `grep -q "sspf-compat-core/src/helper.rs"` **永远匹配不到**
|
||
# ⇒ 尺子明明抓到了违规,自证却报「尺子是假的」(实测踩过)。
|
||
# ⇒ `-H` 保证路径在场,反自证才能**按路径**精确验证。
|
||
hits="$(grep -HnE '^[[:space:]]*(pub )?use[[:space:]]+(super::[a-z_]+|crate::res)' "${files[@]}" 2>/dev/null \
|
||
| grep -vE 'super::helper|crate::helper' || true)"
|
||
fi
|
||
# 跨 crate 形态:底座的 Cargo.toml 不许依赖 6 个契约面包
|
||
local toml="$CRATES/sspf-compat-core/Cargo.toml"
|
||
if [ -f "$toml" ]; then
|
||
local dep_hits
|
||
dep_hits="$(grep -nE '^[[:space:]]*sspf-compat-[a-z_-]+[[:space:]]*=' "$toml" 2>/dev/null || true)"
|
||
if [ -n "$dep_hits" ]; then
|
||
hits="${hits:+$hits$'\n'}${dep_hits}"
|
||
fi
|
||
fi
|
||
if [ -z "$hits" ]; then
|
||
ok "AR11 契约面底座(helper/sspf-compat-core)不依赖其它契约面模块(14 个模块依赖它 ⇒ 反向依赖即成环)"
|
||
else
|
||
bad "AR11 契约面底座反向依赖契约面业务模块(拆 crate 时即成环):"
|
||
printf '%s\n' "$hits" | sed 's/^/ /'
|
||
fi
|
||
}
|
||
|
||
# ---------------------------------------------------------------- AR12
|
||
# **契约面各包之间不许互相依赖**(M4 拆 6 个包时的防环回流闸门)。
|
||
#
|
||
# 🔴 **为什么需要**:M4 把 49,000 行契约面拆成 7 个 crate。各包本应**彼此独立**
|
||
# (都只依赖 `sspf-compat-core` 底座 + `sspf-core` 平台核心)。
|
||
# 一旦 A 包 `use sspf_compat_b::…` 而 B 包又 `use sspf_compat_a::…`
|
||
# ⇒ **循环依赖** ⇒ 编译器直接报错(但那时已经改了一堆东西,回滚成本高)。
|
||
#
|
||
# 🔴 **唯一允许的两条单向依赖**(方向单一 ⇒ 不成环,已核实被依赖方不反向依赖):
|
||
# · `sspf-compat-permission` → `sspf-compat-system`
|
||
# (权限域用系统域的 `SYSTEM_LIST_PROJECTION` / `load_system_tops` /
|
||
# `log_page` / `shape_system_list_item`)
|
||
# · `sspf-compat-ext` → `sspf-compat-system` + `sspf-compat-msg`
|
||
# (移动端复用系统域 `home_data` 控制台卡片 + 消息域 `send_config_select_list`)
|
||
#
|
||
# 判据:每个 `crates/sspf-compat-*/Cargo.toml` 里出现的 `sspf-compat-*` 依赖,
|
||
# 必须在白名单内,且**白名单方向要反过来核实**(被依赖方不许依赖依赖方)。
|
||
check_ar12() {
|
||
local hits=""
|
||
local dir
|
||
for dir in "$CRATES"/sspf-compat-*; do
|
||
[ -d "$dir" ] || continue
|
||
local toml="$dir/Cargo.toml"
|
||
[ -f "$toml" ] || continue
|
||
local self_name
|
||
self_name="$(basename "$dir")"
|
||
local dep
|
||
for dep in $(grep -oE '^[[:space:]]*sspf-compat-[a-z_-]+[[:space:]]*=' "$toml" 2>/dev/null | grep -oE 'sspf-compat-[a-z_-]+' | sort -u); do
|
||
# 底座(sspf-compat-core)永远允许
|
||
[ "$dep" = "sspf-compat-core" ] && continue
|
||
# 白名单:按「依赖方 → 被依赖方」判定
|
||
local allowed=0
|
||
case "${self_name}:${dep}" in
|
||
sspf-compat-permission:sspf-compat-system) allowed=1 ;;
|
||
sspf-compat-ext:sspf-compat-system) allowed=1 ;;
|
||
sspf-compat-ext:sspf-compat-msg) allowed=1 ;;
|
||
esac
|
||
if [ "$allowed" -eq 0 ]; then
|
||
hits="${hits:+$hits$'\n'}${toml}: ${self_name} → ${dep}(不在白名单)"
|
||
fi
|
||
done
|
||
done
|
||
if [ -z "$hits" ]; then
|
||
ok "AR12 契约面各包彼此独立(只依赖底座 + 两条单向白名单 ⇒ 不会成环)"
|
||
else
|
||
bad "AR12 契约面包之间出现了未授权依赖(跨包依赖易成环):"
|
||
printf '%s\n' "$hits" | sed 's/^/ /'
|
||
fi
|
||
}
|
||
|
||
# ---------------------------------------------------------------- AR13
|
||
# **低代码执行层的依赖白名单**(M5 把 `lowcode_*.rs` 下沉到 `sspf-lowcode-exec`)。
|
||
#
|
||
# 🔴 **为什么需要**:`sspf-lowcode`(AR7)是**纯计算**层 —— 只认 serde,不许碰 DB/HTTP。
|
||
# M5 新增的 `sspf-lowcode-exec` 是它的**执行层**,允许连库;但依赖面必须**锁死**:
|
||
# 一旦它拖进 `axum`(web 框架)⇒ 这层就再也用不了 CLI / MCP / 离线工具;
|
||
# 一旦它拖进 `sspf_pack_*`(业务包)⇒ 平台层开始认识业务 ⇒ 破 AR9。
|
||
#
|
||
# 判据(两层):
|
||
# ① `crates/sspf-lowcode-exec/Cargo.toml` 的依赖 ⊆ 白名单;
|
||
# ② 该 crate 的源码里**不许**出现 `sspf_pack_`(与 AR9 同款语义,但独立钉住
|
||
# —— AR9 只扫平台层目录,执行层是新的目录,得单独管)。
|
||
check_ar13() {
|
||
local f="$CRATES/sspf-lowcode-exec/Cargo.toml"
|
||
if [ ! -f "$f" ]; then
|
||
skip "AR13 sspf-lowcode-exec 不存在"
|
||
return
|
||
fi
|
||
local deps; deps="$(deps_of "$f" | tr '\n' ' ')"
|
||
# 🔴 白名单:`sspf-lowcode`(纯计算)+ `sspf-core`(平台核心)+ `sspf-store`(Db 真源)
|
||
# + `sspf-mcp`(ToolError)+ `pglite-rs`(真实库)+ `chrono` + `serde_json`。
|
||
# **不许** axum(web 框架)/ tokio(异步运行时,本层是同步函数 + 调用方 await)。
|
||
if subset_of "$deps" "sspf-lowcode sspf-core sspf-store sspf-mcp pglite-rs chrono serde_json"; then
|
||
ok "AR13 sspf-lowcode-exec 依赖干净([$deps])"
|
||
else
|
||
bad "AR13 sspf-lowcode-exec 依赖越界:[$deps] —— 只许 {lowcode, core, store, mcp, pglite-rs, chrono, serde_json},不许 web 框架 / 业务包"
|
||
fi
|
||
# 第二层:源码不许出现业务包引用
|
||
local src="$CRATES/sspf-lowcode-exec/src"
|
||
if [ -d "$src" ]; then
|
||
local hits
|
||
hits="$(grep -rnE '^[[:space:]]*(pub )?use[[:space:]]+sspf_pack_' "$src" 2>/dev/null || true)"
|
||
if [ -z "$hits" ]; then
|
||
ok "AR13 执行层源码没有 use sspf_pack_*(业务知识没漏进执行层)"
|
||
else
|
||
bad "AR13 执行层源码出现了业务包引用(业务知识漏进平台层):"
|
||
printf '%s\n' "$hits" | sed 's/^/ /'
|
||
fi
|
||
fi
|
||
}
|
||
|
||
# ---------------------------------------------------------------- AR14
|
||
# **MCP 适配层的依赖白名单**(M6 把 `mcp_{adapter,compat}.rs` 下沉到 `sspf-mcp-adapter`)。
|
||
#
|
||
# 🔴 **为什么需要**:`sspf-mcp-adapter` 是**全仓唯一「知道全部包」的 crate** ——
|
||
# `mcp_compat.rs` 直调 workflow / system / permission / onlinedev 四个契约面域包
|
||
# 的 handler ⇒ 依赖图上它是**顶层汇聚点**。
|
||
# 这本身**不是环**(被依赖方谁都不认识它 ⇒ 方向单一),但它有两个真实风险:
|
||
# ① 依赖面失控 —— 一旦拖进业务包(`sspf_pack_*`),适配层就开始认识业务
|
||
# ⇒ 破 AR9 的「平台层零业务知识」承诺;
|
||
# ② 退化成「万能壳」 —— 拖进 `sspf-contract` / `sspf-plugin` 等非必需依赖,
|
||
# 会让它变成第二个什么都认识的模块 ⇒ 迁移的收益(壳瘦下来)被抵消。
|
||
#
|
||
# 🔴 **为什么不复用 AR9**:AR9 扫的是**平台层目录**(`sspf-core` + `sspf-compat-*` +
|
||
# `platform/` 壳)。适配层是**新的目录**,AR9 扫不到 ⇒ 必须单列一条钉住
|
||
# (与 AR13 对 `sspf-lowcode-exec` 的处理同款)。
|
||
#
|
||
# 判据(两层):
|
||
# ① `crates/sspf-mcp-adapter/Cargo.toml` 的依赖 ⊆ 白名单;
|
||
# ② 该 crate 的源码里**不许**出现 `use sspf_pack_`(业务包引用)。
|
||
check_ar14() {
|
||
local f="$CRATES/sspf-mcp-adapter/Cargo.toml"
|
||
if [ ! -f "$f" ]; then
|
||
skip "AR14 sspf-mcp-adapter 不存在"
|
||
return
|
||
fi
|
||
local deps; deps="$(deps_of "$f" | tr '\n' ' ')"
|
||
# 🔴 白名单:MCP 工具层(工具契约)+ 平台核心(AppState/Db/ids/cipher/信封)
|
||
# + 契约面四个域包(handler 直调对象)+ 低代码两层(动态 CRUD 工具)
|
||
# + axum(handler 的 extractor / 信封)+ pglite-rs(ToSql 参数绑定)+ 序列化。
|
||
# **不许** sspf_pack_*(业务包)/ sspf-contract(间接依赖即可)/ sspf-plugin。
|
||
if subset_of "$deps" "sspf-mcp sspf-core sspf-compat-system sspf-compat-permission sspf-compat-workflow sspf-compat-onlinedev sspf-lowcode sspf-lowcode-exec axum pglite-rs serde_json serde_urlencoded"; then
|
||
ok "AR14 sspf-mcp-adapter 依赖干净([$deps])"
|
||
else
|
||
bad "AR14 sspf-mcp-adapter 依赖越界:[$deps] —— 只许 {mcp, core, compat-*, lowcode*, axum, pglite-rs, serde*}"
|
||
fi
|
||
# 第二层:源码不许出现业务包引用
|
||
local src="$CRATES/sspf-mcp-adapter/src"
|
||
if [ -d "$src" ]; then
|
||
local hits
|
||
hits="$(grep -rnE '^[[:space:]]*(pub )?use[[:space:]]+sspf_pack_' "$src" 2>/dev/null || true)"
|
||
if [ -z "$hits" ]; then
|
||
ok "AR14 适配层源码没有 use sspf_pack_*(业务知识没漏进适配层)"
|
||
else
|
||
bad "AR14 适配层源码出现了业务包引用(业务知识漏进适配层):"
|
||
printf '%s\n' "$hits" | sed 's/^/ /'
|
||
fi
|
||
fi
|
||
}
|
||
|
||
# ---------------------------------------------------------------- AR15
|
||
# **M7 删壳后:旧平台路径不许复活**(`crate::platform::…` / `ssw_platform::platform::…`)。
|
||
#
|
||
# 🔴 **为什么需要**:M7 把 `src/backend/src/platform/` 的 38 个转发壳**全删了**,
|
||
# 平台能力的路径变成 `sspf_core::…` / `sspf_compat_<包>::…`。
|
||
# 删除本身是**可逆的**(git 一 revert 就回来了)⇒ 必须有闸门钉住「不许回来」。
|
||
#
|
||
# 🔴 **为什么这条不能靠「编译不过」兜底**:如果有人为了图省事
|
||
# ① 重建 `src/backend/src/platform/mod.rs` + 几个 `pub use` 壳,
|
||
# ② 把 import 改回 `crate::platform::…`,
|
||
# ⇒ **一切照常编译、测试照常全绿**,但架构**已经退回 M2 之前** ——
|
||
# 而 M2–M7 这 7 个批次(几万行搬迁、6 个契约面包)的收益**全部蒸发**,
|
||
# 而且**没有任何闸门会报红**。⇒ 这正是本仓最怕的那类静默退化。
|
||
#
|
||
# 🔴 **判据**(源码级,全仓 Rust 文件):
|
||
# ① 不许出现 `crate::platform::`(壳内引用旧路径);
|
||
# ② 不许出现 `ssw_platform::platform::`(集成测试引用旧路径);
|
||
# ③ 不许存在 `src/backend/src/platform/` 目录(M7 的删除不被回退)。
|
||
#
|
||
# 🔴 **注释不算违规** —— 文档里提到旧路径是**正常**的(迁移记录 / 历史说明)。
|
||
# ⇒ 只判**非注释行**(与 AR10 同一套路)。
|
||
check_ar15() {
|
||
local hits=""
|
||
local roots=()
|
||
[ -d "$KERNEL/src" ] && roots+=("$KERNEL/src")
|
||
[ -d "$KERNEL/tests" ] && roots+=("$KERNEL/tests")
|
||
[ -d "$CRATES" ] && roots+=("$CRATES")
|
||
[ -d "$ROOT/packs" ] && roots+=("$ROOT/packs")
|
||
if [ "${#roots[@]}" -gt 0 ]; then
|
||
hits="$(python3 - "${roots[@]}" <<'PY'
|
||
import os, re, sys
|
||
pat = re.compile(r'(crate::platform::|ssw_platform::platform::)')
|
||
bad = []
|
||
for root in sys.argv[1:]:
|
||
for dirpath, dirnames, files in os.walk(root):
|
||
for fn in files:
|
||
if not fn.endswith('.rs'):
|
||
continue
|
||
p = os.path.join(dirpath, fn)
|
||
try:
|
||
lines = open(p, encoding='utf-8').read().splitlines()
|
||
except OSError:
|
||
continue
|
||
for i, line in enumerate(lines, 1):
|
||
s = line.strip()
|
||
if s.startswith('//'):
|
||
continue # 整行注释(含 //! / ///)
|
||
code = line.split('//', 1)[0]
|
||
if pat.search(code):
|
||
bad.append(f'{p}:{i}: {s}')
|
||
for b in bad:
|
||
print(b)
|
||
PY
|
||
)"
|
||
fi
|
||
# 🔴 第三层:旧目录本身不许复活。
|
||
# ⚠️ **只看「含 .rs 文件」** —— git **不跟踪空目录** ⇒ 自证里
|
||
# `mkdir -p` 出来的空目录在清理后可能残留(rmdir 失败)⇒
|
||
# 若按「目录存在」判 ⇒ 假红(报了一个不存在的违规)。
|
||
# ⇒ 判据 = 「目录里**有** .rs 文件」= 真的有壳被重建了。
|
||
if [ -d "$KERNEL/src/platform" ]; then
|
||
local plat_rs
|
||
plat_rs="$(find "$KERNEL/src/platform" -name '*.rs' -type f 2>/dev/null | head -1)"
|
||
if [ -n "$plat_rs" ]; then
|
||
hits="${hits:+$hits$'\n'}$KERNEL/src/platform: 目录复活(M7 已删除该转发壳层,发现 ${plat_rs})"
|
||
fi
|
||
fi
|
||
if [ -z "$hits" ]; then
|
||
ok "AR15 旧平台路径未复活(无 crate::platform:: / ssw_platform::platform:: / platform/ 目录)"
|
||
else
|
||
bad "AR15 旧平台路径复活(M7 已删转发壳层 ⇒ 平台能力只能走 sspf_core:: / sspf_compat_*/::):"
|
||
printf '%s\n' "$hits" | sed 's/^/ /'
|
||
fi
|
||
}
|
||
|
||
# ---------------------------------------------------------------- PACK1
|
||
# **spec 单一真源**:`modules/<app>.rs` 只许做转发,不许自己写 spec。
|
||
#
|
||
# 🔴 背景:批次 12 之前 `modules/asset.rs` 与 `packs/asset/src/lib.rs` 是
|
||
# **两份逐字拷贝** ⇒ 改一处忘另一处 ⇒ **静默**不一致,且当时没有任何闸门比对。
|
||
# 现在 spec 的真源在包里,模块文件只 `pub use` 转发。
|
||
# ⇒ 本闸门要防的是「有人又在模块文件里写了一份」——
|
||
# 那等于回到两份拷贝,而且**看起来一切正常**(编译过、测试过)。
|
||
#
|
||
# 判据(对每个「模块文件里有 `pub use sspf_pack_`」的模块):
|
||
# · 模块文件里**不许**出现 `: EntitySpec =` / `: MenuSpec =` 的定义
|
||
# (`pub use` 转发不算定义 —— 它没有 `=` 字面量);
|
||
# · 与它同 app_code 的包**必须存在**且**确实声明了** EntitySpec(否则转发了个空)。
|
||
check_pack1() {
|
||
local n=0
|
||
for mf in "$MODULES_DIR"/*.rs; do
|
||
[ -f "$mf" ] || continue
|
||
case "$(basename "$mf")" in mod.rs) continue ;; esac
|
||
grep -q "pub use sspf_pack_" "$mf" 2>/dev/null || continue
|
||
n=$((n + 1))
|
||
local name; name="$(basename "$mf" .rs)"
|
||
# ① 模块文件里不许有 spec / menu 的**定义**(`= EntitySpec {` / `= MenuSpec {`)
|
||
local defs
|
||
defs="$(grep -nE '=[[:space:]]*(EntitySpec|MenuSpec)[[:space:]]*\{' "$mf" 2>/dev/null || true)"
|
||
if [ -n "$defs" ]; then
|
||
bad "PACK1 ${name}.rs 既 re-export 又**自己定义**了 spec(两份拷贝回来了):"
|
||
printf '%s\n' "$defs" | sed 's/^/ /'
|
||
continue
|
||
fi
|
||
# ② 包必须存在,且真的声明了 EntitySpec
|
||
local lib="$ROOT/packs/$name/src/lib.rs"
|
||
if [ ! -f "$lib" ]; then
|
||
bad "PACK1 ${name}.rs 从 sspf_pack_${name} 转发,但 packs/${name}/src/lib.rs 不存在"
|
||
continue
|
||
fi
|
||
if ! grep -qE ':[[:space:]]*EntitySpec[[:space:]]*=' "$lib" 2>/dev/null; then
|
||
bad "PACK1 packs/${name}/src/lib.rs 没有 EntitySpec 声明(模块转发了个空)"
|
||
continue
|
||
fi
|
||
ok "PACK1 ${name}.rs 只做 re-export,spec 真源在 packs/${name}/src/lib.rs"
|
||
done
|
||
if [ "$n" -eq 0 ]; then
|
||
# 🔴 2026-11-04 清理:没有业务模块可检查时**不能跳过**(假闸门)。
|
||
# 正向钉住「modules/ 只剩 mod.rs」;反自证 3/14 注入的临时模块仍会
|
||
# 在上面的循环里被抓到(它带 `pub use sspf_pack_` ⇒ n > 0)。
|
||
local stray
|
||
stray="$(find "$MODULES_DIR" -maxdepth 1 -name '*.rs' ! -name 'mod.rs' -print 2>/dev/null)"
|
||
if [ -n "$stray" ]; then
|
||
bad "PACK1 平台包零业务:modules/ 出现业务适配器(应在业务仓):\n${stray}"
|
||
else
|
||
ok "PACK1 平台包零业务:modules/ 只剩 mod.rs(无 spec 两份拷贝的风险)"
|
||
fi
|
||
fi
|
||
return 0
|
||
}
|
||
|
||
# ---------------------------------------------------------------- MEM1
|
||
# 只看**代码行**:去掉 `//` 之后的注释、`//!` / `///` 文档注释、以及字符串里的反引号示例。
|
||
check_mem1() {
|
||
local hits
|
||
hits="$(python3 - "$ROOT" <<'PY'
|
||
import os, re, sys
|
||
root = sys.argv[1]
|
||
pat = re.compile(r'SELECT\s+\*', re.I)
|
||
bad = []
|
||
for base in ('src/backend/src', 'crates'):
|
||
for dirpath, dirnames, files in os.walk(os.path.join(root, base)):
|
||
dirnames[:] = [d for d in dirnames if d not in ('target', 'tests', 'data')]
|
||
for fn in files:
|
||
if not fn.endswith('.rs'):
|
||
continue
|
||
p = os.path.join(dirpath, fn)
|
||
# 文件名以 _it.rs 结尾的是集成测试,不查
|
||
if fn.endswith('_it.rs'):
|
||
continue
|
||
try:
|
||
lines = open(p, encoding='utf-8').read().splitlines()
|
||
except OSError:
|
||
continue
|
||
in_test = False
|
||
for i, line in enumerate(lines, 1):
|
||
s = line.strip()
|
||
if s.startswith('#[cfg(test)]'):
|
||
in_test = True
|
||
if in_test:
|
||
continue
|
||
code = line.split('//', 1)[0]
|
||
if pat.search(code):
|
||
bad.append(f'{p}:{i}: {s}')
|
||
for b in bad:
|
||
print(b)
|
||
PY
|
||
)"
|
||
if [ -z "$hits" ]; then
|
||
ok "MEM1 无非注释的 SELECT *(全表读进 Vec 会直接超内存预算)"
|
||
else
|
||
bad "MEM1 发现 SELECT *(终端产品内存预算 ≤120MB,禁止整表载入):"
|
||
printf '%s\n' "$hits" | sed 's/^/ /'
|
||
fi
|
||
}
|
||
|
||
# ---------------------------------------------------------------- MEM2
|
||
# 近似检查:出现 `Mutex<HashMap` 的静态缓存,同文件必须有 MAX_ / CAPACITY 常量。
|
||
check_mem2() {
|
||
local hits
|
||
hits="$(python3 - "$ROOT" <<'PY'
|
||
import os, re, sys
|
||
root = sys.argv[1]
|
||
cache = re.compile(r'Mutex\s*<\s*(std::collections::)?HashMap')
|
||
cap = re.compile(r'\b(MAX|CAPACITY|LIMIT)_[A-Z0-9_]+\b')
|
||
bad = []
|
||
for base in ('src/backend/src', 'crates'):
|
||
for dirpath, dirnames, files in os.walk(os.path.join(root, base)):
|
||
dirnames[:] = [d for d in dirnames if d not in ('target', 'tests', 'data')]
|
||
for fn in files:
|
||
if not fn.endswith('.rs') or fn.endswith('_it.rs'):
|
||
continue
|
||
p = os.path.join(dirpath, fn)
|
||
try:
|
||
text = open(p, encoding='utf-8').read()
|
||
except OSError:
|
||
continue
|
||
if cache.search(text) and not cap.search(text):
|
||
for i, line in enumerate(text.splitlines(), 1):
|
||
if cache.search(line):
|
||
bad.append(f'{p}:{i}: {line.strip()}')
|
||
break
|
||
for b in bad:
|
||
print(b)
|
||
PY
|
||
)"
|
||
if [ -z "$hits" ]; then
|
||
ok "MEM2 缓存均有上限常量(无界缓存 = 慢性内存泄漏)"
|
||
else
|
||
bad "MEM2 发现疑似无界缓存(同文件没有 MAX_/CAPACITY_ 常量):"
|
||
printf '%s\n' "$hits" | sed 's/^/ /'
|
||
fi
|
||
}
|
||
|
||
# ---------------------------------------------------------------- AR16
|
||
# **内核只是库,可执行的装配只有一个,集成测试不挂在内核包里**(2026-11-04 定)。
|
||
#
|
||
# 🔴 **为什么需要**:这三件事在 2026-11-04 之前是**反的**,而且没有任何闸门会红:
|
||
# ① `src/backend` 自带 `[[bin]]` ⇒ 内核既是库又是服务器。谁想复用内核
|
||
# (CLI / MCP 适配器 / 另一个应用 / 测试)都得连带享受一份「启动即开库、
|
||
# 即绑端口」的语义;`cargo add` 一个库顺带下载一个服务器。
|
||
# ② 37 个集成测试(`*_it.rs`)摆在 `src/backend/tests/` ⇒ 它们测的是
|
||
# 「装配好的平台」(内核 + 契约面 + 业务包 + 路由),却被登记成**内核的实现细节**:
|
||
# 内核改一次名/拆一次包,37 个文件跟着搬(历史上真搬过 3 次)。
|
||
# ③ 于是「默认装配」散落在各处:进程级的事(读环境变量 / 开库 / 种子 / 绑端口 /
|
||
# 优雅停机)写在 `main.rs` 里,而 `main.rs` 在内核包里 ⇒ 没有一个地方叫「应用」。
|
||
# ⇒ 现在:内核 = lib;`crates/sspf-admin` = 默认装配(bin);`crates/tests` = 测试宿主。
|
||
#
|
||
# 判据:
|
||
# ① `src/backend/Cargo.toml` 里**不许**有 `[[bin]]`;
|
||
# ② `src/backend/tests/` 里**不许**有 `.rs`(测试宿主在 `crates/tests/tests/`);
|
||
# ③ `crates/sspf-admin/Cargo.toml` **必须存在**且声明 `[[bin]]`(默认装配不许被删)。
|
||
check_ar16() {
|
||
local hits=""
|
||
local kernel_toml="$KERNEL/Cargo.toml"
|
||
if [ -f "$kernel_toml" ]; then
|
||
local binln
|
||
binln="$(grep -nE '^\[\[bin\]\]' "$kernel_toml" 2>/dev/null | head -1)"
|
||
if [ -n "$binln" ]; then
|
||
hits="src/backend/Cargo.toml:${binln%%:*}: 内核声明了 [[bin]](内核只能是 lib ⇒ 装配归 crates/sspf-admin)"
|
||
fi
|
||
fi
|
||
# ⚠️ 只看「有 .rs 文件」:git 不跟踪空目录 ⇒ 空目录残留不算违规(与 AR15 同款)。
|
||
if [ -d "$KERNEL/tests" ]; then
|
||
local trs
|
||
trs="$(find "$KERNEL/tests" -name '*.rs' -type f 2>/dev/null | head -3)"
|
||
if [ -n "$trs" ]; then
|
||
hits="${hits:+$hits$'\n'}src/backend/tests: 集成测试回到了内核包(宿主是 crates/tests/tests/):$(printf '%s' "$trs" | tr '\n' ' ')"
|
||
fi
|
||
fi
|
||
local admin="$CRATES/sspf-admin/Cargo.toml"
|
||
if [ ! -f "$admin" ]; then
|
||
hits="${hits:+$hits$'\n'}crates/sspf-admin/Cargo.toml: 不存在(默认装配缺失 ⇒ 全仓没有可执行入口)"
|
||
elif ! grep -qE '^\[\[bin\]\]' "$admin" 2>/dev/null; then
|
||
hits="${hits:+$hits$'\n'}crates/sspf-admin/Cargo.toml: 没有 [[bin]](默认装配必须产出可执行文件)"
|
||
fi
|
||
|
||
if [ -z "$hits" ]; then
|
||
ok "AR16 内核只有 lib + 默认装配在 crates/sspf-admin + 集成测试在 crates/tests"
|
||
else
|
||
bad "AR16 内核/装配/测试的边界被打破:"
|
||
printf '%s\n' "$hits" | sed 's/^/ /'
|
||
fi
|
||
}
|
||
|
||
# ---------------------------------------------------------------- AR17
|
||
# 🔴 **平台包零业务:依赖清单里不许有任何业务包 / 选装开关**(2026-11-04 清理)。
|
||
#
|
||
# 原判据是「示例包依赖必须 optional + default 不开 example-packs」。清理后示例包、
|
||
# `example-packs` feature、`[features]` 段**全部退役** ⇒ 那条判据在空清单上恒真,
|
||
# 反自证也没有探针可用(实测自证 12/14 直接红)。
|
||
#
|
||
# 新判据(清单层面,秒级,不跑 cargo tree):
|
||
# ① 内核 / 门面 / sspf-admin / sspf-tests / workspace 五个 Cargo.toml 的
|
||
# **非注释行**里不许出现 `sspf-pack-*` 依赖或 `example-packs` feature;
|
||
# ② `src/backend/Cargo.toml` 的 `>>>GEN:PACK_DEPS` 标记段必须恒空;
|
||
# ③ `packs/` 目录不许存在(与 AR2 互补,AR2 看依赖、这里看目录)。
|
||
# ⇒ 业务仓只依赖门面 `sspf`,通过 `Platform::packs()` 注入,不开任何平台 feature。
|
||
check_ar17() {
|
||
local hits=""
|
||
local toml="$KERNEL/Cargo.toml"
|
||
[ -f "$toml" ] || { bad "AR17 内核 Cargo.toml 不存在"; return; }
|
||
|
||
# ① 五个清单:跳过注释行(注释里讲「不许有 sspf-pack-*」是合法的)
|
||
local f h
|
||
for f in "$KERNEL/Cargo.toml" "$CRATES/sspf/Cargo.toml" \
|
||
"$CRATES/sspf-admin/Cargo.toml" "$CRATES/tests/Cargo.toml" "$ROOT/Cargo.toml"; do
|
||
[ -f "$f" ] || continue
|
||
h="$(awk '!/^[[:space:]]*#/ && /sspf-pack-|example-packs/ {print NR": "$0}' "$f" 2>/dev/null || true)"
|
||
if [ -n "$h" ]; then
|
||
hits="${hits:+$hits$'\n'}${f#$ROOT/}: 平台仓不许有业务包依赖 / example-packs feature:$'\n'$(printf '%s\n' "$h" | sed 's/^/ /')"
|
||
fi
|
||
done
|
||
|
||
# ② 生成段恒空
|
||
local gen
|
||
gen="$(awk '/>>>GEN:PACK_DEPS/{f=1;next} /<<<GEN:PACK_DEPS/{f=0} f && NF' "$toml" 2>/dev/null || true)"
|
||
if [ -n "$gen" ]; then
|
||
hits="${hits:+$hits$'\n'}src/backend/Cargo.toml: >>>GEN:PACK_DEPS 段必须恒空,实际:$'\n'$(printf '%s\n' "$gen" | sed 's/^/ /')"
|
||
fi
|
||
|
||
# ③ packs/ 目录
|
||
if [ -d "$ROOT/packs" ]; then
|
||
hits="${hits:+$hits$'\n'}平台仓出现 packs/ 目录 ⇒ 业务包请用 sspf::Platform::packs() 注入"
|
||
fi
|
||
|
||
if [ -z "$hits" ]; then
|
||
ok "AR17 平台包零业务:5 个 Cargo.toml 无业务包依赖 / feature,GEN 段恒空,packs/ 不存在"
|
||
else
|
||
bad "AR17 平台包里混进了业务包(业务仓会被拖进示例包):"
|
||
printf '%s\n' "$hits" | sed 's/^/ /'
|
||
fi
|
||
}
|
||
|
||
# ---------------------------------------------------------------- AR18
|
||
# **门面 crate 不得出现任何业务字面量**(2026-11-04 标准平台包)。
|
||
#
|
||
# 🔴 **为什么需要**:门面是「平台 ↔ 业务」的**唯一汇聚点** —— 它既认识平台的 19 个
|
||
# crate,又会被业务仓依赖。正因为它两边都碰得到,「顺手写一句业务」的成本极低:
|
||
# `${业务表}_list` 的默认路由、`/api/ssw/...` 的示例端点、某个租户的写死分支……
|
||
# 这类代码**不会让任何测试变红**,但平台包就从「可复用」退化成「那一个业务的」。
|
||
#
|
||
# 判据:`crates/sspf/src/**` 里**任何一行**(含注释)不得出现:
|
||
# - 业务仓名 `tdc`
|
||
# - 本仓 4 个示例包的表名(`asset_data_resource` / `demo_item` /
|
||
# `shop_product` / `book_shop_book`)
|
||
# - 面 A 的端点前缀 `/api/ssw/`
|
||
#
|
||
# 🔴 **注释也扫**(故意的):门面里出现业务名,读者就会以为平台认识它。
|
||
# 要写业务示例 ⇒ 写在 `docs/` 或业务仓自己那边。
|
||
check_ar18() {
|
||
local dir="$CRATES/sspf/src"
|
||
[ -d "$dir" ] || { skip "AR18 门面 crate 不存在(crates/sspf)"; return; }
|
||
local hits
|
||
hits="$(python3 - "$dir" <<'PY'
|
||
import os, re, sys
|
||
pat = re.compile(r'(?i)(tdc|asset_data_resource|demo_item|shop_product|book_shop_book|/api/ssw/)')
|
||
bad = []
|
||
for root in sys.argv[1:]:
|
||
for dirpath, _, files in os.walk(root):
|
||
for fn in files:
|
||
if not fn.endswith('.rs'):
|
||
continue
|
||
p = os.path.join(dirpath, fn)
|
||
try:
|
||
lines = open(p, encoding='utf-8').read().splitlines()
|
||
except OSError:
|
||
continue
|
||
for i, line in enumerate(lines, 1):
|
||
if pat.search(line):
|
||
bad.append(f'{p}:{i}: {line.strip()}')
|
||
for b in bad:
|
||
print(b)
|
||
PY
|
||
)"
|
||
if [ -z "$hits" ]; then
|
||
ok "AR18 门面里没有业务字面量(无业务仓名 / 业务表名 / 面 A 端点)"
|
||
else
|
||
bad "AR18 门面里出现业务字面量(平台包退化成「那一个业务的」):"
|
||
printf '%s\n' "$hits" | sed 's/^/ /'
|
||
fi
|
||
}
|
||
|
||
# ---------------------------------------------------------------- AR19
|
||
# **唯一装配链**(2026-11-04 v0.3.0 两阶段装配)。
|
||
#
|
||
# 🔴 **为什么需要**:业务自带状态的 `Router<()>` 现在能在 merge 点注入,
|
||
# 「自己再抄一遍 fallback + layer + with_state」的诱惑变大了 —— 抄错顺序时
|
||
# axum 不报编译错,404 兜底只是悄悄失去 catch-all 保护,且**测试全绿**。
|
||
#
|
||
# 判据(只看 `src/backend/src/routes.rs` 的**非注释**代码行):
|
||
# - `pub fn build_app_with` 恰好 1 处;
|
||
# - `.layer(catch_all())` 恰好 1 处;
|
||
# - `.fallback(` / `.fallback_service(` 恰好 2 处(`if/else` 互斥分支 ⇒ 恒只有一个生效);
|
||
# - `Extras.router_owned` 的文档注释必须含「不许自带 fallback」。
|
||
check_ar19() {
|
||
local file="$KERNEL/src/routes.rs"
|
||
[ -f "$file" ] || { skip "AR19 routes.rs 不存在"; return; }
|
||
local hits
|
||
hits="$(python3 - "$file" <<'PY'
|
||
import re, sys
|
||
lines = open(sys.argv[1], encoding='utf-8').read().splitlines()
|
||
code = [(i, l) for i, l in enumerate(lines, 1) if not l.lstrip().startswith('//')]
|
||
def hits(pat):
|
||
return [(i, l) for i, l in code if re.search(pat, l)]
|
||
bad = []
|
||
n = hits(r'pub fn build_app_with\b')
|
||
if len(n) != 1:
|
||
bad.append(f'unique-chain: pub fn build_app_with 应恰好 1 处,实际 {len(n)} 处')
|
||
n = hits(r'\.layer\(catch_all\(\)\)')
|
||
if len(n) != 1:
|
||
bad.append(f'unique-catch-all: .layer(catch_all()) 应恰好 1 处,实际 {len(n)} 处')
|
||
n = hits(r'\.fallback(_service)?\(')
|
||
if len(n) != 2:
|
||
bad.append(f'single-fallback: fallback 调用点应恰好 2 处(互斥分支),实际 {len(n)} 处')
|
||
doc = '\n'.join(lines)
|
||
m = re.search(r'((?:^\s*///.*\n)+)\s*pub router_owned:', doc, re.M)
|
||
if not m or '不许自带 fallback' not in m.group(1):
|
||
bad.append('router_owned-doc: Extras.router_owned 注释缺「不许自带 fallback」约定')
|
||
for b in bad:
|
||
print(b)
|
||
PY
|
||
)"
|
||
if [ -z "$hits" ]; then
|
||
ok "AR19 唯一装配链(build_app_with / catch_all / 单兜底 / 自带状态路由注释)"
|
||
else
|
||
bad "AR19 装配链被抄了第二遍(或兜底挂法退化):"
|
||
printf '%s\n' "$hits" | sed 's/^/ /'
|
||
fi
|
||
}
|
||
|
||
# ---------------------------------------------------------------- AR20
|
||
# **库入口的锁与归一纪律**(2026-11-04 v0.5.0:`query_json_raw` / `query_rows` / `lock_owned`)。
|
||
#
|
||
# 🔴 **为什么需要**:新增的 raw 入口是为了让厚业务仓(`tdc-rs`)把库操作收进
|
||
# **同一把 `Db.lock`**。它一旦被「顺手加上归一」或「自己造第二把锁」,
|
||
# 后果都不是报错,而是**静默变形状 / 静默并发交错**:
|
||
# - raw 路径混进 `normalize_json_keys` ⇒ 业务仓 132 条端点的 JSON 键漂移;
|
||
# - 新入口不持 `self.lock` ⇒ 平台与业务各开一把锁,并发写同一个 PGlite 交错。
|
||
#
|
||
# 判据(扫 `crates/sspf-store/src/db.rs` 的函数体):
|
||
# 1. `query_json_raw` 里**不许**出现 `normalize_json_keys`;
|
||
# 2. `query_json_raw` **必须**走共用的 `query_json_inner_raw`(不许复制一份 SQL 包裹),
|
||
# 且**不许**调会归一的 `query_json_inner`;
|
||
# 3. 共用段 `query_json_inner_raw` 自身也不许归一(否则两条路都归一了);
|
||
# 4. 所有公开库入口都持 `self.lock`;`lock_owned` 必须基于 `self.lock`(不是第二把锁)。
|
||
check_ar20() {
|
||
local file="$ROOT/crates/sspf-store/src/db.rs"
|
||
[ -f "$file" ] || { skip "AR20 db.rs 不存在"; return; }
|
||
local hits
|
||
hits="$(python3 - "$file" <<'PY'
|
||
import re
|
||
import sys
|
||
|
||
src = open(sys.argv[1], encoding="utf-8").read()
|
||
|
||
|
||
def body(name):
|
||
"""取 `<[pub] async fn> <name>` 的函数体(花括号配平)。
|
||
|
||
🔴 **允许不带 `pub`**:`query_json_inner_raw` 是私有的共用段,
|
||
只认 `pub async fn` 会把它判成「不存在」⇒ 尺子自己先红。
|
||
"""
|
||
m = re.search(r"(?:\bpub )?\basync fn " + name + r"\b", src)
|
||
if not m:
|
||
return None
|
||
i = src.find("{", m.end())
|
||
if i < 0:
|
||
return None
|
||
depth, j = 0, i
|
||
while j < len(src):
|
||
c = src[j]
|
||
if c == "{":
|
||
depth += 1
|
||
elif c == "}":
|
||
depth -= 1
|
||
if depth == 0:
|
||
return src[i : j + 1]
|
||
j += 1
|
||
return None
|
||
|
||
|
||
bad = []
|
||
|
||
raw = body("query_json_raw")
|
||
if raw is None:
|
||
bad.append("raw-missing: 找不到 async fn query_json_raw")
|
||
else:
|
||
if "normalize_json_keys" in raw:
|
||
bad.append("raw-normalizes: query_json_raw 里出现 normalize_json_keys(raw 必须不归一)")
|
||
if "query_json_inner_raw" not in raw:
|
||
bad.append("raw-not-shared: query_json_raw 没走共用的 query_json_inner_raw(SQL 包裹会漂成两份)")
|
||
if re.search(r"query_json_inner\s*\(", raw):
|
||
bad.append("raw-goes-through-normalizing-path: query_json_raw 调了 query_json_inner(那条会归一)")
|
||
|
||
shared = body("query_json_inner_raw")
|
||
if shared is None:
|
||
bad.append("shared-missing: 找不到 query_json_inner_raw(raw 与归一必须共用同一段)")
|
||
elif "normalize_json_keys" in shared:
|
||
bad.append("shared-normalizes: query_json_inner_raw 里出现 normalize_json_keys")
|
||
|
||
for fn in (
|
||
"query_json",
|
||
"query_json_params",
|
||
"query_json_raw",
|
||
"query_rows",
|
||
"exec",
|
||
"exec_params",
|
||
"scalar_text",
|
||
"begin",
|
||
):
|
||
b = body(fn)
|
||
if b is None:
|
||
bad.append(f"lock-fn-missing: 找不到 {fn}")
|
||
elif "self.lock" not in b:
|
||
bad.append(f"lock-missing: {fn} 没有持 self.lock(并发会绕过平台串行域)")
|
||
|
||
lo = body("lock_owned")
|
||
if lo is None:
|
||
bad.append("lock-owned-missing: 找不到 async fn lock_owned")
|
||
elif "self.lock" not in lo:
|
||
bad.append("lock-owned-different: lock_owned 没基于 self.lock(等于造了第二把锁)")
|
||
|
||
for b in bad:
|
||
print(b)
|
||
PY
|
||
)"
|
||
if [ -z "$hits" ]; then
|
||
ok "AR20 库入口纪律(raw 不归一 / 共用包裹段 / 全部持同一把 lock)"
|
||
else
|
||
bad "AR20 库入口纪律被破坏(归一漂移或第二把锁):"
|
||
printf '%s\n' "$hits" | sed 's/^/ /'
|
||
fi
|
||
}
|
||
|
||
# ---------------------------------------------------------------- 反自证
|
||
# 🔴 永远返回「干净」的尺子 = 没有尺子。造明知违规的输入,必须被抓到。
|
||
self_test() {
|
||
local rc=0
|
||
|
||
echo "── 反自证 1/15:造一个依赖越界的假 pack,AR2 必须报 ❌ ──"
|
||
local tmp="$ROOT/packs/__arch_selftest__"
|
||
mkdir -p "$tmp"
|
||
cat > "$tmp/Cargo.toml" <<'TOML'
|
||
[package]
|
||
name = "arch-selftest"
|
||
version = "0.0.0"
|
||
edition = "2021"
|
||
|
||
[dependencies]
|
||
sspf-sdk = { path = "../../crates/sspf-sdk" }
|
||
axum = "0.8"
|
||
TOML
|
||
local before=$FAIL
|
||
check_ar2 >/dev/null 2>&1
|
||
local caught=0
|
||
[ "$FAIL" -gt "$before" ] && caught=1
|
||
rm -rf "$tmp"
|
||
# 🔴 2026-11-04 清理:`mkdir -p packs/__arch_selftest__` 会把 `packs/` 一起造出来,
|
||
# 只删子目录会留下**空 packs/** ⇒ AR2/AR17 的零业务判据当场红。
|
||
# ⇒ 用 rmdir(只删空目录,绝不动真文件)把探针外壳收干净。
|
||
rmdir "$ROOT/packs" 2>/dev/null || true
|
||
FAIL=$before
|
||
if [ "$caught" -eq 1 ]; then
|
||
echo "✅ 反自证通过:AR2 抓到了 axum 依赖"
|
||
else
|
||
echo "❌ 反自证失败:AR2 没抓到明显违规 ⇒ 这把尺子是假的"
|
||
rc=1
|
||
fi
|
||
|
||
echo "── 反自证 2/15:往平台层塞一个 use sspf_pack_*,AR9 必须报 ❌ ──"
|
||
#
|
||
# 🔴 **为什么必须自证 AR9**:它的判据是 `grep 目录`。
|
||
# 目录名写错 / 路径拼错 ⇒ `grep` 永远返回空 ⇒ **永远"通过"**。
|
||
# 这类尺子比没有更危险(它给出虚假的安全感)。
|
||
# 🔴🔴 **M7 起:平台层**只有真源**(`src/backend/src/platform/` 的 38 个转发壳已删)
|
||
# ⇒ 注入点只剩真源一处。但**契约面各包也要注入**(AR9 扫的是整个
|
||
# `PLAT_SRC_DIRS`,含 `sspf-compat-*/src`)—— 只注入 core 不注入 compat
|
||
# ⇒ 单点注入会漏判「闸门只扫 core 不扫 compat」⇒ **两处都注入**、
|
||
# 且**两处都被抓到**才算尺子有效。
|
||
local a9core="$CRATES/sspf-core/src/__ar9_selftest.rs"
|
||
local a9compat="$CRATES/sspf-compat-system/src/__ar9_selftest.rs"
|
||
local a9ok=0
|
||
if [ -d "$CRATES/sspf-core/src" ] || [ -d "$CRATES/sspf-compat-system/src" ]; then
|
||
[ -d "$CRATES/sspf-core/src" ] && printf 'use sspf_pack_asset::DATA_RESOURCE_SPEC;\n' > "$a9core"
|
||
[ -d "$CRATES/sspf-compat-system/src" ] && printf 'use sspf_pack_asset::DATA_RESOURCE_SPEC;\n' > "$a9compat"
|
||
local a9out
|
||
a9out="$(check_ar9 2>&1 || true)"
|
||
rm -f "$a9core" "$a9compat"
|
||
# 🔴 **按路径分别验**:必须证明闸门**两处都看得到** ——
|
||
# 只验「输出里有 __ar9_selftest」不够(单处抓到会误判成两处都抓到)。
|
||
local a9need=0 a9c=0
|
||
if [ -d "$CRATES/sspf-core/src" ]; then
|
||
a9need=$((a9need+1))
|
||
echo "$a9out" | grep -q "sspf-core/src/__ar9_selftest" && a9c=$((a9c+1))
|
||
fi
|
||
if [ -d "$CRATES/sspf-compat-system/src" ]; then
|
||
a9need=$((a9need+1))
|
||
echo "$a9out" | grep -q "sspf-compat-system/src/__ar9_selftest" && a9c=$((a9c+1))
|
||
fi
|
||
[ "$a9need" -gt 0 ] && [ "$a9c" -ge "$a9need" ] && a9ok=1
|
||
fi
|
||
if [ "$a9ok" -eq 1 ]; then
|
||
echo "✅ 反自证通过:AR9 抓到了真源与契约面包里的 use sspf_pack_*"
|
||
else
|
||
echo "❌ 反自证失败:AR9 没抓到平台层里的业务包引用(或漏扫了真源/契约面)⇒ 尺子是假的"
|
||
rc=1
|
||
fi
|
||
|
||
echo "── 反自证 3/15:往 re-export 的模块里塞一份 spec,PACK1 必须报 ❌ ──"
|
||
#
|
||
# 🔴 造在**临时模块文件**上(不动真文件):只要它同时有 `pub use sspf_pack_`
|
||
# 和 `= EntitySpec {`,PACK1 就必须红。
|
||
local mprobe="$MODULES_DIR/__pack1_selftest.rs"
|
||
if [ -d "$MODULES_DIR" ]; then
|
||
cat > "$mprobe" <<'RS'
|
||
pub use sspf_pack_asset::DATA_RESOURCE_SPEC;
|
||
pub const DUP_SPEC: EntitySpec = EntitySpec { entity: "Dup", table: "dup", .. };
|
||
RS
|
||
before=$FAIL
|
||
check_pack1 >/dev/null 2>&1
|
||
caught=0
|
||
[ "$FAIL" -gt "$before" ] && caught=1
|
||
rm -f "$mprobe"
|
||
FAIL=$before
|
||
if [ "$caught" -eq 1 ]; then
|
||
echo "✅ 反自证通过:PACK1 抓到了「既 re-export 又自己定义 spec」"
|
||
else
|
||
echo "❌ 反自证失败:PACK1 没抓到两份拷贝 ⇒ 尺子是假的"
|
||
rc=1
|
||
fi
|
||
else
|
||
echo "⏭ 跳过 PACK1 反自证(业务模块目录不存在)"
|
||
fi
|
||
|
||
echo "── 反自证 4/15:往 sspf-plugin 塞 axum 依赖,AR8 必须报 ❌ ──"
|
||
local pfile="$CRATES/sspf-plugin/Cargo.toml"
|
||
if [ -f "$pfile" ]; then
|
||
cp "$pfile" "$pfile.bak"
|
||
printf 'axum = "0.8"\n' >> "$pfile"
|
||
before=$FAIL
|
||
check_ar8 >/dev/null 2>&1
|
||
caught=0
|
||
[ "$FAIL" -gt "$before" ] && caught=1
|
||
mv "$pfile.bak" "$pfile"
|
||
FAIL=$before
|
||
if [ "$caught" -eq 1 ]; then
|
||
echo "✅ 反自证通过:AR8 抓到了装载器里的 axum 依赖"
|
||
else
|
||
echo "❌ 反自证失败:AR8 没抓到装载器里的 axum ⇒ 尺子是假的"
|
||
rc=1
|
||
fi
|
||
else
|
||
echo "⏭ 跳过 AR8 反自证(sspf-plugin 不存在)"
|
||
fi
|
||
|
||
echo "── 反自证 5/15:往平台层塞 crate::platform::compat,AR10 必须报 ❌ ──"
|
||
#
|
||
# 🔴 **必须自证 AR10**:它的判据是「扫平台层目录找契约面引用」。
|
||
# 目录名写错 / 路径拼错 ⇒ 扫描永远返回空 ⇒ **永远"通过"** ⇒ 虚假安全感。
|
||
# 而且这条判据守护的是**拆 crate 的前置条件** —— 它一旦失效,后续批次才炸。
|
||
# 🔴🔴 **M7 起注入两处**(平台核心真源 + 契约面真源),与 2/6 同理:单点注入会漏判。
|
||
# ⚠️ 契约面**自己**引用 `compat::` 是合法的(面 B 内部互引)⇒ AR10 的
|
||
# Python 扫描会跳过名为 `compat` 的子目录 —— 但现在契约面在**独立 crate**里
|
||
# ⇒ 目录里**没有** `compat` 子目录 ⇒ 注入到 `sspf-compat-system/src/` 会被抓到。
|
||
local a10core="$CRATES/sspf-core/src/__ar10_selftest.rs"
|
||
local a10compat="$CRATES/sspf-compat-system/src/__ar10_selftest.rs"
|
||
local a10ok=0
|
||
if [ -d "$CRATES/sspf-core/src" ] || [ -d "$CRATES/sspf-compat-system/src" ]; then
|
||
[ -d "$CRATES/sspf-core/src" ] && printf 'use crate::platform::compat::helper::current_user;\n' > "$a10core"
|
||
[ -d "$CRATES/sspf-compat-system/src" ] && printf 'use crate::platform::compat::helper::current_user;\n' > "$a10compat"
|
||
local a10out
|
||
a10out="$(check_ar10 2>&1 || true)"
|
||
rm -f "$a10core" "$a10compat"
|
||
local a10need=0 a10c=0
|
||
if [ -d "$CRATES/sspf-core/src" ]; then
|
||
a10need=$((a10need+1))
|
||
echo "$a10out" | grep -q "sspf-core/src/__ar10_selftest" && a10c=$((a10c+1))
|
||
fi
|
||
if [ -d "$CRATES/sspf-compat-system/src" ]; then
|
||
a10need=$((a10need+1))
|
||
echo "$a10out" | grep -q "sspf-compat-system/src/__ar10_selftest" && a10c=$((a10c+1))
|
||
fi
|
||
[ "$a10need" -gt 0 ] && [ "$a10c" -ge "$a10need" ] && a10ok=1
|
||
fi
|
||
if [ "$a10ok" -eq 1 ]; then
|
||
echo "✅ 反自证通过:AR10 抓到了真源里的 crate::platform::compat"
|
||
else
|
||
echo "❌ 反自证失败:AR10 没抓到平台层的契约面反向依赖(或漏扫了真源)⇒ 尺子是假的"
|
||
rc=1
|
||
fi
|
||
|
||
echo "── 反自证 6/15:往契约面底座塞 use super::system,AR11 必须报 ❌ ──"
|
||
#
|
||
# 🔴🔴 **M7 起底座只有一处**:真源 `crates/sspf-compat-core/src/helper.rs`
|
||
# (转发壳 `src/backend/src/platform/compat/helper.rs` 已随 M7 删除)。
|
||
# ⇒ 注入点只剩真源一处。
|
||
# 做法:备份真文件 → 追加违规行 → 跑判据 → 还原(helper.rs 是活文件)。
|
||
local a11ok=0
|
||
local a11core="$CRATES/sspf-compat-core/src/helper.rs"
|
||
local a11need=0 a11c=0 a11out
|
||
if [ -f "$a11core" ]; then
|
||
cp "$a11core" "$a11core.bak" && printf '\nuse super::system::menu_node;\n' >> "$a11core" && a11need=$((a11need+1))
|
||
a11out="$(check_ar11 2>&1 || true)"
|
||
[ -f "$a11core.bak" ] && mv "$a11core.bak" "$a11core"
|
||
[ -f "$a11core" ] && { echo "$a11out" | grep -q "sspf-compat-core/src/helper.rs" && a11c=$((a11c+1)); }
|
||
[ "$a11need" -gt 0 ] && [ "$a11c" -ge "$a11need" ] && a11ok=1
|
||
fi
|
||
if [ "$a11ok" -eq 1 ]; then
|
||
echo "✅ 反自证通过:AR11 抓到了底座真源里的 use super::system"
|
||
else
|
||
echo "❌ 反自证失败:AR11 没抓到底座的反向依赖(或漏扫了真源)⇒ 尺子是假的"
|
||
rc=1
|
||
fi
|
||
|
||
echo "── 反自证 7/15:往壳里写 crate::platform::,AR15 必须报 ❌ ──"
|
||
#
|
||
# 🔴 **必须自证 AR15**:删掉 `platform/` 转发壳之后,旧路径就**没有编译器**兜底了
|
||
# —— 只要有人重建壳目录并把 import 改回去,**一切照常编译、测试照常全绿**,
|
||
# 而 M2–M7 的架构收益全部蒸发。⇒ 必须有一条闸门钉住「不许回来」。
|
||
# 🔴 **注入三处**(证明三层判据都有效):
|
||
# ① 壳内引用旧路径(`crate::platform::`)⇒ 源码级判据要抓到;
|
||
# ② 集成测试引用旧路径(`ssw_platform::platform::`)⇒ 同上;
|
||
# ③ 重建 `src/backend/src/platform/` 目录 ⇒ 目录级判据要抓到。
|
||
local a15ok=0
|
||
local a15probe="$KERNEL/src/__ar15_selftest.rs"
|
||
# 🔴 **2026-11-04 起集成测试宿主在 `crates/tests/tests/`**(AR16)——
|
||
# 探针必须打在**真在扫描面里**的目录上:AR15 的 roots 含 `$CRATES`,
|
||
# 所以打到 `crates/tests/tests/` 才证明「测试里的旧路径也被抓」。
|
||
local a15testdir="$ROOT/crates/tests/tests"
|
||
local a15test="$a15testdir/__ar15_selftest.rs"
|
||
local a15dir="$KERNEL/src/platform"
|
||
local a15had_dir=0
|
||
[ -d "$a15dir" ] && a15had_dir=1
|
||
printf 'use crate::platform::sys::user_list;\n' > "$a15probe"
|
||
[ -d "$a15testdir" ] && printf 'use ssw_platform::platform::db::Db;\n' > "$a15test"
|
||
mkdir -p "$a15dir"
|
||
printf '//! 探针\n' > "$a15dir/__ar15_selftest.rs"
|
||
local a15out
|
||
a15out="$(check_ar15 2>&1 || true)"
|
||
rm -f "$a15probe" "$a15test" "$a15dir/__ar15_selftest.rs"
|
||
# 🔴 **清理要彻底**:删探针文件 + 删目录(git 不跟踪空目录 ⇒ 残留会让下次
|
||
# 主检查**假红** —— 实测踩过:`rmdir` 失败后留下空目录)。
|
||
rm -rf "$a15dir"
|
||
[ "$a15had_dir" -eq 1 ] && mkdir -p "$a15dir"
|
||
# 🔴 **按判据分别验**:三处都必须被提到(只看「输出非空」不够)。
|
||
local a15c=0
|
||
echo "$a15out" | grep -q "__ar15_selftest.rs" && a15c=$((a15c+1))
|
||
echo "$a15out" | grep -q "platform: 目录复活" && a15c=$((a15c+1))
|
||
[ "$a15c" -ge 2 ] && a15ok=1
|
||
if [ "$a15ok" -eq 1 ]; then
|
||
echo "✅ 反自证通过:AR15 抓到了旧路径引用与 platform/ 目录复活"
|
||
else
|
||
echo "❌ 反自证失败:AR15 没抓到旧平台路径复活(源码级 / 目录级判据可能失效)⇒ 尺子是假的"
|
||
rc=1
|
||
fi
|
||
|
||
echo "── 反自证 8/15:给域包塞一条未授权的跨包依赖,AR12 必须报 ❌ ──"
|
||
#
|
||
# 🔴 **为什么必须自证 AR12**:它的判据是「读 Cargo.toml 找 sspf-compat-* 依赖」。
|
||
# 若 grep 模式写错(包名含连字符/下划线混用)⇒ 永远扫不到依赖 ⇒
|
||
# **永远"通过"** ⇒ 虚假安全感。而 AR12 守的正是「契约面各包不会成环」。
|
||
# 🔴 **注入必须避开白名单**:挑 `sspf-compat-msg`(它不在任何白名单里,
|
||
# 反向依赖 `sspf-compat-workflow` ⇒ 立刻成环)⇒ 必须被抓到。
|
||
local a12ok=0
|
||
local a12toml="$CRATES/sspf-compat-msg/Cargo.toml"
|
||
if [ -f "$a12toml" ]; then
|
||
cp "$a12toml" "$a12toml.bak"
|
||
printf '\nsspf-compat-workflow = { path = "../sspf-compat-workflow" }\n' >> "$a12toml"
|
||
local a12out
|
||
a12out="$(check_ar12 2>&1 || true)"
|
||
mv "$a12toml.bak" "$a12toml"
|
||
# 🔴 必须**按路径验**:输出里要明确出现被注入的那个包 + 那个依赖
|
||
if echo "$a12out" | grep -q "sspf-compat-msg → sspf-compat-workflow"; then
|
||
a12ok=1
|
||
fi
|
||
fi
|
||
if [ "$a12ok" -eq 1 ]; then
|
||
echo "✅ 反自证通过:AR12 抓到了 msg → workflow 的未授权跨包依赖"
|
||
else
|
||
echo "❌ 反自证失败:AR12 没抓到未授权的跨包依赖 ⇒ 尺子是假的"
|
||
rc=1
|
||
fi
|
||
|
||
echo "── 反自证 9/15:给执行层塞一个越界依赖 + 一条业务包引用,AR13 必须报 ❌ ──"
|
||
#
|
||
# 🔴 **必须自证 AR13**:它的判据是「读 Cargo.toml + grep 源码」。
|
||
# 两种失效模式都得堵:
|
||
# ① 依赖白名单写错/漏项 ⇒ 越界依赖进得来(执行层拖进 web 框架 ⇒ CLI/MCP 报废);
|
||
# ② 源码 grep 路径写错 ⇒ 业务包引用扫不到(平台层开始认识业务 ⇒ 破 AR9)。
|
||
# 🔴 **两处都注入、两处都被抓到**才算尺子有效(单点注入会漏判)。
|
||
local a13ok=0
|
||
local a13toml="$CRATES/sspf-lowcode-exec/Cargo.toml"
|
||
local a13src="$CRATES/sspf-lowcode-exec/src/__ar13_selftest.rs"
|
||
local a13need=0 a13c=0 a13out
|
||
if [ -f "$a13toml" ]; then
|
||
cp "$a13toml" "$a13toml.bak"
|
||
printf '\naxum = { workspace = true }\n' >> "$a13toml"
|
||
a13need=$((a13need+1))
|
||
printf 'use sspf_pack_asset::DATA_RESOURCE_SPEC;\n' > "$a13src"
|
||
a13need=$((a13need+1))
|
||
a13out="$(check_ar13 2>&1 || true)"
|
||
[ -f "$a13toml.bak" ] && mv "$a13toml.bak" "$a13toml"
|
||
rm -f "$a13src"
|
||
# ① 越界依赖(axum)必须被依赖白名单抓到
|
||
echo "$a13out" | grep -q "依赖越界" && a13c=$((a13c+1))
|
||
# ② 业务包引用必须被源码层抓到,且**路径明确**(不能只看到"有输出")
|
||
echo "$a13out" | grep -q "sspf-lowcode-exec/src/__ar13_selftest" && a13c=$((a13c+1))
|
||
[ "$a13need" -gt 0 ] && [ "$a13c" -ge "$a13need" ] && a13ok=1
|
||
fi
|
||
if [ "$a13ok" -eq 1 ]; then
|
||
echo "✅ 反自证通过:AR13 抓到了越界依赖(axum)与执行层里的业务包引用"
|
||
else
|
||
echo "❌ 反自证失败:AR13 没抓到越界依赖 / 业务包引用(或漏扫了其中一处)⇒ 尺子是假的"
|
||
rc=1
|
||
fi
|
||
|
||
echo "── 反自证 10/15:给适配层塞一个越界依赖 + 一条业务包引用,AR14 必须报 ❌ ──"
|
||
#
|
||
# 🔴 **必须自证 AR14**:它是 M6 新增的判据,守护的是「全仓唯一知道全部包的
|
||
# 汇聚点」的依赖面。两种失效模式都得堵:
|
||
# ① 依赖白名单写错/漏项 ⇒ 越界依赖进得来(适配层拖进业务包 ⇒ 破 AR9 的隔离);
|
||
# ② 源码 grep 路径写错 ⇒ 业务包引用扫不到(业务知识漏进适配层)。
|
||
# 🔴 **两处都注入、两处都被抓到**才算尺子有效(单点注入会漏判)。
|
||
local a14ok=0
|
||
local a14toml="$CRATES/sspf-mcp-adapter/Cargo.toml"
|
||
local a14src="$CRATES/sspf-mcp-adapter/src/__ar14_selftest.rs"
|
||
local a14need=0 a14c=0 a14out
|
||
if [ -f "$a14toml" ]; then
|
||
cp "$a14toml" "$a14toml.bak"
|
||
printf '\nsspf-contract = { path = "../sspf-contract" }\n' >> "$a14toml"
|
||
a14need=$((a14need+1))
|
||
printf 'use sspf_pack_asset::DATA_RESOURCE_SPEC;\n' > "$a14src"
|
||
a14need=$((a14need+1))
|
||
a14out="$(check_ar14 2>&1 || true)"
|
||
[ -f "$a14toml.bak" ] && mv "$a14toml.bak" "$a14toml"
|
||
rm -f "$a14src"
|
||
# ① 越界依赖(sspf-contract)必须被依赖白名单抓到
|
||
echo "$a14out" | grep -q "依赖越界" && a14c=$((a14c+1))
|
||
# ② 业务包引用必须被源码层抓到,且**路径明确**(不能只看到"有输出")
|
||
echo "$a14out" | grep -q "sspf-mcp-adapter/src/__ar14_selftest" && a14c=$((a14c+1))
|
||
[ "$a14need" -gt 0 ] && [ "$a14c" -ge "$a14need" ] && a14ok=1
|
||
fi
|
||
if [ "$a14ok" -eq 1 ]; then
|
||
echo "✅ 反自证通过:AR14 抓到了越界依赖(sspf-contract)与适配层里的业务包引用"
|
||
else
|
||
echo "❌ 反自证失败:AR14 没抓到越界依赖 / 业务包引用(或漏扫了其中一处)⇒ 尺子是假的"
|
||
rc=1
|
||
fi
|
||
|
||
echo "── 反自证 11/15:内核加回 [[bin]] + 塞回 tests/*.rs,AR16 必须两处都报 ❌ ──"
|
||
#
|
||
# 🔴 **必须自证 AR16**:它的三条判据全是「文件/目录在不在」——
|
||
# 路径写错(比如把 $KERNEL 拼成别的名字)⇒ 永远判「没问题」⇒
|
||
# 结构会静默退回到 2026-11-04 之前的样子(内核自带 bin、测试挂内核包)。
|
||
# ⇒ 两处都注入、两处都被抓到才算尺子有效。
|
||
local a16ok=0
|
||
local a16toml="$KERNEL/Cargo.toml"
|
||
local a16dir="$KERNEL/tests"
|
||
local a16need=0 a16c=0 a16before a16out=""
|
||
if [ -f "$a16toml" ]; then
|
||
a16before=$FAIL
|
||
cp "$a16toml" "$a16toml.bak"
|
||
printf '\n[[bin]]\nname = "__ar16_selftest"\npath = "src/lib.rs"\n' >> "$a16toml"
|
||
a16need=$((a16need + 1))
|
||
mkdir -p "$a16dir"
|
||
printf '// AR16 自证用,跑完即删\n' > "$a16dir/__ar16_selftest.rs"
|
||
a16need=$((a16need + 1))
|
||
a16out="$(check_ar16 2>&1 || true)"
|
||
[ -f "$a16toml.bak" ] && mv "$a16toml.bak" "$a16toml"
|
||
rm -f "$a16dir/__ar16_selftest.rs"
|
||
rmdir "$a16dir" 2>/dev/null || true
|
||
FAIL=$a16before
|
||
echo "$a16out" | grep -qF '内核声明了 [[bin]]' && a16c=$((a16c + 1))
|
||
echo "$a16out" | grep -qF '集成测试回到了内核包' && a16c=$((a16c + 1))
|
||
[ "$a16need" -gt 0 ] && [ "$a16c" -ge "$a16need" ] && a16ok=1
|
||
fi
|
||
if [ "$a16ok" -eq 1 ]; then
|
||
echo "✅ 反自证通过:AR16 抓到了内核里的 [[bin]] 与回流的 tests/*.rs"
|
||
else
|
||
echo "❌ 反自证失败:AR16 没抓到内核 [[bin]] / 回流的 tests(或漏判了其中一处)⇒ 尺子是假的"
|
||
rc=1
|
||
fi
|
||
|
||
echo "── 反自证 12/15:往内核塞回一条 sspf-pack 依赖,AR17 必须报 ❌ ──"
|
||
#
|
||
# 🔴 **2026-11-04 清理**:依赖清单里已经没有 pack 行可改 ⇒ 旧探针(去掉
|
||
# `optional = true`)找不到锚点,自证会**假红**。改成「注入一整条硬依赖」,
|
||
# 判据仍是「AR17 对业务包依赖敏感」,锚点不再依赖示例包是否存在。
|
||
local a17toml="$KERNEL/Cargo.toml"
|
||
local a17ok=0
|
||
if [ -f "$a17toml" ]; then
|
||
cp "$a17toml" "$a17toml.ar17bak"
|
||
printf '\nsspf-pack-probe = { path = "../../packs/probe" }\n' >> "$a17toml"
|
||
local a17before=$FAIL
|
||
check_ar17 >/dev/null 2>&1
|
||
local a17caught=0
|
||
[ "$FAIL" -gt "$a17before" ] && a17caught=1
|
||
mv "$a17toml.ar17bak" "$a17toml"
|
||
FAIL=$a17before
|
||
[ "$a17caught" -eq 1 ] && a17ok=1
|
||
fi
|
||
if [ "$a17ok" -eq 1 ]; then
|
||
echo "✅ 反自证通过:AR17 抓到了回流的 sspf-pack 依赖"
|
||
else
|
||
echo "❌ 反自证失败:AR17 没抓到回流的业务包依赖 ⇒ 尺子是假的"
|
||
rc=1
|
||
fi
|
||
|
||
echo "── 反自证 13/15:往门面里塞一句业务字面量,AR18 必须报 ❌ ──"
|
||
#
|
||
# 🔴 **为什么自证 AR18**:它扫的是「门面源码里的业务名」。目录写错 / 正则写错
|
||
# ⇒ 永远空 ⇒ 永远"通过"。这条自证保证「平台包里零业务」不是一句口号。
|
||
local a18dir="$CRATES/sspf/src"
|
||
local a18ok=0
|
||
if [ -d "$a18dir" ]; then
|
||
printf 'pub const AR18_SELFTEST: &str = "tdc_order";\n' > "$a18dir/__ar18_selftest.rs"
|
||
local a18before=$FAIL
|
||
check_ar18 >/dev/null 2>&1
|
||
local a18caught=0
|
||
[ "$FAIL" -gt "$a18before" ] && a18caught=1
|
||
rm -f "$a18dir/__ar18_selftest.rs"
|
||
FAIL=$a18before
|
||
[ "$a18caught" -eq 1 ] && a18ok=1
|
||
fi
|
||
if [ "$a18ok" -eq 1 ]; then
|
||
echo "✅ 反自证通过:AR18 抓到了门面里的业务表名"
|
||
else
|
||
echo "❌ 反自证失败:AR18 没抓到门面里的业务字面量 ⇒ 尺子是假的"
|
||
rc=1
|
||
fi
|
||
|
||
echo "── 反自证 14/15:往 routes.rs 塞第二处 .layer(catch_all()),AR19 必须报 ❌ ──"
|
||
#
|
||
# 🔴 **为什么自证 AR19**:它数的是「非注释代码里 catch_all 层的条数」。
|
||
# 正则写错 / 扫描面写错 ⇒ 永远数到 1 ⇒ 永远"通过"。
|
||
local a19file="$KERNEL/src/routes.rs"
|
||
local a19ok=0
|
||
if [ -f "$a19file" ]; then
|
||
cp "$a19file" "$a19file.ar19bak"
|
||
printf '\nfn __ar19_selftest() { let _ = axum::Router::new().layer(catch_all()); }\n' >> "$a19file"
|
||
local a19before=$FAIL
|
||
check_ar19 >/dev/null 2>&1
|
||
local a19caught=0
|
||
[ "$FAIL" -gt "$a19before" ] && a19caught=1
|
||
mv "$a19file.ar19bak" "$a19file"
|
||
FAIL=$a19before
|
||
[ "$a19caught" -eq 1 ] && a19ok=1
|
||
fi
|
||
if [ "$a19ok" -eq 1 ]; then
|
||
echo "✅ 反自证通过:AR19 抓到了第二处 catch_all 层"
|
||
else
|
||
echo "❌ 反自证失败:AR19 没抓到重复的装配链层 ⇒ 尺子是假的"
|
||
rc=1
|
||
fi
|
||
|
||
echo "── 反自证 15/15:往 query_json_raw 里塞 normalize_json_keys,AR20 必须报 ❌ ──"
|
||
#
|
||
# 🔴 **为什么自证 AR20**:它读的是「函数体里有没有某个标识符」。
|
||
# 正则写错 / 取错函数体 ⇒ 永远判干净 ⇒ raw 某天被顺手加上归一,
|
||
# 业务仓 132 条端点的键就静默漂移,而且**测试可能全绿**(只要没人比键名)。
|
||
local a20file="$ROOT/crates/sspf-store/src/db.rs"
|
||
local a20ok=0
|
||
if [ -f "$a20file" ]; then
|
||
cp "$a20file" "$a20file.ar20bak"
|
||
python3 - "$a20file" <<'PY'
|
||
import re
|
||
import sys
|
||
|
||
path = sys.argv[1]
|
||
src = open(path, encoding="utf-8").read()
|
||
m = re.search(r"pub async fn query_json_raw\b", src)
|
||
i = src.find("{", m.end())
|
||
# 在函数体开头注入一行「归一」—— 这正是本题最怕的退化。
|
||
src = src[: i + 1] + "\n let _ar20_probe = normalize_json_keys;" + src[i + 1 :]
|
||
open(path, "w", encoding="utf-8").write(src)
|
||
PY
|
||
local a20before=$FAIL
|
||
check_ar20 >/dev/null 2>&1
|
||
local a20caught=0
|
||
[ "$FAIL" -gt "$a20before" ] && a20caught=1
|
||
mv "$a20file.ar20bak" "$a20file"
|
||
FAIL=$a20before
|
||
[ "$a20caught" -eq 1 ] && a20ok=1
|
||
fi
|
||
if [ "$a20ok" -eq 1 ]; then
|
||
echo "✅ 反自证通过:AR20 抓到了 raw 路径里的归一"
|
||
else
|
||
echo "❌ 反自证失败:AR20 没抓到 raw 路径里的 normalize_json_keys ⇒ 尺子是假的"
|
||
rc=1
|
||
fi
|
||
|
||
return $rc
|
||
}
|
||
|
||
# ---------------------------------------------------------------- main
|
||
[ "${1:-}" = "--help" ] && { usage; exit 0; }
|
||
|
||
echo "── 架构边界闸门(crate 依赖纪律 + 内存红线)──"
|
||
check_ar1
|
||
check_ar2
|
||
check_ar3
|
||
check_ar4
|
||
check_ar5
|
||
check_ar6
|
||
check_ar7
|
||
check_ar8
|
||
check_ar9
|
||
check_ar10
|
||
check_ar11
|
||
check_ar12
|
||
check_ar13
|
||
check_ar14
|
||
check_ar15
|
||
check_ar16
|
||
check_ar17
|
||
check_ar18
|
||
check_ar19
|
||
check_ar20
|
||
check_pack1
|
||
check_mem1
|
||
check_mem2
|
||
|
||
echo
|
||
printf '结果: %d 通过 / %d 失败 / %d 跳过\n' "$PASS" "$FAIL" "$SKIP"
|
||
|
||
if [ "${1:-}" = "--self-test" ]; then
|
||
echo
|
||
self_test || exit 1
|
||
fi
|
||
|
||
[ "$FAIL" -eq 0 ] || exit 1
|
||
exit 0
|