Files
pipelines/internal/pipeline/resources_test.go
T
alan 9130ae8c7a Add stage-exclusive resource waiting
Add durable FIFO capacity-one resource leases for executable stages, including cleanup-confirmed release, conservative restart quarantine, queue state events, and CLI/TUI/Android waiting presentation. Add scheduler, cleanup, protocol, client, and Android coverage plus a proposed Android v3 resource draft.

Checked packaged templates and authoring skill references: neither needs updating in this item. The per-item docs note records the shared documentation that docs-fold must update; no shared README or packaged reference was edited.
2026-10-18 12:30:30 +01:00

289 lines
8.1 KiB
Go

package pipeline
import (
"context"
"encoding/json"
"fmt"
"path/filepath"
"strings"
"sync"
"testing"
"time"
)
func TestResourceDeclaration(t *testing.T) {
base := Template([]string{"work"}, true)
for _, value := range []string{`{"exclusive":"phone-X"}`, `{ "exclusive" : "A_1" }`} {
graph, err := Parse(base + "```resources\n" + value + "\n```\n")
if err != nil || graph.Stages[0].Resources == nil {
t.Fatalf("%s: %v", value, err)
}
if _, ok := StageDefinition(graph.Stages[0]).Blocks["resources"]; ok {
t.Fatal("runner control reached executor")
}
encoded, _ := json.Marshal(graph)
if !strings.Contains(string(encoded), `"resources"`) {
t.Fatal("resource lost in persisted graph")
}
}
for _, value := range []string{`{}`, `null`, `[]`, `{"exclusive":""}`, `{"exclusive":"a b"}`, `{"exclusive":"a","exclusive":"b"}`, `{"exclusive":"a","extra":1}`, `{"exclusive":["a","b"]}`, fmt.Sprintf(`{"exclusive":%q}`, strings.Repeat("a", 129))} {
if _, err := Parse(base + "```resources\n" + value + "\n```\n"); err == nil {
t.Fatalf("accepted %s", value)
}
}
human := "# stage gate\n```prompt\nChoose\n```\n```configs\ntype=human\n```\n```edges\ngo -> #success\n```\n```resources\n{\"exclusive\":\"phone\"}\n```\n"
if _, err := Parse(human); err == nil {
t.Fatal("human acquired a resource")
}
}
func resourceStore(t *testing.T) (*Store, func(string) ResourceVisit) {
t.Helper()
ctx := context.Background()
s, err := Open(filepath.Join(t.TempDir(), "resources.db"))
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { s.Close() })
if _, err := s.Submit(ctx, "resource", Template([]string{"work"}, true)); err != nil {
t.Fatal(err)
}
items, _ := s.List(ctx)
d, _ := s.Get(ctx, items[0].ID, 1)
count := 0
return s, func(resource string) ResourceVisit {
count++
id, _, err := s.CreateRun(ctx, d, fmt.Sprint(count), "workspace", false, nil, nil)
if err != nil {
t.Fatal(err)
}
return ResourceVisit{Resource: resource, RunID: id, Stage: "work", Sequence: 1}
}
}
func acquireTestResource(t *testing.T, s *Store, visit ResourceVisit) ResourceLease {
t.Helper()
l, ch, _, err := s.RequestResource(context.Background(), visit)
if err != nil || ch != nil {
t.Fatalf("acquire: %v %v", ch, err)
}
return l
}
func releaseTestResource(t *testing.T, s *Store, lease ResourceLease) {
t.Helper()
if err := s.SetResourceCleanup(context.Background(), lease, true); err != nil {
t.Fatal(err)
}
if err := s.ReleaseResource(context.Background(), lease); err != nil {
t.Fatal(err)
}
}
func TestResourceFIFOOwnershipCancellationAndRegistry(t *testing.T) {
s, create := resourceStore(t)
ctx := context.Background()
a := acquireTestResource(t, s, create("X"))
duplicate := acquireTestResource(t, s, a.ResourceVisit)
if duplicate != a {
t.Fatal("duplicate acquisition changed capability")
}
var visits []ResourceVisit
var channels []<-chan ResourceLease
for i := 0; i < 4; i++ {
v := create("X")
_, ch, wait, err := s.RequestResource(ctx, v)
if err != nil || ch == nil || wait == nil {
t.Fatal("missing waiter", err)
}
_, again, _, err := s.RequestResource(ctx, v)
if err != nil || again != ch {
t.Fatal("duplicate waiter registered", err)
}
visits = append(visits, v)
channels = append(channels, ch)
}
if err := s.ReleaseResource(ctx, a); err != nil {
t.Fatal(err)
} // no cleanup receipt
for _, ch := range channels {
select {
case <-ch:
t.Fatal("unconfirmed release granted")
default:
}
}
if err := s.SetResourceCleanup(ctx, a, true); err != nil {
t.Fatal(err)
}
for _, corrupt := range []func(*ResourceLease){func(l *ResourceLease) { l.RunID++ }, func(l *ResourceLease) { l.Stage = "other" }, func(l *ResourceLease) { l.Sequence++ }, func(l *ResourceLease) { l.token = "wrong" }} {
bad := a
corrupt(&bad)
if err := s.ReleaseResource(ctx, bad); err != nil {
t.Fatal(err)
}
}
for _, ch := range channels {
select {
case <-ch:
t.Fatal("unconfirmed/mismatched release granted")
default:
}
}
if err := s.CancelResource(ctx, visits[1]); err != nil {
t.Fatal(err)
}
releaseTestResource(t, s, a)
for _, i := range []int{0, 2, 3} {
var grant ResourceLease
select {
case grant = <-channels[i]:
case <-time.After(time.Second):
t.Fatal("FIFO grant not delivered")
}
s.AcceptResource(grant)
if grant.ResourceVisit != visits[i] {
t.Fatal("wrong FIFO owner")
}
// An old owner's repeated release cannot release the next owner.
if err := s.ReleaseResource(ctx, a); err != nil {
t.Fatal(err)
}
for _, j := range []int{2, 3} {
if j > i {
select {
case <-channels[j]:
t.Fatal("multiple grants")
default:
}
}
}
releaseTestResource(t, s, grant)
}
if len(s.resourceWaiters) != 0 {
t.Fatal("channel registry leaked")
}
for i := 0; i < 30; i++ {
owner := acquireTestResource(t, s, create("X"))
v := create("X")
_, _, _, err := s.RequestResource(ctx, v)
if err != nil {
t.Fatal(err)
}
releaseTestResource(t, s, owner) // race window: granted but not accepted
if err := s.CancelResource(ctx, v); err != nil {
t.Fatal(err)
}
if len(s.resourceWaiters) != 0 {
t.Fatal("grant/cancel leaked channel")
}
}
for i := 0; i < 30; i++ {
owner := acquireTestResource(t, s, create("X"))
v := create("X")
if _, _, _, err := s.RequestResource(ctx, v); err != nil {
t.Fatal(err)
}
if err := s.SetResourceCleanup(ctx, owner, true); err != nil {
t.Fatal(err)
}
var wg sync.WaitGroup
wg.Add(2)
go func() {
defer wg.Done()
if err := s.ReleaseResource(ctx, owner); err != nil {
t.Error(err)
}
}()
go func() {
defer wg.Done()
if err := s.CancelResource(ctx, v); err != nil {
t.Error(err)
}
}()
wg.Wait()
if len(s.resourceWaiters) != 0 {
t.Fatal("concurrent grant/cancel leaked channel")
}
}
var owners, waiters int
s.db.QueryRow("SELECT COUNT(*) FROM resource_owners").Scan(&owners)
s.db.QueryRow("SELECT COUNT(*) FROM resource_waiters").Scan(&waiters)
if owners != 0 || waiters != 0 {
t.Fatalf("stranded owners/waiters: %d/%d", owners, waiters)
}
}
func TestResourceCancellationPersistenceFailureRemovesChannel(t *testing.T) {
s, create := resourceStore(t)
acquireTestResource(t, s, create("X"))
v := create("X")
if _, _, _, err := s.RequestResource(context.Background(), v); err != nil {
t.Fatal(err)
}
if err := s.Close(); err != nil {
t.Fatal(err)
}
if err := s.CancelResource(context.Background(), v); err == nil {
t.Fatal("closed DB cancellation claimed success")
}
if len(s.resourceWaiters) != 0 {
t.Fatal("persistence failure leaked channel")
}
}
func TestResourceRestartQuarantineAndRetention(t *testing.T) {
for _, confirmed := range []bool{false, true} {
t.Run(fmt.Sprint(confirmed), func(t *testing.T) {
s, create := resourceStore(t)
ctx := context.Background()
a := acquireTestResource(t, s, create("X"))
b := create("X")
if _, _, _, err := s.RequestResource(ctx, b); err != nil {
t.Fatal(err)
}
if confirmed {
if err := s.SetResourceCleanup(ctx, a, true); err != nil {
t.Fatal(err)
}
}
path := s.path
if err := s.Close(); err != nil {
t.Fatal(err)
}
reopened, err := Open(path)
if err != nil {
t.Fatal(err)
}
defer reopened.Close()
if err := reopened.RecoverRuns(ctx); err != nil {
t.Fatal(err)
}
if err := reopened.RecoverRuns(ctx); err != nil {
t.Fatal(err)
}
detail, err := reopened.GetRun(ctx, b.RunID)
if err != nil || detail.Status != "interrupted" || detail.ResourceWait != nil || len(detail.Steps) != 0 || !strings.Contains(detail.Diagnostic, "resource") {
t.Fatal("queued visit replayed/lost diagnostic", detail, err)
}
exists, err := reopened.HasResourceOwner(ctx, a.RunID)
if err != nil || exists == confirmed {
t.Fatal("incorrect recovery disposition", exists, err)
}
report, err := reopened.RetentionReport(ctx, RetentionPolicy{Keep: 0}, "", time.Now())
if err != nil {
t.Fatal(err)
}
protected := false
for _, p := range report.Protected {
if p.ID == a.RunID {
protected = true
}
}
if protected == confirmed {
t.Fatal("quarantined evidence not protected")
}
})
}
}