From c37a7317b70c3b0eb7be0e1521364484afa8449a Mon Sep 17 00:00:00 2001 From: jochen Date: Sun, 22 Nov 2026 14:35:41 +0100 Subject: [PATCH] Builder: every again fetch and gap read follows a live fetch MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit On the turn after an again item ran, the dispatch fetched again and read the live gap without fetching live first, so a live item the stream held but had not yet given to the waiting live pull showed no gap and a later again item went first (review round 2 on b77b70a6, publishitem.go:791). The live consumer is now fetched without waiting on every turn no live item is held. The test row adds that case and bounds its rounds by the level's set-up share. Builds: design 47 H2 §793, H-A-473 (third addendum) --- .../publishes_integration_test.go | 42 ++++++++++++------- .../cmd/mesh-delivery-builder/publishitem.go | 6 +-- 2 files changed, 31 insertions(+), 17 deletions(-) diff --git a/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/publishes_integration_test.go b/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/publishes_integration_test.go index 32c6ac8a2..e05709ad0 100644 --- a/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/publishes_integration_test.go +++ b/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/publishes_integration_test.go @@ -22,6 +22,7 @@ import ( "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshbuilds" "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshcatalog" "git.novox.be/novox/mesh-sdk/go/process" + "git.novox.be/novox/mesh-sdk/go/testbus" "git.novox.be/novox/mesh-sdk/go/views" "mesh-delivery-builder/internal/versions" @@ -136,16 +137,18 @@ func TestThePublishQueueSendsLiveFirstAndNeverADroppedItem(t *testing.T) { } mu.Unlock() - // An idle dispatch (H-A-473, its third addendum): its two pulls wait; a live item put, then an again one, is sent live first, - // every time, 50 rounds, each a holder of its own. - classCh := make(chan string, 2) + // An idle dispatch (H-A-473, its third addendum): its two pulls wait; a live item put, then an again one, is sent live first; + // and an again item put after a live one, while the dispatch runs an again item put before both, is sent after the live one. + // Every time, 50 rounds, each a holder of its own. + sentOf := make(chan string, 8) idle := &publishQueue{js: b.js, ackWait: time.Minute, logf: func(string, ...any) {}, binding: publishesOf("mesh-delivery-builder"), take: func(_ context.Context, m itemMsg) { var q versions.QueuedPublish _ = json.Unmarshal(m.Data(), &q) _ = m.Ack() - classCh <- q.Class + sentOf <- q.Module }} + roundBound := testbus.SetupBound(t) // the level's set-up share (MESH_TEST_LEVEL_BOUND), as the other whole tests for r := range 50 { holder := fmt.Sprintf("idle%d", r) idle.learn(ctx, holder) @@ -164,25 +167,36 @@ func TestThePublishQueueSendsLiveFirstAndNeverADroppedItem(t *testing.T) { } } } - for _, class := range []string{versions.PublishClassLive, versions.PublishClassStart} { - q := versions.QueuedPublish{V: 1, Holder: holder, Module: "m", Version: "0.1.0", Class: class, Queued: time.Now()} + put := func(module, class string) { + q := versions.QueuedPublish{V: 1, Holder: holder, Module: module, Version: "0.1.0", Class: class, Queued: time.Now()} data, _ := json.Marshal(q) if _, err := b.js.Publish(ctx, idle.subject(bind, q), data); err != nil { t.Fatal(err) } } - var order []string - for range 2 { - select { - case c := <-classCh: - order = append(order, c) - case <-time.After(30 * time.Second): - t.Fatalf("round %d: sent %v of a live and an again item", r, order) + sent := func(n int) []string { + var order []string + for range n { + select { + case m := <-sentOf: + order = append(order, m) + case <-time.After(roundBound): + t.Fatalf("round %d: sent %v of %d items", r, order, n) + } } + return order } - if order[0] != versions.PublishClassLive { + put("live", versions.PublishClassLive) + put("again", versions.PublishClassStart) + if order := sent(2); order[0] != "live" { t.Errorf("round %d: an idle dispatch sent %v, want the live item put first sent first", r, order) } + put("before", versions.PublishClassStart) + put("live2", versions.PublishClassLive) + put("after", versions.PublishClassStart) + if order := sent(3); slices.Index(order, "after") < slices.Index(order, "live2") { + t.Errorf("round %d: the dispatch sent %v, want the again item put after the live one sent after it", r, order) + } } // The move of the old state, run twice, puts each item once (at another holder, so the pull of oci is not asked). diff --git a/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/publishitem.go b/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/publishitem.go index 56b134604..ff2df922c 100644 --- a/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/publishitem.go +++ b/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/publishitem.go @@ -659,8 +659,8 @@ func (pq *publishQueue) pull(ctx context.Context, holder string) error { } // dispatch runs the items of one holder, at most four at once, every live item before an again one (design 47 H2 §793, -// H-A-473 and its third addendum): it pulls the live consumer itself, a fetch of up to its free slots that does not wait, and -// pulls the again consumer only when that fetch returns nothing. When neither holds an item, a pull of one item waits on each, +// H-A-473 and its third addendum): on every turn no live item is held it pulls the live consumer itself, a fetch of up to its +// free slots that does not wait, and pulls the again consumer, or reads the live gap, only after that fetch returned nothing. When neither holds an item, a pull of one item waits on each, // the bus's only wake for an item put or delivered again. An again item taken while the live pull waits is run only once the // live consumer's delivered sequence is no further than the live items the dispatch received: a gap is a live item in flight // to the waiting pull, and the again items are held until it arrives and runs. A pull the bus refuses ends the dispatch, said; @@ -788,7 +788,7 @@ func (pq *publishQueue) dispatch(ctx context.Context, holder string, live, again held := false // again items held for a live item in flight if heldLive != nil { got, heldLive = []jetstream.Msg{heldLive}, nil - } else if !liveWaiting || len(heldAgain) > 0 { + } else { ms, err := now(live, n) if refused(err) { failed(err)