feat(agent): add IsAlive and Reattach to VMDriver interface + StubDriver

Author: syscod3

internal/agent/driver.go

@@ -41,4 +41,13 @@ type VMDriver interface {
 	// The VM is always resumed before Snapshot returns, even on error.
 	// destDir must exist and be writable.
 	Snapshot(ctx context.Context, vm *impdevv1alpha1.ImpVM, destDir string) (SnapshotResult, error)
+
+	// IsAlive returns true if the process with the given PID is still running.
+	// Uses syscall.Kill(pid, 0) on Linux. StubDriver returns IsAliveResult.
+	IsAlive(pid int64) bool
+
+	// Reattach re-registers an already-running VM (started by a previous agent
+	// process) into the driver's internal state without launching a new process.
+	// Called during lazy recovery when the agent restarts and finds a live PID.
+	Reattach(ctx context.Context, vm *impdevv1alpha1.ImpVM) error
 }

internal/agent/firecracker_driver.go

@@ -89,6 +89,9 @@ type FirecrackerDriver struct {
 	procs map[string]*fcProc // keyed by vmKey(vm)
 }
 
+// compile-time interface check.
+var _ VMDriver = (*FirecrackerDriver)(nil)
+
 // NewFirecrackerDriver constructs a FirecrackerDriver from environment variables:
 //   - FC_BIN         — path to firecracker binary (falls back to exec.LookPath)
 //   - FC_SOCK_DIR    — socket directory (default: /run/imp/sockets)
@@ -639,5 +642,12 @@ func (d *FirecrackerDriver) applySnapshotBoot(ctx context.Context, vm *impdevv1a
 	return nil
 }
 
-// compile-time interface check.
-var _ VMDriver = (*FirecrackerDriver)(nil)
+// IsAlive is a placeholder — real implementation in Task 2.
+func (d *FirecrackerDriver) IsAlive(_ int64) bool {
+	return false
+}
+
+// Reattach is a placeholder — real implementation in Task 2.
+func (d *FirecrackerDriver) Reattach(_ context.Context, _ *impdevv1alpha1.ImpVM) error {
+	return fmt.Errorf("not implemented")
+}

internal/agent/stub_driver.go

@@ -28,6 +28,13 @@ type StubDriver struct {
 	startErr   error
 	stopErr    error
 	inspectErr error
+
+	// IsAliveResult is returned by IsAlive.
+	IsAliveResult bool
+	// ReattachCalls records the vmKey of each Reattach call for test assertions.
+	ReattachCalls []string
+	// ReattachErr is returned by Reattach (one-shot, cleared after use).
+	ReattachErr error
 }
 
 // InjectStartError causes the next Start call to return err (one-shot).
@@ -111,3 +118,23 @@ func (d *StubDriver) Snapshot(_ context.Context, vm *impdevv1alpha1.ImpVM, destD
 	}
 	return SnapshotResult{StatePath: statePath, MemPath: memPath}, nil
 }
+
+// IsAlive returns IsAliveResult. The pid argument is ignored.
+func (d *StubDriver) IsAlive(_ int64) bool {
+	d.mu.Lock()
+	defer d.mu.Unlock()
+	return d.IsAliveResult
+}
+
+// Reattach records the call and returns ReattachErr (one-shot, cleared after use).
+func (d *StubDriver) Reattach(_ context.Context, vm *impdevv1alpha1.ImpVM) error {
+	d.mu.Lock()
+	defer d.mu.Unlock()
+	d.ReattachCalls = append(d.ReattachCalls, vmKey(vm))
+	if d.ReattachErr != nil {
+		err := d.ReattachErr
+		d.ReattachErr = nil
+		return err
+	}
+	return nil
+}

internal/agent/stub_driver_test.go

@@ -1,118 +1,70 @@
-package agent_test
+//go:build linux
+
+package agent
 
 import (
 	"context"
-	"fmt"
-	"testing"
+	"errors"
 
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	impdevv1alpha1 "github.com/syscode-labs/imp/api/v1alpha1"
-	"github.com/syscode-labs/imp/internal/agent"
 )
 
