Files
ssw-platform/scripts/check-arch.sh
T
admin eea3d0329f refactor(arch): M3 契约面公共底座下沉 —— helper/res 进 crates/sspf-compat-core
平台能力全迁 crates/ 迁移计划第 3 批(docs/CRATES-MIGRATION.md)。
本批次 = M3:被 14 个契约面模块共用的底座先下沉,M4 的 6 个包才能都依赖它。

搬迁:
- compat/helper.rs(994) + compat/res.rs(460) git mv 进 crates/sspf-compat-core/src/
- src/backend/src/platform/compat/{helper,res}.rs 改成 pub use sspf_compat_core::<mod>::*
  ⇒ 14 个契约面模块的 use super::helper::{…} 零感知
- 路径改写 crate::platform::X → sspf_core::X(独立 crate 不能用 crate::X)
- pub(super) → pub(54 处):转发壳的 pub use …::* 只转发 pub 项(含 struct 字段)
- helper 的 8 个单测自足 ⇒ 随迁,总测试数不变 695

闸门改造(同 M2 纪律 = 两处都扫:真源 + 转发壳):
- check-arch.sh AR11 扫 crates/sspf-compat-core/src/helper.rs + 壳,
  并新增 Cargo.toml 级判据(sspf-compat-core 不许依赖 sspf-compat-* ⇒ M4 的 6 个包)
- check-arch.sh 反自证 6/6 两处注入探针、按路径分别验
- check-contract-scan.py 的 plat_files 对 compat__<mod> 收真源 + 壳同键拼接
  (守卫常量 EN_ROLE 等在 helper 真源里,漏收 ⇒ CC6 假漂移)
- 修 1 条引文:compat/helper.rs:89-92 → crates/sspf-compat-core/src/helper.rs:87-91

反向验证:只往真源 helper 塞 use crate::res::Res; ⇒ AR11 报红;清理后恢复绿。

顺带落档四个决策(§11):壳最后删 / compat 拆 6 包 / mcp_compat 放 crates / tests 跟着拆。

影响:功能零变化(响应形状、路由、语义均未动),纯结构下沉。
验证:cargo build 零警告;cargo test --workspace 695 passed / 0 failed(与基线一致);
check-arch 14/14;--self-test 6/6;check-boundary 11/11;check-contract 10/10(CC6 零漂移);
check-module 123/123;check-citations 4/4;verify --smoke 14 步全绿(561.3s)。
2026-11-03 17:48:41 +08:00

