Add standby compression start delay

cmd/api/api/instances.go

@@ -534,6 +534,16 @@ func (s *ApiService) StandbyInstance(ctx context.Context, request oapi.StandbyIn
 		}
 		standbyReq.Compression = compression
 	}
+	if request.Body != nil && request.Body.CompressionDelay != nil {
+		compressionDelay, err := parseOptionalDuration(*request.Body.CompressionDelay, "compression_delay")
+		if err != nil {
+			return oapi.StandbyInstance400JSONResponse{
+				Code:    "invalid_compression_delay",
+				Message: err.Error(),
+			}, nil
+		}
+		standbyReq.CompressionDelay = compressionDelay
+	}
 
 	result, err := s.InstanceManager.StandbyInstance(ctx, inst.Id, standbyReq)
 	if err != nil {
@@ -1135,6 +1145,13 @@ func toInstanceSnapshotPolicy(policy oapi.SnapshotPolicy) (*instances.SnapshotPo
 		}
 		out.Compression = compression
 	}
+	if policy.StandbyCompressionDelay != nil {
+		delay, err := parseOptionalDuration(*policy.StandbyCompressionDelay, "standby_compression_delay")
+		if err != nil {
+			return nil, err
+		}
+		out.StandbyCompressionDelay = delay
+	}
 	return out, nil
 }
 
@@ -1159,5 +1176,20 @@ func toOAPISnapshotPolicy(policy instances.SnapshotPolicy) oapi.SnapshotPolicy {
 		compression := toOAPISnapshotCompressionConfig(*policy.Compression)
 		out.Compression = &compression
 	}
+	if policy.StandbyCompressionDelay != nil {
+		delay := policy.StandbyCompressionDelay.String()
+		out.StandbyCompressionDelay = &delay
+	}
 	return out
 }
+
+func parseOptionalDuration(value string, field string) (*time.Duration, error) {
+	duration, err := time.ParseDuration(value)
+	if err != nil {
+		return nil, fmt.Errorf("%s must be a valid duration: %w", field, err)
+	}
+	if duration < 0 {
+		return nil, fmt.Errorf("%s cannot be negative", field)
+	}
+	return &duration, nil
+}

cmd/api/api/instances_test.go

@@ -477,6 +477,81 @@ func TestCreateInstance_MapsNetworkEgressEnforcementMode(t *testing.T) {
 	assert.Equal(t, instances.EgressEnforcementModeHTTPHTTPSOnly, mockMgr.lastReq.NetworkEgress.EnforcementMode)
 }
 
