Files
archie/internal/container/kit_test.go
T
sam ac738e6d07 feat(container): end the install phase between install and startup hooks
StartKit calls InstallDone after the install hooks, before files and
startup hooks, so the caller moves the egress session to its runtime
policy exactly where the Kit spec ends the install phase.
2026-09-26 03:17:49 +10:00

163 lines
5.8 KiB
Go

package container
import (
"context"
"fmt"
"io"
"strings"
"testing"
"time"
"github.com/docker/sandbox-kit-spec/v3/spec"
"github.com/moby/moby/client"
"github.com/samcharles93/archie-core/internal/agentexec"
"github.com/samcharles93/archie-core/internal/infrastructure/kit"
)
const kitProbeImage = "alpine:3"
func kitClient(t *testing.T) *client.Client {
t.Helper()
cli, err := client.New(client.FromEnv)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = cli.Close() })
if _, err := cli.ImageInspect(t.Context(), kitProbeImage); err != nil {
rc, err := cli.ImagePull(t.Context(), kitProbeImage, client.ImagePullOptions{})
if err != nil {
t.Fatal(err)
}
_, _ = io.Copy(io.Discard, rc)
_ = rc.Close()
}
return cli
}
func kitSpec(t *testing.T, install ...kit.Hook) KitSpec {
t.Helper()
name := fmt.Sprintf("archie-kit-test-%d", time.Now().UnixNano())
overwrite := false
return KitSpec{
Name: name,
Image: kitProbeImage,
Network: "none",
Worker: []string{"sleep", "300"},
WorkerEnv: []string{"STATE_STORE_TOKEN=worker-secret", "NATS_TOKEN=worker-secret"},
Labels: map[string]string{"archie-kit-test": name},
Launch: kit.Launch{
Harness: agentexec.HarnessSpec{User: kit.DefaultHarnessUser},
Install: install,
Startup: []kit.Hook{{Argv: []string{"sh", "-c", "id -u > /tmp/startup-uid"}, User: kit.DefaultHarnessUser}},
Files: []spec.File{
{Path: "/tmp/kit/settings.json", Content: `{"theme":1}`, Mode: "0600"},
{Path: "/tmp/kit/keep.json", Content: "second", Overwrite: &overwrite},
},
Volumes: []kit.Volume{{Name: name + "-state", Path: "/data"}},
},
}
}
func startKit(t *testing.T, cli *client.Client, s KitSpec) string {
t.Helper()
id, err := StartKit(t.Context(), cli, s)
t.Cleanup(func() {
ctx := context.WithoutCancel(t.Context())
if id != "" {
_, _ = cli.ContainerRemove(ctx, id, client.ContainerRemoveOptions{Force: true})
}
_ = RemoveKitVolumes(ctx, cli, s.Launch.Volumes)
})
if err != nil {
t.Fatalf("StartKit: %v", err)
}
return id
}
func run(t *testing.T, cli *client.Client, id, user string, argv ...string) (int, string) {
t.Helper()
code, out, err := ExecIn(t.Context(), cli, id, user, []string{"PATH=/usr/bin:/bin"}, argv)
if err != nil {
t.Fatal(err)
}
return code, out
}
// TestKitContainerSeparatesTheHarnessFromTheWorker proves the one-container
// design's boundary on a real container: the worker's credentials are in
// its environment, and the harness user cannot read them.
func TestKitContainerSeparatesTheHarnessFromTheWorker(t *testing.T) {
cli := kitClient(t)
id := startKit(t, cli, kitSpec(t, kit.Hook{
Argv: []string{"sh", "-c", `echo "$WORKSPACE_DIR" > /etc/seeded; echo first > /tmp/kit-keep-seed`},
User: "0", Env: []string{"WORKSPACE_DIR=/workspace"},
}))
inspected, err := cli.ContainerInspect(t.Context(), id, client.ContainerInspectOptions{})
if err != nil {
t.Fatal(err)
}
workerUser := inspected.Container.Config.User
if code, out := run(t, cli, id, workerUser, "cat", "/proc/1/environ"); code != 0 || !strings.Contains(out, "worker-secret") {
t.Fatalf("the worker's own user cannot see its environment (%d %q); the probe below would prove nothing", code, out)
}
if code, out := run(t, cli, id, kit.DefaultHarnessUser, "cat", "/proc/1/environ"); code == 0 || strings.Contains(out, "worker-secret") {
t.Fatalf("the harness user read the worker's environment: %q", out)
}
if _, out := run(t, cli, id, "0", "cat", "/etc/seeded"); out != "/workspace" {
t.Errorf("install hook did not run as root with its declared env: /etc/seeded = %q", out)
}
if _, out := run(t, cli, id, "0", "cat", "/tmp/startup-uid"); out != kit.DefaultHarnessUser {
t.Errorf("startup hook ran as uid %q, want %s", out, kit.DefaultHarnessUser)
}
if _, out := run(t, cli, id, "0", "stat", "-c", "%u %a", "/tmp/kit/settings.json"); out != kit.DefaultHarnessUser+" 600" {
t.Errorf("kit file owner and mode %q, want the harness user and 600", out)
}
if _, out := run(t, cli, id, "0", "cat", "/tmp/kit/keep.json"); out != "second" {
t.Errorf("kit file content %q", out)
}
}
func TestKitContainerFailingInstallHookIsRemoved(t *testing.T) {
cli := kitClient(t)
s := kitSpec(t, kit.Hook{Argv: []string{"sh", "-c", "echo broken registry >&2; exit 3"}, User: "0"})
id, err := StartKit(t.Context(), cli, s)
t.Cleanup(func() { _ = RemoveKitVolumes(context.WithoutCancel(t.Context()), cli, s.Launch.Volumes) })
if err == nil || !strings.Contains(err.Error(), "install hook 1") || !strings.Contains(err.Error(), "broken registry") {
t.Fatalf("StartKit error %v, want the failing hook and its output", err)
}
if id != "" {
t.Fatalf("StartKit returned container %s for a failed start", id)
}
list, err := cli.ContainerList(t.Context(), client.ContainerListOptions{All: true, Filters: client.Filters{}.Add("label", "archie-kit-test="+s.Name)})
if err != nil {
t.Fatal(err)
}
if len(list.Items) != 0 {
t.Fatalf("a failed Kit start left %d container(s) behind", len(list.Items))
}
}
func TestKitContainerEndsTheInstallPhaseBetweenInstallAndStartup(t *testing.T) {
cli := kitClient(t)
s := kitSpec(t, kit.Hook{Argv: []string{"sh", "-c", "touch /tmp/installed"}, User: "0"})
var containerName string
var sawInstalled, sawStartup bool
s.InstallDone = func() {
containerName = s.Name
code, _, err := ExecIn(context.WithoutCancel(t.Context()), cli, containerName, "0", nil, []string{"test", "-e", "/tmp/installed"})
sawInstalled = err == nil && code == 0
code, _, err = ExecIn(context.WithoutCancel(t.Context()), cli, containerName, "0", nil, []string{"test", "-e", "/tmp/startup-uid"})
sawStartup = err == nil && code == 0
}
startKit(t, cli, s)
if containerName == "" {
t.Fatal("InstallDone was never called")
}
if !sawInstalled || sawStartup {
t.Fatalf("InstallDone ran with install done=%v and startup done=%v; want after install, before startup", sawInstalled, sawStartup)
}
}