Thales Maciel
ebb68c3126
Upgrades from the pre-bundle layout can leave the unmanaged default image pointing at repo-root artifacts that no longer exist, causing vm start preflight to fail forever. Treat the default image as reconcilable state instead of bailing out when a record exists. Compute the desired default image from current runtime/config defaults, update an existing unmanaged default in place when its paths diverge, keep managed defaults untouched, and preserve the original ID so existing VMs keep referencing it. Added regression tests covering creation, no-op, reconciliation, managed-image skip, and missing-artifact behavior.
332 lines
9 KiB
Go
332 lines
9 KiB
Go
package daemon
|
|
|
|
import (
|
|
"context"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
"time"
|
|
|
|
"banger/internal/model"
|
|
"banger/internal/store"
|
|
)
|
|
|
|
func TestEnsureDefaultImageUsesConfiguredDefaultRootfs(t *testing.T) {
|
|
dir := t.TempDir()
|
|
rootfs, kernel, _, _, _ := writeDefaultImageArtifacts(t, dir)
|
|
db := openDefaultImageStore(t, dir)
|
|
|
|
d := &Daemon{
|
|
config: model.DaemonConfig{
|
|
DefaultImageName: "default",
|
|
DefaultRootfs: rootfs,
|
|
DefaultKernel: kernel,
|
|
},
|
|
store: db,
|
|
}
|
|
|
|
if err := d.ensureDefaultImage(context.Background()); err != nil {
|
|
t.Fatalf("ensureDefaultImage: %v", err)
|
|
}
|
|
|
|
image, err := db.GetImageByName(context.Background(), "default")
|
|
if err != nil {
|
|
t.Fatalf("GetImageByName: %v", err)
|
|
}
|
|
if image.RootfsPath != rootfs {
|
|
t.Fatalf("RootfsPath = %q, want %q", image.RootfsPath, rootfs)
|
|
}
|
|
if image.KernelPath != kernel {
|
|
t.Fatalf("KernelPath = %q, want %q", image.KernelPath, kernel)
|
|
}
|
|
if image.Managed {
|
|
t.Fatal("default image should be unmanaged")
|
|
}
|
|
}
|
|
|
|
func TestEnsureDefaultImageLeavesCurrentUnmanagedDefaultUntouched(t *testing.T) {
|
|
dir := t.TempDir()
|
|
rootfs, kernel, initrd, modulesDir, packages := writeDefaultImageArtifacts(t, dir)
|
|
db := openDefaultImageStore(t, dir)
|
|
now := time.Date(2026, time.March, 16, 12, 0, 0, 0, time.UTC)
|
|
image := model.Image{
|
|
ID: "default-id",
|
|
Name: "default",
|
|
Managed: false,
|
|
RootfsPath: rootfs,
|
|
KernelPath: kernel,
|
|
InitrdPath: initrd,
|
|
ModulesDir: modulesDir,
|
|
PackagesPath: packages,
|
|
Docker: true,
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
}
|
|
if err := db.UpsertImage(context.Background(), image); err != nil {
|
|
t.Fatalf("UpsertImage: %v", err)
|
|
}
|
|
|
|
d := &Daemon{
|
|
config: model.DaemonConfig{
|
|
DefaultImageName: "default",
|
|
DefaultRootfs: rootfs,
|
|
DefaultKernel: kernel,
|
|
DefaultInitrd: initrd,
|
|
DefaultModulesDir: modulesDir,
|
|
DefaultPackagesFile: packages,
|
|
},
|
|
store: db,
|
|
}
|
|
|
|
if err := d.ensureDefaultImage(context.Background()); err != nil {
|
|
t.Fatalf("ensureDefaultImage: %v", err)
|
|
}
|
|
|
|
got, err := db.GetImageByName(context.Background(), "default")
|
|
if err != nil {
|
|
t.Fatalf("GetImageByName: %v", err)
|
|
}
|
|
if got.ID != image.ID {
|
|
t.Fatalf("ID = %q, want %q", got.ID, image.ID)
|
|
}
|
|
if !got.UpdatedAt.Equal(image.UpdatedAt) {
|
|
t.Fatalf("UpdatedAt = %s, want unchanged %s", got.UpdatedAt, image.UpdatedAt)
|
|
}
|
|
}
|
|
|
|
func TestEnsureDefaultImageReconcilesStaleUnmanagedDefaultInPlace(t *testing.T) {
|
|
dir := t.TempDir()
|
|
rootfs, kernel, initrd, modulesDir, packages := writeDefaultImageArtifacts(t, dir)
|
|
db := openDefaultImageStore(t, dir)
|
|
now := time.Date(2026, time.March, 16, 12, 0, 0, 0, time.UTC)
|
|
stale := model.Image{
|
|
ID: "default-id",
|
|
Name: "default",
|
|
Managed: false,
|
|
RootfsPath: "/home/thales/projects/personal/banger/rootfs-docker.ext4",
|
|
KernelPath: "/home/thales/projects/personal/banger/wtf/root/boot/vmlinux-6.8.0-94-generic",
|
|
InitrdPath: "/home/thales/projects/personal/banger/wtf/root/boot/initrd.img-6.8.0-94-generic",
|
|
ModulesDir: "/home/thales/projects/personal/banger/wtf/root/lib/modules/6.8.0-94-generic",
|
|
PackagesPath: "/home/thales/projects/personal/banger/packages.apt",
|
|
Docker: true,
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
}
|
|
if err := db.UpsertImage(context.Background(), stale); err != nil {
|
|
t.Fatalf("UpsertImage: %v", err)
|
|
}
|
|
vm := testVM("uses-default", stale.ID, "172.16.0.25")
|
|
if err := db.UpsertVM(context.Background(), vm); err != nil {
|
|
t.Fatalf("UpsertVM: %v", err)
|
|
}
|
|
|
|
d := &Daemon{
|
|
config: model.DaemonConfig{
|
|
DefaultImageName: "default",
|
|
DefaultRootfs: rootfs,
|
|
DefaultKernel: kernel,
|
|
DefaultInitrd: initrd,
|
|
DefaultModulesDir: modulesDir,
|
|
DefaultPackagesFile: packages,
|
|
},
|
|
store: db,
|
|
}
|
|
|
|
if err := d.ensureDefaultImage(context.Background()); err != nil {
|
|
t.Fatalf("ensureDefaultImage: %v", err)
|
|
}
|
|
|
|
got, err := db.GetImageByName(context.Background(), "default")
|
|
if err != nil {
|
|
t.Fatalf("GetImageByName: %v", err)
|
|
}
|
|
if got.ID != stale.ID {
|
|
t.Fatalf("ID = %q, want preserved %q", got.ID, stale.ID)
|
|
}
|
|
if !got.CreatedAt.Equal(stale.CreatedAt) {
|
|
t.Fatalf("CreatedAt = %s, want preserved %s", got.CreatedAt, stale.CreatedAt)
|
|
}
|
|
if got.RootfsPath != rootfs || got.KernelPath != kernel || got.InitrdPath != initrd || got.ModulesDir != modulesDir || got.PackagesPath != packages {
|
|
t.Fatalf("stale default not reconciled: %+v", got)
|
|
}
|
|
if !got.UpdatedAt.After(stale.UpdatedAt) {
|
|
t.Fatalf("UpdatedAt = %s, want newer than %s", got.UpdatedAt, stale.UpdatedAt)
|
|
}
|
|
gotVM, err := db.GetVMByID(context.Background(), vm.ID)
|
|
if err != nil {
|
|
t.Fatalf("GetVMByID: %v", err)
|
|
}
|
|
if gotVM.ImageID != stale.ID {
|
|
t.Fatalf("VM image ID = %q, want preserved %q", gotVM.ImageID, stale.ID)
|
|
}
|
|
}
|
|
|
|
func TestEnsureDefaultImageLeavesManagedDefaultUntouched(t *testing.T) {
|
|
dir := t.TempDir()
|
|
rootfs, kernel, _, _, _ := writeDefaultImageArtifacts(t, dir)
|
|
db := openDefaultImageStore(t, dir)
|
|
now := time.Date(2026, time.March, 16, 12, 0, 0, 0, time.UTC)
|
|
managed := model.Image{
|
|
ID: "managed-default",
|
|
Name: "default",
|
|
Managed: true,
|
|
RootfsPath: "/managed/rootfs.ext4",
|
|
KernelPath: "/managed/vmlinux",
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
}
|
|
if err := db.UpsertImage(context.Background(), managed); err != nil {
|
|
t.Fatalf("UpsertImage: %v", err)
|
|
}
|
|
|
|
d := &Daemon{
|
|
config: model.DaemonConfig{
|
|
DefaultImageName: "default",
|
|
DefaultRootfs: rootfs,
|
|
DefaultKernel: kernel,
|
|
},
|
|
store: db,
|
|
}
|
|
|
|
if err := d.ensureDefaultImage(context.Background()); err != nil {
|
|
t.Fatalf("ensureDefaultImage: %v", err)
|
|
}
|
|
|
|
got, err := db.GetImageByName(context.Background(), "default")
|
|
if err != nil {
|
|
t.Fatalf("GetImageByName: %v", err)
|
|
}
|
|
if got.RootfsPath != managed.RootfsPath || got.KernelPath != managed.KernelPath {
|
|
t.Fatalf("managed default was rewritten: %+v", got)
|
|
}
|
|
}
|
|
|
|
func TestEnsureDefaultImageSkipsRewriteWhenCurrentArtifactsMissing(t *testing.T) {
|
|
dir := t.TempDir()
|
|
db := openDefaultImageStore(t, dir)
|
|
now := time.Date(2026, time.March, 16, 12, 0, 0, 0, time.UTC)
|
|
stale := model.Image{
|
|
ID: "default-id",
|
|
Name: "default",
|
|
Managed: false,
|
|
RootfsPath: "/old/rootfs.ext4",
|
|
KernelPath: "/old/vmlinux",
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
}
|
|
if err := db.UpsertImage(context.Background(), stale); err != nil {
|
|
t.Fatalf("UpsertImage: %v", err)
|
|
}
|
|
|
|
d := &Daemon{
|
|
config: model.DaemonConfig{
|
|
DefaultImageName: "default",
|
|
DefaultRootfs: filepath.Join(dir, "missing-rootfs.ext4"),
|
|
DefaultKernel: filepath.Join(dir, "missing-vmlinux"),
|
|
},
|
|
store: db,
|
|
}
|
|
|
|
if err := d.ensureDefaultImage(context.Background()); err != nil {
|
|
t.Fatalf("ensureDefaultImage: %v", err)
|
|
}
|
|
|
|
got, err := db.GetImageByName(context.Background(), "default")
|
|
if err != nil {
|
|
t.Fatalf("GetImageByName: %v", err)
|
|
}
|
|
if got.RootfsPath != stale.RootfsPath || got.KernelPath != stale.KernelPath {
|
|
t.Fatalf("default image should have stayed stale when no current artifacts exist: %+v", got)
|
|
}
|
|
}
|
|
|
|
func openDefaultImageStore(t *testing.T, dir string) *store.Store {
|
|
t.Helper()
|
|
db, err := store.Open(filepath.Join(dir, "state.db"))
|
|
if err != nil {
|
|
t.Fatalf("open store: %v", err)
|
|
}
|
|
t.Cleanup(func() {
|
|
_ = db.Close()
|
|
})
|
|
return db
|
|
}
|
|
|
|
func writeDefaultImageArtifacts(t *testing.T, dir string) (rootfs, kernel, initrd, modulesDir, packages string) {
|
|
t.Helper()
|
|
rootfs = filepath.Join(dir, "rootfs-docker.ext4")
|
|
kernel = filepath.Join(dir, "vmlinux")
|
|
initrd = filepath.Join(dir, "initrd.img")
|
|
modulesDir = filepath.Join(dir, "modules")
|
|
packages = filepath.Join(dir, "packages.apt")
|
|
files := []string{
|
|
rootfs,
|
|
kernel,
|
|
initrd,
|
|
packages,
|
|
filepath.Join(modulesDir, "modules.dep"),
|
|
}
|
|
for _, path := range files {
|
|
if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
|
|
t.Fatalf("mkdir %s: %v", filepath.Dir(path), err)
|
|
}
|
|
if err := os.WriteFile(path, []byte("test"), 0o644); err != nil {
|
|
t.Fatalf("write %s: %v", path, err)
|
|
}
|
|
}
|
|
return rootfs, kernel, initrd, modulesDir, packages
|
|
}
|
|
|
|
func TestSetDNSUsesConfiguredMapDNSDataFile(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
dataFile := filepath.Join(t.TempDir(), "mapdns", "records.json")
|
|
runner := &scriptedRunner{
|
|
t: t,
|
|
steps: []runnerStep{
|
|
{
|
|
call: runnerCall{
|
|
name: "custom-mapdns",
|
|
args: []string{"set", "--data-file", dataFile, "devbox.vm", "172.16.0.8"},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
d := &Daemon{
|
|
runner: runner,
|
|
config: model.DaemonConfig{
|
|
MapDNSBin: "custom-mapdns",
|
|
MapDNSDataFile: dataFile,
|
|
},
|
|
}
|
|
|
|
if err := d.setDNS(context.Background(), "devbox", "172.16.0.8"); err != nil {
|
|
t.Fatalf("setDNS: %v", err)
|
|
}
|
|
runner.assertExhausted()
|
|
}
|
|
|
|
func TestSetDNSUsesMapDNSDefaultsWhenDataFileUnset(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
runner := &scriptedRunner{
|
|
t: t,
|
|
steps: []runnerStep{
|
|
{
|
|
call: runnerCall{
|
|
name: "mapdns",
|
|
args: []string{"set", "devbox.vm", "172.16.0.8"},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
d := &Daemon{
|
|
runner: runner,
|
|
config: model.DaemonConfig{},
|
|
}
|
|
|
|
if err := d.setDNS(context.Background(), "devbox", "172.16.0.8"); err != nil {
|
|
t.Fatalf("setDNS: %v", err)
|
|
}
|
|
runner.assertExhausted()
|
|
}
|