Fix snapshot compression review follow-ups

Author: sjmiller609

cmd/api/config/config.go

@@ -489,6 +489,7 @@ func (c *Config) Validate() error {
 				}
 			}
 		}
+		c.Snapshot.CompressionDefault.Algorithm = algorithm
 	}
 	if c.Hypervisor.Memory.KernelPageInitMode != "performance" && c.Hypervisor.Memory.KernelPageInitMode != "hardened" {
 		return fmt.Errorf("hypervisor.memory.kernel_page_init_mode must be one of {performance,hardened}, got %q", c.Hypervisor.Memory.KernelPageInitMode)

cmd/api/config/config_test.go

@@ -87,12 +87,15 @@ func TestValidateRejectsInvalidVMLabelBudget(t *testing.T) {
 func TestValidateAllowsLZ4CompressionDefaultWithImplicitLevel(t *testing.T) {
 	cfg := defaultConfig()
 	cfg.Snapshot.CompressionDefault.Enabled = true
-	cfg.Snapshot.CompressionDefault.Algorithm = "lz4"
+	cfg.Snapshot.CompressionDefault.Algorithm = "LZ4"
 	cfg.Snapshot.CompressionDefault.Level = nil
 
 	if err := cfg.Validate(); err != nil {
 		t.Fatalf("expected lz4 compression default to validate, got %v", err)
 	}
+	if cfg.Snapshot.CompressionDefault.Algorithm != "lz4" {
+		t.Fatalf("expected algorithm to normalize to lowercase, got %q", cfg.Snapshot.CompressionDefault.Algorithm)
+	}
 }
 
 func TestValidateAllowsExplicitLZ4CompressionLevelRange(t *testing.T) {

lib/instances/snapshot.go

@@ -393,6 +393,9 @@ func (m *manager) forkSnapshot(ctx context.Context, snapshotID string, req ForkS
 	if target != nil {
 		m.recordSnapshotCompressionPreemption(ctx, snapshotCompressionPreemptionForkSnapshot, *target)
 	}
+	if err := m.ensureSnapshotMemoryReady(ctx, m.paths.SnapshotGuestDir(snapshotID), "", rec.StoredMetadata.HypervisorType); err != nil {
+		return nil, fmt.Errorf("prepare snapshot memory for fork: %w", err)
+	}
 
 	if err := forkvm.CopyGuestDirectory(m.paths.SnapshotGuestDir(snapshotID), dstDir); err != nil {
 		if errors.Is(err, forkvm.ErrSparseCopyUnsupported) {

lib/instances/snapshot_compression.go

@@ -320,6 +320,7 @@ func (m *manager) startCompressionJob(ctx context.Context, target compressionTar
 		var uncompressedSize int64
 		var compressedSize int64
 		metricsCtx := context.Background()
+		log := logger.FromContext(ctx)
 
 		defer func() {
 			m.recordSnapshotCompressionJob(metricsCtx, target, result, start, uncompressedSize, compressedSize)
@@ -329,7 +330,6 @@ func (m *manager) startCompressionJob(ctx context.Context, target compressionTar
 			close(job.done)
 		}()
 
-		log := logger.FromContext(ctx)
 		rawPath, ok := findRawSnapshotMemoryFile(target.SnapshotDir)
 		if !ok {
 			if compressedPath, algorithm, found := findCompressedSnapshotMemoryFile(target.SnapshotDir); found && target.SnapshotID != "" {
@@ -339,8 +339,8 @@ func (m *manager) startCompressionJob(ctx context.Context, target compressionTar
 					size := st.Size()
 					compressedSizeBytes = &size
 				}
-				if metaErr := m.updateSnapshotCompressionMetadata(target.SnapshotID, snapshotstore.SnapshotCompressionStateCompressed, "", &cfg, compressedSizeBytes, nil); metaErr != nil {
-					log.ErrorContext(ctx, "failed to update snapshot compression metadata", "snapshot_id", target.SnapshotID, "error", metaErr)
+				if err := m.updateSnapshotCompressionMetadata(target.SnapshotID, snapshotstore.SnapshotCompressionStateCompressed, "", &cfg, compressedSizeBytes, nil); err != nil {
+					log.ErrorContext(jobCtx, "failed to update snapshot compression metadata", "snapshot_id", target.SnapshotID, "snapshot_dir", target.SnapshotDir, "state", snapshotstore.SnapshotCompressionStateCompressed, "error", err)
 				}
 			}
 			return
@@ -352,25 +352,25 @@ func (m *manager) startCompressionJob(ctx context.Context, target compressionTar
 			if errors.Is(err, context.Canceled) {
 				result = snapshotCompressionResultCanceled
 				if target.SnapshotID != "" {
-					if metaErr := m.updateSnapshotCompressionMetadata(target.SnapshotID, snapshotstore.SnapshotCompressionStateNone, "", nil, nil, nil); metaErr != nil {
-						log.ErrorContext(ctx, "failed to update snapshot compression metadata", "snapshot_id", target.SnapshotID, "error", metaErr)
+					if err := m.updateSnapshotCompressionMetadata(target.SnapshotID, snapshotstore.SnapshotCompressionStateNone, "", nil, nil, nil); err != nil {
+						log.ErrorContext(jobCtx, "failed to update snapshot compression metadata", "snapshot_id", target.SnapshotID, "snapshot_dir", target.SnapshotDir, "state", snapshotstore.SnapshotCompressionStateNone, "error", err)
 					}
 				}
 				return
 			}
 			result = snapshotCompressionResultFailed
 			if target.SnapshotID != "" {
-				if metaErr := m.updateSnapshotCompressionMetadata(target.SnapshotID, snapshotstore.SnapshotCompressionStateError, err.Error(), &target.Policy, nil, nil); metaErr != nil {
-					log.ErrorContext(ctx, "failed to update snapshot compression metadata", "snapshot_id", target.SnapshotID, "error", metaErr)
+				if metadataErr := m.updateSnapshotCompressionMetadata(target.SnapshotID, snapshotstore.SnapshotCompressionStateError, err.Error(), &target.Policy, nil, nil); metadataErr != nil {
+					log.ErrorContext(jobCtx, "failed to update snapshot compression metadata", "snapshot_id", target.SnapshotID, "snapshot_dir", target.SnapshotDir, "state", snapshotstore.SnapshotCompressionStateError, "error", metadataErr)
 				}
 			}
-			log.WarnContext(ctx, "snapshot compression failed", "snapshot_dir", target.SnapshotDir, "error", err)
+			log.WarnContext(jobCtx, "snapshot compression failed", "snapshot_dir", target.SnapshotDir, "error", err)
 			return
 		}
 
 		if target.SnapshotID != "" {
-			if metaErr := m.updateSnapshotCompressionMetadata(target.SnapshotID, snapshotstore.SnapshotCompressionStateCompressed, "", &target.Policy, &compressedSize, &uncompressedSize); metaErr != nil {
-				log.ErrorContext(ctx, "failed to update snapshot compression metadata", "snapshot_id", target.SnapshotID, "error", metaErr)
+			if err := m.updateSnapshotCompressionMetadata(target.SnapshotID, snapshotstore.SnapshotCompressionStateCompressed, "", &target.Policy, &compressedSize, &uncompressedSize); err != nil {
+				log.ErrorContext(jobCtx, "failed to update snapshot compression metadata", "snapshot_id", target.SnapshotID, "snapshot_dir", target.SnapshotDir, "state", snapshotstore.SnapshotCompressionStateCompressed, "error", err)
 			}
 		}
 	}()

lib/instances/snapshot_test.go

@@ -237,6 +237,49 @@ func TestCreateStandbySnapshotFromCompressedSourceCopiesRawMemory(t *testing.T)
 	assert.False(t, ok, "snapshot copy should not inherit compressed memory artifacts from the source standby instance")
 }
 
+func TestForkSnapshotFromCompressedSourceCopiesRawMemory(t *testing.T) {
+	t.Parallel()
+
+	mgr, _ := setupTestManager(t)
+	ctx := context.Background()
+
+	hvType := mgr.defaultHypervisor
+	sourceID := "snapshot-fork-compressed-src"
+	createStandbySnapshotSourceFixture(t, mgr, sourceID, "snapshot-fork-compressed-src", hvType)
+
+	snap, err := mgr.CreateSnapshot(ctx, sourceID, CreateSnapshotRequest{
+		Kind: SnapshotKindStandby,
+		Name: "standby-for-fork-compressed",
+	})
+	require.NoError(t, err)
+
+	snapshotDir := mgr.paths.SnapshotGuestDir(snap.Id)
+	rawPath := filepath.Join(snapshotDir, "memory-ranges")
+	snapshotConfigPath := filepath.Join(snapshotDir, "snapshots", "snapshot-latest", "config.json")
+	require.NoError(t, os.MkdirAll(filepath.Dir(snapshotConfigPath), 0o755))
+	require.NoError(t, os.WriteFile(snapshotConfigPath, []byte(`{}`), 0o644))
+	require.NoError(t, os.WriteFile(rawPath, []byte("some guest memory"), 0o644))
+	_, _, err = compressSnapshotMemoryFile(ctx, rawPath, snapshotstore.SnapshotCompressionConfig{
+		Enabled:   true,
+		Algorithm: snapshotstore.SnapshotCompressionAlgorithmZstd,
+		Level:     intPtr(1),
+	})
+	require.NoError(t, err)
+
+	forked, err := mgr.ForkSnapshot(ctx, snap.Id, ForkSnapshotRequest{
+		Name:        "snapshot-fork-compressed",
+		TargetState: StateStopped,
+	})
+	require.NoError(t, err)
+	t.Cleanup(func() { _ = mgr.DeleteInstance(context.Background(), forked.Id) })
+
+	forkSnapshotDir := mgr.paths.InstanceDir(forked.Id)
+	_, ok := findRawSnapshotMemoryFile(forkSnapshotDir)
+	assert.True(t, ok, "forked snapshot payload should contain raw memory after preparing a compressed snapshot source")
+	_, _, ok = findCompressedSnapshotMemoryFile(forkSnapshotDir)
+	assert.False(t, ok, "forked snapshot payload should not retain compressed memory artifacts from the source snapshot")
+}
+
 func createStoppedSnapshotSourceFixture(t *testing.T, mgr *manager, id, name string, hvType hypervisor.Type) {
 	t.Helper()
 	require.NoError(t, mgr.ensureDirectories(id))