@furongjun1999/dsh-memory 0.4.11 → 0.5.1

package/md_cg/test_session_isolation.py

@@ -0,0 +1,168 @@
+# -*- coding: utf-8 -*-
+"""test_session_isolation —— 会话隔离模型守卫（issue #35 设计定稿）
+
+设计定稿（2026-09-23 使用者拍板）：
+  · public / internal = 跨会话共享档——通过 clearance 即可见（含他人会话写入）；
+  · private / secret  = 会话绑定档——仅归属会话可见；
+    - 归属会话 = frontmatter.session（服务端身份不可伪造）；
+    - 绑定档无归属（存量）→ fail-closed 仅设计者可见；
+    - 查询侧 "*" 不再越过 private 绑定（非 admin 的 "*" 与不传等价）；
+  · can_admin（设计者）豁免——整体判断需要全景；错误/冲突信息（rejected/
+    unresolved）恒不进默认正排，设计者经显式通道获取；
+  · tenant 物理根接线（issue #35 本体）：已登记租户走登记根，冲突 fail-closed，
+    未登记回落 MDCG_ROOT（零变更）。
+
+运行：python -X utf8 -m md_cg.test_session_isolation
+"""
+import os
+import sys
+import tempfile
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from md_cg.mcp_server import _resolve_root                # noqa: E402
+from md_cg.mdcos import MdCGSecure                        # noqa: E402
+from md_cg.security import Principal, TenantRegistry      # noqa: E402
+
+passed = failed = 0
+
+
+def check(name, cond, detail=""):
+    global passed, failed
+    if cond:
+        passed += 1
+        print("  [PASS] " + name)
+    else:
+        failed += 1
+        print("  [FAIL] " + name + "  " + str(detail)[:200])
+
+
+def _principal(sess, **kw):
+    kw.setdefault("actor", "tester")
+    kw.setdefault("clearance", "private")
+    kw.setdefault("can_write", True)
+    kw.setdefault("role", "recorder")
+    return Principal(session=sess, **kw)
+
+
+def _search_ids(cg, q="共享 私有 标记", k=20, **kw):
+    res, _m = cg.search_rrf(q, k=k, judge=False, **kw)
+    return sorted(r[0]["id"] for r in res)
+
+
+def main():
+    root = tempfile.mkdtemp(prefix="sess_iso_")
+    pa = _principal("sessA")
+    a = MdCGSecure(os.path.join(root, "mem"), principal=pa)
+    a.add("pub1", "共享公开级记忆：发布窗口每周三", "knowledge",
+          sensitivity="public")
+    a.add("int1", "共享默认级记忆：接口约定时间戳毫秒", "knowledge",
+          sensitivity="internal")
+    a.add("priv1", "会话私有记忆：A 的个人偏好与口令提示", "knowledge",
+          sensitivity="private")
+    a.flush()
+
+    print("[1] 跨会话共享档：B 能看到 A 的 public/internal，看不到 private")
+    b = MdCGSecure(os.path.join(root, "mem"), principal=_principal("sessB"))
+    ids = _search_ids(b)
+    check("B（不传 session）见共享档", "pub1" in ids and "int1" in ids, ids)
+    check("B（不传 session）不见 A 的 private", "priv1" not in ids, ids)
+    check("B get(private) → None（不可见即不存在）",
+          b.get("priv1") is None)
+    check("B get(public) 可读", b.get("pub1") is not None)
+
+    print("[2] 查询侧 session 参数与收紧的 \"*\"")
+    ids2 = _search_ids(b, session="sessB")
+    check("B 传自己 session 仍见共享档（super 硬等值已上收）",
+          "pub1" in ids2 and "int1" in ids2 and "priv1" not in ids2, ids2)
+    ids3 = _search_ids(b, session="*")
+    check("B 传 \"*\" 不越过 private 绑定（收紧）", "priv1" not in ids3, ids3)
+
+    print("[3] 归属会话自身与设计者豁免")
+    a2 = MdCGSecure(os.path.join(root, "mem"), principal=_principal("sessA"))
+    ids4 = _search_ids(a2)
+    check("A（归属会话）见自己的全部三档",
+          {"pub1", "int1", "priv1"} <= set(ids4), ids4)
+    adm = MdCGSecure(os.path.join(root, "mem"),
+                     principal=_principal("sessAdmin", can_admin=True,
+                                          role="designer"))
+    ids5 = _search_ids(adm)
+    check("设计者（can_admin）跨会话见全部（含 private）",
+          {"pub1", "int1", "priv1"} <= set(ids5), ids5)
+
+    print("[4] 绑定档无归属（存量）fail-closed")
+    import json as _json
+    e = a.index["nodes"]["priv1"]
+    p = os.path.join(root, "mem", e["path"])
+    fm, content = a._read(e)
+    fm.pop("session", None)
+    a._write_node("priv1", p, fm, content)
+    a.index["nodes"]["priv1"]["session"] = None
+    a.rebuild_index()
+    b2 = MdCGSecure(os.path.join(root, "mem"), principal=_principal("sessB"))
+    check("无归属 private：普通会话不可见（fail-closed）",
+          "priv1" not in _search_ids(b2))
+    check("无归属 private：设计者可见",
+          "priv1" in _search_ids(adm))
+
+    print("[5] rejected（错误标记）不进默认正排")
+    rj = a.add_rejected("会话私有的错误假设", "守卫用", sensitivity="public")
+    a.flush()
+    check("rejected 不进任何会话的默认正排",
+          rj not in _search_ids(b2) and rj not in _search_ids(adm))
+
+    print("[6] 租户物理根解析（_resolve_root）")
+    reg_path = os.path.join(root, "_tenants.json")
+    reg = TenantRegistry(path=reg_path)
+    reg.register("tenantA", os.path.join(root, "A"))
+    reg.register("tenantB", os.path.join(root, "B"))
+
+    r, err = _resolve_root({"MDCG_ROOT": os.path.join(root, "A"),
+                            "MDCG_TENANT": "tenantA",
+                            "MDCG_TENANT_REGISTRY": reg_path})
+    check("已登记租户 + 一致 MDCG_ROOT → 登记根",
+          not err and os.path.abspath(r) == os.path.abspath(
+              os.path.join(root, "A")), (r, err))
+
+    r, err = _resolve_root({"MDCG_TENANT": "tenantB",
+                            "MDCG_TENANT_REGISTRY": reg_path})
+    check("已登记租户 + 无 MDCG_ROOT → 登记根（私库可零配置）",
+          not err and r == os.path.abspath(os.path.join(root, "B")), (r, err))
+
+    r, err = _resolve_root({"MDCG_ROOT": os.path.join(root, "A"),
+                            "MDCG_TENANT": "tenantB",
+                            "MDCG_TENANT_REGISTRY": reg_path})
+    check("登记根与 MDCG_ROOT 冲突 → fail-closed（root=None + 冲突说明）",
+          r is None and "fail-closed" in (err or ""), (r, err))
+
+    r, err = _resolve_root({"MDCG_ROOT": os.path.join(root, "X")})
+    check("未设租户 → 维持 MDCG_ROOT（零变更）",
+          not err and r == os.path.join(root, "X"), (r, err))
+
+    r, err = _resolve_root({"MDCG_ROOT": os.path.join(root, "X"),
+                            "MDCG_TENANT": "未登记租户"})
+    check("租户未登记 → 回落 MDCG_ROOT（不误伤）",
+          not err and r == os.path.join(root, "X"), (r, err))
+
+    r, err = _resolve_root({})
+    check("全空 → (None, None)（main 侧报缺 MDCG_ROOT）",
+          r is None and not err, (r, err))
+
+    print("[7] 双租户物理隔离端到端（各自根，互不可见）")
+    ta = MdCGSecure(os.path.join(root, "A"), principal=_principal("sessA"))
+    ta.add("only_a", "租户A的记忆", "knowledge", sensitivity="public")
+    ta.flush()
+    tb = MdCGSecure(os.path.join(root, "B"), principal=_principal("sessB"))
+    tb.add("only_b", "租户B的记忆", "knowledge", sensitivity="public")
+    tb.flush()
+    check("A 根检索只见 A（物理隔离）",
+          "only_a" in _search_ids(ta) and "only_b" not in _search_ids(ta))
+    check("B 根检索只见 B（物理隔离）",
+          "only_b" in _search_ids(tb) and "only_a" not in _search_ids(tb))
+
+    print(f"\nsession_isolation: {passed} 通过 / {failed} 失败")
+    return 0 if not failed else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/md_cg/test_snapshot_autoclose.py

