diff --git a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositionbounds.go b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositionbounds.go index 7edfaaf5..5c1b5902 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositionbounds.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositionbounds.go @@ -236,9 +236,14 @@ func (r *compositionRuns) endRun(key, ask, outcome, said string, verdict map[str // endRunOf is endRun of a run whose ask is untaken, or not, as its caller judged. func (r *compositionRuns) endRunOf(key, ask, outcome, said string, verdict map[string]any, untaken bool) (bool, error) { + return r.endRunMoving(key, ask, outcome, said, verdict, untaken, true) +} + +// endRunMoving is endRunOf, moving the readers a rerun carried or not: a drop says its readers' ends itself (A-470r). +func (r *compositionRuns) endRunMoving(key, ask, outcome, said string, verdict map[string]any, untaken, move bool) (bool, error) { // The readers a rerun carried move with the run's end (§727, A-470d): chosen before the end is written, while the rerun's own // step still waits on it, so it alone says its own end; each mover waits for the end in the key. - if moved := r.moved.Load(); moved != nil { + if moved := r.moved.Load(); moved != nil && move { if run, _, ok, err := r.read(key); err == nil && ok && run.Ended == nil && run.Ask == ask { (*moved)(run) } diff --git a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositions_tools.go b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositions_tools.go index ee3c5f2a..df955f7d 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositions_tools.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositions_tools.go @@ -48,8 +48,9 @@ func (r *compositionRuns) compositions(in meshwants.CompositionsInput) (meshwant } // drop drops one composition run by hand (§728): the act and why written in the hand-act log first (record), then a running run's -// ask dropped, each of its readers' waits stopped and its end said could not run naming the drop, and the key deleted with its -// bound keys. It answers the entry deleted and the readers it ended. +// ask dropped, each of its readers' waits stopped and, for each reader whose end is owed (no `ended`, or marked rerun), its end +// said could not run naming the drop, once (A-470r), and the key deleted with its bound keys. It answers the entry deleted and +// the readers it ended. func (c *compositionSteps) drop(r *compositionRuns, record func(meshhandactsclient.Request) error, caller string, in meshwants.CompositionsDropInput) (meshwants.CompositionsDropAnswer, error) { why := strings.TrimSpace(in.Why) if in.Candidate == "" || in.Machine == "" || why == "" { @@ -80,11 +81,15 @@ func (c *compositionSteps) drop(r *compositionRuns, record func(meshhandactsclie ids = append(ids, reader.ID) } c.leave(ids) // their waits say no end of their own - if _, err := r.endRun(key, run.Ask, meshwants.CompositionRunOutcomeCouldNotRun, said, nil); err != nil { + // The run ends without moving its readers: the drop says each owed end itself, once (A-470r). + if _, err := r.endRunMoving(key, run.Ask, meshwants.CompositionRunOutcomeCouldNotRun, said, nil, r.untaken(key, run.Ask), false); err != nil { return answer, err } shared := []meshwants.Shared{{Machine: run.Machine, Run: key, Ask: run.Ask}} for _, reader := range run.Readers { + if reader.Ended != nil && !reader.Rerun { + continue // it ended passed already and keeps its verdict (A-470r) + } again := "" // a reader whose step said its end already says it again under the dropped run's ask (A-470q) if reader.Ended != nil { again = run.Ask diff --git a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositions_tools_test.go b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositions_tools_test.go index bfb98d46..b1688be1 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositions_tools_test.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositions_tools_test.go @@ -21,18 +21,34 @@ func TestTheCompositionRunsAreReadAndDroppedByTheirVerbs(t *testing.T) { var drops []string r.drop = func(ask, why string) error { drops = append(drops, ask); return nil } ends := newSaidEvents() - c := &compositionSteps{node: "n1", say: ends.say, now: func() time.Time { return now }, logf: t.Logf} + var endIDs []string // the message id of each end said + c := &compositionSteps{node: "n1", now: func() time.Time { return now }, logf: t.Logf, say: func(event string, body any, id string) error { + endIDs = append(endIDs, id) + return ends.say(event, body, id) + }} + moves := 0 + move := func(meshwants.CompositionRun) { moves++ } + r.moved.Store(&move) for _, m := range []string{"n1", "n2"} { if _, err := r.join(readerOf("ask-a", meshwants.StepRun{Pipeline: "main.3.a", Step: meshwants.StepRunStepComposition, Module: "a"}), "main.3", m, "run-"+m); err != nil { t.Fatal(err) } } + // A-470r: n2's run carries a reader that ended passed (p) and one marked rerun (q); only q's end is owed, said once. + _, _, _ = r.change(runKeyOf("main.3", "n2"), func(run *meshwants.CompositionRun) bool { + for _, id := range []string{"ask-p", "ask-q"} { + c := readerOf(id, meshwants.StepRun{Pipeline: "main.3." + id, Step: meshwants.StepRunStepComposition, Module: id}) + c.Ended, c.Rerun = &now, id == "ask-q" + run.Readers = append(run.Readers, c) + } + return true + }) var recorded []meshhandactsclient.Request record := func(q meshhandactsclient.Request) error { recorded = append(recorded, q); return nil } verbs := compositionVerbs(r, c, record) out, err := verbs[meshwants.VerbCompositions]("op", json.RawMessage(`{"machine":"n2"}`)) read, _ := out.(meshwants.CompositionsAnswer) - if err != nil || len(read.Runs) != 1 || read.Runs[0].Key != runKeyOf("main.3", "n2") || read.Runs[0].Ask != "run-n2" || len(read.Runs[0].Readers) != 1 || + if err != nil || len(read.Runs) != 1 || read.Runs[0].Key != runKeyOf("main.3", "n2") || read.Runs[0].Ask != "run-n2" || len(read.Runs[0].Readers) != 3 || read.Fill.Store != "composition-runs" || read.Fill.Cap != 16<<20 || read.Fill.Bytes == 0 { t.Fatalf("compositions = %+v %v", out, err) } @@ -43,12 +59,13 @@ func TestTheCompositionRunsAreReadAndDroppedByTheirVerbs(t *testing.T) { } out, err = verbs[meshwants.VerbCompositionsDrop]("op@n1", json.RawMessage(`{"candidate":"main.3","machine":"n2","why":"stuck"}`)) dropped, _ := out.(meshwants.CompositionsDropAnswer) - if err != nil || dropped.Run.Key != runKeyOf("main.3", "n2") || len(dropped.Ended) != 1 || dropped.Ended[0].ID != "ask-a" || + if err != nil || dropped.Run.Key != runKeyOf("main.3", "n2") || len(dropped.Ended) != 2 || dropped.Ended[0].ID != "ask-a" || dropped.Ended[1].ID != "ask-q" || + moves != 0 || len(endIDs) != 2 || endIDs[0] != "ask-a" || endIDs[1] != "ask-q.run-n2" || len(recorded) != 1 || recorded[0].Why != "stuck (op@n1)" || len(drops) != 1 || drops[0] != "run-n2" { - t.Fatalf("compositions-drop = %+v %v, recorded %+v, drops %v", out, err, recorded, drops) + t.Fatalf("compositions-drop = %+v %v, recorded %+v, drops %v, moves %d, ends %v", out, err, recorded, drops, moves, endIDs) } end, _ := ends.said[meshwants.EventStepEnded+".n1"].(meshwants.StepEnded) - if end.ID != "ask-a" || end.Outcome != meshwants.StepEndedOutcomeCouldNotRun || !strings.Contains(end.Said, "dropped by hand: stuck") || + if end.ID != "ask-q" || end.Outcome != meshwants.StepEndedOutcomeCouldNotRun || !strings.Contains(end.Said, "dropped by hand: stuck") || len(end.Shared) != 1 || end.Shared[0].Ask != "run-n2" { t.Errorf("the reader's end %+v", end) }