Files
archie/internal/releaseupdate/installer_test.go
T

216 lines
7.1 KiB
Go

package releaseupdate
import (
"archive/zip"
"crypto/sha256"
"fmt"
"os"
"os/exec"
"path/filepath"
"strings"
"testing"
"golang.org/x/sys/unix"
)
func TestUpdateTransaction(t *testing.T) {
for _, scenario := range []string{"healthy", "checksum", "unsafe-path", "missing-digest", "busy", "lock", "unhealthy", "crash"} {
t.Run(scenario, func(t *testing.T) {
f := newUpdateFixture(t, scenario)
var lock *os.File
if scenario == "lock" {
var err error
lock, err = os.OpenFile(filepath.Join(f.state, "lock"), os.O_CREATE|os.O_RDWR, 0o600)
if err != nil {
t.Fatal(err)
}
defer lock.Close()
if err := unix.Flock(int(lock.Fd()), unix.LOCK_EX); err != nil {
t.Fatal(err)
}
fixtureWrite(t, filepath.Join(f.state, "holder"), "fixture-owner", 0o600)
}
args := []string{}
if scenario == "busy" {
args = append(args, "--auto")
}
output, err := f.run(t, f.installer, args...)
refusal := map[string]string{"checksum": "checksum mismatch", "unsafe-path": "unsafe archive path", "missing-digest": "digest-pinned", "busy": "work in flight", "lock": "fixture-owner"}[scenario]
if refusal != "" {
if err == nil || !strings.Contains(output, refusal) {
t.Fatalf("wanted %q refusal; err=%v output=%s", refusal, err, output)
}
f.assertVersion(t, "old")
return
}
if err != nil {
t.Fatalf("installer: %v\n%s", err, output)
}
f.assertVersion(t, "old") // Staging cannot mutate a running executable.
old, err := os.Open(filepath.Join(f.bin, "archied"))
if err != nil {
t.Fatal(err)
}
defer old.Close()
watchdog := filepath.Join(f.state, "transaction", "watchdog")
output, err = f.run(t, watchdog)
if scenario == "crash" {
if err == nil {
t.Fatal("expected injected crash")
}
f.env = append(f.env, "CRASH_AFTER=")
output, err = f.run(t, watchdog, "--boot-recover")
}
if err != nil {
t.Fatalf("watchdog: %v\n%s", err, output)
}
want := "old"
if scenario == "healthy" {
want = "new"
}
f.assertVersion(t, want)
data := make([]byte, 100)
n, _ := old.Read(data)
if !strings.Contains(string(data[:n]), "old") {
t.Fatal("promotion overwrote the open old inode")
}
if _, err := os.Stat(filepath.Join(f.state, "transaction")); !os.IsNotExist(err) {
t.Fatalf("journal not retired: %v", err)
}
})
}
}
type updateFixture struct {
bin, state, installer string
env []string
}
func fixtureWrite(t *testing.T, path, data string, mode os.FileMode) {
t.Helper()
if err := os.WriteFile(path, []byte(data), mode); err != nil {
t.Fatal(err)
}
}
func newUpdateFixture(t *testing.T, scenario string) updateFixture {
t.Helper()
root := t.TempDir()
bin, state, fake := filepath.Join(root, "bin"), filepath.Join(root, "state"), filepath.Join(root, "fake")
for _, dir := range []string{bin, state, fake} {
if err := os.MkdirAll(dir, 0o700); err != nil {
t.Fatal(err)
}
}
scripts, err := filepath.Abs("../../scripts")
if err != nil {
t.Fatal(err)
}
for _, name := range []string{"archied", "archie-state-store", "archie-gateway", "archie-ui", "archie-messaging"} {
fixtureWrite(t, filepath.Join(bin, name), "#!/bin/bash\n# old\nexit 0\n", 0o755)
}
config := filepath.Join(root, "config.toml")
fixtureWrite(t, config, "[services.state]\n[services.gateway]\n", 0o600)
archive := makeUpdateArchive(t, root, scripts, scenario)
sum := sha256.Sum256(archive)
if scenario == "checksum" {
sum[0]++
}
fixtureWrite(t, filepath.Join(root, "SHA256SUMS"), fmt.Sprintf("%x archie-core-archied-v2.0.0-linux-amd64.zip\n", sum), 0o600)
fixtureWrite(t, filepath.Join(fake, "curl"), `#!/bin/bash
out=""
for ((i=1;i<=$#;i++)); do
if [ "${!i}" = -o ]; then j=$((i+1)); out="${!j}"; fi
case "${!i}" in
*/SHA256SUMS) source="$FIXTURE/SHA256SUMS" ;;
*.zip) source="$FIXTURE/archive.zip" ;;
esac
done
if [ -n "$out" ]; then cp "$source" "$out"; exit; fi
if [ "$SCENARIO" = unhealthy ]; then exit 22; fi
busy=0
[ "$SCENARIO" = busy ] && busy=1
printf '{"status":"ok","version":"2.0.0","in_flight":%s}\n' "$busy"
`, 0o755)
for _, name := range []string{"systemctl", "systemd-run", "docker"} {
fixtureWrite(t, filepath.Join(fake, name), "#!/bin/bash\nexit 0\n", 0o755)
}
fixtureWrite(t, filepath.Join(fake, "git"), "#!/bin/bash\necho unexpected-git >&2\nexit 98\n", 0o755)
fixtureWrite(t, filepath.Join(fake, "mv"), `#!/bin/bash
/bin/mv "$@" || exit
if [ -n "$CRASH_AFTER" ] && [[ "$*" == *".archied.new"* ]]; then kill -KILL "$PPID"; fi
`, 0o755)
return updateFixture{bin: bin, state: state, installer: filepath.Join(scripts, "archie-update-install"), env: append(os.Environ(),
"PATH="+fake+":"+os.Getenv("PATH"), "FIXTURE="+root, "SCENARIO="+scenario,
"ARCHIE_BIN_DIR="+bin, "ARCHIE_CONFIG_PATH="+config, "ARCHIE_UPDATE_STATE_DIR="+state,
"ARCHIE_UPDATE_DAEMON_PREVIOUS=1.0.0", "ARCHIE_UPDATE_DAEMON_VERSION=2.0.0",
"ARCHIE_UPDATE_AGENT_PREVIOUS=1.0.0", "ARCHIE_UPDATE_AGENT_VERSION="+map[bool]string{true: "2.0.0"}[scenario == "missing-digest"],
"ARCHIE_UPDATE_HEALTH_TIMEOUT=1", "ARCHIE_UPDATE_OBSERVE_SECONDS=0", "ARCHIE_UPDATE_POLL_INTERVAL=0.01",
"ARCHIE_UPDATE_STATE_STORE_TARGET=", "CRASH_AFTER="+map[bool]string{true: "archied"}[scenario == "crash"],
)}
}
func makeUpdateArchive(t *testing.T, root, scripts, scenario string) []byte {
t.Helper()
file, err := os.Create(filepath.Join(root, "archive.zip"))
if err != nil {
t.Fatal(err)
}
z := zip.NewWriter(file)
files := map[string]string{"release.json": `{"required_topology":{"units":["archie-state-store","archie-gateway","archie-ui","archie-messaging","archied"],"config_sections":["services.state","services.gateway"]},"agent_image":"mutable:latest"}`}
for _, name := range []string{"archied", "archie-state-store", "archie-gateway", "archie-ui", "archie-messaging"} {
files[name] = "#!/bin/bash\n# new\nif [ \"$1\" = -version ]; then echo '" + name + " 2.0.0'; fi\nexit 0\n"
}
for _, name := range []string{"archie-update-install", "archie-update-watchdog", "archie-update-check"} {
data, err := os.ReadFile(filepath.Join(scripts, name))
if err != nil {
t.Fatal(err)
}
files[name] = string(data)
}
if scenario == "unsafe-path" {
files["../escape"] = "escape"
}
for name, body := range files {
header := &zip.FileHeader{Name: "archie-core-archied-v2.0.0-linux-amd64/" + name, Method: zip.Deflate}
header.SetMode(0o755)
w, err := z.CreateHeader(header)
if err != nil {
t.Fatal(err)
}
if _, err := w.Write([]byte(body)); err != nil {
t.Fatal(err)
}
}
if err := z.Close(); err != nil {
t.Fatal(err)
}
if err := file.Close(); err != nil {
t.Fatal(err)
}
data, err := os.ReadFile(file.Name())
if err != nil {
t.Fatal(err)
}
return data
}
func (f updateFixture) run(t *testing.T, path string, args ...string) (string, error) {
t.Helper()
cmd := exec.CommandContext(t.Context(), path, args...)
cmd.Env = f.env
data, err := cmd.CombinedOutput()
return string(data), err
}
func (f updateFixture) assertVersion(t *testing.T, want string) {
t.Helper()
data, err := os.ReadFile(filepath.Join(f.bin, "archied"))
if err != nil {
t.Fatal(err)
}
if !strings.Contains(string(data), "# "+want) {
t.Fatalf("wanted %s executable: %s", want, data)
}
}