diff --git a/modules/mesh-grants/cmd/mesh-grants/create.go b/modules/mesh-grants/cmd/mesh-grants/create.go index 2e489eef6..4957c3dde 100644 --- a/modules/mesh-grants/cmd/mesh-grants/create.go +++ b/modules/mesh-grants/cmd/mesh-grants/create.go @@ -5,6 +5,7 @@ import ( "errors" "fmt" "slices" + "time" "github.com/nats-io/nats.go/jetstream" @@ -107,6 +108,30 @@ func (c creating) RaiseMaxBytes(stream string, to int64) (int64, bool, error) { return from, true, nil } +// AllowMsgTTL turns on a held stream's per-message time to live, its delete markers living markerTTL, when it is off, and +// changes nothing else (design 47 H2 H-A-501, corrected): it reads the stream's configuration and updates with the rest as +// it was. A stream with it on already is left as it is. +func (c creating) AllowMsgTTL(stream string, markerTTL time.Duration) (bool, error) { + ctx, cancel := context.WithTimeout(c.ctx, requestWithin) + defer cancel() + s, err := c.js.Stream(ctx, stream) + if err != nil { + return false, err + } + cfg := s.CachedInfo().Config + if cfg.AllowMsgTTL { + return false, nil + } + cfg.AllowMsgTTL = true + if cfg.SubjectDeleteMarkerTTL == 0 { + cfg.SubjectDeleteMarkerTTL = markerTTL + } + if _, err := c.js.UpdateStream(ctx, cfg); err != nil { + return false, err + } + return true, nil +} + // SourceFilter brings the filter subject of a held stream's source from `source` to `filter` and changes nothing else // (design 47 H H-A-145): it reads the stream's configuration and updates with the rest as it was, so its messages stay. A // stream with no source from `source`, or one already at `filter`, is left as it is. diff --git a/modules/mesh-grants/grants_test.go b/modules/mesh-grants/grants_test.go index 4f31eb006..b57f323a3 100644 --- a/modules/mesh-grants/grants_test.go +++ b/modules/mesh-grants/grants_test.go @@ -202,6 +202,19 @@ func (b *fakeBus) AddSubjects(stream string, add []string) error { // SourceFilter is the bus's update of a held stream's source filter: the fake holds no sources, so nothing changes. func (b *fakeBus) SourceFilter(string, string, string) (string, bool, error) { return "", false, nil } +// AllowMsgTTL is the bus's turning on of a held stream's per-message time to live, every other setting kept. +func (b *fakeBus) AllowMsgTTL(stream string, _ time.Duration) (bool, error) { + b.mu.Lock() + defer b.mu.Unlock() + for _, s := range b.streams { + if s["name"] == stream && s["allow_msg_ttl"] != true { + s["allow_msg_ttl"] = true + return true, nil + } + } + return false, nil +} + // RaiseMaxBytes is the bus's raise of a held stream's size cap: only to a larger cap, an unbounded stream and every other // setting kept. func (b *fakeBus) RaiseMaxBytes(stream string, to int64) (int64, bool, error) { @@ -719,10 +732,11 @@ func TestGrants(t *testing.T) { if n := strings.Count(string(src), "CreateStream"); (path == createOnly && n != 1) || (path != createOnly && n != 0) { t.Errorf("%s holds CreateStream %d times: only create.go creates, once", path, n) } - // The three updates of a stream: adding subjects to a held one (the operator, 2026-11-05), raising its size cap - // (2026-11-09) and bringing a kept stream's source filter to its definition's (design 47 H H-A-145), all in create.go. - if n := strings.Count(string(src), "UpdateStream("); (path == createOnly && n != 3) || (path != createOnly && n != 0) { - t.Errorf("%s holds UpdateStream %d times: only create.go updates a stream, three times, to add subjects, to raise a size cap and to bring a kept stream's source filter", path, n) + // The four updates of a stream: adding subjects to a held one (the operator, 2026-11-05), raising its size cap + // (2026-11-09), bringing a kept stream's source filter to its definition's (design 47 H H-A-145) and turning on a + // key-ttl state's per-message time to live (design 47 H2 H-A-501, corrected), all in create.go. + if n := strings.Count(string(src), "UpdateStream("); (path == createOnly && n != 4) || (path != createOnly && n != 0) { + t.Errorf("%s holds UpdateStream %d times: only create.go updates a stream, four times, to add subjects, to raise a size cap, to bring a kept stream's source filter and to turn on per-message time to live", path, n) } // The one object bucket: the part's own, of the user list sealed to the bus node, in sealed.go (ADR 0547 clause 7). if path == sealedOnly { diff --git a/modules/mesh-grants/internal/grants/askstreams_test.go b/modules/mesh-grants/internal/grants/askstreams_test.go index 9f81a2a81..bde7131c8 100644 --- a/modules/mesh-grants/internal/grants/askstreams_test.go +++ b/modules/mesh-grants/internal/grants/askstreams_test.go @@ -30,6 +30,7 @@ func (c *askCreator) RaiseMaxBytes(string, int64) (int64, bool, error) { func (c *askCreator) SourceFilter(string, string, string) (string, bool, error) { return "", false, nil } +func (c *askCreator) AllowMsgTTL(string, time.Duration) (bool, error) { return false, nil } // A seat whose queues came with G (mesh-builds) gets its work-queue ask stream from the seat list, as the controller made one for // every seat before G; a seat that accepts nothing gets none, and a stream the bus holds is never made again (lead-47, 2026-11-15). diff --git a/modules/mesh-grants/internal/grants/assertions.go b/modules/mesh-grants/internal/grants/assertions.go index 3d37f0797..e78b1cd37 100644 --- a/modules/mesh-grants/internal/grants/assertions.go +++ b/modules/mesh-grants/internal/grants/assertions.go @@ -8,6 +8,7 @@ import ( "sort" "strings" "sync" + "time" "github.com/nats-io/nats.go/jetstream" @@ -74,6 +75,10 @@ type Creator interface { // messages and every other setting, the stream not made again (design 47 H H-A-145). It answers the filter it held and // whether it changed; a stream with no source from `source` is left as it is. SourceFilter(stream, source, filter string) (from string, changed bool, err error) + // AllowMsgTTL turns on per-message time to live on a stream the bus holds, its delete markers living markerTTL, when it + // is off, and changes nothing else (design 47 H2 H-A-501, corrected): a state declared key-ttl whose bucket was made + // before the declaration. It answers whether it turned it on; one on already is left as it is. It never turns it off. + AllowMsgTTL(stream string, markerTTL time.Duration) (turned bool, err error) } // Raise is one held stream's size cap raised to the manifest's, said in the event and the journal. @@ -126,6 +131,24 @@ type creations struct { // refused is, by stream, the refusal of the last addition of subjects (an overlap with another stream, say), so a // refusal that stands is said once and not at every pass; a success or a different refusal says again. refused map[string]string + // ttl is, by stream, the manifest digest at which its per-message time to live was last compared with the manifest's + // key-ttl, so the bus is asked once per manifest (a hand assert asks again). + ttl map[string]string +} + +func (c *creations) ttlAt(stream string) string { + c.mu.Lock() + defer c.mu.Unlock() + return c.ttl[stream] +} + +func (c *creations) keepTTL(stream, digest string) { + c.mu.Lock() + defer c.mu.Unlock() + if c.ttl == nil { + c.ttl = map[string]string{} + } + c.ttl[stream] = digest } // refusedAgain says whether this refusal of an addition to the stream was the last one said, and keeps it. @@ -265,6 +288,26 @@ func createMissing(c Creator, done *creations, a *Assertion, m catalogue.Manifes made = append(made, fmt.Sprintf("%s %s size cap raised from %d to %d bytes", it.Kind, it.Stream, from, it.Composed.MaxBytes)) } } + // A held bucket of a state declared key-ttl gets per-message time to live when it lacks it, add-only like the cap: a + // bucket made before its state was declared key-ttl refuses every key written with a time to live (design 47 H2 + // H-A-501, corrected). Compared once per manifest. + for i := range a.Items { + it := &a.Items[i] + cfg, ok := cfgs[it.Stream] + if it.Held == nil || it.Kind != "bucket" || !ok || !cfg.AllowMsgTTL || (!force && done.ttlAt(it.Stream) == a.Manifest) { + continue + } + turned, err := c.AllowMsgTTL(it.Stream, cfg.SubjectDeleteMarkerTTL) + if err != nil { + it.Created = ItemNotCreated + "per-message time to live not turned on: " + err.Error() + " (tried again at the next event)" + continue + } + done.keepTTL(it.Stream, a.Manifest) + if turned { + it.Created = "per-message time to live turned on (its state is declared key-ttl)" + made = append(made, it.Kind+" "+it.Stream+" per-message time to live turned on, its state declared key-ttl") + } + } if len(made) > 0 { a.Asserted = true } diff --git a/modules/mesh-grants/internal/grants/statecap_test.go b/modules/mesh-grants/internal/grants/statecap_test.go index 08512d8dd..32eb33c4c 100644 --- a/modules/mesh-grants/internal/grants/statecap_test.go +++ b/modules/mesh-grants/internal/grants/statecap_test.go @@ -1,11 +1,15 @@ package grants import ( + "fmt" "slices" "strings" "testing" + "time" "git.novox.be/novox/mesh-sdk/go/catalogue" + + "mesh-grants/internal/buscompose" ) // raiser is a Creator that holds one stream at a cap and records the cap it is raised to. @@ -41,6 +45,40 @@ func TestAStatesDeclaredCapReachesItsBucket(t *testing.T) { } } +// ttlTurner is a Creator that records each held stream whose per-message time to live it turns on. +type ttlTurner struct { + Creator + turned []string +} + +func (r *ttlTurner) AllowMsgTTL(stream string, marker time.Duration) (bool, error) { + r.turned = append(r.turned, fmt.Sprintf("%s %s", stream, marker)) + return true, nil +} + +func (r *ttlTurner) RaiseMaxBytes(string, int64) (int64, bool, error) { return 0, false, nil } + +// A held bucket of a state declared key-ttl gets per-message time to live, once per manifest, and is said (design 47 H2 +// H-A-501, corrected); a bucket of a state with no key-ttl is not touched. +func TestAHeldKeyTTLStateGetsPerMessageTTL(t *testing.T) { + m := catalogue.Manifest{Module: "mesh-delivery-indexer", State: []catalogue.StateDeclaration{{Name: "heard", KeyTTL: true}, {Name: "plain"}}} + a := Assertion{Manifest: "d", Items: Composed(m, nil)} + for i := range a.Items { + a.Items[i].Held = &Limits{} + } + r, done := &ttlTurner{}, &creations{} + made, _ := createMissing(r, done, &a, m, nil, false) + if want := []string{"KV_mesh-delivery-indexer_heard " + buscompose.KeyTTLMarkerTTL.String()}; !slices.Equal(r.turned, want) { + t.Fatalf("turned on %v, want %v", r.turned, want) + } + if !a.Asserted || !slices.ContainsFunc(made, func(s string) bool { return strings.Contains(s, "per-message time to live turned on") }) { + t.Errorf("asserted %v, said %v; want the turning on said", a.Asserted, made) + } + if createMissing(r, done, &a, m, nil, false); len(r.turned) != 1 { + t.Errorf("asked again at the same manifest: %v", r.turned) + } +} + // adder is a Creator that records the subjects it is asked to add to a held stream. type adder struct { Creator