128 lines
4.3 KiB
Go
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")
|
|
}
|