+func TestCreateInstance_MapsStandbyCompressionDelayInSnapshotPolicy(t *testing.T) {
+	t.Parallel()
+
+	svc := newTestService(t)
+	origMgr := svc.InstanceManager
+	mockMgr := &captureCreateManager{Manager: origMgr}
+	svc.InstanceManager = mockMgr
+
+	delay := "2m30s"
+	resp, err := svc.CreateInstance(ctx(), oapi.CreateInstanceRequestObject{
+		Body: &oapi.CreateInstanceRequest{
+			Name:  "test-standby-compression-delay",
+			Image: "docker.io/library/alpine:latest",
+			SnapshotPolicy: &oapi.SnapshotPolicy{
+				StandbyCompressionDelay: &delay,
+			},
+		},
+	})
+	require.NoError(t, err)
+	_, ok := resp.(oapi.CreateInstance201JSONResponse)
+	require.True(t, ok, "expected 201 response")
+
+	require.NotNil(t, mockMgr.lastReq)
+	require.NotNil(t, mockMgr.lastReq.SnapshotPolicy)
+	require.NotNil(t, mockMgr.lastReq.SnapshotPolicy.StandbyCompressionDelay)
+	assert.Equal(t, 150*time.Second, *mockMgr.lastReq.SnapshotPolicy.StandbyCompressionDelay)
+}
+
+func TestCreateInstance_InvalidStandbyCompressionDelayInSnapshotPolicy(t *testing.T) {
+	t.Parallel()
+
+	svc := newTestService(t)
+	delay := "not-a-duration"
+
+	resp, err := svc.CreateInstance(ctx(), oapi.CreateInstanceRequestObject{
+		Body: &oapi.CreateInstanceRequest{
+			Name:  "test-invalid-standby-delay",
+			Image: "docker.io/library/alpine:latest",
+			SnapshotPolicy: &oapi.SnapshotPolicy{
+				StandbyCompressionDelay: &delay,
+			},
+		},
+	})
+	require.NoError(t, err)
+
+	badReq, ok := resp.(oapi.CreateInstance400JSONResponse)
+	require.True(t, ok, "expected 400 response")
+	assert.Equal(t, "invalid_snapshot_policy", badReq.Code)
+	assert.Contains(t, badReq.Message, "standby_compression_delay")
+}
+
+func TestInstanceToOAPI_EmitsStandbyCompressionDelayInSnapshotPolicy(t *testing.T) {
+	t.Parallel()
+
+	delay := 90 * time.Second
+	inst := instances.Instance{
+		StoredMetadata: instances.StoredMetadata{
+			Id:             "inst-standby-delay",
+			Name:           "inst-standby-delay",
+			Image:          "docker.io/library/alpine:latest",
+			CreatedAt:      time.Now(),
+			HypervisorType: hypervisor.TypeCloudHypervisor,
+			SnapshotPolicy: &instances.SnapshotPolicy{
+				StandbyCompressionDelay: &delay,
+			},
+		},
+		State: instances.StateStandby,
+	}
+
+	oapiInst := instanceToOAPI(inst)
+	require.NotNil(t, oapiInst.SnapshotPolicy)
+	require.NotNil(t, oapiInst.SnapshotPolicy.StandbyCompressionDelay)
+	assert.Equal(t, "1m30s", *oapiInst.SnapshotPolicy.StandbyCompressionDelay)
+}
+
 func TestUpdateInstance_MapsEnvPatch(t *testing.T) {
 	t.Parallel()
 	svc := newTestService(t)
@@ -753,6 +828,81 @@ func TestStandbyInstance_InvalidRequest(t *testing.T) {
 	assert.Contains(t, badReq.Message, "invalid snapshot compression level")
 }
 
+func TestStandbyInstance_MapsCompressionDelay(t *testing.T) {
+	t.Parallel()
+
+	svc := newTestService(t)
+	now := time.Now()
+	source := instances.Instance{
+		StoredMetadata: instances.StoredMetadata{
+			Id:             "standby-delay-src",
+			Name:           "standby-delay-src",
+			Image:          "docker.io/library/alpine:latest",
+			CreatedAt:      now,
+			HypervisorType: hypervisor.TypeCloudHypervisor,
+		},
+		State: instances.StateRunning,
+	}
+
+	mockMgr := &captureStandbyManager{
+		Manager: svc.InstanceManager,
+		result:  &source,
+	}
+	svc.InstanceManager = mockMgr
+
+	delay := "45s"
+	resp, err := svc.StandbyInstance(
+		mw.WithResolvedInstance(ctx(), source.Id, source),
+		oapi.StandbyInstanceRequestObject{
+			Id: source.Id,
+			Body: &oapi.StandbyInstanceRequest{
+				CompressionDelay: &delay,
+			},
+		},
+	)
+	require.NoError(t, err)
+	_, ok := resp.(oapi.StandbyInstance200JSONResponse)
+	require.True(t, ok, "expected 200 response")
+
+	require.NotNil(t, mockMgr.lastReq)
+	require.NotNil(t, mockMgr.lastReq.CompressionDelay)
+	assert.Equal(t, 45*time.Second, *mockMgr.lastReq.CompressionDelay)
+}
+
+func TestStandbyInstance_InvalidCompressionDelay(t *testing.T) {
+	t.Parallel()
+
+	svc := newTestService(t)
+	now := time.Now()
+	source := instances.Instance{
+		StoredMetadata: instances.StoredMetadata{
+			Id:             "standby-invalid-delay-src",
+			Name:           "standby-invalid-delay-src",
+			Image:          "docker.io/library/alpine:latest",
+			CreatedAt:      now,
+			HypervisorType: hypervisor.TypeCloudHypervisor,
+		},
+		State: instances.StateRunning,
+	}
+
+	delay := "-5s"
+	resp, err := svc.StandbyInstance(
+		mw.WithResolvedInstance(ctx(), source.Id, source),
+		oapi.StandbyInstanceRequestObject{
+			Id: source.Id,
+			Body: &oapi.StandbyInstanceRequest{
+				CompressionDelay: &delay,
+			},
+		},
+	)
+	require.NoError(t, err)
+
+	badReq, ok := resp.(oapi.StandbyInstance400JSONResponse)
+	require.True(t, ok, "expected 400 response")
+	assert.Equal(t, "invalid_compression_delay", badReq.Code)
+	assert.Contains(t, badReq.Message, "compression_delay")
+}
+
 func TestForkInstance_FromRunningFlagForwarded(t *testing.T) {
 	t.Parallel()
 	svc := newTestService(t)

lib/instances/create.go

@@ -570,6 +570,11 @@ func validateCreateRequest(req *CreateInstanceRequest) error {
 			return err
 		}
 	}
+	if req.SnapshotPolicy != nil && req.SnapshotPolicy.StandbyCompressionDelay != nil {
+		if _, err := normalizeStandbyCompressionDelay(req.SnapshotPolicy.StandbyCompressionDelay); err != nil {
+			return err
+		}
+	}
 
 	// Validate volume attachments
 	if err := validateVolumeAttachments(req.Volumes); err != nil {

lib/instances/delete.go

@@ -39,8 +39,8 @@ func (m *manager) deleteInstance(
 	if err != nil {
 		return fmt.Errorf("wait for instance compression to stop: %w", err)
 	}
-	if target != nil {
-		m.recordSnapshotCompressionPreemption(ctx, snapshotCompressionPreemptionDeleteInstance, *target)
+	if target != nil && target.State == compressionJobStateRunning {
+		m.recordSnapshotCompressionPreemption(ctx, snapshotCompressionPreemptionDeleteInstance, target.Target)
 	}
 
 	// 2. Get network allocation BEFORE killing VMM (while we can still query it)

lib/instances/fork.go

@@ -485,6 +485,9 @@ func cloneStoredMetadataForFork(src StoredMetadata) StoredMetadata {
 	if src.Credentials != nil {
 		dst.Credentials = cloneCredentialPolicies(src.Credentials)
 	}
+	if src.SnapshotPolicy != nil {
+		dst.SnapshotPolicy = cloneSnapshotPolicy(src.SnapshotPolicy)
+	}
 	if src.Tags != nil {
 		dst.Tags = make(map[string]string, len(src.Tags))
 		for k, v := range src.Tags {

lib/instances/manager.go

@@ -111,6 +111,7 @@ type manager struct {
 	snapshotDefaults          SnapshotPolicy
 	compressionMu             sync.Mutex
 	compressionJobs           map[string]*compressionJob
+	compressionTimerFactory   func(time.Duration) compressionTimer
 	nativeCodecMu             sync.Mutex
 	nativeCodecPaths          map[string]string
 	imageUsageRecorder        ImageUsageRecorder