Validate microvm constraints on snapshot backend switch

Author: cursoragent

lib/instances/snapshot.go

@@ -273,6 +273,10 @@ func (m *manager) restoreSnapshot(ctx context.Context, id string, snapshotID str
 	if err != nil {
 		return nil, err
 	}
+	targetMachineType, err := m.resolveSnapshotTargetMachineType(rec.StoredMetadata, targetHypervisor)
+	if err != nil {
+		return nil, err
+	}
 
 	target, err := m.cancelAndWaitCompressionJob(ctx, m.snapshotJobKeyForSnapshot(snapshotID))
 	if err != nil {
@@ -303,10 +307,7 @@ func (m *manager) restoreSnapshot(ctx context.Context, id string, snapshotID str
 	restored.ExitCode = nil
 	restored.ExitMessage = ""
 	restored.HypervisorType = targetHypervisor
-	restored.MachineType, err = normalizeSnapshotMachineType(restored.MachineType, rec.StoredMetadata.HypervisorType, targetHypervisor)
-	if err != nil {
-		return nil, err
-	}
+	restored.MachineType = targetMachineType
 
 	starter, err := m.getVMStarter(targetHypervisor)
 	if err != nil {
@@ -400,6 +401,10 @@ func (m *manager) forkSnapshot(ctx context.Context, snapshotID string, req ForkS
 	if err != nil {
 		return nil, err
 	}
+	targetMachineType, err := m.resolveSnapshotTargetMachineType(rec.StoredMetadata, targetHypervisor)
+	if err != nil {
+		return nil, err
+	}
 
 	forkID := cuid2.Generate()
 	if _, err := m.loadMetadata(forkID); err == nil {
@@ -441,10 +446,7 @@ func (m *manager) forkSnapshot(ctx context.Context, snapshotID string, req ForkS
 	forkMeta.HypervisorPID = nil
 	forkMeta.DataDir = dstDir
 	forkMeta.HypervisorType = targetHypervisor
-	forkMeta.MachineType, err = normalizeSnapshotMachineType(forkMeta.MachineType, rec.StoredMetadata.HypervisorType, targetHypervisor)
-	if err != nil {
-		return nil, err
-	}
+	forkMeta.MachineType = targetMachineType
 	if targetHypervisor != rec.StoredMetadata.HypervisorType {
 		hvVersion, err := starter.GetVersion(m.paths)
 		if err != nil {
@@ -556,6 +558,30 @@ func (m *manager) resolveSnapshotTargetHypervisor(rec *snapshotRecord, requested
 	return requested, nil
 }
 
+func (m *manager) resolveSnapshotTargetMachineType(stored StoredMetadata, target hypervisor.Type) (hypervisor.MachineType, error) {
+	if target == hypervisor.TypeQEMUMicroVM {
+		var gpu *GPUConfig
+		if stored.GPUProfile != "" {
+			gpu = &GPUConfig{Profile: stored.GPUProfile}
+		}
+		if _, err := m.resolveCreateMachineType(CreateInstanceRequest{
+			HotplugSize:    stored.HotplugSize,
+			Devices:        stored.Devices,
+			Volumes:        stored.Volumes,
+			NetworkEnabled: stored.NetworkEnabled,
+			GPU:            gpu,
+		}, target); err != nil {
+			return "", err
+		}
+	}
+
+	machineType, err := normalizeSnapshotMachineType(stored.MachineType, stored.HypervisorType, target)
+	if err != nil {
+		return "", err
+	}
+	return machineType, nil
+}
+
 func resolveSnapshotTargetState(kind SnapshotKind, requested State) (State, error) {
 	resolved, err := snapshotstore.ResolveTargetState(kind, string(requested))
 	if err != nil {

lib/instances/snapshot_test.go

@@ -84,6 +84,74 @@ func TestStandbySnapshotRejectsTargetHypervisorOverride(t *testing.T) {
 	assert.ErrorIs(t, err, ErrInvalidRequest)
 }
 
+func TestStoppedSnapshotRestoreRejectsIncompatibleMicroVMSwitch(t *testing.T) {
+	t.Parallel()
+	mgr, _ := setupTestManager(t)
+	if _, err := mgr.getVMStarter(hypervisor.TypeQEMUMicroVM); err != nil {
+		t.Skipf("qemu-microvm starter unavailable: %v", err)
+	}
+	ctx := context.Background()
+
+	sourceID := "snapshot-stopped-restore-microvm-src"
+	createStoppedSnapshotSourceFixture(t, mgr, sourceID, "snapshot-stopped-restore-microvm-src", mgr.defaultHypervisor)
+
+	sourceMeta, err := mgr.loadMetadata(sourceID)
+	require.NoError(t, err)
+	sourceMeta.HotplugSize = 1
+	require.NoError(t, mgr.saveMetadata(sourceMeta))
+
+	snap, err := mgr.CreateSnapshot(ctx, sourceID, CreateSnapshotRequest{
+		Kind: SnapshotKindStopped,
+		Name: "stopped-microvm-restore",
+	})
+	require.NoError(t, err)
+
+	_, err = mgr.RestoreSnapshot(ctx, sourceID, snap.Id, RestoreSnapshotRequest{
+		TargetState:      StateStopped,
+		TargetHypervisor: hypervisor.TypeQEMUMicroVM,
+	})
+	require.Error(t, err)
+	assert.ErrorIs(t, err, ErrInvalidRequest)
+	assert.Contains(t, err.Error(), "does not support hotplug memory")
+
+	after, err := mgr.loadMetadata(sourceID)
+	require.NoError(t, err)
+	assert.Equal(t, mgr.defaultHypervisor, after.HypervisorType)
+	assert.Equal(t, int64(1), after.HotplugSize)
+}
+
+func TestStoppedSnapshotForkRejectsIncompatibleMicroVMSwitch(t *testing.T) {
+	t.Parallel()
+	mgr, _ := setupTestManager(t)
+	if _, err := mgr.getVMStarter(hypervisor.TypeQEMUMicroVM); err != nil {
+		t.Skipf("qemu-microvm starter unavailable: %v", err)
+	}
+	ctx := context.Background()
+
+	sourceID := "snapshot-stopped-fork-microvm-src"
+	createStoppedSnapshotSourceFixture(t, mgr, sourceID, "snapshot-stopped-fork-microvm-src", mgr.defaultHypervisor)
+
+	sourceMeta, err := mgr.loadMetadata(sourceID)
+	require.NoError(t, err)
+	sourceMeta.HotplugSize = 1
+	require.NoError(t, mgr.saveMetadata(sourceMeta))
+
+	snap, err := mgr.CreateSnapshot(ctx, sourceID, CreateSnapshotRequest{
+		Kind: SnapshotKindStopped,
+		Name: "stopped-microvm-fork",
+	})
+	require.NoError(t, err)
+
+	_, err = mgr.ForkSnapshot(ctx, snap.Id, ForkSnapshotRequest{
+		Name:             "snapshot-fork-microvm-invalid",
+		TargetState:      StateStopped,
+		TargetHypervisor: hypervisor.TypeQEMUMicroVM,
+	})
+	require.Error(t, err)
+	assert.ErrorIs(t, err, ErrInvalidRequest)
+	assert.Contains(t, err.Error(), "does not support hotplug memory")
+}
+
 func TestRestoreSnapshotCancelsSourceInstanceCompressionJob(t *testing.T) {
 	t.Parallel()