@@ -0,0 +1,187 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""索引快照自动落盘守卫（issue：add→close 永不写快照，重开付全库扫描+重放）。
+
+缺陷形态（缺陷报告实测）：flush 只 append 分片日志、compact_index 生产零
+调用、close/atexit 只 flush——「add→close」的库永远没有快照，每次重开
+_load_index 都 _scan_nodes 全库逐文件 open+frontmatter 解析（1500 池本机
+~104ms），随后无条件重放全部索引日志（在扫描基底上纯冗余）。
+
+本守卫断言（调用计数/存在性形态，非时间阈值）：
+  C1 close 落快照：add→close 后 _index.json 存在（旧代码恒不存在 → 红）；
+  C2 重开零全库扫描：close 后重开期间 _scan_nodes 调用 == 0（旧代码
+     每次重开 1 次全库扫描 → 红）；
+  C3 重开零日志重放：close 后重开期间 ShardedLog.read_all 产出条数 == 0
+     （旧代码重放全部增量日志 → 红）；
+  C4 节点集一致：close→重开后 index["nodes"] 的 id 集与关闭前一致；
+  C5 尾部写入不丢：未达 autoflush 阈值的尾部 add 在 close 后重开可见；
+  C6 快照损坏防御：_index.json 写坏后 close/compact 不产出空快照——
+     节点仍全量可见（旧 compact 拿空骨架+增量日志会写出清池快照 → 红）；
+  C7 空库不落快照：无节点时 close 不产生 _index.json（保持原行为）。
+"""
+import os
+import shutil
+import sys
+import tempfile
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import md_cg.mdcg as mdcg_mod               # noqa: E402
+from md_cg.fsutil import ShardedLog         # noqa: E402
+from md_cg.mdcos import MdCGOS              # noqa: E402
+
+PASS = 0
+FAIL = 0
+FAILS = []
+
+
+def check(name, cond, detail=""):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+        print(f"  OK   {name}")
+    else:
+        FAIL += 1
+        FAILS.append(name)
+        print(f"  FAIL {name}  {detail}")
+
+
+def count_reload_reads(fn):
+    """打桩 _scan_nodes 调用数与 ShardedLog.read_all 产出条数。"""
+    n_scan, n_replay = 0, 0
+    real_scan = mdcg_mod.MdCG._scan_nodes
+    real_read = ShardedLog.read_all
+
+    def _scan_spy(self):
+        nonlocal n_scan
+        n_scan += 1
+        return real_scan(self)
+
+    def _read_spy(path, *a, **kw):
+        nonlocal n_replay
+        out = list(real_read(path, *a, **kw))
+        n_replay += len(out)
+        return iter(out)
+
+    mdcg_mod.MdCG._scan_nodes = _scan_spy
+    ShardedLog.read_all = staticmethod(_read_spy)
+    mdcg_mod.ShardedLog.read_all = staticmethod(_read_spy)
+    try:
+        return fn(), n_scan, n_replay
+    finally:
+        mdcg_mod.MdCG._scan_nodes = real_scan
+        ShardedLog.read_all = real_read
+        mdcg_mod.ShardedLog.read_all = real_read
+
+
+def build(root, n=30):
+    cg = MdCGOS(root, autoflush=64)          # 高阈值：尾部写入留在 _dirty
+    for i in range(n):
+        cg.add("mem_%04d" % i,
+               "# 功能名：快照守卫 %d\n# 正文：蜂群调度 样本 %d" % (i, i),
+               layer="knowledge")
+    return cg
+
+
+def main():
+    root = tempfile.mkdtemp(prefix="mdcg_snap_guard_")
+    try:
+        # C1/C4/C5：close 落快照 + 尾部写入 + 节点集一致
+        print("== C1/C4/C5 close 落快照 ==")
+        cg = build(root)
+        ids_before = set(cg.index["nodes"])
+        check("C5pre 尾部写入在 _dirty（未 flush）", len(cg._dirty) > 0,
+              f"dirty={len(cg._dirty)}")
+        cg.close()
+        snap = os.path.join(root, "_index.json")
+        check("C1a add→close 后 _index.json 快照存在（旧代码恒不存在）",
+              os.path.exists(snap))
+
+        def _reopen():
+            return MdCGOS(root)
+
+        cg2, n_scan, n_replay = count_reload_reads(_reopen)
+        try:
+            ids_after = set(cg2.index["nodes"])
+            check("C4a 重开后节点集与关闭前一致",
+                  ids_after == ids_before and len(ids_after) == 30,
+                  f"before={len(ids_before)} after={len(ids_after)}")
+        finally:
+            cg2.close()
+        check("C2a 重开零全库扫描（_scan_nodes 调用==0，旧每次重开 1 次）",
+              n_scan == 0, f"scans={n_scan}")
+        check("C3a 重开零日志重放（read_all 条数==0，旧全量重放）",
+              n_replay == 0, f"replayed={n_replay}")
+
+        # C6 快照损坏防御：写坏快照 → 重开（scan 基底）→ close 不产空快照
+        print("== C6 快照损坏防御 ==")
+        with open(snap, "w", encoding="utf-8") as f:
+            f.write("{corrupted json !!!")
+        root6 = root                            # 同库继续
+        cg6 = MdCGOS(root6)                      # 损坏 → _scan_nodes 基底
+        n6 = len(cg6.index["nodes"])
+        check("C6a 损坏快照下重开走全库扫描（节点全量可见）",
+              n6 == 30, f"nodes={n6}")
+        cg6.close()
+        cg6b = MdCGOS(root6)
+        try:
+            n6b = len(cg6b.index["nodes"])
+            check("C6b 损坏后 close/compact 不产空快照（重开仍 30 节点）",
+                  n6b == 30, f"nodes={n6b}")
+        finally:
+            cg6b.close()
+
+        # C8 未 flush 写入兜底（issue #33 修复中发现的回归形态）：实例 A
+        # 写节点不收尾（dirty 未 flush、文件已落盘），实例 B close 落快照
+        # ——B 的账本不含 A 的节点。此后重开必须仍能看到 A 的节点
+        # （compact 计数对账 + 重开指纹校验双保险；任一缺失都会让节点
+        # 「在盘上但索引不可见」）。
+        print("== C8 未 flush 写入兜底 ==")
+        root8 = tempfile.mkdtemp(prefix="mdcg_snap_guard8_")
+        try:
+            a = MdCGOS(root8, autoflush=64)
+            a.add("a1", "# 功能名：甲\n# 正文：甲的节点 蜂群", layer="knowledge")
+            a.add("a2", "# 功能名：乙\n# 正文：乙的节点 星云", layer="knowledge")
+            b = MdCGOS(root8, autoflush=64)
+            b.add("b1", "# 功能名：丙\n# 正文：丙的节点 水位", layer="knowledge")
+            b.close()                       # B 落快照（账本不含 a1/a2）
+            c = MdCGOS(root8)
+            try:
+                ids_c = set(c.index["nodes"])
+                check("C8a A 未 flush 的节点在 B close 落快照后重开仍可见",
+                      {"a1", "a2", "b1"} <= ids_c, f"ids={sorted(ids_c)}")
+            finally:
+                c.close()
+            d = MdCGOS(root8)
+            try:
+                ids_d = set(d.index["nodes"])
+                check("C8b C close 后再次重开节点仍全量可见（快照已含全部）",
+                      {"a1", "a2", "b1"} <= ids_d, f"ids={sorted(ids_d)}")
+            finally:
+                d.close()
+        finally:
+            shutil.rmtree(root8, ignore_errors=True)
+
+        # C7 空库不落快照
+        print("== C7 空库不落快照 ==")
+        root7 = tempfile.mkdtemp(prefix="mdcg_snap_guard7_")
+        try:
+            cg7 = MdCGOS(root7)
+            cg7.close()
+            check("C7a 空库 close 不产生 _index.json（保持原行为）",
+                  not os.path.exists(os.path.join(root7, "_index.json")))
+        finally:
+            shutil.rmtree(root7, ignore_errors=True)
+    finally:
+        shutil.rmtree(root, ignore_errors=True)
+
+    print("\n" + "=" * 60)
+    print(f"结果：PASS {PASS} / FAIL {FAIL}")
+    if FAILS:
+        for f in FAILS:
+            print(f"  - {f}")
+    return 0 if FAIL == 0 else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())