672 lines
29 KiB
Bash
Executable File
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#!/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/*/Cargo.toml` 依赖 ⊆ {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` 常量同文件出现)
#
# 🔴 AR1–AR5 是 PLAN.md §3.2 的分层纪律;MEM1–MEM2 是判断 ⑥ 的四条内存红线的静态部分。
set -u
ROOT="$(cd "$(dirname "$0")/.." && pwd)"
CRATES="$ROOT/crates"
KERNEL="$ROOT/src/backend"
MODULES_DIR="$KERNEL/src/modules"
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–AR7)与内存红线(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
[ "$n" -eq 0 ] && skip "AR2 尚无 packs/*(P3 才落地)"
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=()
[ -d "$CRATES/sspf-core/src" ] && dirs+=("$CRATES/sspf-core/src")
[ -d "$KERNEL/src/platform" ] && dirs+=("$KERNEL/src/platform")
[ "${#dirs[@]}" -gt 0 ] || { skip "AR9 平台层目录不存在"; return; }
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/ 或 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=()
[ -d "$CRATES/sspf-core/src" ] && dirs+=("$CRATES/sspf-core/src")
[ -d "$KERNEL/src/platform" ] && dirs+=("$KERNEL/src/platform")
[ "${#dirs[@]}" -gt 0 ] || { skip "AR10 平台层目录不存在"; return; }
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")
[ -f "$KERNEL/src/platform/compat/helper.rs" ] && files+=("$KERNEL/src/platform/compat/helper.rs")
local hits=""
if [ "${#files[@]}" -gt 0 ]; then
hits="$(grep -nE '^[[: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 '^\s*sspf-compat-[a-z-]+\s*=' "$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
}
# ---------------------------------------------------------------- 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
[ "$n" -eq 0 ] && skip "PACK1 尚无「模块转发业务包」的模块"
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
}
# ---------------------------------------------------------------- 反自证
# 🔴 永远返回「干净」的尺子 = 没有尺子。造明知违规的输入,必须被抓到。
self_test() {
local rc=0
echo "── 反自证 1/6:造一个依赖越界的假 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"
FAIL=$before
if [ "$caught" -eq 1 ]; then
echo "✅ 反自证通过:AR2 抓到了 axum 依赖"
else
echo "❌ 反自证失败:AR2 没抓到明显违规 ⇒ 这把尺子是假的"
rc=1
fi
echo "── 反自证 2/6:往平台层塞一个 use sspf_pack_*,AR9 必须报 ❌ ──"
#
# 🔴 **为什么必须自证 AR9**:它的判据是 `grep 目录`。
# 目录名写错 / 路径拼错 ⇒ `grep` 永远返回空 ⇒ **永远"通过"**。
# 这类尺子比没有更危险(它给出虚假的安全感)。
# 🔴 **M2 起必须注入两处**:真源 `crates/sspf-core/src/`(实现所在)
# + 转发壳 `src/backend/src/platform/`。**只注入一处不够** ——
# 若闸门只扫壳不扫真源(或反之),单点注入会漏判 ⇒ 两处都注入、
# 且**两处都被抓到**才算尺子有效。
local a9core="$CRATES/sspf-core/src/__ar9_selftest.rs"
local a9shell="$KERNEL/src/platform/__ar9_selftest.rs"
local a9ok=0
if [ -d "$CRATES/sspf-core/src" ] || [ -d "$KERNEL/src/platform" ]; then
[ -d "$CRATES/sspf-core/src" ] && printf 'use sspf_pack_asset::DATA_RESOURCE_SPEC;\n' > "$a9core"
[ -d "$KERNEL/src/platform" ] && printf 'use sspf_pack_asset::DATA_RESOURCE_SPEC;\n' > "$a9shell"
local a9out
a9out="$(check_ar9 2>&1 || true)"
rm -f "$a9core" "$a9shell"
# 🔴 **按路径分别验**:必须证明闸门**两处都看得到** ——
# 只验「输出里有 __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 "$KERNEL/src/platform" ]; then
a9need=$((a9need+1))
echo "$a9out" | grep -q "platform/__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/6:往 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/6:往 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/6:往平台层塞 crate::platform::compat,AR10 必须报 ❌ ──"
#
# 🔴 **必须自证 AR10**:它的判据是「扫平台层目录找契约面引用」。
# 目录名写错 / 路径拼错 ⇒ 扫描永远返回空 ⇒ **永远"通过"** ⇒ 虚假安全感。
# 而且这条判据守护的是**拆 crate 的前置条件** —— 它一旦失效,后续批次才炸。
# 🔴 **M2 起注入两处**(真源 + 转发壳),与 2/6 同理:单点注入会漏判。
local a10core="$CRATES/sspf-core/src/__ar10_selftest.rs"
local a10shell="$KERNEL/src/platform/__ar10_selftest.rs"
local a10ok=0
if [ -d "$CRATES/sspf-core/src" ] || [ -d "$KERNEL/src/platform" ]; then
[ -d "$CRATES/sspf-core/src" ] && printf 'use crate::platform::compat::helper::current_user;\n' > "$a10core"
[ -d "$KERNEL/src/platform" ] && printf 'use crate::platform::compat::helper::current_user;\n' > "$a10shell"
local a10out
a10out="$(check_ar10 2>&1 || true)"
rm -f "$a10core" "$a10shell"
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 "$KERNEL/src/platform" ]; then
a10need=$((a10need+1))
echo "$a10out" | grep -q "platform/__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/6:往契约面底座塞 use super::system,AR11 必须报 ❌ ──"
#
# 🔴 **M3 起底座有两处**:真源 `crates/sspf-compat-core/src/helper.rs`(实现)
# + 转发壳 `src/backend/src/platform/compat/helper.rs`。**两处都注入、
# 两处都被抓到**才算尺子有效(只注入一处会漏判「闸门只扫壳/只扫真源」)。
# 做法:备份真文件 → 追加违规行 → 跑判据 → 还原(helper.rs 是活文件)。
local a11ok=0
local a11core="$CRATES/sspf-compat-core/src/helper.rs"
local a11shell="$KERNEL/src/platform/compat/helper.rs"
local a11need=0 a11c=0 a11out
if [ -f "$a11core" ] || [ -f "$a11shell" ]; then
[ -f "$a11core" ] && cp "$a11core" "$a11core.bak" && printf '\nuse super::system::menu_node;\n' >> "$a11core" && a11need=$((a11need+1))
[ -f "$a11shell" ] && cp "$a11shell" "$a11shell.bak" && printf '\nuse super::system::menu_node;\n' >> "$a11shell" && a11need=$((a11need+1))
a11out="$(check_ar11 2>&1 || true)"
[ -f "$a11core.bak" ] && mv "$a11core.bak" "$a11core"
[ -f "$a11shell.bak" ] && mv "$a11shell.bak" "$a11shell"
[ -f "$a11core" ] && { echo "$a11out" | grep -q "sspf-compat-core/src/helper.rs" && a11c=$((a11c+1)); }
[ -f "$a11shell" ] && { echo "$a11out" | grep -q "platform/compat/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
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_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