go-sip/internal/agent/recording_cleanup.go

package agent

import (
	"errors"
	"fmt"
	"log/slog"
	"os"
	"path/filepath"
	"strings"
)

type RecordingCleanupResult struct {
	DeletedFiles   int
	DeletedBytes   int64
	RetainedReason string
}

// cleanupDelivered requires the recording path lock. A temporary durable copy
// of the delivered info remains outside the leaf until that leaf is gone.
func (r *RecordingRecovery) cleanupDelivered(entry RecordingRecoveryEntry) (result RecordingCleanupResult, cleanupErr error) {
	defer func() {
		attrs := append(recordingRecoveryAttrs(entry), "stage", "delivered_recording_cleanup", "deleted_files", result.DeletedFiles, "deleted_bytes", result.DeletedBytes)
		if cleanupErr != nil {
			slog.Error("Delivered recording cleanup failed; unfinished evidence retained", append(attrs, "error", cleanupErr)...)
		} else if result.RetainedReason != "" {
			slog.Info("Delivered recording retained", append(attrs, "reason", result.RetainedReason)...)
		} else {
			slog.Info("Delivered recording files cleaned", attrs...)
		}
	}()
	if entry.State != "delivered" || entry.Uploaded == nil {
		return result, errors.New("recording cleanup requires its persisted delivery receipt")
	}
	dir, audio, info, err := r.paths(entry.Bucket, entry.ObjectKey)
	if err != nil {
		return result, err
	}
	proofPath, err := r.cleanupProofPath(entry.Bucket, entry.ObjectKey)
	if err != nil {
		return result, err
	}
	_, proofErr := r.readCleanupProof(proofPath)
	if proofErr != nil && !errors.Is(proofErr, os.ErrNotExist) {
		return result, proofErr
	}
	proved := proofErr == nil
	leafExists := true
	current := r.Root
	for _, segment := range append([]string{"", entry.Bucket}, strings.Split(entry.ObjectKey, "/")...) {
		if segment != "" {
			current = filepath.Join(current, segment)
		}
		if err := privateCleanupDirectory(current); err != nil {
			if current == dir && proved && errors.Is(err, os.ErrNotExist) {
				leafExists = false
				break
			}
			return result, err
		}
	}
	if leafExists {
		items, err := os.ReadDir(dir)
		if err != nil {
			return result, err
		}
		for _, item := range items {
			if item.Name() != "recording.wav" && item.Name() != "info.json" {
				return result, errors.New("recording cleanup target contains an unrecognized file")
			}
		}
	}
	journal := ResultJournal{Root: r.Root}
	resultPath, err := journal.path(entry.SourceEventID)
	if err != nil {
		return result, err
	}
	release, err := holdPrivateState(resultPath)
	if err != nil {
		return result, err
	}
	defer release()
	pending, _, err := journal.load(entry.SourceEventID)
	if err == nil {
		if entry.DispatcherID != "" && (pending.DispatcherID != entry.DispatcherID || pending.TenantID != entry.TenantID) {
			return result, errors.New("original result reference conflicts with delivered recording ownership")
		}
		result.RetainedReason = "uncompleted_original_result_reference"
		return result, nil
	}
	if !errors.Is(err, os.ErrNotExist) {
		return result, fmt.Errorf("inspect original recording result reference: %w", err)
	}
	remove := func(path string) error {
		stat, err := os.Lstat(path)
		if errors.Is(err, os.ErrNotExist) {
			return nil
		}
		if err != nil {
			return err
		}
		if !stat.Mode().IsRegular() || stat.Mode().Perm()&0077 != 0 {
			return errors.New("recording cleanup file is not an owned private regular file")
		}
		if r.removeFile != nil {
			err = r.removeFile(path)
		} else {
			err = os.Remove(path)
		}
		if err != nil && !errors.Is(err, os.ErrNotExist) {
			return err
		}
		if err == nil {
			result.DeletedFiles++
			result.DeletedBytes += stat.Size()
		}
		return nil
	}
	stat, err := os.Lstat(info)
	if !(proved && errors.Is(err, os.ErrNotExist)) {
		if err != nil || !stat.Mode().IsRegular() || stat.Mode().Perm()&0077 != 0 {
			return result, errors.Join(errors.New("recording delivery proof is not a private regular file"), err)
		}
	}
	// Validate any existing receipt before deleting either original member, and
	// persist its copy before info unlink. Hard exits cannot lose the last proof.
	proofPath, err = r.preserveCleanupProof(entry)
	if err != nil {
		return result, fmt.Errorf("preserve delivered cleanup receipt: %w", err)
	}
	if err := remove(audio); err != nil {
		return result, fmt.Errorf("delete delivered recording audio: %w", err)
	}
	if leafExists {
		if err := syncDirectory(dir); err != nil {
			return result, fmt.Errorf("persist delivered audio deletion: %w", err)
		}
	}
	if err := remove(info); err != nil {
		return result, fmt.Errorf("delete delivered recording info: %w", err)
	}
	if leafExists {
		if err := syncDirectory(dir); err != nil {
			return result, fmt.Errorf("persist delivered info deletion: %w", err)
		}
		if r.removeFile != nil {
			err = r.removeFile(dir)
		} else {
			err = os.Remove(dir)
		}
		if err != nil && !errors.Is(err, os.ErrNotExist) {
			return result, fmt.Errorf("remove completed recording leaf: %w", err)
		}
	}
	if err := syncDirectory(filepath.Dir(dir)); err != nil {
		return result, fmt.Errorf("persist recording leaf deletion: %w", err)
	}
	if err := remove(proofPath); err != nil {
		return result, fmt.Errorf("remove completed cleanup receipt: %w", err)
	}
	if err := syncDirectory(filepath.Dir(proofPath)); err != nil {
		return result, fmt.Errorf("persist cleanup receipt deletion: %w", err)
	}
	return result, nil
}