Files
knowledge-governance/internal/librarysnapshot/transfer_test.go
T
姚章浩 e6472b0ec6 feat(library): 云测试发布目标接入的角色分离、快照搬运与图谱门禁
为什么改:发布执行链是"与目标同机"假设写死的(本机 docker.sock、本机 drain.json、
本机 Redis/PG),把目标换成云测试不能只改展示 URL;直接搬整套 worker 又会抢走
本机封存/QA/周报队列并按本机配置写错目标。所以先把"谁消费哪段队列"变成显式角色,
再补齐跨主机搬运与目标侧门禁。

角色(LIBRARY_WORKER_ROLE=full/release-executor/capture)不只影响 handler 列表,
还决定是否拥有 DDL(release-executor 只读校验迁移版本,落后即拒绝启动)、
收拾哪些 library_jobs.kind、是否跑 release 接管扫描、是否起 scheduler/QA/周报/探测。
capture 保留本机原有全部业务;release-executor 只挂 sync/restore/recover/baseline。

快照跨主机:新增内容寻址的 bundle(版本清单先落、blob 按 sha256 命名、清单最后
Link 作提交点),pack/unpack 幂等且拒绝覆盖与同名不同内容;执行器使用前仍逐 blob
重算 sha256,因此传输不可变有两道证据。

目标侧门禁:目标知识库 graph_enabled=true 时拒绝发布(发布只写 PG/ES/OSS,不写
Neo4j;未知也拒绝),只读检测、不改目标配置、不做图谱迁移。

云端入口:新增 drain 感知的 ingress 闸门(建连超时与读超时分离,半关闭单向传播,
SIGTERM 排空后写 drain.json 并 exit 0/2)、compose 叠加片段(app 不再发布端口、
frontend 与 adapter 的入口收敛到闸门、指向真实网络 weknora-test-v071-network)、
执行器启动脚本与治理 PG 反向隧道脚本(默认 unix socket,不占 TCP)。

验证:deploy/cloud-test/test_gate.py 13 项全 PASS(含 12 秒静默流、半关闭、2MiB 完整、
排空 exit 0/active_at_close=1、排空超时 exit 2、上游不可达不挂住);go test 相关包全绿;
scripts/ci_checks.py 16 项全部 success(EXIT=0,1241 用例通过/0 失败/191 已声明可选集成跳过);
云测试只读预检 17 项 / 6 FAIL,FAIL 项即当前部署缺口(无闸门、app 仍发布端口、
adapter 与 frontend 仍直连 app、云端归档根未建),未部署、未改云端任何状态。
2026-10-30 18:38:38 +08:00

226 lines
7.0 KiB
Go

