feat(agent): snapshot-based VM boot via cfg.Snapshot (node-local)

When ImpVM.Spec.SnapshotRef is set, applySnapshotBoot looks up the
child ImpVMSnapshot, reads status.SnapshotPath, and populates
cfg.Snapshot with SnapshotPath/MemFilePath/ResumeVM=true before
firecracker.NewMachine is called. The SDK activates
LoadSnapshotHandler automatically via cfg.hasSnapshot(). If the
snapshot has no node-local path yet the VM cold-boots unchanged.

Author: syscod3

internal/agent/firecracker_driver.go

@@ -168,6 +168,13 @@ func (d *FirecrackerDriver) Start(ctx context.Context, vm *impdevv1alpha1.ImpVM)
 	// 5. Build Firecracker config.
 	cfg := d.buildConfig(&class, rootfsPath, sockPath, netInfo, gaEnabled)
 
+	// 5a. Apply snapshot-based boot if requested.
+	if vm.Spec.SnapshotRef != "" {
+		if err := d.applySnapshotBoot(ctx, vm, &cfg); err != nil {
+			return 0, fmt.Errorf("apply snapshot boot: %w", err)
+		}
+	}
+
 	// 6. Build the VMM command.
 	cmd := exec.CommandContext(ctx, d.BinPath, "--api-sock", sockPath) //nolint:gosec // G204: BinPath validated in NewFirecrackerDriver
 
@@ -532,5 +539,33 @@ func (d *FirecrackerDriver) Snapshot(ctx context.Context, vm *impdevv1alpha1.Imp
 	return SnapshotResult{StatePath: statePath, MemPath: memPath}, nil
 }
 
+// applySnapshotBoot looks up the ImpVMSnapshot named by vm.Spec.SnapshotRef,
+// reads its node-local SnapshotPath, and configures cfg.Snapshot for
+// snapshot-based boot. The Firecracker SDK activates LoadSnapshotHandler
+// automatically when cfg.hasSnapshot() returns true (i.e. SnapshotPath != "").
+// If the snapshot has no node-local path yet (e.g. still being created), the
+// function returns nil without modifying cfg — the VM will do a cold boot.
+func (d *FirecrackerDriver) applySnapshotBoot(ctx context.Context, vm *impdevv1alpha1.ImpVM, cfg *firecracker.Config) error {
+	log := logf.FromContext(ctx)
+	snap := &impdevv1alpha1.ImpVMSnapshot{}
+	if err := d.Client.Get(ctx, ctrlclient.ObjectKey{
+		Namespace: vm.Namespace,
+		Name:      vm.Spec.SnapshotRef,
+	}, snap); err != nil {
+		return fmt.Errorf("get snapshot %q: %w", vm.Spec.SnapshotRef, err)
+	}
+	if snap.Status.SnapshotPath == "" {
+		log.Info("snapshot has no node-local path, skipping snapshot boot", "snapshot", snap.Name)
+		return nil
+	}
+	cfg.Snapshot = firecracker.SnapshotConfig{
+		SnapshotPath: filepath.Join(snap.Status.SnapshotPath, "vm.state"),
+		MemFilePath:  filepath.Join(snap.Status.SnapshotPath, "vm.mem"),
+		ResumeVM:     true,
+	}
+	log.Info("configured snapshot-based boot", "snapshotPath", cfg.Snapshot.SnapshotPath)
+	return nil
+}
+
 // compile-time interface check.
 var _ VMDriver = (*FirecrackerDriver)(nil)

internal/agent/firecracker_driver_test.go

@@ -8,6 +8,7 @@ import (
 	"os/exec"
 	"testing"
 
+	firecracker "github.com/firecracker-microvm/firecracker-go-sdk"
 	"k8s.io/apimachinery/pkg/runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client/fake"
 
@@ -458,6 +459,72 @@ func TestFirecrackerDriver_Stop_callsRemoveNATOnLastVM(t *testing.T) {
 	}
 }
 
+func TestFirecrackerDriver_applySnapshotBoot_noPath(t *testing.T) {
+	scheme := runtime.NewScheme()
+	if err := impdevv1alpha1.AddToScheme(scheme); err != nil {
+		t.Fatalf("scheme: %v", err)
+	}
+
+	snap := &impdevv1alpha1.ImpVMSnapshot{}
+	snap.Namespace = "default"
+	snap.Name = "snap-nopath"
+	// snap.Status.SnapshotPath is empty — snapshot not yet written to disk.
+
+	fakeClient := fake.NewClientBuilder().WithScheme(scheme).WithObjects(snap).Build()
+
+	d := &FirecrackerDriver{Client: fakeClient}
+
+	vm := &impdevv1alpha1.ImpVM{}
+	vm.Namespace = "default"
+	vm.Name = "vm-nopath"
+	vm.Spec.SnapshotRef = "snap-nopath"
+
+	cfg := firecracker.Config{}
+	if err := d.applySnapshotBoot(context.Background(), vm, &cfg); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if cfg.Snapshot.SnapshotPath != "" {
+		t.Errorf("SnapshotPath = %q, want empty (cold boot)", cfg.Snapshot.SnapshotPath)
+	}
+}
+
+func TestFirecrackerDriver_applySnapshotBoot_withPath(t *testing.T) {
+	scheme := runtime.NewScheme()
+	if err := impdevv1alpha1.AddToScheme(scheme); err != nil {
+		t.Fatalf("scheme: %v", err)
+	}
+
+	snap := &impdevv1alpha1.ImpVMSnapshot{}
+	snap.Namespace = "default"
+	snap.Name = "snap-ready"
+	snap.Status.SnapshotPath = "/mnt/snaps/default/p/c"
+
+	fakeClient := fake.NewClientBuilder().WithScheme(scheme).WithObjects(snap).Build()
+
+	d := &FirecrackerDriver{Client: fakeClient}
+
+	vm := &impdevv1alpha1.ImpVM{}
+	vm.Namespace = "default"
+	vm.Name = "vm-withpath"
+	vm.Spec.SnapshotRef = "snap-ready"
+
+	cfg := firecracker.Config{}
+	if err := d.applySnapshotBoot(context.Background(), vm, &cfg); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	wantState := "/mnt/snaps/default/p/c/vm.state"
+	if cfg.Snapshot.SnapshotPath != wantState {
+		t.Errorf("SnapshotPath = %q, want %q", cfg.Snapshot.SnapshotPath, wantState)
+	}
+	wantMem := "/mnt/snaps/default/p/c/vm.mem"
+	if cfg.Snapshot.MemFilePath != wantMem {
+		t.Errorf("MemFilePath = %q, want %q", cfg.Snapshot.MemFilePath, wantMem)
+	}
+	if !cfg.Snapshot.ResumeVM {
+		t.Error("ResumeVM = false, want true")
+	}
+}
+
 func TestFirecrackerDriver_Snapshot_noVM_returnsError(t *testing.T) {
 	d := &FirecrackerDriver{procs: make(map[string]*fcProc)}
 	vm := &impdevv1alpha1.ImpVM{}