-func TestStubDriver_StartInspectStop(t *testing.T) {
-	ctx := context.Background()
-	d := agent.NewStubDriver()
-
-	vm := &impdevv1alpha1.ImpVM{
-		ObjectMeta: metav1.ObjectMeta{Name: "test-vm", Namespace: "default"},
-	}
-
-	// Before Start: Inspect returns not-running.
-	state, err := d.Inspect(ctx, vm)
-	if err != nil {
-		t.Fatalf("Inspect before Start: %v", err)
-	}
-	if state.Running {
-		t.Fatal("expected not running before Start")
-	}
-
-	// Start allocates a PID and IP.
-	pid, err := d.Start(ctx, vm)
-	if err != nil {
-		t.Fatalf("Start: %v", err)
-	}
-	if pid <= 0 {
-		t.Fatalf("expected positive PID, got %d", pid)
-	}
-
-	// Inspect after Start: running=true, IP set, PID matches.
-	state, err = d.Inspect(ctx, vm)
-	if err != nil {
-		t.Fatalf("Inspect after Start: %v", err)
-	}
-	if !state.Running {
-		t.Fatal("expected running after Start")
-	}
-	if state.IP == "" {
-		t.Fatal("expected non-empty IP after Start")
-	}
-	if state.PID != pid {
-		t.Fatalf("expected PID %d, got %d", pid, state.PID)
-	}
-
-	// Stop clears state.
-	if err := d.Stop(ctx, vm); err != nil {
-		t.Fatalf("Stop: %v", err)
-	}
-
-	// Inspect after Stop: not running.
-	state, err = d.Inspect(ctx, vm)
-	if err != nil {
-		t.Fatalf("Inspect after Stop: %v", err)
-	}
-	if state.Running {
-		t.Fatal("expected not running after Stop")
-	}
-}
-
-func TestStubDriver_Snapshot_success(t *testing.T) {
-	d := agent.NewStubDriver()
-	vm := &impdevv1alpha1.ImpVM{}
-	vm.Namespace, vm.Name = "ns", "vm1"
-	_, _ = d.Start(context.Background(), vm)
-
-	res, err := d.Snapshot(context.Background(), vm, t.TempDir())
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if res.StatePath == "" || res.MemPath == "" {
-		t.Errorf("expected non-empty paths, got %+v", res)
-	}
-}
-
-func TestStubDriver_Snapshot_notRunning(t *testing.T) {
-	d := agent.NewStubDriver()
-	vm := &impdevv1alpha1.ImpVM{}
-	vm.Namespace, vm.Name = "ns", "vm-missing"
-
-	_, err := d.Snapshot(context.Background(), vm, t.TempDir())
-	if err == nil {
-		t.Error("expected error for non-running VM")
-	}
-}
-
-func TestStubDriver_ConcurrentSafe(t *testing.T) {
-	ctx := context.Background()
-	d := agent.NewStubDriver()
-
-	done := make(chan struct{})
-	for i := 0; i < 10; i++ {
-		go func(i int) {
-			vm := &impdevv1alpha1.ImpVM{
+var _ = Describe("StubDriver: IsAlive and Reattach", func() {
+	var d *StubDriver
+	var vm *impdevv1alpha1.ImpVM
+
+	BeforeEach(func() {
+		d = NewStubDriver()
+		vm = &impdevv1alpha1.ImpVM{
+			ObjectMeta: metav1.ObjectMeta{
+				Name:      "test-vm",
+				Namespace: "default",
+			},
+		}
+	})
+
+	Describe("IsAlive", func() {
+		It("returns false when IsAliveResult is false (default)", func() {
+			Expect(d.IsAlive(int64(12345))).To(BeFalse())
+		})
+
+		It("returns true when IsAliveResult is true", func() {
+			d.IsAliveResult = true
+			Expect(d.IsAlive(int64(12345))).To(BeTrue())
+		})
+	})
+
+	Describe("Reattach", func() {
+		It("records the vmKey in ReattachCalls", func() {
+			Expect(d.Reattach(context.Background(), vm)).To(Succeed())
+			Expect(d.ReattachCalls).To(ConsistOf("default/test-vm"))
+		})
+
+		It("accumulates multiple calls", func() {
+			vm2 := &impdevv1alpha1.ImpVM{
 				ObjectMeta: metav1.ObjectMeta{
-					Name:      fmt.Sprintf("vm-%d", i),
+					Name:      "other-vm",
 					Namespace: "default",
 				},
 			}
-			_, _ = d.Start(ctx, vm)
-			_, _ = d.Inspect(ctx, vm)
-			_ = d.Stop(ctx, vm)
-			done <- struct{}{}
-		}(i)
-	}
-	for i := 0; i < 10; i++ {
-		<-done
-	}
-}
+			Expect(d.Reattach(context.Background(), vm)).To(Succeed())
+			Expect(d.Reattach(context.Background(), vm2)).To(Succeed())
+			Expect(d.ReattachCalls).To(ConsistOf("default/test-vm", "default/other-vm"))
+		})
+
+		It("returns and clears ReattachErr on error", func() {
+			sentinel := errors.New("reattach failed")
+			d.ReattachErr = sentinel
+
+			err := d.Reattach(context.Background(), vm)
+			Expect(err).To(MatchError(sentinel))
+
+			// error is cleared — second call succeeds
+			Expect(d.Reattach(context.Background(), vm)).To(Succeed())
+		})
+	})
+})