package librarysnapshot
import (
"archive/tar"
"bytes"
"io"
"os"
"path/filepath"
"testing"
)
func newTransferArchive(t *testing.T) (*Archive, string) {
t.Helper()
root := t.TempDir()
if err := os.Chmod(root, 0700); err != nil {
t.Fatal(err)
}
archive, err := Open(root, 1024*1024)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { archive.Close() })
return archive, root
}
func sealFixture(t *testing.T, archive *Archive) (string, Manifest) {
t.Helper()
part, err := archive.Put(bytes.NewBufferString("[]"))
if err != nil {
t.Fatal(err)
}
manifest := testManifest(part)
id, err := archive.Seal(manifest)
if err != nil {
t.Fatal(err)
}
return id, manifest
}
// 一份验证过的快照搬过去必须字节一致、身份不变,重复导入幂等。
func TestPackUnpackRoundTripKeepsIdentityAndBytes(t *testing.T) {
source, _ := newTransferArchive(t)
id, manifest := sealFixture(t, source)
bundle := filepath.Join(t.TempDir(), "snapshot.tar")
info, err := source.Pack(id, bundle)
if err != nil {
t.Fatalf("Pack() error = %v", err)
}
if info.Snapshot != id || info.Parts != len(manifest.Parts) || info.Bytes <= 0 || len(info.Blobs) == 0 {
t.Fatalf("bundle info = %#v", info)
}
destination, _ := newTransferArchive(t)
got, err := destination.Unpack(bundle, id)
if err != nil {
t.Fatalf("Unpack() error = %v", err)
}
if got.KnowledgeBaseID != manifest.KnowledgeBaseID || len(got.Parts) != len(manifest.Parts) {
t.Fatal("imported manifest identity changed")
}
if _, err := destination.Load(id); err != nil {
t.Fatalf("imported snapshot does not load: %v", err)
}
if _, err := destination.Unpack(bundle, id); err != nil {
t.Fatalf("repeated import is not idempotent: %v", err)
}
}
// 包不覆盖已有文件:导出和导入都不能"顺手替换"一份已存在的产物。
func TestPackRefusesToOverwriteExistingBundle(t *testing.T) {
source, _ := newTransferArchive(t)
id, _ := sealFixture(t, source)
bundle := filepath.Join(t.TempDir(), "snapshot.tar")
if err := os.WriteFile(bundle, []byte("occupied"), 0600); err != nil {
t.Fatal(err)
}
if _, err := source.Pack(id, bundle); err == nil {
t.Fatal("Pack() overwrote an existing bundle")
}
}
// 身份对不上就不许导入:调用方点错快照时,宁可失败。
func TestUnpackRejectsUnexpectedSnapshotIdentity(t *testing.T) {
source, _ := newTransferArchive(t)
id, _ := sealFixture(t, source)
bundle := filepath.Join(t.TempDir(), "snapshot.tar")
if _, err := source.Pack(id, bundle); err != nil {
t.Fatal(err)
}
destination, _ := newTransferArchive(t)
if _, err := destination.Unpack(bundle, digest([]byte("another snapshot"))); err == nil {
t.Fatal("Unpack() accepted a bundle whose ID does not match the expectation")
}
}
// 包里的字节必须与名字(sha256)一致:篡改一个 blob 就整体拒绝,且不留下版本。
func TestUnpackRejectsTamperedBlobAndLeavesNoVersion(t *testing.T) {
source, _ := newTransferArchive(t)
id, manifest := sealFixture(t, source)
bundle := filepath.Join(t.TempDir(), "snapshot.tar")
info, err := source.Pack(id, bundle)
if err != nil {
t.Fatal(err)
}
tampered := filepath.Join(t.TempDir(), "tampered.tar")
rewriteBundle(t, bundle, tampered, func(name string, body []byte) (string, []byte) {
if name == bundleBlobPrefix+info.Blobs[0] && len(body) > 0 {
body = append([]byte(nil), body...)
body[0] ^= 0xff
}
return name, body
})
destination, root := newTransferArchive(t)
if _, err := destination.Unpack(tampered, id); err == nil {
t.Fatal("Unpack() accepted a tampered blob")
}
if _, err := os.Stat(filepath.Join(root, "versions", id+".json")); !os.IsNotExist(err) {
t.Fatal("a failed import left a version behind")
}
_ = manifest
}
// 包里出现快照不声明的 blob / 缺 blob / 非普通文件,一律拒绝。
func TestUnpackRejectsIncompleteAndForeignBundles(t *testing.T) {
source, _ := newTransferArchive(t)
id, manifest := sealFixture(t, source)
bundle := filepath.Join(t.TempDir(), "snapshot.tar")
if _, err := source.Pack(id, bundle); err != nil {
t.Fatal(err)
}
missing := filepath.Join(t.TempDir(), "missing.tar")
first := manifest.Parts[0].SHA256
rewriteBundle(t, bundle, missing, func(name string, body []byte) (string, []byte) {
if name == bundleBlobPrefix+first {
return "", nil
}
return name, body
})
destination, _ := newTransferArchive(t)
if _, err := destination.Unpack(missing, id); err == nil {
t.Fatal("Unpack() accepted a bundle missing a declared blob")
}
foreign := filepath.Join(t.TempDir(), "foreign.tar")
extra := digest([]byte("extra blob"))
rewriteBundle(t, bundle, foreign, func(name string, body []byte) (string, []byte) {
if name == bundleBlobPrefix+first {
return bundleBlobPrefix + extra, []byte("x")
}
return name, body
})
other, _ := newTransferArchive(t)
if _, err := other.Unpack(foreign, id); err == nil {
t.Fatal("Unpack() accepted a bundle carrying a blob the snapshot does not declare")
}
traversal := filepath.Join(t.TempDir(), "traversal.tar")
rewriteBundle(t, bundle, traversal, func(name string, body []byte) (string, []byte) {
if name == bundleBlobPrefix+first {
return "../escape", body
}
return name, body
})
third, _ := newTransferArchive(t)
if _, err := third.Unpack(traversal, id); err == nil {
t.Fatal("Unpack() accepted an entry outside the bundle layout")
}
}
// 目标机已经存在同名不同内容的 blob:那是身份冲突,必须拒绝而不是覆盖。
func TestUnpackRejectsConflictingExistingBlob(t *testing.T) {
source, _ := newTransferArchive(t)
id, manifest := sealFixture(t, source)
bundle := filepath.Join(t.TempDir(), "snapshot.tar")
if _, err := source.Pack(id, bundle); err != nil {
t.Fatal(err)
}
destination, root := newTransferArchive(t)
victim := manifest.Parts[0].SHA256
if err := os.WriteFile(filepath.Join(root, "blobs", victim), []byte("[]different"), 0600); err != nil {
t.Fatal(err)
}
if _, err := destination.Unpack(bundle, id); err == nil {
t.Fatal("Unpack() overwrote a blob whose bytes differ")
}
}
// rewriteBundle 逐条重放一个包,按 mutate 改名字/内容;返回空名字表示删掉该条。
func rewriteBundle(t *testing.T, source, target string, mutate func(name string, body []byte) (string, []byte)) {
t.Helper()
in, err := os.Open(source)
if err != nil {
t.Fatal(err)
}
defer in.Close()
out, err := os.OpenFile(target, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0600)
if err != nil {
t.Fatal(err)
}
writer := tar.NewWriter(out)
reader := tar.NewReader(in)
for {
header, err := reader.Next()
if err != nil {
break
}
body := make([]byte, header.Size)
if _, err := io.ReadFull(reader, body); err != nil {
t.Fatal(err)
}
name, rewritten := mutate(header.Name, body)
if name == "" {
continue
}
if err := writer.WriteHeader(&tar.Header{Name: name, Mode: 0600, Size: int64(len(rewritten)), Typeflag: tar.TypeReg}); err != nil {
t.Fatal(err)
}
if _, err := writer.Write(rewritten); err != nil {
t.Fatal(err)
}
}
if err := writer.Close(); err != nil {
t.Fatal(err)
}
if err := out.Close(); err != nil {
t.Fatal(err)
}
}