feat: dispatch queued commands after reconciliation

2026-09-06 07:34:01 +00:00
parent 0035e1cf43
commit 467ca65f60
7 changed files with 337 additions and 2 deletions
@@ -0,0 +1,137 @@
+package store
+
+import (
+	"bytes"
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+	"math"
+	"time"
+
+	"github.com/klauspost/compress/zstd"
+	"github.com/rvbox/rvbox/internal/domain"
+)
+
+const maxStoredExecutionSpecBytes = 1 << 20
+
+// DispatchCandidate is the immutable work reconstructed after an atomic
+// queued-to-dispatched transition. The session writer must use the supplied
+// generation and call RequeueDispatch if its network write never starts.
+type DispatchCandidate struct {
+	IssueUUID       domain.UUID
+	Revision        uint64
+	IssueTime       time.Time
+	QueueExpiryTime *time.Time
+	ExecutionSpec   []byte
+}
+
+// ClaimNextDispatch expires old queued rows and atomically assigns the oldest
+// remaining row to one live client-session generation. It deliberately records
+// the dispatch before the wire write so uncertain writes are reconciled rather
+// than accidentally delivered twice.
+func (store *Store) ClaimNextDispatch(ctx context.Context, clientID string, generation uint64, now time.Time) (*DispatchCandidate, error) {
+	if clientID == "" || generation == 0 || now.IsZero() {
+		return nil, errors.New("invalid dispatch claim")
+	}
+	store.writeMu.Lock()
+	defer store.writeMu.Unlock()
+	database, err := store.openDatabase()
+	if err != nil {
+		return nil, err
+	}
+	tx, err := database.BeginTx(ctx, nil)
+	if err != nil {
+		return nil, err
+	}
+	defer tx.Rollback()
+	// Expiry is terminal. The revision advance distinguishes it from a delayed
+	// queued snapshot or a late dispatch attempt.
+	if _, err := tx.ExecContext(ctx, `UPDATE commands SET lifecycle = 10, terminal_time = ?, revision = revision + 1
+WHERE client_id = ? AND lifecycle = 1 AND queue_expiry_time IS NOT NULL AND queue_expiry_time <= ?`, now.UTC().UnixNano(), clientID, now.UTC().UnixNano()); err != nil {
+		return nil, err
+	}
+	var encodedIssue, stored []byte
+	var revision uint64
+	var issueTime int64
+	var expiry sql.NullInt64
+	var rawBytes uint64
+	err = tx.QueryRowContext(ctx, `SELECT issue_uuid, revision, issue_time, queue_expiry_time, execution_spec, execution_spec_raw_bytes
+FROM commands WHERE client_id = ? AND lifecycle = 1 ORDER BY issue_time, issue_uuid LIMIT 1`, clientID).Scan(&encodedIssue, &revision, &issueTime, &expiry, &stored, &rawBytes)
+	if errors.Is(err, sql.ErrNoRows) {
+		if err := tx.Commit(); err != nil {
+			return nil, err
+		}
+		return nil, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+	if len(encodedIssue) != 16 {
+		return nil, ErrInvalidSegmentRecord
+	}
+	var issue domain.UUID
+	copy(issue[:], encodedIssue)
+	spec, err := decompressCommandSpec(stored, rawBytes)
+	if err != nil {
+		return nil, err
+	}
+	result, err := tx.ExecContext(ctx, `UPDATE commands SET lifecycle = 2, target_session_generation = ? WHERE issue_uuid = ? AND client_id = ? AND lifecycle = 1`, generation, issue[:], clientID)
+	if err != nil {
+		return nil, err
+	}
+	changed, err := result.RowsAffected()
+	if err != nil {
+		return nil, err
+	}
+	if changed != 1 {
+		return nil, errors.New("queued command changed during dispatch claim")
+	}
+	if err := tx.Commit(); err != nil {
+		return nil, err
+	}
+	candidate := &DispatchCandidate{IssueUUID: issue, Revision: revision, IssueTime: time.Unix(0, issueTime).UTC(), ExecutionSpec: spec}
+	if expiry.Valid {
+		value := time.Unix(0, expiry.Int64).UTC()
+		candidate.QueueExpiryTime = &value
+	}
+	return candidate, nil
+}
+
+// RequeueDispatch reverses only a known pre-acceptance write failure. A later
+// session generation, acceptance, or reconciliation decision cannot be rolled
+// back by a stale writer.
+func (store *Store) RequeueDispatch(ctx context.Context, issueUUID domain.UUID, clientID string, generation uint64) (bool, error) {
+	if isZeroUUID([16]byte(issueUUID)) || clientID == "" || generation == 0 {
+		return false, errors.New("invalid dispatch requeue")
+	}
+	store.writeMu.Lock()
+	defer store.writeMu.Unlock()
+	database, err := store.openDatabase()
+	if err != nil {
+		return false, err
+	}
+	result, err := database.ExecContext(ctx, `UPDATE commands SET lifecycle = 1, target_session_generation = NULL
+WHERE issue_uuid = ? AND client_id = ? AND lifecycle = 2 AND target_session_generation = ?`, issueUUID[:], clientID, generation)
+	if err != nil {
+		return false, err
+	}
+	changed, err := result.RowsAffected()
+	return changed == 1, err
+}
+
+func decompressCommandSpec(stored []byte, rawBytes uint64) ([]byte, error) {
+	if rawBytes == 0 || rawBytes > maxStoredExecutionSpecBytes || rawBytes > uint64(math.MaxInt) {
+		return nil, errors.New("invalid stored execution spec size")
+	}
+	decoder, err := zstd.NewReader(nil, zstd.WithDecoderConcurrency(1), zstd.WithDecoderMaxMemory(maxStoredExecutionSpecBytes+1))
+	if err != nil {
+		return nil, err
+	}
+	defer decoder.Close()
+	decoded, err := decoder.DecodeAll(stored, nil)
+	if err != nil || uint64(len(decoded)) != rawBytes || uint64(len(decoded)) > maxStoredExecutionSpecBytes {
+		return nil, fmt.Errorf("invalid stored execution spec")
+	}
+	return bytes.Clone(decoded), nil
+}