From 64d5490ea270c96f78b79b327c25503198fa4965 Mon Sep 17 00:00:00 2001 From: jochen Date: Fri, 20 Nov 2026 23:21:23 +0100 Subject: [PATCH] Design 47 H1 (3): a publish whose recompute fails is not acknowledged The registry's published is offered again when the recompute of its users fails, as a failed series write already was. Builds: design 47 H S15 (H-pins-spec-and-gaps item 3), H-A-167 --- .../cmd/mesh-delivery-indexer/series.go | 8 ++- .../cmd/mesh-delivery-indexer/series_test.go | 61 +++++++++++++++++++ 2 files changed, 66 insertions(+), 3 deletions(-) create mode 100644 modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/series_test.go diff --git a/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/series.go b/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/series.go index ff1b77f2..8ac23cb9 100644 --- a/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/series.go +++ b/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/series.go @@ -22,8 +22,8 @@ var ( ) // heardVersion reads one message of the consumer as a version, false for any other subject. A package's is kept in its -// series; one that does not decode is said and acknowledged; a write that fails is left unacknowledged, so the bus gives -// it again. +// series; one that does not decode is said and acknowledged; a write that fails, or the recompute of its users that a +// publish starts, is left unacknowledged, so the bus gives it again. func heardVersion(ctx context.Context, ix *index.Indexer, m jetstream.Msg, logf func(string, ...any)) bool { var h index.HeardVersion switch seat, ok := publishedSeats[m.Subject()]; { @@ -53,8 +53,10 @@ func heardVersion(ctx context.Context, ix *index.Indexer, m jetstream.Msg, logf } if kept && h.Published { // A series' newest moved: its users' fingerprints take it (DLV-I6), in the same turn as the publish is heard. + // A recompute that fails is not acknowledged, so the publish is offered again (design 47 H S15, H-A-167). if err := ix.Recompute(ctx); err != nil { - logf("writing the modules again after %s %s was published: %v", h.Package, h.Version, err) + logf("writing the modules again after %s %s was published failed, so the bus gives it again: %v", h.Package, h.Version, err) + return true } } _ = m.Ack() diff --git a/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/series_test.go b/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/series_test.go new file mode 100644 index 00000000..85ddbb54 --- /dev/null +++ b/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/series_test.go @@ -0,0 +1,61 @@ +package main + +import ( + "context" + "encoding/json" + "errors" + "testing" + + "github.com/nats-io/nats.go/jetstream" + + "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/gopackageregistry" + + "mesh-delivery-indexer/internal/index" +) + +// ackedMsg is a message that counts its acknowledgements. +type ackedMsg struct { + jetstream.Msg + subject string + data []byte + acked int +} + +func (a *ackedMsg) Subject() string { return a.subject } +func (a *ackedMsg) Data() []byte { return a.data } +func (a *ackedMsg) Ack() error { a.acked++; return nil } + +// unlistedStore is a store whose listing fails: a recompute over it fails. +type unlistedStore struct{ memStore } + +func (unlistedStore) Keys(context.Context) ([]string, error) { + return nil, errors.New("the bus does not answer") +} + +// TestHeardVersionRecomputeFailed: a publish whose recompute of its users fails is not acknowledged, so the bus gives +// it again (design 47 H S15, the pin specification's item 3); one whose recompute passes is. +func TestHeardVersionRecomputeFailed(t *testing.T) { + data, err := json.Marshal(gopackageregistry.PublishedEvent{Kind: "package", Name: "git.example/novox/lib", Version: "0.1.4"}) + if err != nil { + t.Fatal(err) + } + for _, c := range []struct { + name string + modules index.Store + acked int + }{ + {"recompute fails", &unlistedStore{memStore{vals: map[string][]byte{}}}, 0}, + {"recompute passes", &memStore{vals: map[string][]byte{}}, 1}, + } { + t.Run(c.name, func(t *testing.T) { + ix := &index.Indexer{Packages: &memStore{vals: map[string][]byte{}}, Modules: c.modules, Manifests: &memStore{vals: map[string][]byte{}}} + m := &ackedMsg{subject: gopackageregistry.SubjectPublished, data: data} + if !heardVersion(context.Background(), ix, m, t.Logf) { + t.Fatal("the registry's published is not taken as a version") + } + if m.acked != c.acked { + t.Errorf("acknowledged %d times, want %d", m.acked, c.acked) + } + }) + } +}