A retry now carries the operator's worktree choice (refresh onto the base branch or continue the work already pushed on the task branch) from the dashboard through the task action to the daemon dispatch, and persists it on the task row so it survives a reload. The daemon resolves the mode from the task, never from the workflow; BeginRemediation records continue explicitly so a remediation still resumes its pull request branch.
760 lines
28 KiB
Go
760 lines
28 KiB
Go
// Package postgres implements the State Store contract on PostgreSQL.
|
|
package postgres
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
|
|
"github.com/jackc/pgx/v5"
|
|
"github.com/jackc/pgx/v5/pgxpool"
|
|
|
|
"github.com/samcharles93/archie-core/internal/domain/org"
|
|
"github.com/samcharles93/archie-core/internal/domain/storecontract"
|
|
"github.com/samcharles93/archie-core/internal/domain/workflow"
|
|
task "github.com/samcharles93/archie-core/internal/domain/workflow/task"
|
|
"github.com/samcharles93/archie-core/internal/events"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/postgres/postgresdb"
|
|
"github.com/samcharles93/archie-core/internal/taskstate"
|
|
)
|
|
|
|
// Store is the PostgreSQL implementation of the State Store. It carries the
|
|
// full task/event/identity/status surface behind the storecontract interfaces,
|
|
// with the control-plane resource surface embedded from Resources. The pool is
|
|
// process-scoped and owned by the composition (internal/app/archied), not by
|
|
// the Store, so Close is a no-op.
|
|
type Store struct {
|
|
pool *pgxpool.Pool
|
|
*Resources
|
|
}
|
|
|
|
// New returns a Store over pool.
|
|
func New(pool *pgxpool.Pool) *Store {
|
|
return &Store{pool: pool, Resources: NewResources(pool)}
|
|
}
|
|
|
|
func (s *Store) queries() *postgresdb.Queries {
|
|
return postgresdb.New(s.pool)
|
|
}
|
|
|
|
// guardTransition locks the task's row and checks the status write the caller
|
|
// is about to perform: a row whose status is not the expected from is stale
|
|
// (ErrStaleTransition), a from->to pair outside the shared transition table is
|
|
// refused with ErrIllegalTransition
|
|
// (docs/prds/execution-tree-state-machine.md). Staleness is decided first, so
|
|
// a caller that is wrong about the row's state gets the stale sentinel even
|
|
// when its pair is also unroutable. The row stays locked for the caller's
|
|
// transaction, so the checks cannot race the guarded write that follows.
|
|
// A missing row is stale, matching what the guarded update alone used to
|
|
// return.
|
|
func guardTransition(ctx context.Context, q *postgresdb.Queries, taskID int64, from, to string) error {
|
|
status, err := q.LockTaskStatus(ctx, taskID)
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return storecontract.ErrStaleTransition
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if status != from {
|
|
return storecontract.ErrStaleTransition
|
|
}
|
|
if !taskstate.CanTransition(from, to) {
|
|
return storecontract.ErrIllegalTransition
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Close is a no-op: this store owns no file handle
|
|
// or connection -- the pool belongs to the composition that opened it.
|
|
func (s *Store) Close() error { return nil }
|
|
|
|
// syntheticIssueNumberBase is the seed for a repo's first chat task. The
|
|
// COALESCE allocator adds one to the passed fallback, so the fallback here is
|
|
// base-1 and the first chat task lands on exactly base: the reserved
|
|
// JSON-safe floor that keeps synthetic issue numbers clear of real ones.
|
|
const syntheticIssueNumberBase = 1_000_000_000_000_000
|
|
|
|
// structuredPayloadBytes is the write-side bound the store applies to a
|
|
// structured payload (review_payload today, task outputs now). A value that
|
|
// would exceed it is refused for outputs -- clipped JSON does not parse, and a
|
|
// caller must receive an object or nothing -- where the legacy review payload
|
|
// is still clipped (docs/prds/workflow-call-outputs.md, "Storage and wire").
|
|
const structuredPayloadBytes = 4000
|
|
|
|
// taskFromRow maps the generated task row to the workflow.Task the daemon and
|
|
// webui consume.
|
|
func taskFromRow(t postgresdb.Task) *workflow.Task {
|
|
// The inputs and outputs columns are only ever written by EncodeInputs and
|
|
// EncodeOutputs, so a decode failure cannot arise from stored data this
|
|
// package produced.
|
|
inputs, _ := task.DecodeInputs(t.Inputs)
|
|
outputs, _ := task.DecodeOutputs(t.Outputs)
|
|
return &workflow.Task{
|
|
ID: t.ID,
|
|
Owner: t.Owner,
|
|
Repo: t.Repo,
|
|
IssueNumber: int(t.IssueNumber),
|
|
Title: t.Title,
|
|
Body: t.Body,
|
|
Labels: t.Labels,
|
|
Status: t.Status,
|
|
Workflow: t.Workflow,
|
|
WorkflowDefinitionVersion: t.WorkflowDefinitionVersion,
|
|
WorkflowDefinitionDigest: t.WorkflowDefinitionDigest,
|
|
WorkflowDefinitionYAML: t.WorkflowDefinitionYaml,
|
|
Branch: t.Branch,
|
|
Plan: t.Plan,
|
|
Notes: t.Notes,
|
|
PRNumber: int(t.PrNumber),
|
|
TokensUsed: int(t.TokensUsed),
|
|
Iterations: int(t.Iterations),
|
|
Attempt: int(t.Attempt),
|
|
ParkReason: t.ParkReason,
|
|
RetryCount: int(t.RetryCount),
|
|
RetryMode: t.RetryMode,
|
|
WatchCommentID: t.WatchCommentID,
|
|
ReviewCursor: t.ReviewCursor,
|
|
Source: t.Source,
|
|
Identity: t.Identity,
|
|
Org: org.OrgID(t.OrgID),
|
|
BindingID: t.BindingID,
|
|
BindingVersion: int(t.BindingVersion),
|
|
Inputs: inputs,
|
|
Outputs: outputs,
|
|
ReviewPayload: t.ReviewPayload,
|
|
ReviewGate: t.ReviewGate,
|
|
RereviewRounds: int(t.RereviewRounds),
|
|
ParkClass: t.ParkClass,
|
|
RemediationRounds: int(t.RemediationRounds),
|
|
CallParentTaskID: t.CallParentTaskID,
|
|
CallDepth: int(t.CallDepth),
|
|
CreatedAt: t.CreatedAt,
|
|
UpdatedAt: t.UpdatedAt,
|
|
}
|
|
}
|
|
|
|
// Compile-time checks: *Store satisfies every surface the SQLite store did.
|
|
var (
|
|
_ storecontract.TaskStore = (*Store)(nil)
|
|
_ storecontract.StepRecorder = (*Store)(nil)
|
|
_ storecontract.ExecutionCanceller = (*Store)(nil)
|
|
_ storecontract.BindingTaskCreator = (*Store)(nil)
|
|
_ storecontract.ConfigSnapshotStore = (*Store)(nil)
|
|
_ storecontract.ChannelStatusStore = (*Store)(nil)
|
|
_ storecontract.ApplyStatusStore = (*Store)(nil)
|
|
_ task.Caller = (*Store)(nil)
|
|
_ workflow.Store = (*Store)(nil)
|
|
)
|
|
|
|
// EnqueueIssue inserts a new queued task for the issue; returns false if the
|
|
// issue is already tracked (the idempotency key is owner/repo/number).
|
|
func (s *Store) EnqueueIssue(ctx context.Context, owner, repo string, number int, title, body, labels, identity string) (bool, error) {
|
|
n, err := s.queries().EnqueueIssue(ctx, postgresdb.EnqueueIssueParams{
|
|
Owner: owner, Repo: repo, IssueNumber: int64(number),
|
|
Title: title, Body: body, Labels: labels, Identity: identity,
|
|
})
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
return n > 0, nil
|
|
}
|
|
|
|
// EnqueueChatTask inserts a queued chat-sourced task and returns the full row.
|
|
// The store allocates the synthetic issue number durably so processes sharing
|
|
// the database cannot generate the same value. inputs are the task's workflow
|
|
// inputs (the operator trigger's pr_number, for instance); a chat task carries
|
|
// no binding provenance, so the insert is the only writer of that column.
|
|
func (s *Store) EnqueueChatTask(ctx context.Context, owner, repo, title, body, wf, identity string, inputs map[string]any) (*workflow.Task, error) {
|
|
encoded, err := task.EncodeInputs(inputs)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
t, err := s.queries().InsertChatTask(ctx, postgresdb.InsertChatTaskParams{
|
|
Owner: owner, Repo: repo, Title: title, Body: body, Workflow: wf, Identity: identity,
|
|
Inputs: encoded,
|
|
FallbackIssueNumber: syntheticIssueNumberBase - 1,
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return taskFromRow(t), nil
|
|
}
|
|
|
|
// EnqueueBindingTask enqueues a binding-triggered task and stamps its binding
|
|
// provenance in a second statement (best-effort, as in the SQLite store). The
|
|
// inputs travel with the insert, so a failed stamp leaves a task whose inputs
|
|
// are already right and whose provenance is absent, never the reverse.
|
|
func (s *Store) EnqueueBindingTask(ctx context.Context, owner, repo, title, body, wf, identity, bindingID string, bindingVersion int, inputs map[string]any) (*workflow.Task, error) {
|
|
t, err := s.EnqueueChatTask(ctx, owner, repo, title, body, wf, identity, inputs)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := s.queries().StampTaskBinding(ctx, postgresdb.StampTaskBindingParams{
|
|
ID: t.ID, BindingID: bindingID, BindingVersion: int64(bindingVersion),
|
|
}); err != nil {
|
|
return nil, fmt.Errorf("store: stamp binding provenance: %w", err)
|
|
}
|
|
t.BindingID = bindingID
|
|
t.BindingVersion = bindingVersion
|
|
return t, nil
|
|
}
|
|
|
|
// ClaimNext atomically moves the oldest queued task to running and returns it;
|
|
// nil when the queue is empty.
|
|
func (s *Store) ClaimNext(ctx context.Context) (*workflow.Task, error) {
|
|
t, err := s.queries().ClaimNextTask(ctx)
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return nil, nil
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return taskFromRow(t), nil
|
|
}
|
|
|
|
// ClaimByIssue atomically claims a queued task by owner/repo/issue_number.
|
|
func (s *Store) ClaimByIssue(ctx context.Context, owner, repo string, number int) (*workflow.Task, error) {
|
|
t, err := s.queries().ClaimByIssue(ctx, postgresdb.ClaimByIssueParams{
|
|
Owner: owner, Repo: repo, IssueNumber: int64(number),
|
|
})
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return nil, nil
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return taskFromRow(t), nil
|
|
}
|
|
|
|
// Transition moves a task to a new status and records the audit detail. The
|
|
// from status guards the update; a mismatch returns ErrStaleTransition without
|
|
// writing an audit row, and a from->to pair outside the shared transition
|
|
// table returns ErrIllegalTransition. Transitioning to parked also stores
|
|
// detail as ParkReason in the same transaction.
|
|
func (s *Store) Transition(ctx context.Context, taskID int64, from, to, detail string) error {
|
|
tx, err := s.pool.Begin(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer func() { _ = tx.Rollback(ctx) }()
|
|
q := postgresdb.New(tx)
|
|
|
|
if err := guardTransition(ctx, q, taskID, from, to); err != nil {
|
|
return err
|
|
}
|
|
n, err := q.TransitionTask(ctx, postgresdb.TransitionTaskParams{
|
|
ID: taskID, Status: to, ParkReason: clip(detail, 4000),
|
|
ParkClass: taskstate.ParkNeedsHuman, Status_2: from,
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if n == 0 {
|
|
return storecontract.ErrStaleTransition
|
|
}
|
|
if err := q.InsertTransition(ctx, postgresdb.InsertTransitionParams{
|
|
TaskID: taskID, FromStatus: from, ToStatus: to, Detail: clip(detail, 4000),
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
return tx.Commit(ctx)
|
|
}
|
|
|
|
// ParkTask is the classified park write: the same guarded running->parked
|
|
// transition Transition performs, carrying the park class the site chose.
|
|
// The park is only legal from running (the transition table), so a stale or
|
|
// off-table from is refused before anything is written.
|
|
func (s *Store) ParkTask(ctx context.Context, taskID int64, from, detail, class string) error {
|
|
tx, err := s.pool.Begin(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer func() { _ = tx.Rollback(ctx) }()
|
|
q := postgresdb.New(tx)
|
|
|
|
if err := guardTransition(ctx, q, taskID, from, workflow.StatusParked); err != nil {
|
|
return err
|
|
}
|
|
n, err := q.ParkTask(ctx, postgresdb.ParkTaskParams{
|
|
ID: taskID, ParkReason: clip(detail, 4000),
|
|
ParkClass: taskstate.NormalizeParkClass(class), Status: from,
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if n == 0 {
|
|
return storecontract.ErrStaleTransition
|
|
}
|
|
if err := q.InsertTransition(ctx, postgresdb.InsertTransitionParams{
|
|
TaskID: taskID, FromStatus: from, ToStatus: workflow.StatusParked, Detail: clip(detail, 4000),
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
return tx.Commit(ctx)
|
|
}
|
|
|
|
// Update persists mutable task fields written by workflows.
|
|
func (s *Store) Update(ctx context.Context, t *workflow.Task) error {
|
|
// The row write is where a run's outputs land (docs/prds/workflow-call-outputs.md).
|
|
// An encoded set past the bound the store applies to a structured payload
|
|
// is refused rather than clipped: clipped JSON does not parse, and a caller
|
|
// would receive a broken object as a value. The engine turns the refusal
|
|
// into a park, so nothing silently loses its structured result.
|
|
outputs, err := task.EncodeOutputs(t.Outputs)
|
|
if err != nil {
|
|
return fmt.Errorf("store: encode task %d outputs: %w", t.ID, err)
|
|
}
|
|
if len(outputs) > structuredPayloadBytes {
|
|
return fmt.Errorf("store: task %d outputs are %d bytes, past the %d-byte structured-payload bound; refuse rather than clip", t.ID, len(outputs), structuredPayloadBytes)
|
|
}
|
|
return s.queries().UpdateTask(ctx, postgresdb.UpdateTaskParams{
|
|
ID: t.ID,
|
|
Workflow: t.Workflow,
|
|
Branch: t.Branch,
|
|
Plan: t.Plan,
|
|
Notes: t.Notes,
|
|
PrNumber: int64(t.PRNumber),
|
|
TokensUsed: int64(t.TokensUsed),
|
|
Iterations: int64(t.Iterations),
|
|
ParkReason: clip(t.ParkReason, 4000),
|
|
WatchCommentID: t.WatchCommentID,
|
|
RetryCount: int64(t.RetryCount),
|
|
RemediationRounds: int64(t.RemediationRounds),
|
|
ReviewPayload: t.ReviewPayload,
|
|
ReviewGate: t.ReviewGate,
|
|
RereviewRounds: int64(t.RereviewRounds),
|
|
RetryMode: t.RetryMode,
|
|
WorkflowDefinitionVersion: t.WorkflowDefinitionVersion,
|
|
WorkflowDefinitionDigest: t.WorkflowDefinitionDigest,
|
|
WorkflowDefinitionYaml: t.WorkflowDefinitionYAML,
|
|
Outputs: outputs,
|
|
})
|
|
}
|
|
|
|
// BeginRemediation queues a remediate run carrying the review unit in the same
|
|
// guarded write, so a claimed remediation always has its input.
|
|
func (s *Store) BeginRemediation(ctx context.Context, taskID int64, payload string) error {
|
|
tx, err := s.pool.Begin(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer func() { _ = tx.Rollback(ctx) }()
|
|
q := postgresdb.New(tx)
|
|
|
|
if err := guardTransition(ctx, q, taskID, workflow.StatusPROpen, workflow.StatusQueued); err != nil {
|
|
return err
|
|
}
|
|
n, err := q.BeginRemediationTask(ctx, postgresdb.BeginRemediationTaskParams{
|
|
ID: taskID, ReviewPayload: clip(payload, 4000),
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if n == 0 {
|
|
return storecontract.ErrStaleTransition
|
|
}
|
|
if err := q.InsertTransition(ctx, postgresdb.InsertTransitionParams{
|
|
TaskID: taskID, FromStatus: workflow.StatusPROpen, ToStatus: workflow.StatusQueued,
|
|
Detail: "review reaction queued remediation",
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
return tx.Commit(ctx)
|
|
}
|
|
|
|
// UpdateReviewPayload replaces a queued remediation's review unit.
|
|
func (s *Store) UpdateReviewPayload(ctx context.Context, taskID int64, payload string) error {
|
|
n, err := s.queries().UpdateReviewPayloadTask(ctx, postgresdb.UpdateReviewPayloadTaskParams{
|
|
ID: taskID, ReviewPayload: clip(payload, 4000),
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if n == 0 {
|
|
return storecontract.ErrStaleTransition
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// SetReviewCursors persists the poll backstop's per-task review and comment
|
|
// high-water marks, guarded on pr_open.
|
|
func (s *Store) SetReviewCursors(ctx context.Context, taskID, reviewCursor, commentCursor int64) error {
|
|
n, err := s.queries().SetReviewCursors(ctx, postgresdb.SetReviewCursorsParams{
|
|
ID: taskID, ReviewCursor: reviewCursor, WatchCommentID: commentCursor,
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if n == 0 {
|
|
return storecontract.ErrStaleTransition
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Requeue puts a task back on the queue; an empty workflow keeps the task's
|
|
// current workflow. The from->queued pair must be routed by the transition
|
|
// table: requeueing out of a terminal status is refused, not rewritten.
|
|
func (s *Store) Requeue(ctx context.Context, taskID int64, fromStatus, wf string) error {
|
|
return s.requeue(ctx, taskID, fromStatus, wf, "requeued "+wf, func(q *postgresdb.Queries) (int64, error) {
|
|
return q.RequeueTask(ctx, postgresdb.RequeueTaskParams{
|
|
ID: taskID, Workflow: wf, FromStatus: fromStatus,
|
|
})
|
|
})
|
|
}
|
|
|
|
// RetryTask requeues a task and increments retry_count in the same guarded
|
|
// transaction, under the same table check Requeue applies. retryMode is the
|
|
// operator's worktree choice for the next dispatch; the store persists it
|
|
// unread so the daemon's prepareWorkspace reads the mode the operator set.
|
|
func (s *Store) RetryTask(ctx context.Context, taskID int64, fromStatus, wf, retryMode string) error {
|
|
return s.requeue(ctx, taskID, fromStatus, wf, "retried "+wf, func(q *postgresdb.Queries) (int64, error) {
|
|
return q.RetryTask(ctx, postgresdb.RetryTaskParams{
|
|
ID: taskID, Workflow: wf, FromStatus: fromStatus, RetryMode: retryMode,
|
|
})
|
|
})
|
|
}
|
|
|
|
// RespondReviewGate is the review gate response write
|
|
// (docs/prds/pr-review-operator-response.md, Decision 2): one guarded
|
|
// requeue that records the operator's answer, increments rereview_rounds for
|
|
// a re-review only, and writes one audit row -- all in one transaction. The
|
|
// cap is checked under the row lock the transition guard takes, so two
|
|
// simultaneous re-reviews cannot both spend the last round.
|
|
func (s *Store) RespondReviewGate(ctx context.Context, taskID int64, fromStatus, gate string, rereview bool, maxRounds int) error {
|
|
tx, err := s.pool.Begin(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer func() { _ = tx.Rollback(ctx) }()
|
|
q := postgresdb.New(tx)
|
|
|
|
if err := guardTransition(ctx, q, taskID, fromStatus, workflow.StatusQueued); err != nil {
|
|
return err
|
|
}
|
|
// The row is locked by the guard read, so the cap decision and the
|
|
// increment below cannot interleave with a second response write.
|
|
rounds, err := q.RereviewRounds(ctx, taskID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if rereview && rounds >= int64(maxRounds) {
|
|
return storecontract.ErrRereviewCapReached
|
|
}
|
|
n, err := q.RespondReviewGateTask(ctx, postgresdb.RespondReviewGateTaskParams{
|
|
ID: taskID, FromStatus: fromStatus, Gate: gate, Rereview: rereview, Cap: int64(maxRounds),
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if n == 0 {
|
|
return storecontract.ErrStaleTransition
|
|
}
|
|
detail := "operator approved the review gate"
|
|
if rereview {
|
|
detail = "operator requested a re-review"
|
|
}
|
|
if err := q.InsertTransition(ctx, postgresdb.InsertTransitionParams{
|
|
TaskID: taskID, FromStatus: fromStatus, ToStatus: workflow.StatusQueued, Detail: detail,
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
return tx.Commit(ctx)
|
|
}
|
|
|
|
// requeue carries the guarded requeue write Requeue and RetryTask share: the
|
|
// transition-table check, the update guarded on the from status, and one audit
|
|
// row. update is the query that differs between the two callers; detail is the
|
|
// audit line it records.
|
|
func (s *Store) requeue(ctx context.Context, taskID int64, fromStatus, wf, detail string, update func(*postgresdb.Queries) (int64, error)) error {
|
|
tx, err := s.pool.Begin(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer func() { _ = tx.Rollback(ctx) }()
|
|
q := postgresdb.New(tx)
|
|
|
|
if err := guardTransition(ctx, q, taskID, fromStatus, workflow.StatusQueued); err != nil {
|
|
return err
|
|
}
|
|
n, err := update(q)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if n == 0 {
|
|
return storecontract.ErrStaleTransition
|
|
}
|
|
if err := q.InsertTransition(ctx, postgresdb.InsertTransitionParams{
|
|
TaskID: taskID, FromStatus: fromStatus, ToStatus: workflow.StatusQueued, Detail: detail,
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
return tx.Commit(ctx)
|
|
}
|
|
|
|
// ArchiveTask removes one terminal task from the active task board and returns
|
|
// the id of the audit event written alongside the delete.
|
|
func (s *Store) ArchiveTask(ctx context.Context, taskID int64, fromStatus string, audit events.Event) (int64, error) {
|
|
tx, err := s.pool.Begin(ctx)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
defer func() { _ = tx.Rollback(ctx) }()
|
|
q := postgresdb.New(tx)
|
|
|
|
eventID, err := insertEventQ(ctx, q, audit)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
n, err := q.ArchiveTaskDelete(ctx, postgresdb.ArchiveTaskDeleteParams{
|
|
ID: taskID, Status: fromStatus,
|
|
})
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
if n == 0 {
|
|
return 0, storecontract.ErrStaleTransition
|
|
}
|
|
if err := tx.Commit(ctx); err != nil {
|
|
return 0, err
|
|
}
|
|
return eventID, nil
|
|
}
|
|
|
|
// RecoverStale re-queues tasks left running by a crashed or replaced daemon
|
|
// and, in the same transaction, moves the steps those executions left running
|
|
// to the step transition table's interrupted outcome
|
|
// (docs/prds/execution-tree-state-machine.md, "Crash recovery"): one event row
|
|
// per step transition and the execution's audit row land in the same write.
|
|
// Both edges are pinned in SQL (the execution's running->queued, the step's
|
|
// running->interrupted) and pinned to the tables by
|
|
// TestSQLPinnedTransitionsAreTableLegal. The next attempt starts with fresh
|
|
// steps; earlier attempts are never rewritten.
|
|
func (s *Store) RecoverStale(ctx context.Context) (int64, error) {
|
|
tx, err := s.pool.Begin(ctx)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
defer func() { _ = tx.Rollback(ctx) }()
|
|
q := postgresdb.New(tx)
|
|
|
|
executions, err := q.LockRunningExecutions(ctx)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
for _, execution := range executions {
|
|
steps, err := q.InterruptAttemptSteps(ctx, postgresdb.InterruptAttemptStepsParams{
|
|
ExecutionID: execution.ID, Attempt: execution.Attempt,
|
|
})
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
for _, step := range steps {
|
|
if _, err := insertEventQ(ctx, q, stepEvent(events.KindStageFinish, execution.ID,
|
|
execution.Owner, execution.Repo, execution.IssueNumber, execution.Workflow,
|
|
int(execution.Attempt), step.Name, map[string]any{"interrupted": true})); err != nil {
|
|
return 0, err
|
|
}
|
|
}
|
|
if err := q.InsertTransition(ctx, postgresdb.InsertTransitionParams{
|
|
TaskID: execution.ID, FromStatus: workflow.StatusRunning, ToStatus: workflow.StatusQueued,
|
|
Detail: "re-queued after a crashed or replaced daemon",
|
|
}); err != nil {
|
|
return 0, err
|
|
}
|
|
}
|
|
n, err := q.RecoverStaleTasks(ctx)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
if err := tx.Commit(ctx); err != nil {
|
|
return 0, err
|
|
}
|
|
return n, nil
|
|
}
|
|
|
|
// OpenPRs returns tasks whose PR state should be reconciled with the forge,
|
|
// carrying the attempt and the review/comment cursors the reconcile loop and
|
|
// poll backstop read.
|
|
func (s *Store) OpenPRs(ctx context.Context) ([]workflow.Task, error) {
|
|
rows, err := s.queries().ListOpenPRs(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
tasks := make([]workflow.Task, 0, len(rows))
|
|
for _, r := range rows {
|
|
outputs, _ := task.DecodeOutputs(r.Outputs)
|
|
tasks = append(tasks, workflow.Task{
|
|
ID: r.ID, Owner: r.Owner, Repo: r.Repo, IssueNumber: int(r.IssueNumber),
|
|
PRNumber: int(r.PrNumber), Status: r.Status, Source: r.Source,
|
|
Identity: r.Identity, Attempt: int(r.Attempt),
|
|
ReviewCursor: r.ReviewCursor, WatchCommentID: r.WatchCommentID,
|
|
Outputs: outputs,
|
|
})
|
|
}
|
|
return tasks, nil
|
|
}
|
|
|
|
// ClearTerminalTasks deletes tasks whose status is terminal.
|
|
func (s *Store) ClearTerminalTasks(ctx context.Context) (int64, error) {
|
|
return s.queries().ClearTerminalTasks(ctx)
|
|
}
|
|
|
|
// Tasks returns all tasks, newest first (dashboard listing).
|
|
func (s *Store) Tasks(ctx context.Context, limit int) ([]workflow.Task, error) {
|
|
rows, err := s.queries().ListTaskSummaries(ctx, int32(limit))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
tasks := make([]workflow.Task, 0, len(rows))
|
|
for _, r := range rows {
|
|
outputs, _ := task.DecodeOutputs(r.Outputs)
|
|
tasks = append(tasks, workflow.Task{
|
|
ID: r.ID, Owner: r.Owner, Repo: r.Repo, IssueNumber: int(r.IssueNumber),
|
|
Title: r.Title, Status: r.Status, Workflow: r.Workflow,
|
|
PRNumber: int(r.PrNumber), TokensUsed: int(r.TokensUsed), Iterations: int(r.Iterations),
|
|
Attempt: int(r.Attempt), ParkReason: r.ParkReason, RetryCount: int(r.RetryCount),
|
|
CreatedAt: r.CreatedAt, UpdatedAt: r.UpdatedAt, Plan: r.Plan, Source: r.Source,
|
|
Identity: r.Identity, BindingID: r.BindingID, BindingVersion: int(r.BindingVersion),
|
|
Outputs: outputs,
|
|
ReviewGate: r.ReviewGate, RereviewRounds: int(r.RereviewRounds),
|
|
})
|
|
}
|
|
return tasks, nil
|
|
}
|
|
|
|
// StatusCounts returns task counts by status.
|
|
func (s *Store) StatusCounts(ctx context.Context) (map[string]int, error) {
|
|
rows, err := s.queries().CountTasksByStatus(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
counts := make(map[string]int, len(rows))
|
|
for _, r := range rows {
|
|
counts[r.Status] = int(r.Count)
|
|
}
|
|
return counts, nil
|
|
}
|
|
|
|
// TaskByIssue returns the task tracking an issue, or nil.
|
|
func (s *Store) TaskByIssue(ctx context.Context, owner, repo string, number int) (*workflow.Task, error) {
|
|
t, err := s.queries().TaskByIssue(ctx, postgresdb.TaskByIssueParams{
|
|
Owner: owner, Repo: repo, IssueNumber: int64(number),
|
|
})
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return nil, nil
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return taskFromRow(t), nil
|
|
}
|
|
|
|
// OpenTaskByPR returns the live task that owns the given pull request, or nil.
|
|
func (s *Store) OpenTaskByPR(ctx context.Context, owner, repo string, number int) (*workflow.Task, error) {
|
|
t, err := s.queries().TaskByPR(ctx, postgresdb.TaskByPRParams{
|
|
Owner: owner, Repo: repo, PrNumber: int64(number), Status: workflow.StatusPROpen,
|
|
})
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return nil, nil
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return taskFromRow(t), nil
|
|
}
|
|
|
|
// TaskByID returns the task with the given database ID, or nil.
|
|
func (s *Store) TaskByID(ctx context.Context, taskID int64) (*workflow.Task, error) {
|
|
t, err := s.queries().TaskByID(ctx, taskID)
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return nil, nil
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return taskFromRow(t), nil
|
|
}
|
|
|
|
// StartCall enqueues the callee of callerTaskID's workflow.call step
|
|
// (docs/prds/workflow-calls.md). The store owns the table, so it re-checks
|
|
// both runtime invariants the engine checks: the caller must be running and
|
|
// the call must not pass workflow.MaxCallDepth. The callee inherits the
|
|
// caller's org, workspace, identity, owner and repo, and takes a fresh
|
|
// synthetic issue number, the same allocator chat tasks use.
|
|
func (s *Store) StartCall(ctx context.Context, callerTaskID int64, wf string, inputs map[string]any) (*workflow.Task, error) {
|
|
encoded, err := task.EncodeInputs(inputs)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
callee, err := s.queries().EnqueueCallTask(ctx, postgresdb.EnqueueCallTaskParams{
|
|
ID: callerTaskID,
|
|
FallbackIssueNumber: syntheticIssueNumberBase - 1,
|
|
Title: fmt.Sprintf("workflow.call %s from task %d", wf, callerTaskID),
|
|
Body: fmt.Sprintf("Started by a workflow.call step from task %d (workflow %q); the call's inputs travel with the task.", callerTaskID, wf),
|
|
Workflow: wf,
|
|
Inputs: encoded,
|
|
MaxDepth: int32(workflow.MaxCallDepth),
|
|
})
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
// The WITH reads the caller FOR UPDATE before inserting, so "no
|
|
// rows" means the caller is missing, not running, or past the depth
|
|
// limit. Name which, off a plain read.
|
|
return nil, s.callRefusal(ctx, callerTaskID)
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return taskFromRow(callee), nil
|
|
}
|
|
|
|
// callRefusal names why EnqueueCallTask inserted nothing. The three refusals
|
|
// are distinct failures an operator reads differently: a missing caller is a
|
|
// problem, a caller that is not running is a stale retry, and a depth
|
|
// refusal is the limit doing its job. The two behavioural ones carry the
|
|
// caller's detail in the log and the sentinel across the wire.
|
|
func (s *Store) callRefusal(ctx context.Context, callerTaskID int64) error {
|
|
caller, err := s.queries().TaskByID(ctx, callerTaskID)
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return fmt.Errorf("store: workflow.call caller task %d does not exist: %w", callerTaskID, storecontract.ErrCallNotYours)
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if caller.Status != "running" {
|
|
return fmt.Errorf("store: workflow.call caller task %d is %s: %w", callerTaskID, caller.Status, storecontract.ErrCallCallerNotRunning)
|
|
}
|
|
return fmt.Errorf("store: workflow.call from task %d at depth %d: %w", callerTaskID, caller.CallDepth, storecontract.ErrCallDepthExceeded)
|
|
}
|
|
|
|
// CallStatus reads one call's callee for a waiting caller: its status, its
|
|
// latest transition detail and the outputs its finished run wrote. The parent
|
|
// check is the row check the wire grant cannot do: a caller reads only the
|
|
// tasks it started.
|
|
func (s *Store) CallStatus(ctx context.Context, callerTaskID, callTaskID int64) (string, string, map[string]any, error) {
|
|
callee, err := s.queries().TaskByID(ctx, callTaskID)
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return "", "", nil, storecontract.ErrCallNotYours
|
|
}
|
|
if err != nil {
|
|
return "", "", nil, err
|
|
}
|
|
if callee.CallParentTaskID != callerTaskID {
|
|
return "", "", nil, storecontract.ErrCallNotYours
|
|
}
|
|
// The row is the callee's own; its outputs travel beside status and detail
|
|
// (docs/prds/workflow-call-outputs.md, "Storage and wire"). The caller
|
|
// decides whether to use them -- only a successful terminal state's values
|
|
// reach it.
|
|
outputs, _ := task.DecodeOutputs(callee.Outputs)
|
|
// A callee that has not moved yet has no transition row; its queue
|
|
// status is the whole answer, and the empty detail says so.
|
|
detail, err := s.queries().CallStatusDetail(ctx, callTaskID)
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return callee.Status, "", outputs, nil
|
|
}
|
|
if err != nil {
|
|
return "", "", nil, err
|
|
}
|
|
return callee.Status, detail, outputs, nil
|
|
}
|