- 删 src/backend/src/platform/ 下 38 个转发壳 ⇒ 平台层只有真源(在 crates/) - 新增 src/backend/src/compat.rs 别名表(16 个域)⇒ routes.rs 的 1010 处 compat::<域>:: 调用点零改动,风险面从 1010 处降到 1 个文件 - test_support.rs 从 platform/ 迁到壳侧根(依赖装配根 ensure_schema_all ⇒ 认识业务层) - 全仓改写 import:crate::platform::X → sspf_core::X(44 处/9 文件); ssw_platform::platform::X → sspf_core::X(229 处/38 文件) - 修 check-contract-scan.py 的 plat_key 推导:按 crate 名判定(原按路径段数猜, M7 拆 crate 后必然失效 ⇒ CC6 静默失效);新增 derive_plat_key + 20 条断言自证 - 新增 AR15 防旧平台路径复活(三层判据,含目录级「含 .rs 才算复活」) - 闸门去壳路径:check-arch / check-boundary / check-module / check-contract-scan - 文档同步:CRATES-MIGRATION / contract / HANDOFF / HOWTO_MODULE / CLAUDE.md 验证:cargo build 零警告;cargo test 695 passed / 0 failed(与 M1 基线一致); check-arch 20/20;--self-test 10/10;check-boundary 12/12;check-contract 10/10 (反自证 12 例 + 20 条推导断言);check-module 123/123;check-citations 4/4; check-naming 3/0/1;verify.sh --smoke 14 步全绿。 至此 M1–M7 全部完成:crates/ 17 个包,src/backend/src/ 只剩装配 + 业务层。
1048 lines
49 KiB
Bash
Executable File
1048 lines
49 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` 常量同文件出现)
|
||
# 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 的架构收益会**静默蒸发**
|
||
#
|
||
# 🔴 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"
|
||
|
||
# 🔴 **平台侧真源目录表**(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–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=()
|
||
[ "${#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 / online_dev 四个契约面域包
|
||
# 的 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-online_dev 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
|
||
[ "$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/10:造一个依赖越界的假 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/10:往平台层塞一个 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/10:往 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/10:往 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/10:往平台层塞 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/10:往契约面底座塞 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/10:往壳里写 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"
|
||
local a15test="$KERNEL/tests/__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"
|
||
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/10:给域包塞一条未授权的跨包依赖,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/10:给执行层塞一个越界依赖 + 一条业务包引用,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/10:给适配层塞一个越界依赖 + 一条业务包引用,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
|
||
|
||
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_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
|