H-A-311 (2): a step-progress or step-end heard late still places what its end unlocks

A late progress or end moved nothing, so movers waiting on what the
step's end gave stayed unplaced: main.137 placed nothing after its
lint's late progress at 20:17:55.

Builds: design 47 H H-A-311 (2), H-A-286, H-A-288
This commit is contained in:
2026-11-21 20:43:02 +01:00
parent 6c66bf9a5a
commit e137df7189
4 changed files with 59 additions and 6 deletions
@@ -94,6 +94,23 @@ func TestAMoversBuildWaitsForItsDependenciesInThePipeline(t *testing.T) {
return e
}
before := mem["main.7"]
// H-A-311 (2): the build's end written while its placing was cut (heard by a hearer that places nothing): the same end
// heard again, late, moves nothing of the build and still places tool, which that end unlocked.
cut := *h
cut.Release = nil
if _, err := cut.OnStepEnded(bs, bs.Prefix+"n1", end("passed")); err != nil {
t.Fatal(err)
}
if p, _, _ = mem.Get("main.7"); placed(p, "tool") {
t.Fatalf("the cut placing placed tool: %+v", stepsOf(p, "tool"))
}
if _, err := h.OnStepEnded(bs, bs.Prefix+"n1", end("passed")); err != nil {
t.Fatal(err)
}
if p, _, _ = mem.Get("main.7"); !placed(p, "tool") || stepsOf(p, "tool")[0].Outcome != seat.StepResultOutcomeRunning {
t.Errorf("after builder's build passed, heard late, tool's steps = %+v, want placed and asked", stepsOf(p, "tool"))
}
mem["main.7"] = before
if _, err := h.OnStepEnded(bs, bs.Prefix+"n1", end("passed")); err != nil {
t.Fatal(err)
}
@@ -75,12 +75,18 @@ func IsRunBound(key string) bool {
// runOfAsk is the test run asked under ask: the run its asking step names in Shared, read from the state pipelines.
func (h *Hearer) runOfAsk(ask string) (string, bool) {
run, _, ok := h.runAndPipelineOfAsk(ask)
return run, ok
}
// runAndPipelineOfAsk is runOfAsk with the key of the pipeline whose step asked it.
func (h *Hearer) runAndPipelineOfAsk(ask string) (string, string, bool) {
if h.TestRuns == nil || ask == "" {
return "", false
return "", "", false
}
pkeys, err := allKeys(h.Store)
if err != nil {
return "", false
return "", "", false
}
for _, key := range pkeys {
p, _, err := h.Store.Get(key)
@@ -89,10 +95,26 @@ func (h *Hearer) runOfAsk(ask string) (string, bool) {
}
if i := stepOfAsk(p, ask); i >= 0 {
run := sharedRun(p.Steps[i])
return run, run != ""
return run, key, run != ""
}
}
return "", "", false
}
// releaseLate places what the end of a step heard late unlocks (H-A-311 (2)): a step-progress or step-end that arrives
// after its ask ended moves nothing of the step itself, yet the movers waiting on what that end gave (the dependents'
// builds) are placed, in each pipeline named, as the end heard in time would have placed them (Release).
func (h *Hearer) releaseLate(pipelines ...string) {
if h.Release == nil {
return
}
seen := map[string]bool{}
for _, key := range pipelines {
if key != "" && !seen[key] {
seen[key] = true
h.Release(key)
}
}
return "", false
}
// RunTaken takes the ask-taken of a test run's ask (§725, A-470): the node that took it is kept on the run, its untaken
@@ -158,13 +180,18 @@ func armBound(clock RunClock, runs TestRuns, key, run, ask string, ttl time.Dura
// RunProgress takes a build seat's step-progress of a test run's ask (§725, A-466p): its clock begins again, so a run that
// keeps saying its progress is never ended by it. An ask of no running, taken test run takes nothing.
func (h *Hearer) RunProgress(ask string) error {
run, ok := h.runOfAsk(ask)
run, key, ok := h.runAndPipelineOfAsk(ask)
if !ok {
return nil
}
r, _, err := h.TestRuns.Get(run)
if errors.Is(err, ErrNoRun) || (err == nil && (r.Ask != ask || r.Ended != nil)) {
h.logf("the step-progress of ask %s is late: the test run %s names ask %q (ended %v), so it moves nothing (A-470n)", ask, run, r.Ask, r.Ended != nil)
h.logf("the step-progress of ask %s is late: the test run %s names ask %q (ended %v), so it moves nothing of its own; what its end unlocks is placed (A-470n, H-A-311)", ask, run, r.Ask, r.Ended != nil)
late := []string{key}
for _, reader := range r.Readers {
late = append(late, reader.Pipeline)
}
h.releaseLate(late...)
return nil
}
if err != nil {
@@ -273,6 +273,8 @@ func (h *Hearer) OnStepEndedPinned(bs StepSeat, subject string, ev StepEnded, sh
ev.Module, ev.Commit, ev.Fingerprint, p.Steps[i].Step, p.Steps[i].Module, m.Commit, m.Fingerprint)
case !open(p.Steps[i]):
h.Asks.answeredLate(p.Steps[i], h.logf)
// An end heard late moves nothing of its step, and still places what that step's end unlocks (H-A-311 (2)).
defer h.releaseLate(ev.Pipeline)
if run := sharedRun(p.Steps[i]); run != "" && h.TestRuns != nil {
if r, _, err := h.TestRuns.Get(run); err == nil && r.Ended == nil && r.Ask == ev.ID {
// The asking step's end was written and its run's was not (a write failed): the run ends now, heard again.
@@ -2,6 +2,7 @@ package pipeline
import (
"fmt"
"slices"
"strings"
"testing"
"time"
@@ -599,6 +600,8 @@ func TestNoWriteOfATestRunActsOnAReadBeforeItsLatestChange(t *testing.T) {
run := unit.Shared[0].Run
asked(f, run)
delete(f.clock.bound, UntakenPrefix+run)
var released []string
f.h.Release = func(key string) { released = append(released, key) }
_ = f.h.RunTaken(unit.Ask, "ace")
_ = f.h.RunProgress(unit.Ask)
late := 0
@@ -610,6 +613,10 @@ func TestNoWriteOfATestRunActsOnAReadBeforeItsLatestChange(t *testing.T) {
if _, ok := f.clock.bound[BoundPrefix+run]; ok || late != 2 {
t.Errorf("bounds %v, journal %q; want no clock and both late signals journaled", f.clock.bound, f.logged)
}
// H-A-311 (2): the late step-progress still places what its step's end unlocks, in the pipeline that asked it.
if !slices.Contains(released, p.Pipeline) {
t.Errorf("the late step-progress placed in %v, want %s's waiting movers placed", released, p.Pipeline)
}
})
// A run's end is written as its step-ended is heard, before the finding the step says (A-470o).
t.Run("the run ends before the step's finding is written", func(t *testing.T) {