平台能力全迁 crates/ 迁移计划第 2 批(docs/CRATES-MIGRATION.md,基线 tag v0.1.0)。
本批次 = M2:平台核心从 src/backend/src/platform/ 下沉到 crates/sspf-core/。
搬迁:
- 19 个模块 git mv 进 crates/sspf-core/src/(保留历史):
auth/authorization/cipher/config/crud/db/entity/envelope/guard/ids/menu/
monitor/registry/route/seed/session/state/sys/variate_catalog
- src/backend/src/platform/*.rs 全改成 pub use sspf_core::<mod>::* 转发壳(5 行/个)
⇒ 上层零感知:routes / modules / 695 个测试的 import 一个没改
- crate 内路径改写 crate::platform::X → crate::X(compat 除外,那是 M3/M4)
- pub(crate) → pub(10 处,跨 crate 后失效)
闸门改造(🔴 本批最大风险不是代码是闸门 —— 搬迁后闸门扫空壳 = 虚假安全感):
- 纪律 = 「两处都扫」:真源 crates/sspf-core/src/(管实现)+ 转发壳(防塞私货)
- check-arch.sh AR9/AR10 扫两处;反自证 2/6、5/6 两处注入探针且按路径分别验
- check-boundary.sh 新增 PLATFORM_CORE;CP1/CP2 两处扫;CP6 的 seed.rs 改读真源
- check-contract-scan.py 的 plat_files 两处都收、重名键拼接(覆盖会丢函数 ⇒ 推不出守卫)
- check-module.sh 的 CRUD 改读 crates/sspf-core/src/crud.rs(软删契约要看 SQL)
- gen-function-catalog.py 的 OUT 改写真源(否则覆盖转发壳 ⇒ 上层 import 全断)
- 反向验证:只往 crates/sspf-core/ 塞违规 ⇒ AR9/AR10 都报红(证明真在扫真源)
测试归属调整:crud.rs 3 个测试原依赖 crate::modules::all_specs()(业务层)
⇒ 改用契约层合成 spec 参数化测试;registry.rs 测试改自建库 + seed::ensure_base(db, &[])。
顺带记录技术债:write_cast 的 numeric 映射是列名枚举而非 spec 声明。
影响:功能零变化(路由、响应形状、语义均未动),纯结构下沉。
验证: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(反自证 12 例全过);
check-module 123/123;check-citations 4/4;verify --smoke 14 步全绿(512.3s)。
652 lines
28 KiB
Bash
Executable File
652 lines
28 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/*/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,切断了这两条边。
|
||
#
|
||
# 判据:`compat/helper.rs` 里不许 `use super::` 指向**非 helper 的模块**。
|
||
check_ar11() {
|
||
local f="$KERNEL/src/platform/compat/helper.rs"
|
||
[ -f "$f" ] || { skip "AR11 compat/helper.rs 不存在"; return; }
|
||
local hits
|
||
hits="$(grep -nE '^[[:space:]]*(pub )?use[[:space:]]+super::[a-z_]+' "$f" 2>/dev/null \
|
||
| grep -v 'super::helper' || true)"
|
||
if [ -z "$hits" ]; then
|
||
ok "AR11 契约面底座(helper)不依赖其它契约面模块(14 个模块依赖它 ⇒ 反向依赖即成环)"
|
||
else
|
||
bad "AR11 契约面底座(helper)反向依赖契约面业务模块(拆 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 必须报 ❌ ──"
|
||
#
|
||
# 🔴 造在**临时副本**上:不动真文件(helper.rs 是 900+ 行的活文件)。
|
||
local a11dir="$KERNEL/src/platform/compat"
|
||
local a11probe="$a11dir/__ar11_selftest.rs"
|
||
if [ -d "$a11dir" ] && [ -f "$a11dir/helper.rs" ]; then
|
||
# 🔴 AR11 只扫 `helper.rs` ⇒ 探针必须是 helper.rs 本身。
|
||
# 做法:备份真文件 → 追加违规行 → 跑判据 → 还原。
|
||
cp "$a11dir/helper.rs" "$a11dir/helper.rs.bak"
|
||
printf '\nuse super::system::menu_node;\n' >> "$a11dir/helper.rs"
|
||
before=$FAIL
|
||
check_ar11 >/dev/null 2>&1
|
||
caught=0
|
||
[ "$FAIL" -gt "$before" ] && caught=1
|
||
mv "$a11dir/helper.rs.bak" "$a11dir/helper.rs"
|
||
FAIL=$before
|
||
if [ "$caught" -eq 1 ]; then
|
||
echo "✅ 反自证通过:AR11 抓到了契约面底座里的 use super::system"
|
||
else
|
||
echo "❌ 反自证失败:AR11 没抓到底座的反向依赖 ⇒ 尺子是假的"
|
||
rc=1
|
||
fi
|
||
else
|
||
echo "⏭ 跳过 AR11 反自证(契约面目录或 helper.rs 不存在)"
|
||
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
|