Plan item 6 of docs/prds/execution-tree-state-machine.md (archie-core-1214), the crash-recovery sweep the step table made decidable. RecoverStale used to be one bare UPDATE of tasks running -> queued; the steps an interrupted execution left running stayed running forever, so the next attempt started under steps that were never closed. Recovery is now one transaction: the running executions are locked, every step each one's current attempt left running moves to the step transition table's interrupted outcome with one stage_finish event row carrying the interruption marker -- the same document stageOutcome reads, so the attempt view renders the interruption the way the pre-step-table producer wrote it -- each execution's audit row lands in the same write, and the existing running->queued requeue query runs last inside it. Both edges are pinned in SQL and pinned to their tables (the execution pair beside claim and BeginRemediation, the step pair in its own test, because the two tables are different tables), so a query edit cannot move a write off a table. Deliberately running-only, per the PRD's letter: pending rows never persist outside StartStep's own transaction, so a crashed attempt leaves only running rows, and a finished step is never rewritten. The interrupted steps' events render as the PRD's interrupted -- distinct from cancelled, which an operator or parent asked for, and from failed, which the step reported. The wait:true-callee and agent-child sweeps ride #1216's tree, and the dashboard's ListSteps read is plan item 7; both untouched here, and the RecoverStale signature and RPC are unchanged.
297 lines
8.0 KiB
Go
297 lines
8.0 KiB
Go
// Code generated by sqlc. DO NOT EDIT.
|
|
// versions:
|
|
// sqlc v1.31.1
|
|
// source: steps.sql
|
|
|
|
package postgresdb
|
|
|
|
import (
|
|
"context"
|
|
|
|
"github.com/jackc/pgx/v5/pgtype"
|
|
)
|
|
|
|
const cancelAttemptSteps = `-- name: CancelAttemptSteps :many
|
|
UPDATE step_executions
|
|
SET status = 'cancelled', finished_at = now()
|
|
WHERE execution_id = $1 AND attempt = $2 AND status IN ('pending', 'running')
|
|
RETURNING id, name
|
|
`
|
|
|
|
type CancelAttemptStepsParams struct {
|
|
ExecutionID int64
|
|
Attempt int64
|
|
}
|
|
|
|
type CancelAttemptStepsRow struct {
|
|
ID int64
|
|
Name string
|
|
}
|
|
|
|
// The half of CancelExecution that cancels the current attempt's
|
|
// non-terminal steps, returning them so the store writes one event row per
|
|
// transition in the same transaction. Earlier attempts' rows never match:
|
|
// history is never rewritten.
|
|
func (q *Queries) CancelAttemptSteps(ctx context.Context, arg CancelAttemptStepsParams) ([]CancelAttemptStepsRow, error) {
|
|
rows, err := q.db.Query(ctx, cancelAttemptSteps, arg.ExecutionID, arg.Attempt)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []CancelAttemptStepsRow
|
|
for rows.Next() {
|
|
var i CancelAttemptStepsRow
|
|
if err := rows.Scan(&i.ID, &i.Name); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const finishStepExecution = `-- name: FinishStepExecution :execrows
|
|
UPDATE step_executions
|
|
SET status = $1, detail = $2, tokens_used = $3, finished_at = now()
|
|
WHERE id = $4 AND status = $5
|
|
`
|
|
|
|
type FinishStepExecutionParams struct {
|
|
Status string
|
|
Detail string
|
|
TokensUsed int64
|
|
ID int64
|
|
Status_2 string
|
|
}
|
|
|
|
func (q *Queries) FinishStepExecution(ctx context.Context, arg FinishStepExecutionParams) (int64, error) {
|
|
result, err := q.db.Exec(ctx, finishStepExecution,
|
|
arg.Status,
|
|
arg.Detail,
|
|
arg.TokensUsed,
|
|
arg.ID,
|
|
arg.Status_2,
|
|
)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected(), nil
|
|
}
|
|
|
|
const insertStepExecution = `-- name: InsertStepExecution :one
|
|
INSERT INTO step_executions (org_id, workspace_id, execution_id, attempt, parent_id, depth, kind, name, called_execution_id, status)
|
|
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, 'pending')
|
|
RETURNING id
|
|
`
|
|
|
|
type InsertStepExecutionParams struct {
|
|
OrgID string
|
|
WorkspaceID string
|
|
ExecutionID int64
|
|
Attempt int64
|
|
ParentID pgtype.Int8
|
|
Depth int32
|
|
Kind string
|
|
Name string
|
|
CalledExecutionID int64
|
|
}
|
|
|
|
func (q *Queries) InsertStepExecution(ctx context.Context, arg InsertStepExecutionParams) (int64, error) {
|
|
row := q.db.QueryRow(ctx, insertStepExecution,
|
|
arg.OrgID,
|
|
arg.WorkspaceID,
|
|
arg.ExecutionID,
|
|
arg.Attempt,
|
|
arg.ParentID,
|
|
arg.Depth,
|
|
arg.Kind,
|
|
arg.Name,
|
|
arg.CalledExecutionID,
|
|
)
|
|
var id int64
|
|
err := row.Scan(&id)
|
|
return id, err
|
|
}
|
|
|
|
const interruptAttemptSteps = `-- name: InterruptAttemptSteps :many
|
|
UPDATE step_executions
|
|
SET status = 'interrupted', finished_at = now()
|
|
WHERE execution_id = $1 AND attempt = $2 AND status = 'running'
|
|
RETURNING id, name
|
|
`
|
|
|
|
type InterruptAttemptStepsParams struct {
|
|
ExecutionID int64
|
|
Attempt int64
|
|
}
|
|
|
|
type InterruptAttemptStepsRow struct {
|
|
ID int64
|
|
Name string
|
|
}
|
|
|
|
// The crash-recovery step edge (docs/prds/execution-tree-state-machine.md):
|
|
// the steps an interrupted execution left running move to the table's
|
|
// interrupted outcome, guarded by the row's own status so only the pair the
|
|
// step transition table routes is written. Returning them lets the store
|
|
// write one event row per transition in the same transaction.
|
|
func (q *Queries) InterruptAttemptSteps(ctx context.Context, arg InterruptAttemptStepsParams) ([]InterruptAttemptStepsRow, error) {
|
|
rows, err := q.db.Query(ctx, interruptAttemptSteps, arg.ExecutionID, arg.Attempt)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []InterruptAttemptStepsRow
|
|
for rows.Next() {
|
|
var i InterruptAttemptStepsRow
|
|
if err := rows.Scan(&i.ID, &i.Name); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const lockExecutionForStep = `-- name: LockExecutionForStep :one
|
|
|
|
SELECT id, status, org_id, workspace_id, owner, repo, issue_number, workflow, attempt
|
|
FROM tasks WHERE id = $1 FOR UPDATE
|
|
`
|
|
|
|
type LockExecutionForStepRow struct {
|
|
ID int64
|
|
Status string
|
|
OrgID string
|
|
WorkspaceID string
|
|
Owner string
|
|
Repo string
|
|
IssueNumber int64
|
|
Workflow string
|
|
Attempt int64
|
|
}
|
|
|
|
// Step-execution queries (docs/prds/execution-tree-state-machine.md). The
|
|
// store method owns the transaction that pairs each step transition with its
|
|
// event row; these are only the guarded row writes and reads.
|
|
// FOR UPDATE locks the execution's row, so the status check, the step insert
|
|
// and the event append are one serialized operation per execution -- the way
|
|
// guardTransition locks a task's row for its transition. The row also carries
|
|
// every field the transition's event needs (org, workspace, the task
|
|
// identity) and the attempt the step must belong to.
|
|
func (q *Queries) LockExecutionForStep(ctx context.Context, id int64) (LockExecutionForStepRow, error) {
|
|
row := q.db.QueryRow(ctx, lockExecutionForStep, id)
|
|
var i LockExecutionForStepRow
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.Status,
|
|
&i.OrgID,
|
|
&i.WorkspaceID,
|
|
&i.Owner,
|
|
&i.Repo,
|
|
&i.IssueNumber,
|
|
&i.Workflow,
|
|
&i.Attempt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const lockRunningExecutions = `-- name: LockRunningExecutions :many
|
|
SELECT id, org_id, workspace_id, owner, repo, issue_number, workflow, attempt
|
|
FROM tasks WHERE status = 'running' FOR UPDATE
|
|
`
|
|
|
|
type LockRunningExecutionsRow struct {
|
|
ID int64
|
|
OrgID string
|
|
WorkspaceID string
|
|
Owner string
|
|
Repo string
|
|
IssueNumber int64
|
|
Workflow string
|
|
Attempt int64
|
|
}
|
|
|
|
// The executions a crashed or replaced daemon left running, locked for the
|
|
// recovery transaction so the step sweep and the requeue cannot race a
|
|
// concurrent write. The row carries the identity the steps' events need.
|
|
func (q *Queries) LockRunningExecutions(ctx context.Context) ([]LockRunningExecutionsRow, error) {
|
|
rows, err := q.db.Query(ctx, lockRunningExecutions)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []LockRunningExecutionsRow
|
|
for rows.Next() {
|
|
var i LockRunningExecutionsRow
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.OrgID,
|
|
&i.WorkspaceID,
|
|
&i.Owner,
|
|
&i.Repo,
|
|
&i.IssueNumber,
|
|
&i.Workflow,
|
|
&i.Attempt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const lockStepExecution = `-- name: LockStepExecution :one
|
|
SELECT id, org_id, workspace_id, execution_id, attempt, parent_id, depth, kind, name, called_execution_id, status, detail, tokens_used, started_at, finished_at
|
|
FROM step_executions WHERE id = $1 FOR UPDATE
|
|
`
|
|
|
|
// FOR UPDATE, shared by a start's parent check and a finish's guarded write:
|
|
// the row is held for the caller's transaction, so the state a check reads is
|
|
// the state the guarded write sees.
|
|
func (q *Queries) LockStepExecution(ctx context.Context, id int64) (StepExecution, error) {
|
|
row := q.db.QueryRow(ctx, lockStepExecution, id)
|
|
var i StepExecution
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.OrgID,
|
|
&i.WorkspaceID,
|
|
&i.ExecutionID,
|
|
&i.Attempt,
|
|
&i.ParentID,
|
|
&i.Depth,
|
|
&i.Kind,
|
|
&i.Name,
|
|
&i.CalledExecutionID,
|
|
&i.Status,
|
|
&i.Detail,
|
|
&i.TokensUsed,
|
|
&i.StartedAt,
|
|
&i.FinishedAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const startStepExecution = `-- name: StartStepExecution :execrows
|
|
UPDATE step_executions SET status = 'running', started_at = now()
|
|
WHERE id = $1 AND status = 'pending'
|
|
`
|
|
|
|
// The pending -> running half of StartStep, guarded by the row's own status:
|
|
// the step transition table routes the pair, so a row that is not pending is
|
|
// stale rather than silently restarted.
|
|
func (q *Queries) StartStepExecution(ctx context.Context, id int64) (int64, error) {
|
|
result, err := q.db.Exec(ctx, startStepExecution, id)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected(), nil
|
|
}
|