ci(e2e-kind): build and load local images before smoke tests

Author: syscod3

internal/agent/firecracker_driver.go

@@ -586,6 +586,10 @@ func (d *FirecrackerDriver) Snapshot(ctx context.Context, vm *impdevv1alpha1.Imp
 		return SnapshotResult{}, fmt.Errorf("VM %s is not running on this node", key)
 	}
 
+	if proc.machine == nil {
+		return SnapshotResult{}, fmt.Errorf("cannot snapshot VM %s: no machine handle (started by a previous agent process)", key)
+	}
+
 	log := logf.FromContext(ctx).WithValues("vm", key)
 
 	// Pause the VM. Always resume via defer — VM must never be left paused.
@@ -664,6 +668,14 @@ func (d *FirecrackerDriver) Reattach(_ context.Context, vm *impdevv1alpha1.ImpVM
 			vmKey(vm), sock, err)
 	}
 	d.mu.Lock()
+	// Note: the reattached fcProc has nil netInfo and machine.
+	// If the process later dies and Inspect cleans it up, the allocator
+	// entry will not be released via Stop (which checks netInfo). The
+	// reconciler's handleRunning will detect the dead PID via IsAlive=false
+	// on the next reconcile and call finishFailed, which does not release
+	// the allocator either. This is an accepted limitation: the IP remains
+	// reserved until the agent restarts again and the VM is definitively
+	// dead (PID gone and socket absent).
 	d.procs[vmKey(vm)] = &fcProc{
 		pid:    vm.Status.RuntimePID,
 		socket: sock,

internal/agent/network/ipallocator.go

@@ -93,8 +93,10 @@ func (a *Allocator) Reserve(netKey, ip string) {
 	if a.allocated[netKey] == nil {
 		a.allocated[netKey] = make(map[string]struct{})
 	}
-	a.allocated[netKey][ip] = struct{}{}
-	a.vmCount[netKey]++
+	if _, alreadyReserved := a.allocated[netKey][ip]; !alreadyReserved {
+		a.allocated[netKey][ip] = struct{}{}
+		a.vmCount[netKey]++
+	}
 }
 
 // sizeToCIDRPrefix returns the smallest CIDR prefix length that accommodates n hosts.

internal/agent/network/ipallocator_test.go

@@ -113,6 +113,19 @@ func TestAllocator_release_unknown_key(t *testing.T) {
 	}
 }
 
+func TestAllocator_reserve_idempotent(t *testing.T) {
+	a := network.NewAllocator()
+	// Calling Reserve twice for the same IP (e.g. two agent restarts) must not
+	// inflate vmCount. A single Release should return wasLast=true.
+	a.Reserve("ns/net", "10.0.0.2")
+	a.Reserve("ns/net", "10.0.0.2") // duplicate — idempotent
+
+	wasLast := a.Release("ns/net", "10.0.0.2")
+	if !wasLast {
+		t.Error("expected wasLast=true: duplicate Reserve must not inflate vmCount")
+	}
+}
+
 func TestAllocator_reserve_countsForWasLast(t *testing.T) {
 	a := network.NewAllocator()
 	// Reserve two IPs as if recovering running VMs on restart.