Files
archie/internal/gateway/tasks.go
T
sam 36981c2024 feat(statestore): CancelExecution, and one cancel path for daemon stop and operator actions
Plan item 5 of docs/prds/execution-tree-state-machine.md (archie-core-1217).
Until now a stop was a context cancel plus a caller-side transition, and the
step rows a worker still held running could never be told: the execution moved
while the work carried on, and the old interrupt-first ordering existed only
because the record could not defend itself. The step table can: the PRD's
ordering -- the store is the record, the context cancel is the delivery --
became safe the moment a worker's next step write fails ErrStaleTransition
against a cancelled step.

- storecontract.ExecutionCanceller and the CancelExecution RPC: one
  transaction moves every non-terminal StepExecution of the execution's
  current attempt to cancelled (one event row each, in the same
  transaction), and the execution itself to the status the operator action
  names, under the shared transition table with its audit row. Staleness is
  decided before legality, the way guardTransition decides it. Earlier
  attempts are never rewritten. Deliberately administrative: the
  deny-by-default grant rule covers it, pinned by a test.
- taskactions.Service routes stop, cancel, abandon and reject through it and
  the old Transition/CancelTask combinations are deleted; the daemon's
  in-memory cancel is demoted to the delivery hook the PRD names, called
  after the store record.
