Files
sam e75d5c8ade
deploy / plan (push) Successful in 7s
deploy / archied-image (push) Canceled after 0s
deploy / agent-image (push) Canceled after 0s
deploy / dist-zip (push) Canceled after 0s
deploy / gate (push) Canceled after 4m4s
fix(store): a restart re-queues a running task at its interrupted step and parks it after 3 restarts (#1841)
2026-11-09 14:36:08 +11:00

509 lines
14 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, results = $6, finished_at = now()
WHERE id = $4 AND status = $5
`
type FinishStepExecutionParams struct {
Status string
Detail string
TokensUsed int64
ID int64
Status_2 string
Results []byte
}
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,
arg.Results,
)
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, depth, kind
`
type InterruptAttemptStepsParams struct {
ExecutionID int64
Attempt int64
}
type InterruptAttemptStepsRow struct {
ID int64
Name string
Depth int32
Kind 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,
&i.Depth,
&i.Kind,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const latestStageResults = `-- name: LatestStageResults :one
SELECT status, results FROM step_executions
WHERE execution_id = $1 AND depth = 0 AND kind = 'stage' AND name = $2
AND status IN ('succeeded', 'failed')
ORDER BY attempt DESC, id DESC
LIMIT 1
`
type LatestStageResultsParams struct {
ExecutionID int64
Name string
}
type LatestStageResultsRow struct {
Status string
Results []byte
}
// The most recent finished run of a root stage, across attempts: a resumed
// attempt skips the stages before its resume point, so the last attempt that
// ran this stage may be an earlier one. NULL results mean that run did not
// move past the stage.
func (q *Queries) LatestStageResults(ctx context.Context, arg LatestStageResultsParams) (LatestStageResultsRow, error) {
row := q.db.QueryRow(ctx, latestStageResults, arg.ExecutionID, arg.Name)
var i LatestStageResultsRow
err := row.Scan(&i.Status, &i.Results)
return i, err
}
const listStepExecutions = `-- name: ListStepExecutions :many
SELECT id, execution_id, attempt, parent_id, depth, kind, name, status, detail, tokens_used, started_at, finished_at, called_execution_id
FROM step_executions
WHERE execution_id = $1::bigint AND ($2::bigint = 0 OR attempt = $2::bigint)
AND ($3::text IS NULL OR org_id = $3)
ORDER BY attempt, id
`
type ListStepExecutionsParams struct {
ExecutionID int64
Attempt int64
ScopeOrg pgtype.Text
}
type ListStepExecutionsRow struct {
ID int64
ExecutionID int64
Attempt int64
ParentID pgtype.Int8
Depth int32
Kind string
Name string
Status string
Detail string
TokensUsed int64
StartedAt pgtype.Timestamptz
FinishedAt pgtype.Timestamptz
CalledExecutionID int64
}
// attempt = 0 lists every attempt of the execution, oldest first; the index
// (execution_id, attempt, id) makes both this and the single-attempt form a
// straight index scan.
func (q *Queries) ListStepExecutions(ctx context.Context, arg ListStepExecutionsParams) ([]ListStepExecutionsRow, error) {
rows, err := q.db.Query(ctx, listStepExecutions, arg.ExecutionID, arg.Attempt, arg.ScopeOrg)
if err != nil {
return nil, err
}
defer rows.Close()
var items []ListStepExecutionsRow
for rows.Next() {
var i ListStepExecutionsRow
if err := rows.Scan(
&i.ID,
&i.ExecutionID,
&i.Attempt,
&i.ParentID,
&i.Depth,
&i.Kind,
&i.Name,
&i.Status,
&i.Detail,
&i.TokensUsed,
&i.StartedAt,
&i.FinishedAt,
&i.CalledExecutionID,
); 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,
restart_requeues, retry_mode, resume_from, resume_results
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
RestartRequeues int64
RetryMode string
ResumeFrom string
ResumeResults []byte
}
// 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,
&i.RestartRequeues,
&i.RetryMode,
&i.ResumeFrom,
&i.ResumeResults,
); 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
`
type LockStepExecutionRow struct {
ID int64
OrgID string
WorkspaceID string
ExecutionID int64
Attempt int64
ParentID pgtype.Int8
Depth int32
Kind string
Name string
CalledExecutionID int64
Status string
Detail string
TokensUsed int64
StartedAt pgtype.Timestamptz
FinishedAt pgtype.Timestamptz
}
// 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) (LockStepExecutionRow, error) {
row := q.db.QueryRow(ctx, lockStepExecution, id)
var i LockStepExecutionRow
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 priorStageResults = `-- name: PriorStageResults :one
SELECT results FROM step_executions
WHERE execution_id = $1 AND attempt = $2 AND id < $3 AND depth = 0 AND kind = 'stage'
AND status IN ('succeeded', 'failed', 'skipped') AND results IS NOT NULL
ORDER BY id DESC
LIMIT 1
`
type PriorStageResultsParams struct {
ExecutionID int64
Attempt int64
ID int64
}
// What the attempt's last finished root stage before the given step recorded,
// the results a restart resumes that step with.
func (q *Queries) PriorStageResults(ctx context.Context, arg PriorStageResultsParams) ([]byte, error) {
row := q.db.QueryRow(ctx, priorStageResults, arg.ExecutionID, arg.Attempt, arg.ID)
var results []byte
err := row.Scan(&results)
return results, 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
}
const stepCalleeParent = `-- name: StepCalleeParent :one
SELECT call_parent_task_id FROM tasks WHERE id = $1
`
// The caller linkage a call step's callee must carry: the callee's
// call_parent_task_id names the execution whose tree records the call. A
// call step naming a task that is not this execution's callee is refused,
// because a cancel of that execution would otherwise cancel work the
// caller never started.
func (q *Queries) StepCalleeParent(ctx context.Context, id int64) (int64, error) {
row := q.db.QueryRow(ctx, stepCalleeParent, id)
var call_parent_task_id int64
err := row.Scan(&call_parent_task_id)
return call_parent_task_id, err
}
const waitingCallSteps = `-- name: WaitingCallSteps :many
SELECT id, called_execution_id FROM step_executions
WHERE execution_id = $1 AND attempt = $2
AND kind = 'call' AND status IN ('pending', 'running') AND called_execution_id <> 0
`
type WaitingCallStepsParams struct {
ExecutionID int64
Attempt int64
}
type WaitingCallStepsRow struct {
ID int64
CalledExecutionID int64
}
// The call steps of the execution's current attempt that are still open and
// name a callee: a call step closes when the callee ends, so an open one is
// a callee the caller waits on (wait:true). The callee sweep of CancelExecution
// walks these, because a callee whose call step already closed -- wait:false,
// or one that ended before the cancel arrived -- runs on.
func (q *Queries) WaitingCallSteps(ctx context.Context, arg WaitingCallStepsParams) ([]WaitingCallStepsRow, error) {
rows, err := q.db.Query(ctx, waitingCallSteps, arg.ExecutionID, arg.Attempt)
if err != nil {
return nil, err
}
defer rows.Close()
var items []WaitingCallStepsRow
for rows.Next() {
var i WaitingCallStepsRow
if err := rows.Scan(&i.ID, &i.CalledExecutionID); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}