From 334bc5476751fc023360e38783d8d29efddc57d6 Mon Sep 17 00:00:00 2001 From: jochen Date: Thu, 19 Nov 2026 15:42:16 +0100 Subject: [PATCH] steprun: an unread ask whose refusal cannot be written is given back; the unwritten-end and said-end cases assert what they claim; kit case RunsCounted MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Builds: design 47 G §24; lead answers A-489a, A-489b Claude-Session: https://claude.ai/code/session_01JG73KHUnBze48rdua8u2sy --- .../steprun/conformance/conformance.go | 23 ++++ .../steprun/conformance/conformance_test.go | 15 +++ modules/mesh-delivery-sdk/steprun/pull.go | 4 +- modules/mesh-delivery-sdk/steprun/pull_bus.go | 4 +- .../steprun/pull_poison_test.go | 116 +++++++++++++++--- 5 files changed, 145 insertions(+), 17 deletions(-) diff --git a/modules/mesh-delivery-sdk/steprun/conformance/conformance.go b/modules/mesh-delivery-sdk/steprun/conformance/conformance.go index a8eb5b33..2338afa1 100644 --- a/modules/mesh-delivery-sdk/steprun/conformance/conformance.go +++ b/modules/mesh-delivery-sdk/steprun/conformance/conformance.go @@ -11,6 +11,8 @@ package conformance import ( "embed" + "encoding/json" + "errors" "fmt" "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-sdk/steprun" "slices" @@ -288,3 +290,24 @@ func StepEnds(t *testing.T, steps steprun.AskSteps) { t.Errorf("the build module's steps cannot say a step's end: %v", err) } } + +// RunsCounted is the case every build module runs on its puller (A-489a): the poison rule and a transport fault's run count the +// runs the module's steps state says started, so the puller is built with Prior over the module's own read of that state. The +// module builds its puller with read as its steps state's read; a step key it holds with a started run must count as that run. +func RunsCounted(t *testing.T, puller func(read func(key string) (json.RawMessage, error)) *steprun.Puller) { + t.Helper() + if err := runsCounted(puller); err != nil { + t.Error(err) + } +} + +func runsCounted(puller func(read func(key string) (json.RawMessage, error)) *steprun.Puller) error { + p := puller(func(string) (json.RawMessage, error) { return json.RawMessage(`{"run":2}`), nil }) + switch { + case p == nil || p.Prior == nil: + return errors.New("the build module's puller has no Prior: an ask given back would count toward poison") + case p.Prior("any") != 2: + return fmt.Errorf("Prior over a step key holding run 2 = %d, want 2: the puller does not read the module's steps state", p.Prior("any")) + } + return nil +} diff --git a/modules/mesh-delivery-sdk/steprun/conformance/conformance_test.go b/modules/mesh-delivery-sdk/steprun/conformance/conformance_test.go index e24f65bd..51c33107 100644 --- a/modules/mesh-delivery-sdk/steprun/conformance/conformance_test.go +++ b/modules/mesh-delivery-sdk/steprun/conformance/conformance_test.go @@ -196,3 +196,18 @@ func TestStepEndsRefusesStepsThatCannotSayTheirEnd(t *testing.T) { } StepEnds(t, steprun.AskSteps{Node: "n", SayStep: say}) } + +// A puller built without Prior, or with one that does not read the module's steps state, fails the case. +func TestRunsCountedRefusesAPullerThatDoesNotReadTheStepsState(t *testing.T) { + wired := func(read func(string) (json.RawMessage, error)) *steprun.Puller { + return &steprun.Puller{Prior: steprun.PriorRuns(read)} + } + if err := runsCounted(wired); err != nil { + t.Errorf("a wired puller: %v", err) + } + for name, p := range map[string]*steprun.Puller{"none": {}, "constant": {Prior: func(string) int { return 0 }}} { + if runsCounted(func(func(string) (json.RawMessage, error)) *steprun.Puller { return p }) == nil { + t.Errorf("%s: the case passed a puller that does not count the state's runs", name) + } + } +} diff --git a/modules/mesh-delivery-sdk/steprun/pull.go b/modules/mesh-delivery-sdk/steprun/pull.go index 15418a1a..d753a92b 100644 --- a/modules/mesh-delivery-sdk/steprun/pull.go +++ b/modules/mesh-delivery-sdk/steprun/pull.go @@ -632,7 +632,9 @@ func (p *Puller) refuseUnread(msg *Pulled, why error) { step := sdkstep.Step{ID: probe.ID, Tool: tool, Node: p.Node, State: sdkstep.StepRefused, Started: at, Ended: at, Reason: fmt.Sprintf("this build module on %s cannot read the ask: %v", p.Node, why), Owner: buildrun.Owner} if werr := writeEnd(p.Put, key, step); werr != nil { - p.logf("the unread ask %s cannot be answered on %s: %v", probe.ID, p.Node, werr) + p.logf("the unread ask %s cannot be answered on %s, so it is given back: %v", probe.ID, p.Node, werr) + _ = msg.Nak() // A-489a: an end that could not be written is given back, never acknowledged + return } else { p.logf("an ask refused: %v", why) _ = msg.Ack() // A-489: ended and written, so it leaves the work queue diff --git a/modules/mesh-delivery-sdk/steprun/pull_bus.go b/modules/mesh-delivery-sdk/steprun/pull_bus.go index 08e9a1b8..4053993a 100644 --- a/modules/mesh-delivery-sdk/steprun/pull_bus.go +++ b/modules/mesh-delivery-sdk/steprun/pull_bus.go @@ -146,12 +146,12 @@ func DeclareAskWorkers(ctx context.Context, js jetstream.JetStream, language str subject, _ := sdkstep.AskSubject(language, kind) // Two workers whose filters do not overlap: main's subject and the asker's, `.` (design 47 G §544). if _, err := js.CreateOrUpdateConsumer(ctx, stream, jetstream.ConsumerConfig{Durable: worker, FilterSubjects: []string{subject}, - AckPolicy: jetstream.AckExplicitPolicy, AckWait: ackWait, MaxDeliver: 5}); err != nil { + AckPolicy: jetstream.AckExplicitPolicy, AckWait: ackWait, MaxDeliver: sdkstep.AskMaxDeliver}); err != nil { return fmt.Errorf("the worker %s: %w", worker, err) } named, _ := sdkstep.AskNamedWorker(language, kind) if _, err := js.CreateOrUpdateConsumer(ctx, stream, jetstream.ConsumerConfig{Durable: named, FilterSubjects: []string{subject + ".*"}, - AckPolicy: jetstream.AckExplicitPolicy, AckWait: ackWait, MaxDeliver: 5}); err != nil { + AckPolicy: jetstream.AckExplicitPolicy, AckWait: ackWait, MaxDeliver: sdkstep.AskMaxDeliver}); err != nil { return fmt.Errorf("the worker %s: %w", named, err) } } diff --git a/modules/mesh-delivery-sdk/steprun/pull_poison_test.go b/modules/mesh-delivery-sdk/steprun/pull_poison_test.go index bfa165f8..974cb160 100644 --- a/modules/mesh-delivery-sdk/steprun/pull_poison_test.go +++ b/modules/mesh-delivery-sdk/steprun/pull_poison_test.go @@ -9,6 +9,7 @@ import ( "testing" "time" + nodebuildgo "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/nodebuildgo" sdkstep "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-sdk/buildstep" ) @@ -45,7 +46,7 @@ func TestOnlyRunsThatStartedCountTowardPoison(t *testing.T) { var mu sync.Mutex var ended []sdkstep.StepEnded ran := make(chan struct{}, 1) - p := &Puller{Source: src, Language: sdkstep.AskGo, Node: "shanks", Put: st.put, Capacity: func() int { return 1 }, + p := &Puller{Source: src, Language: sdkstep.AskGo, Logf: t.Logf, Node: "shanks", Put: st.put, Capacity: func() int { return 1 }, PullWait: 10 * time.Millisecond, Heartbeat: time.Hour, Prior: func(string) int { return c.prior }, Say: func(event string, body any, id string) error { if event == "step-ended" { @@ -90,20 +91,107 @@ func TestOnlyRunsThatStartedCountTowardPoison(t *testing.T) { } } -// A-489a: an end that could not be written is given back, never acknowledged. +// A-489a: an end that could not be written is given back, never acknowledged: the ask's start is written, its end is not +// (poison), and an unreadable ask with an id whose refusal cannot be written. func TestAnEndThatCannotBeWrittenIsGivenBack(t *testing.T) { - src := NewFakeAsks() - src.Delivered = sdkstep.AskMaxDeliver - _ = src.PublishAsk(testAsk(sdkstep.AskDelivery)) - put := func(string, any) (uint64, error) { return 0, errors.New("the state is full") } - p := &Puller{Source: src, Language: sdkstep.AskGo, Node: "shanks", Put: put, Capacity: func() int { return 1 }, PullWait: 10 * time.Millisecond, - Run: func(context.Context, sdkstep.StepAsk) (any, error) { return nil, nil }} - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - go p.Pull(ctx) - waitFor(t, "the ask given back", func() bool { _, _, nk := src.Fates(); return len(nk) >= 1 }) - if acked, _, _ := src.Fates(); len(acked) != 0 { - t.Errorf("acked %v, want none: no end was written", acked) + was := EndAttempts + EndAttempts = 1 + defer func() { EndAttempts = was }() + for _, c := range []struct { + name string + data func() []byte + prior int + }{ + {"poison", func() []byte { raw, _ := sdkstep.EncodeStepAsk(testAsk(sdkstep.AskDelivery)); return raw }, sdkstep.AskRuns}, + {"unread with an id", func() []byte { return []byte(`{"id":"mwn1abcdef0123","kind":"check","v":99}`) }, 0}, + } { + t.Run(c.name, func(t *testing.T) { + src := NewFakeAsks() + src.Publish(sdkstep.AskCheck, c.data()) + if c.prior > 0 { // a delivery of the delivery queue + src = NewFakeAsks() + src.Publish(sdkstep.AskDelivery, c.data()) + } + var mu sync.Mutex + puts := 0 + put := func(string, any) (uint64, error) { + mu.Lock() + defer mu.Unlock() + puts++ + if puts > 1 || c.prior == 0 { // the start is written, the end is not + return 0, errors.New("the state is full") + } + return 1, nil + } + p := &Puller{Source: src, Language: sdkstep.AskGo, Node: "shanks", Put: put, Capacity: func() int { return 1 }, PullWait: 10 * time.Millisecond, + Prior: func(string) int { return c.prior }, Run: func(context.Context, sdkstep.StepAsk) (any, error) { return nil, nil }} + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + go p.Pull(ctx) + waitFor(t, "the ask given back", func() bool { _, _, nk := src.Fates(); return len(nk) >= 1 }) + if acked, termed, _ := src.Fates(); len(acked)+len(termed) != 0 { + t.Errorf("acked %v termed %v, want none: no end was written", acked, termed) + } + }) + } +} + +// A-489a: a refused run (Declining) and a dropped ask each say their pipeline step's end as could not +// run, naming its pipeline, and are acknowledged once it is written. +func TestAnEndedPipelineStepIsSaidAndAcknowledged(t *testing.T) { + for _, c := range []string{"declined in its run", "dropped"} { + t.Run(c, func(t *testing.T) { + src, st := NewFakeAsks(), newSteps() + a := sdkstep.StepAsk{ID: sdkstep.NewID(), Kind: sdkstep.AskStep, Language: sdkstep.AskGo, Asker: "mesh-delivery-pipeline", At: time.Now(), + Step: &sdkstep.StepRun{Pipeline: "main.12.m", Step: sdkstep.StepLint, Module: "m", Artifact: "m:program", Commit: strings.Repeat("a", 40), + Fingerprint: "fp-1", Fetch: sdkstep.Fetch{Repository: "novox/x", Commit: strings.Repeat("a", 40), Dir: "modules/m"}}} + raw, eerr := sdkstep.EncodeStepAsk(a) + if eerr != nil { + t.Fatal(eerr) + } + src.Publish(sdkstep.AskCheck, raw) + var mu sync.Mutex + var ended []sdkstep.StepEnded + p := &Puller{Source: src, Language: sdkstep.AskGo, Node: "shanks", Put: st.put, Capacity: func() int { return 1 }, PullWait: 10 * time.Millisecond, + Say: func(event string, body any, id string) error { + if event == "step-ended" { + var e sdkstep.StepEnded + b, _ := json.Marshal(body) + if json.Unmarshal(b, &e) == nil { + mu.Lock() + ended = append(ended, e) + mu.Unlock() + } + } + return nil + }, + Run: func(context.Context, sdkstep.StepAsk) (any, error) { + return nil, &Declining{Text: "this node builds with another toolchain", Lacks: []string{"the toolchain"}} + }} + if c == "dropped" { + drop, _ := json.Marshal(nodebuildgo.Drop{V: int64(sdkstep.Version), By: "mesh-delivery-builder", Why: "superseded", At: ptr(time.Now())}) + p.Load = func(key string) ([]byte, error) { + if key == sdkstep.DropKey(a.ID) { + return drop, nil + } + return nil, nil + } + } + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + go p.Pull(ctx) + waitFor(t, "the end said", func() bool { mu.Lock(); defer mu.Unlock(); return len(ended) >= 1 }) + waitFor(t, "the ask acknowledged", func() bool { ak, _, _ := src.Fates(); return len(ak) == 1 }) + mu.Lock() + e := ended[0] + mu.Unlock() + if e.Outcome != sdkstep.OutcomeCouldNotRun || e.Pipeline != "main.12.m" { + t.Errorf("the end said %+v, want could not run naming its pipeline", e) + } + if _, termed, naked := src.Fates(); len(termed)+len(naked) != 0 { + t.Errorf("termed %v naked %v, want it acknowledged alone", termed, naked) + } + }) } }