- The gateway's chat controller records first and delivers second, the same
  order, and records even when no runtime is wired here (a standalone
  gateway cannot reach the daemon's goroutines): the record is what unsticks
  a lost-cancel task, and the delivery is best effort. StopRunning and
  TaskRuntime.CancelRunningTasks are deleted outright -- no production
  caller remained once the task_action tool owned stopping, and the daemon's
  CancelRunningTasks/runningTasks.stopAll go with them.
- The gateway's chat adapter writes through CancelExecution instead of a
  bare Transition, so chat /cancel and the dashboard's action service land
  on the same path.

PRD decisions recorded here:
- Each cancelled step's event row is stage_finish with {cancelled: true} and
  the reason as its detail -- the exact-one-event-per-step-transition rule
  covers the pending -> cancelled transition too, even for a step that never
  ran.
- A parked cancel carries the needs_human class, matching the Transition
  path this replaces; the transient class stays with parkRunningTask's
  unwind parks, which now meet ErrStaleTransition for cancelled runs and are
  ignored there.
- Cancelling a wait:true callee is deferred to #1216's agent-call children:
  the callee's own tree and the wait flag are what make
  "cancelling a caller cancels each callee it waits on" decidable, and the
  callee writes it cannot fake are this issue's half of the contract.
- RecoverStale's interrupted sweep is plan item 6, untouched here.
2026-09-27 06:34:01 +10:00

227 lines
8.4 KiB
Go

package gateway
import (
"context"
"fmt"
"github.com/samcharles93/archie-core/internal/taskstate"
)
// StoreTaskCreator implements TaskCreator backed by a store interface.
// Chat-spawned tasks use a timestamp-based synthetic issue number to
// avoid colliding with Gitea-issued tasks; the created row is native
// (Source "chat", no backing forge issue). The configured default repo
// is used when a spawn request doesn't specify one explicitly.
type StoreTaskCreator struct {
store chatTaskWriter
defaultOwner string
defaultRepo string
// allowed lists "owner/name" repos this identity may spawn tasks
// against. An explicit SpawnRequest.Repo not in this set is
// rejected -- chat must not be able to spawn work against a repo
// the identity isn't configured for.
allowed map[string]bool
profiles map[string]taskProfile
}
// TaskProfile defines the repositories available to one daemon identity.
// Identity is the stable IdentityConfig.Name stored on chat-originated tasks.
type TaskProfile struct {
Identity string
DefaultOwner string
DefaultRepo string
Repos []string
}
type taskProfile struct {
defaultOwner string
defaultRepo string
allowed map[string]bool
}
// chatTaskWriter is the write surface StoreTaskCreator needs. It
// returns the created task's real database ID, not a *workflow.Task --
// gateway deliberately has no dependency on the task store or
// internal/domain/workflow; the daemon supplies an adapter closure over
// the store.TaskStore method of the same name.
type chatTaskWriter interface {
EnqueueChatTask(ctx context.Context, owner, repo, title, body, workflow, identity string) (taskID int64, err error)
}
// NewStoreTaskCreator returns a TaskCreator that enqueues chat-spawned
// tasks via the daemon's store. defaultOwner/defaultRepo are used when
// a spawn request doesn't specify repo=owner/name explicitly. repos
// lists every "owner/name" pair the identity is configured for (the
// default included); an explicit repo= selection outside this set is
// rejected. When defaultOwner/defaultRepo are empty, /spawn without an
// explicit repo= returns a configuration error.
func NewStoreTaskCreator(sw chatTaskWriter, defaultOwner, defaultRepo string, repos []string) *StoreTaskCreator {
allowed := make(map[string]bool, len(repos))
for _, r := range repos {
allowed[r] = true
}
return &StoreTaskCreator{store: sw, defaultOwner: defaultOwner, defaultRepo: defaultRepo, allowed: allowed}
}
// NewStoreTaskCreatorForProfiles returns a creator that resolves repository
// defaults and allow-lists from the identity selected in each request.
func NewStoreTaskCreatorForProfiles(sw chatTaskWriter, profiles []TaskProfile) *StoreTaskCreator {
byIdentity := make(map[string]taskProfile, len(profiles))
for _, profile := range profiles {
allowed := make(map[string]bool, len(profile.Repos))
for _, repo := range profile.Repos {
allowed[repo] = true
}
byIdentity[profile.Identity] = taskProfile{
defaultOwner: profile.DefaultOwner,
defaultRepo: profile.DefaultRepo,
allowed: allowed,
}
}
return &StoreTaskCreator{store: sw, profiles: byIdentity}
}
func (c *StoreTaskCreator) CreateTask(ctx context.Context, req SpawnRequest) (int64, error) {
owner, repo, allowed := c.defaultOwner, c.defaultRepo, c.allowed
if c.profiles != nil {
profile, ok := c.profiles[req.Identity]
if !ok {
return 0, fmt.Errorf("identity %q is not configured for chat tasks", req.Identity)
}
owner, repo, allowed = profile.defaultOwner, profile.defaultRepo, profile.allowed
}
if req.Repo != "" {
if !allowed[req.Repo] {
return 0, fmt.Errorf("repo %q is not configured for this identity", req.Repo)
}
o, r, ok := splitOwnerRepo(req.Repo)
if !ok {
return 0, fmt.Errorf("repo %q must be owner/name", req.Repo)
}
owner, repo = o, r
}
if owner == "" || repo == "" {
return 0, fmt.Errorf("no repo configured for chat-spawned tasks")
}
return c.store.EnqueueChatTask(ctx, owner, repo, req.Title, req.Body, req.Workflow, req.Identity)
}
func splitOwnerRepo(s string) (owner, repo string, ok bool) {
for i, c := range s {
if c == '/' {
return s[:i], s[i+1:], s[:i] != "" && s[i+1:] != ""
}
}
return "", "", false
}
// Task lifecycle statuses come from internal/taskstate, a leaf package with
// no dependencies, so gateway stays decoupled from the task store without
// keeping a hand-synced copy of the strings. The copy that used to live here
// is how the dashboard and chat ended up recording different states for the
// same operator decision.
// ChatTaskStatus is the minimal task state StoreTaskController needs to
// authorize and validate /approve and /cancel.
type ChatTaskStatus struct {
Status string
Identity string
}
// chatTaskController is the read/write surface StoreTaskController
// needs. The daemon supplies an adapter over store.TaskStore's
// TaskByID, Requeue, and Transition methods.
type chatTaskController interface {
// ChatTaskStatus returns the task's status and owning identity, and
// false if no task with that ID exists.
ChatTaskStatus(ctx context.Context, taskID int64) (ChatTaskStatus, bool, error)
// ApproveChatTask requeues a waiting_human task. Callers must have
// already validated the current status is waiting_human.
ApproveChatTask(ctx context.Context, taskID int64) error
// CancelChatTask transitions an active task to a rejected/terminal
// state. Callers must have already validated the current status is
// cancellable.
CancelChatTask(ctx context.Context, taskID int64, reason string) error
}
// TaskRuntime reaches tasks that are currently executing. The daemon
// implements it; the store cannot, because a row records what a task is
// meant to be doing, not the goroutine doing it. It is only the delivery
// mechanism: the store's CancelExecution record precedes it.
type TaskRuntime interface {
// CancelTask interrupts one running task, reporting whether it was
// running.
CancelTask(taskID int64) bool
}
// StoreTaskController implements TaskController backed by a store
// interface. Authorization requires the caller identity to exactly
// match the task identity, including the empty identity (single-identity deployments).
type StoreTaskController struct {
store chatTaskController
// runtime interrupts running work. Nil leaves running tasks
// uninterruptible, which is the pre-existing behaviour and is
// reported as such rather than silently succeeding.
runtime TaskRuntime
}
// NewStoreTaskController returns a TaskController backed by c.
func NewStoreTaskController(c chatTaskController) *StoreTaskController {
return &StoreTaskController{store: c}
}
// WithRuntime returns a controller that can also interrupt running tasks.
func (c *StoreTaskController) WithRuntime(rt TaskRuntime) *StoreTaskController {
c.runtime = rt
return c
}
func (c *StoreTaskController) Approve(ctx context.Context, taskID int64, identity string) error {
st, err := c.authorize(ctx, taskID, identity)
if err != nil {
return err
}
if err := taskstate.CheckApprove(st.Status); err != nil {
return err
}
return c.store.ApproveChatTask(ctx, taskID)
}
func (c *StoreTaskController) Cancel(ctx context.Context, taskID int64, identity string) error {
st, err := c.authorize(ctx, taskID, identity)
if err != nil {
return err
}
if err := taskstate.CheckDecline(st.Status); err != nil {
return err
}
// The store records the cancellation first -- the one cancel path -- and
// the context cancel delivers it. The order is the PRD's: a worker that
// keeps writing after the record fails ErrStaleTransition on its next
// step write, so it cannot win the race the old interrupt-first ordering
// guarded against. A task the store says is running but nothing is
// executing for (a crashed or migrated daemon) is unstuck by the record
// alone, which is why the delivery is reported, not required.
if err := c.store.CancelChatTask(ctx, taskID, "declined by "+identity); err != nil {
return err
}
if st.Status == taskstate.Running && c.runtime != nil {
c.runtime.CancelTask(taskID)
}
return nil
}
func (c *StoreTaskController) authorize(ctx context.Context, taskID int64, identity string) (ChatTaskStatus, error) {
st, ok, err := c.store.ChatTaskStatus(ctx, taskID)
if err != nil {
return ChatTaskStatus{}, fmt.Errorf("lookup failed: %w", err)
}
if !ok {
return ChatTaskStatus{}, fmt.Errorf("task %d not found", taskID)
}
if st.Identity != identity {
return ChatTaskStatus{}, fmt.Errorf("task belongs to a different identity")
}
return st, nil
}