Files
knowledge-governance/internal/testbarrier/barrier_test.go
T
姚章浩 0d3a016a9e feat(worker): 加真实中断演练的固定同步屏障
真杀 worker 只有在"写了一半"那一刻才有意义,靠 sleep 猜时间会错过阶段 ——
上一版演练脚本就是这样永远 exit 0 的。这里把"进程确实停在固定点"变成文件事实:
worker 到达点位后写 <dir>/<point>.hit 再等放行,演练方看到它再 SIGKILL,命中
是确定的。

安全边界:只有 KG_TEST_BARRIER_DIR 与 KG_TEST_BARRIER_POINTS 同时在场才生效
(默认关闭),只由本机 compose overlay 注入;单次等待有硬超时,没人放行就自己
继续;同一进程被杀后重启看到同一份 .hit 直接通过,不会把接管再拦住。屏障挂在
contentTrackedTarget(阶段之间),发布链路不需要知道演练的存在。

验证:屏障包 4 条用例(默认关闭无副作用 / 命中与放行握手 / 超时自行继续并留
.hit+.timeout / 目录不可建报错但不阻塞)与包装层接线用例全绿(后者证明真实
Apply 路径真的走到点位,漏接线会红)。
2026-10-30 03:09:29 +08:00

137 lines
4.5 KiB
Go
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.
package testbarrier
import (
"context"
"encoding/json"
"os"
"path/filepath"
"testing"
"time"
)
// 屏障自己必须是"确定命中"的设施:它要能在真实进程里把写入停住,再由演练方放行,
// 而不是靠 sleep 猜。这里用真实文件握手验证整条路径。
func TestWaitIsNoopByDefault(t *testing.T) {
dir := t.TempDir()
t.Setenv(EnvDir, "")
t.Setenv(EnvPoints, "")
if Enabled() {
t.Fatal("屏障默认必须关闭")
}
start := time.Now()
if err := Wait(context.Background(), "after:database", "job-x"); err != nil {
t.Fatalf("disabled barrier must not error: %v", err)
}
if time.Since(start) > time.Second {
t.Fatal("disabled barrier must return immediately")
}
if entries, _ := os.ReadDir(dir); len(entries) != 0 {
t.Fatalf("disabled barrier must not write anything: %v", entries)
}
}
func TestWaitStopsUntilReleasedThenLetsTakeoverThrough(t *testing.T) {
dir := t.TempDir()
t.Setenv(EnvDir, dir)
t.Setenv(EnvPoints, "after:database,after:resources")
t.Setenv(EnvTimeout, "5s")
if !Enabled() {
t.Fatal("two env variables must enable the barrier")
}
done := make(chan error, 1)
go func() { done <- Wait(context.Background(), "after:database", "libsync-internal-1") }()
hitPath := filepath.Join(dir, "after-database.hit")
record := waitForFile(t, hitPath, 2*time.Second)
var parsed hit
if err := json.Unmarshal(record, &parsed); err != nil {
t.Fatalf("hit file must be JSON: %v", err)
}
if parsed.Subject != "libsync-internal-1" || parsed.PID != os.Getpid() || parsed.Point != "after:database" {
t.Fatalf("hit file does not describe this worker: %+v", parsed)
}
select {
case err := <-done:
t.Fatalf("barrier must still be waiting before release (err=%v)", err)
case <-time.After(150 * time.Millisecond):
}
// 演练方放行(正常演练里是 SIGNAL:这里验证放行路径本身)。
if err := os.WriteFile(filepath.Join(dir, "after-database.go"), []byte("go"), 0600); err != nil {
t.Fatal(err)
}
if err := <-done; err != nil {
t.Fatalf("released barrier must return nil: %v", err)
}
if _, err := os.Stat(filepath.Join(dir, "after-database.go")); !os.IsNotExist(err) {
t.Fatal("放行标记必须被消费掉,否则下一次演练会被它直接放走")
}
// 进程被杀后重启:同一个点位已经有 .hit,必须立刻通过,不许再拦住接管。
start := time.Now()
if err := Wait(context.Background(), "after:database", "libsync-internal-1"); err != nil {
t.Fatal(err)
}
if time.Since(start) > time.Second {
t.Fatal("takeover must not be blocked by an existing hit")
}
// 没配置的点位不停。
if err := Wait(context.Background(), "after:wiki", "libsync-internal-1"); err != nil {
t.Fatal(err)
}
if _, err := os.Stat(filepath.Join(dir, "after-wiki.hit")); !os.IsNotExist(err) {
t.Fatal("未配置的点位不许停留")
}
}
func TestWaitTimesOutInsteadOfHangingWorker(t *testing.T) {
dir := t.TempDir()
t.Setenv(EnvDir, dir)
t.Setenv(EnvPoints, "after:database")
t.Setenv(EnvTimeout, "150ms")
start := time.Now()
if err := Wait(context.Background(), "after:database", "job-timeout"); err != nil {
t.Fatalf("timeout must be a no-error continue: %v", err)
}
if elapsed := time.Since(start); elapsed < 150*time.Millisecond || elapsed > 3*time.Second {
t.Fatalf("超时后必须自己继续,实际等待 %s", elapsed)
}
if _, err := os.Stat(filepath.Join(dir, "after-database.timeout")); err != nil {
t.Fatalf("超时必须留下 .timeout 证据(演练方据此判 missed): %v", err)
}
}
func TestWaitReportsUnusableDirWithoutBlocking(t *testing.T) {
// 屏障目录建不出来(父路径是普通文件):必须报错但不阻塞——屏障是演练设施,
// 坏掉不许让生产写入卡住。
parent := filepath.Join(t.TempDir(), "not-a-dir")
if err := os.WriteFile(parent, []byte("x"), 0600); err != nil {
t.Fatal(err)
}
t.Setenv(EnvDir, filepath.Join(parent, "barrier"))
t.Setenv(EnvPoints, "after:database")
t.Setenv(EnvTimeout, "5s")
start := time.Now()
if err := Wait(context.Background(), "after:database", "job"); err == nil {
t.Fatal("目录不可建时必须报错(演练方据此判无效注入)")
}
if time.Since(start) > time.Second {
t.Fatal("目录不可建时不许阻塞")
}
}
func waitForFile(t *testing.T, path string, limit time.Duration) []byte {
t.Helper()
deadline := time.Now().Add(limit)
for time.Now().Before(deadline) {
if raw, err := os.ReadFile(path); err == nil && len(raw) > 0 {
return raw
}
time.Sleep(20 * time.Millisecond)
}
t.Fatalf("等待屏障现场文件超时:%s", path)
return nil
}