Files
knowledge-governance/internal/libraryfreeze/docker_integration_test.go
T
2026-10-27 23:44:12 +08:00

128 lines
4.3 KiB
Go

package libraryfreeze
import (
"context"
"crypto/rand"
"encoding/hex"
"errors"
"os"
"os/exec"
"strings"
"testing"
"time"
)
func TestFreezeIsolatedDocker(t *testing.T) {
if os.Getenv("KG_FREEZE_DOCKER_ISOLATED") != "1" {
t.Skip("explicit opt-in required for disposable local Docker fixture")
}
if os.Getenv("KG_FREEZE_DOCKER_CHILD") == "1" {
d, err := NewDockerController("/var/run/docker.sock", os.Getenv("KG_FREEZE_SOURCE"), 10*time.Second)
if err != nil {
os.Exit(31)
}
e, err := Open(os.Getenv("KG_FREEZE_ROOT"), os.Getenv("KG_FREEZE_SOURCE"), d)
if err != nil {
os.Exit(32)
}
_, _ = e.Run(context.Background(), "crashed-real", func(context.Context) (string, error) { os.Exit(37); return "", nil })
os.Exit(33)
}
run := func(args ...string) string {
t.Helper()
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
cmd := exec.CommandContext(ctx, "docker", append([]string{"--host", "unix:///var/run/docker.sock"}, args...)...)
out, err := cmd.CombinedOutput()
if err != nil {
t.Fatalf("fixture Docker command failed: %v %s", err, out)
}
return strings.TrimSpace(string(out))
}
image := run("image", "inspect", "busybox:1.36", "--format", "{{.Id}}")
var token [8]byte
if _, err := rand.Read(token[:]); err != nil {
t.Fatal(err)
}
source := "kg-freeze-test-" + hex.EncodeToString(token[:])
var ids []string
defer func() {
for _, id := range ids {
run("rm", "-f", id)
}
if remaining := run("ps", "-aq", "--filter", "label="+sourceLabel+"="+source); remaining != "" {
t.Error("disposable freeze containers remain")
}
}()
for _, name := range []string{"running", "originally-off"} {
id := run("create", "--name", source+"-"+name, "--network", "none", "--read-only", "--tmpfs", "/tmp:rw,noexec,nosuid,size=1m", "--cap-drop", "ALL", "--security-opt", "no-new-privileges", "--memory", "32m", "--cpus", "0.1", "--restart", "unless-stopped", "--label", sourceLabel+"="+source, "--label", environmentLabel+"=test", "--label", roleLabel+"=writer", "--health-cmd", "test -f /tmp/ready", "--health-interval", "1s", "--health-timeout", "1s", "--health-retries", "3", image, "sh", "-c", "trap 'exit 0' TERM; touch /tmp/ready; while :; do sleep 1 & wait $!; done")
ids = append(ids, id)
}
d, err := NewDockerController("/var/run/docker.sock", source, 10*time.Second)
if err != nil {
t.Fatal(err)
}
defer d.Close()
if err = d.Start(context.Background(), ids[0]); err != nil {
t.Fatal(err)
}
root := t.TempDir()
if err = os.Chmod(root, 0700); err != nil {
t.Fatal(err)
}
e, err := Open(root, source, d)
if err != nil {
t.Fatal(err)
}
defer e.Close()
assertRestored := func() {
t.Helper()
a, err := d.inspect(context.Background(), ids[0])
if err != nil || !a.Running || !a.Healthy {
t.Fatalf("original running fixture not healthy: %+v %v", a, err)
}
b, err := d.inspect(context.Background(), ids[1])
if err != nil || b.Running {
t.Fatal("originally-off fixture was started")
}
}
started := time.Now()
result, err := e.Run(context.Background(), "real-success", func(context.Context) (string, error) {
items, err := d.Inventory(context.Background())
if err != nil {
return "", err
}
for _, s := range items {
if s.Running {
t.Fatal("real writer active during capture")
}
}
return strings.Repeat("b", 64), nil
})
if err != nil || result.State != "succeeded" {
t.Fatalf("real freeze=%+v %v", result, err)
}
assertRestored()
t.Logf("disposable_container_freeze_and_health_restore=%s", time.Since(started))
cmd := exec.Command(os.Args[0], "-test.run=^TestFreezeIsolatedDocker$")
cmd.Env = append(os.Environ(), "KG_FREEZE_DOCKER_CHILD=1", "KG_FREEZE_SOURCE="+source, "KG_FREEZE_ROOT="+root)
err = cmd.Run()
var exit *exec.ExitError
if !errors.As(err, &exit) || exit.ExitCode() != 37 {
t.Fatalf("crash injection did not reach stopped window: %v", err)
}
stopped, err := d.inspect(context.Background(), ids[0])
if err != nil || stopped.Running {
t.Fatal("crashed fixture was not stopped")
}
if err = e.Recover(context.Background()); err != nil {
t.Fatal(err)
}
assertRestored()
j, err := e.load("crashed-real")
if err != nil || j.State != "failed" || j.Code != "interrupted" {
t.Fatalf("bad recovery journal: %+v %v", j, err)
}
t.Log("real process exit -> journal reload -> original container healthy; originally-off container remains off")
}