207 lines
9.0 KiB
Go
207 lines
9.0 KiB
Go
package agent
|
|
|
|
import (
|
|
"context"
|
|
"crypto/sha256"
|
|
"errors"
|
|
"fmt"
|
|
"log/slog"
|
|
"strings"
|
|
"time"
|
|
|
|
agentpb "git.ipao.vip/rogee/go-sip/gen/agent"
|
|
)
|
|
|
|
var ErrRecordingNotDue = errors.New("recording recovery retry is not due")
|
|
var ErrRecordingRetryExpired = errors.New("recording recovery retry window expired")
|
|
|
|
// RecoveryTarget must come from the Dispatcher for the original upload. The
|
|
// fresh grant may change its token, but never its bucket, key, ID or checksum.
|
|
type RecoveryTarget struct {
|
|
Bucket string
|
|
Grant *agentpb.UploadGrant
|
|
}
|
|
|
|
type RecoveryGrant func(context.Context, RecordingRecoveryEntry) (RecoveryTarget, error)
|
|
type RecordingResultReporter func(context.Context, RecordingRecoveryEntry) error
|
|
|
|
// Retry runs one due recovery entry. The persisted in-flight barrier prevents
|
|
// a process restart from sending another PUT when its previous outcome is
|
|
// unknown. Once a PUT succeeds, only the original result is reported again.
|
|
func (r *RecordingRecovery) Retry(ctx context.Context, bucket, objectKey string, grant RecoveryGrant, report RecordingResultReporter) (result RecordingRecoveryEntry, retryErr error) {
|
|
phase := "load_recording_recovery"
|
|
started := time.Now()
|
|
digest := sha256.Sum256([]byte(bucket + "/" + objectKey))
|
|
var original RecordingRecoveryEntry
|
|
defer func() {
|
|
observed := result
|
|
if observed.SourceEventID == "" {
|
|
observed = original
|
|
}
|
|
attrs := append(recordingRecoveryAttrs(observed), "recovery_digest", fmt.Sprintf("%x", digest[:6]), "stage", phase, "duration_ms", time.Since(started).Milliseconds())
|
|
manualReview := observed.State == "expired" || observed.State == "put_in_flight" || observed.State == "outcome_unknown"
|
|
if manualReview && (retryErr == nil || errors.Is(retryErr, ErrRecordingNotDue)) {
|
|
reason := "original upload outcome unknown; files retained and PUT replay blocked"
|
|
if observed.State == "expired" {
|
|
reason = "48-hour retry window expired; files retained for inspection"
|
|
}
|
|
slog.WarnContext(ctx, "Recording recovery requires inspection", append(attrs, "stage", "recovery_manual_review", "reason", reason, "files_retained", true)...)
|
|
} else if errors.Is(retryErr, ErrRecordingNotDue) {
|
|
slog.InfoContext(ctx, "Recording retry waiting", append(attrs, "stage", "retry_wait", "reason", retryErr)...)
|
|
} else if retryErr != nil {
|
|
slog.ErrorContext(ctx, "Recording retry blocked", append(attrs, "error", retryErr, "manual_review", observed.State == "expired" || observed.State == "put_in_flight" || observed.State == "outcome_unknown")...)
|
|
} else {
|
|
slog.InfoContext(ctx, "Recording recovery transition complete", attrs...)
|
|
}
|
|
}()
|
|
r.mu.Lock()
|
|
defer r.mu.Unlock()
|
|
entry, err := r.Load(bucket, objectKey)
|
|
if err != nil {
|
|
return RecordingRecoveryEntry{}, err
|
|
}
|
|
original = entry
|
|
phase = "validate_recording_recovery"
|
|
_, audioPath, infoPath, err := r.paths(bucket, objectKey)
|
|
if err != nil {
|
|
return entry, err
|
|
}
|
|
if err := ctx.Err(); err != nil {
|
|
return entry, err
|
|
}
|
|
switch entry.State {
|
|
case "delivered":
|
|
phase = "recovery_already_delivered"
|
|
return entry, nil
|
|
case "expired":
|
|
return entry, ErrRecordingRetryExpired
|
|
case "outcome_unknown", "put_in_flight":
|
|
return entry, ErrUploadOutcomeUnknown
|
|
case "uploaded_unreported":
|
|
phase = "report_original_result"
|
|
return r.reportUploaded(ctx, infoPath, entry, report)
|
|
case "retry_pending":
|
|
default:
|
|
return entry, ErrRecordingRecoveryIncomplete
|
|
}
|
|
phase = "check_retry_window"
|
|
now := r.now().UTC()
|
|
if !now.Before(entry.ExpiresAt) {
|
|
entry.State = "expired"
|
|
entry.NextAttemptAt = time.Time{}
|
|
phase = "save_retry_expired"
|
|
if err := r.persistState(infoPath, entry); err != nil {
|
|
return entry, fmt.Errorf("persist expired recording recovery: %w", err)
|
|
}
|
|
return entry, ErrRecordingRetryExpired
|
|
}
|
|
if now.Before(entry.NextAttemptAt) {
|
|
return entry, ErrRecordingNotDue
|
|
}
|
|
if grant == nil || report == nil {
|
|
return entry, errors.New("Dispatcher recovery grant and final result reporter are required")
|
|
}
|
|
phase = "request_upload_grant"
|
|
slog.InfoContext(ctx, "Request original recovery upload grant", append(recordingRecoveryAttrs(entry), "stage", phase, "direction", "agent->dispatcher")...)
|
|
target, err := grant(ctx, entry)
|
|
if err != nil {
|
|
if ctxErr := ctx.Err(); ctxErr != nil {
|
|
return entry, ctxErr
|
|
}
|
|
entry.Attempts++
|
|
entry.NextAttemptAt = r.now().UTC().Add(recordingRetryDelay(entry.Attempts))
|
|
if saveErr := r.persistState(infoPath, entry); saveErr != nil {
|
|
phase = "save_grant_backoff"
|
|
return entry, errors.Join(fmt.Errorf("request original recovery grant failed: %w", err), fmt.Errorf("persist failed recovery grant backoff: %w", saveErr))
|
|
}
|
|
slog.WarnContext(ctx, "Recording retry backoff saved", append(recordingRecoveryAttrs(entry), "stage", "retry_backoff_saved", "reason", err)...)
|
|
return entry, fmt.Errorf("request original recovery grant failed: %w", err)
|
|
}
|
|
phase = "validate_original_upload_target"
|
|
if err := r.validateTarget(ctx, entry, target); err != nil {
|
|
return entry, err
|
|
}
|
|
inFlight := entry
|
|
inFlight.State = "put_in_flight"
|
|
inFlight.NextAttemptAt = time.Time{}
|
|
phase = "save_put_in_flight"
|
|
if err := r.persistState(infoPath, inFlight); err != nil {
|
|
return entry, fmt.Errorf("persist PUT in-flight barrier: %w", err)
|
|
}
|
|
phase = "oss_put"
|
|
slog.InfoContext(ctx, "Recording retry PUT started", append(recordingRecoveryAttrs(inFlight), "stage", phase, "direction", "agent->oss")...)
|
|
uploaded, err := r.Upload.UploadFile(ctx, target.Grant, audioPath)
|
|
if err != nil {
|
|
var rejected *UploadHTTPError
|
|
if errors.As(err, &rejected) {
|
|
entry.Attempts++
|
|
entry.NextAttemptAt = r.now().UTC().Add(recordingRetryDelay(entry.Attempts))
|
|
if saveErr := r.persistState(infoPath, entry); saveErr != nil {
|
|
phase = "save_put_backoff"
|
|
return inFlight, fmt.Errorf("OSS rejected retry (status %d), recovery barrier retained: %w", rejected.StatusCode, saveErr)
|
|
}
|
|
slog.WarnContext(ctx, "Recording retry backoff saved", append(recordingRecoveryAttrs(entry), "stage", "retry_backoff_saved", "put_status", rejected.StatusCode, "reason", err)...)
|
|
return entry, err
|
|
}
|
|
return inFlight, err
|
|
}
|
|
phase = "save_confirmed_put"
|
|
inFlight.State = "uploaded_unreported"
|
|
inFlight.Uploaded = &uploaded
|
|
if err := r.persistState(infoPath, inFlight); err != nil {
|
|
return inFlight, fmt.Errorf("persist confirmed OSS upload before reporting result: %w", err)
|
|
}
|
|
phase = "report_original_result"
|
|
return r.reportUploaded(ctx, infoPath, inFlight, report)
|
|
}
|
|
|
|
func (r *RecordingRecovery) validateTarget(ctx context.Context, entry RecordingRecoveryEntry, target RecoveryTarget) error {
|
|
if target.Grant == nil || target.Bucket != entry.Bucket || target.Grant.Bucket != entry.Bucket || target.Grant.UploadId != entry.UploadID || target.Grant.ObjectKey != entry.ObjectKey || target.Grant.MaxBytes < entry.SizeBytes || target.Grant.MaxBytes <= 0 || !strings.EqualFold(target.Grant.RequiredChecksumSha256, entry.SHA256) {
|
|
return errors.New("recovery grant target does not match the original OSS asset")
|
|
}
|
|
if _, err := r.Upload.validateGrant(ctx, target.Grant); err != nil {
|
|
return fmt.Errorf("recovery grant is invalid: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func recordingRecoveryAttrs(entry RecordingRecoveryEntry) []any {
|
|
return []any{"event_id", entry.SourceEventID, "dispatcher_id", entry.DispatcherID, "tenant_id", entry.TenantID, "recording_id", entry.RecordingID, "upload_id", entry.UploadID, "recovery_state", entry.State, "attempts", entry.Attempts, "next_attempt_at", entry.NextAttemptAt, "expires_at", entry.ExpiresAt}
|
|
}
|
|
|
|
func (r *RecordingRecovery) reportUploaded(ctx context.Context, infoPath string, entry RecordingRecoveryEntry, report RecordingResultReporter) (RecordingRecoveryEntry, error) {
|
|
if report == nil {
|
|
return entry, errors.New("Dispatcher final result reporter is required")
|
|
}
|
|
slog.InfoContext(ctx, "Report original uploaded result", append(recordingRecoveryAttrs(entry), "stage", "report_original_result", "direction", "agent->dispatcher")...)
|
|
if err := report(ctx, entry); err != nil {
|
|
slog.ErrorContext(ctx, "Original uploaded result reporting failed", append(recordingRecoveryAttrs(entry), "stage", "report_original_result", "error", err)...)
|
|
return entry, fmt.Errorf("report confirmed upload result: %w", err)
|
|
}
|
|
entry.State = "delivered"
|
|
if err := r.persistState(infoPath, entry); err != nil {
|
|
slog.ErrorContext(ctx, "Delivered result receipt persistence failed", append(recordingRecoveryAttrs(entry), "stage", "save_delivered_receipt", "error", err)...)
|
|
return entry, fmt.Errorf("persist delivered result receipt: %w", err)
|
|
}
|
|
slog.InfoContext(ctx, "Original result recovery acknowledged", append(recordingRecoveryAttrs(entry), "stage", "original_result_acknowledged")...)
|
|
return entry, nil
|
|
}
|
|
|
|
func (r *RecordingRecovery) persistState(infoPath string, entry RecordingRecoveryEntry) error {
|
|
if r.writeState != nil {
|
|
return r.writeState(infoPath, entry)
|
|
}
|
|
return writeJSONAtomic(infoPath, entry)
|
|
}
|
|
|
|
func recordingRetryDelay(attempts int) time.Duration {
|
|
delay := time.Minute
|
|
for i := 1; i < attempts && delay < time.Hour; i++ {
|
|
delay *= 2
|
|
if delay > time.Hour {
|
|
return time.Hour
|
|
}
|
|
}
|
|
return delay
|
|
}
|