Files
archie/internal/infrastructure/taskactions/rpc_test.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

180 lines
5.9 KiB
Go

package taskactions
import (
"context"
"errors"
"log/slog"
"testing"
"github.com/nats-io/nats-server/v2/server"
natssrv "github.com/nats-io/nats-server/v2/test"
"github.com/nats-io/nats.go"
"github.com/samcharles93/archie-core/internal/domain/storecontract"
domain "github.com/samcharles93/archie-core/internal/domain/taskactions"
"github.com/samcharles93/archie-core/internal/events"
"github.com/samcharles93/archie-core/internal/taskstate"
)
func startEmbedded(t *testing.T) *server.Server {
t.Helper()
srv := natssrv.RunRandClientPortServer()
t.Cleanup(srv.Shutdown)
return srv
}
func connect(t *testing.T, url string) *nats.Conn {
t.Helper()
nc, err := nats.Connect(url)
if err != nil {
t.Fatalf("nats connect: %v", err)
}
t.Cleanup(nc.Close)
return nc
}
// stubStore returns one task, or none, and fails every mutation with err.
type stubStore struct {
task *domain.Task
err error
}
func (s stubStore) TaskByID(context.Context, int64) (*domain.Task, error) { return s.task, nil }
func (s stubStore) Transition(context.Context, int64, string, string, string) error { return s.err }
func (s stubStore) CancelExecution(context.Context, int64, string, string) ([]int64, error) {
return nil, s.err
}
func (s stubStore) Requeue(context.Context, int64, string, string) error { return s.err }
func (s stubStore) RetryTask(context.Context, int64, string, string) error { return s.err }
func (s stubStore) ArchiveTask(context.Context, int64, string, events.Event) (int64, error) {
return 0, s.err
}
func (s stubStore) InsertEvent(context.Context, events.Event) (int64, error) { return 0, s.err }
// TestActionErrorKeepsItsSentinelAcrossNATS: the dashboard picks its HTTP
// status from these sentinels (404, 409, 503), and this hop reduces an error
// to a JSON string. Without a kind alongside the message every failure
// arrives indistinguishable and the operator is told to check the daemon
// over a task that simply moved on.
func TestActionErrorKeepsItsSentinelAcrossNATS(t *testing.T) {
parked := &domain.Task{ID: 7, Owner: "acme", Repo: "widget", Status: "parked"}
running := &domain.Task{ID: 7, Owner: "acme", Repo: "widget", Status: "running"}
for _, tc := range []struct {
name string
store stubStore
cancel func(int64) bool
action taskstate.Action
want error
}{
{
name: "missing task",
store: stubStore{},
action: taskstate.ActionAbandon,
want: domain.ErrNotFound,
},
{
name: "action the status forbids",
store: stubStore{task: parked},
action: taskstate.ActionApprove,
want: domain.ErrConflict,
},
{
name: "no runtime control wired",
store: stubStore{task: running},
action: taskstate.ActionStop,
want: domain.ErrUnavailable,
},
{
name: "store refused a stale transition",
store: stubStore{task: running, err: storecontract.ErrStaleTransition},
cancel: func(int64) bool { return true },
action: taskstate.ActionStop,
want: storecontract.ErrStaleTransition,
},
} {
t.Run(tc.name, func(t *testing.T) {
srv := startEmbedded(t)
nc := connect(t, srv.ClientURL())
service := domain.Service{Store: tc.store, CancelTask: tc.cancel, Warn: func(string, ...any) {}}
stop, err := Register(nc, service, slog.New(slog.DiscardHandler))
if err != nil {
t.Fatalf("register responder: %v", err)
}
t.Cleanup(stop)
if err := nc.Flush(); err != nil {
t.Fatalf("flush: %v", err)
}
_, err = Client{Conn: nc}.ApplyChatTaskAction(t.Context(), nil, domain.Actor{}, 7, tc.action)
if err == nil {
t.Fatalf("ApplyChatTaskAction(%s) error = nil, want %v", tc.action, tc.want)
}
if !errors.Is(err, tc.want) {
t.Fatalf("error %v (%T) is not %v", err, err, tc.want)
}
// The wording the operator reads survives too, not just the class.
direct := service.Apply(t.Context(), nil, domain.Actor{}, 7, tc.action)
if direct == nil || err.Error() != direct.Error() {
t.Fatalf("remote message = %q, want the daemon's own %v", err.Error(), direct)
}
})
}
}
// TestActionScopeCrossesNATS pins the operator scope over the same hop: a nil
// identity is a caller authenticated across identities, and JSON has to carry
// that absence rather than an empty name. The scope decides which task may be
// touched and nothing else -- it is not an actor, so it must not change what the
// timeline says about who acted.
func TestActionScopeCrossesNATS(t *testing.T) {
for _, tc := range []struct {
name string
identity *string
}{
{name: "operator scope"},
{name: "chat identity scope", identity: new("scout")},
} {
t.Run(tc.name, func(t *testing.T) {
srv := startEmbedded(t)
nc := connect(t, srv.ClientURL())
var published events.Event
service := domain.Service{
Store: stubStore{task: &domain.Task{ID: 7, Owner: "acme", Repo: "widget", Identity: "scout", Status: "parked"}},
Publish: func(e events.Event) { published = e },
}
stop, err := Register(nc, service, slog.New(slog.DiscardHandler))
if err != nil {
t.Fatalf("register responder: %v", err)
}
t.Cleanup(stop)
if err := nc.Flush(); err != nil {
t.Fatalf("flush: %v", err)
}
result, err := Client{Conn: nc}.ApplyChatTaskAction(t.Context(), tc.identity, domain.Actor{}, 7, taskstate.ActionAbandon)
if err != nil {
t.Fatalf("apply: %v", err)
}
if result.TaskID != 7 {
t.Fatalf("result = %+v, want task 7", result)
}
// No actor crosses this hop yet, so the action is recorded with no
// actor at all -- and the scope must not be promoted into one.
if published.ActorID != "" || published.PrincipalID != "" {
t.Fatalf("scope was recorded as an actor: %+v", published)
}
if published.Kind != events.KindTaskAbandoned {
t.Fatalf("event kind = %q, want %q", published.Kind, events.KindTaskAbandoned)
}
const want = "abandoned with no recorded actor"
if published.Detail != want {
t.Fatalf("event detail = %q, want %q", published.Detail, want)
}
})
}
}