From ec305f08e651c9ed02a0045a4c1a732e1adcb42e Mon Sep 17 00:00:00 2001 From: jochen Date: Sat, 21 Nov 2026 02:26:20 +0100 Subject: [PATCH] Design 47 H1: the bus module counts every manifest's old-section entries as asked for (H-A-229) The keeper read only a manifest's new-form asks, so the entries it had made for the artifact registry and the forge, now declared in their old sections, stood as orphans with live data: a rebuild refused, a drop offered. The keeper now reads every manifest's old sections (state, objects, logs, streams) by the SDK's naming per section, as the grants part composes them. An entry it made under one of those bus names is no orphan, is compared and grown to the declared cap and rebuilt on request; it creates none of them and says no created for one, and counts a kept one's cap once, in the old sections' sum. Builds: design 47 H H-A-229, H-A-230, H-A-231 --- modules/nats/cmd/nats-tools/catalogview.go | 14 ++-- .../nats/cmd/nats-tools/catalogview_test.go | 41 ++++++++++++ modules/nats/cmd/nats-tools/keep_test.go | 14 ++-- modules/nats/internal/keeper/keeper.go | 64 ++++++++++++++++-- modules/nats/internal/keeper/keeper_test.go | 48 +++++++++++++ modules/nats/internal/keeper/plan.go | 67 +++++++++++++++++++ 6 files changed, 232 insertions(+), 16 deletions(-) diff --git a/modules/nats/cmd/nats-tools/catalogview.go b/modules/nats/cmd/nats-tools/catalogview.go index 095a49362..a4a21b4c6 100644 --- a/modules/nats/cmd/nats-tools/catalogview.go +++ b/modules/nats/cmd/nats-tools/catalogview.go @@ -45,11 +45,15 @@ func AsksOf(e catalog.CatalogEntry) (Asks, error) { return Asks{}, fmt.Errorf("the manifest of %s is not readable: %w", e.Module, err) } state := m.BusState + // The old sections' entries are asked for too (design 47 H H-A-229, H-A-230), every manifest's, named and capped as + // the grants part composes them. + m.Module = cmp.Or(m.Module, e.Module) + old := keeper.OldPlansOf(m) if e.Verdict != "" && e.Verdict != "accepted" { - state = nil + state, old = nil, nil } sum := sha256.Sum256(mustJSON(state)) - out := Asks{Accepted: keeper.Accepted{Module: e.Module, Digest: hex.EncodeToString(sum[:]), BusState: state}, + out := Asks{Accepted: keeper.Accepted{Module: e.Module, Digest: hex.EncodeToString(sum[:]), BusState: state, Old: old}, EmitsOwn: len(m.Emits) > 0 || len(e.Streams) > 0} for _, c := range m.Claims { out.Claims = append(out.Claims, c.Name) @@ -81,7 +85,7 @@ type Branch struct { // branches in its registration's order (order: the registration's branches; a branch it does not name comes after, in // the order given) whose entry asks it; another branch asking that local name with other settings is a drift naming // the branch, and plans nothing. The module sends when a branch's entry says so; it is a foundation part, and its old -// sections' caps are read, from the first branch. +// sections' caps and entries are read, from the first branch (design 47 H H-A-229). func ViewOf(branches []Branch, order func(module string) []string) (keeper.CatalogView, error) { modules := map[string]bool{} for _, b := range branches { @@ -117,8 +121,8 @@ func ViewOf(branches []Branch, order func(module string) []string) (keeper.Catal return keeper.CatalogView{}, fmt.Errorf("the branch %s: %w", b.Name, err) } if i == 0 { - cm = keeper.CatalogModule{Accepted: keeper.Accepted{Module: module, Digest: b.Entries[module].ManifestDigest, Revision: uint64(max(b.Revision, 0))}, - Foundation: a.Foundation, OldBytes: a.OldBytes} + cm = keeper.CatalogModule{Accepted: keeper.Accepted{Module: module, Digest: b.Entries[module].ManifestDigest, Revision: uint64(max(b.Revision, 0)), + Old: a.Accepted.Old}, Foundation: a.Foundation, OldBytes: a.OldBytes} } cm.EmitsOwn = cm.EmitsOwn || a.EmitsOwn for _, c := range a.Claims { diff --git a/modules/nats/cmd/nats-tools/catalogview_test.go b/modules/nats/cmd/nats-tools/catalogview_test.go index bffa977c4..d67a41fb8 100644 --- a/modules/nats/cmd/nats-tools/catalogview_test.go +++ b/modules/nats/cmd/nats-tools/catalogview_test.go @@ -1,9 +1,14 @@ package main import ( + "encoding/json" + "fmt" + "slices" "testing" catalog "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshcatalog" + + "nats-tools/internal/keeper" ) func TestAsksOf(t *testing.T) { @@ -22,6 +27,42 @@ func TestAsksOf(t *testing.T) { if b.Accepted.Digest != a.Accepted.Digest { t.Errorf("the digest is of the bus-state asked alone: %s vs %s", b.Accepted.Digest, a.Accepted.Digest) } + // Design 47 H H-A-229, H-A-230: the old sections of the artifact registry and the forge, as their manifests declare + // them, are asked for under the bus names the grants part gives them, the names the live orphans of 2026-11-21 hold; + // a manifest not accepted asks none. + for _, row := range []struct{ module, sections, want string }{ + {"distribution", `{"state": ["transfers", {"name": "idle", "key-ttl": true}, "holds", "windows", "mirrors", "findings"], + "streams": [{"name": "distribution-events", "events": ["old-name-closed"], "max-age-days": 7, "max-mib": 16}], + "objects": [{"name": "incoming", "max-mib": 8192}]}`, + "[KV_distribution_transfers KV_distribution_idle KV_distribution_holds KV_distribution_windows KV_distribution_mirrors KV_distribution_findings OBJ_distribution_incoming DISTRIBUTION_EVENTS]"}, + {"gitea", `{"state": ["bound", {"name": "idle", "key-ttl": true}, "transfers"], "objects": [{"name": "incoming", "max-mib": 2048}], + "logs": [{"name": "calls", "max-mib": 8}]}`, + "[KV_gitea_bound KV_gitea_idle KV_gitea_transfers OBJ_gitea_incoming LOG_gitea_calls]"}, + } { + var m map[string]any + if err := json.Unmarshal([]byte(row.sections), &m); err != nil { + t.Fatal(err) + } + m["module"] = row.module + a, err := AsksOf(catalog.CatalogEntry{Module: row.module, Verdict: "accepted", Manifest: m}) + if err != nil { + t.Fatal(err) + } + var names []string + for _, p := range a.Accepted.Old { + names = append(names, p.Objects[0].Stream()) + } + if fmt.Sprint(names) != row.want { + t.Errorf("%s asks %v of its old sections, want %s", row.module, names, row.want) + } + i := slices.IndexFunc(a.Accepted.Old, func(p keeper.Plan) bool { return p.Local == "incoming" }) + if i < 0 || a.Accepted.Old[i].Objects[0].Settings.MaxBytes != int64(m["objects"].([]any)[0].(map[string]any)["max-mib"].(float64))*keeper.MiB { + t.Errorf("%s's incoming is not capped as declared: %+v", row.module, a.Accepted.Old) + } + if n, _ := AsksOf(catalog.CatalogEntry{Module: row.module, Verdict: "refused", Manifest: m}); len(n.Accepted.Old) != 0 { + t.Errorf("a refused manifest of %s asks %v", row.module, n.Accepted.Old) + } + } if _, err := AsksOf(catalog.CatalogEntry{}); err == nil { t.Error("an entry with no module was read") } diff --git a/modules/nats/cmd/nats-tools/keep_test.go b/modules/nats/cmd/nats-tools/keep_test.go index a5724d859..5b12da3d9 100644 --- a/modules/nats/cmd/nats-tools/keep_test.go +++ b/modules/nats/cmd/nats-tools/keep_test.go @@ -21,7 +21,7 @@ import ( // newest revision lists, each local name from the first of its watched branches in its registration's order whose entry // asks it, another branch asking it with other settings a drift naming that branch; a branch the registration does not // name after; a verdict not accepted asks nothing; the claims of every branch; a foundation part and its old sections' -// caps from the first branch. +// caps and entries from the first branch (design 47 H H-A-229). func TestTheCatalogHalfIsReadPerWatchedBranch(t *testing.T) { entryOf := func(verdict string, manifest map[string]any) catalog.CatalogEntry { manifest["module"] = "m" @@ -44,17 +44,17 @@ func TestTheCatalogHalfIsReadPerWatchedBranch(t *testing.T) { want string }{ {"one branch", []Branch{{Name: "main", Revision: 3, Entries: map[string]catalog.CatalogEntry{"m": main}}}, []string{"main"}, - "m 3 [drafts/key-value/state] [a] false 0;"}, + "m 3 [drafts/key-value/state] [a] false 0 0;"}, {"a feature branch asking a local name with other settings drifts, its new one planned", []Branch{{Name: "feature", Revision: 9, Entries: map[string]catalog.CatalogEntry{"m": feature}}, {Name: "main", Revision: 3, Entries: map[string]catalog.CatalogEntry{"m": main}}}, - []string{"main", "feature"}, "m 3 [drafts/key-value/state log/stream/log] [a b] false 0; drifted m drafts feature from main"}, + []string{"main", "feature"}, "m 3 [drafts/key-value/state log/stream/log] [a b] false 0 0; drifted m drafts feature from main"}, {"the registration's order decides", []Branch{{Name: "main", Revision: 3, Entries: map[string]catalog.CatalogEntry{"m": main}}, {Name: "feature", Revision: 9, Entries: map[string]catalog.CatalogEntry{"m": feature}}}, - []string{"feature"}, "m 9 [drafts/key-value/state log/stream/log] [b a] false 0; drifted m drafts main from feature"}, + []string{"feature"}, "m 9 [drafts/key-value/state log/stream/log] [b a] false 0 0; drifted m drafts main from feature"}, {"a verdict not accepted asks nothing", []Branch{{Name: "main", Revision: 3, Entries: map[string]catalog.CatalogEntry{"m": entryOf("refused", map[string]any{"bus-state": []any{state("")}})}}}, []string{"main"}, - "m 3 [] [] false 0;"}, + "m 3 [] [] false 0 0;"}, {"a foundation part, its old sections counted", []Branch{{Name: "main", Revision: 3, Entries: map[string]catalog.CatalogEntry{"m": entryOf("accepted", map[string]any{ "objects": []any{map[string]any{"name": "sent-objects", "max-mib": 256}}, "logs": []any{map[string]any{"name": "l", "max-mib": 4}}, "streams": []any{map[string]any{"name": "s"}}})}}}, []string{"main"}, - "m 3 [] [] true 1284;"}, + "m 3 [] [] true 1284 3;"}, } { t.Run(row.name, func(t *testing.T) { v, err := ViewOf(row.branches, func(string) []string { return row.order }) @@ -67,7 +67,7 @@ func TestTheCatalogHalfIsReadPerWatchedBranch(t *testing.T) { for _, e := range m.BusState { es = append(es, e.Name+"/"+e.Storage+"/"+e.Template) } - got += fmt.Sprintf("%s %d [%s] %v %v %d;", m.Module, m.Revision, strings.Join(es, " "), m.Claims, m.Foundation, m.OldBytes/keeper.MiB) + got += fmt.Sprintf("%s %d [%s] %v %v %d %d;", m.Module, m.Revision, strings.Join(es, " "), m.Claims, m.Foundation, m.OldBytes/keeper.MiB, len(m.Old)) } for _, d := range v.Drifts { got += fmt.Sprintf(" drifted %s %s %s from %s", d.Module, d.Local, d.Branch, d.From) diff --git a/modules/nats/internal/keeper/keeper.go b/modules/nats/internal/keeper/keeper.go index b214641cd..279a8b5b9 100644 --- a/modules/nats/internal/keeper/keeper.go +++ b/modules/nats/internal/keeper/keeper.go @@ -84,11 +84,14 @@ type EventFill struct { // Accepted is one module's entry as the catalog half's watched branches give it (design 47 G §344, §433, §532): the // module, its manifest's digest, the catalog revision of the branch it was read from, and its bus-state entries whole. +// Old are the entries its old sections declare, as OldPlansOf names and caps them (design 47 H H-A-229, H-A-230): asked +// for too, but never made by the keeper. type Accepted struct { Module string `json:"module"` Digest string `json:"digest"` Revision uint64 `json:"revision"` BusState []catalogue.BusStateEntry `json:"bus-state"` + Old []Plan `json:"old-sections,omitempty"` } // CatalogModule is one module of the catalog half for the bus module (design 47 G §344, §532, §533, §547): what its @@ -146,7 +149,9 @@ type Asked struct { Digest string `json:"digest,omitempty"` Revision uint64 `json:"revision"` Entries []catalogue.BusStateEntry `json:"entries"` - Made map[string]Made `json:"made,omitempty"` + // Old are the entries its old sections declare, as last planned (Accepted's Old; design 47 H H-A-229, H-A-230). + Old []Plan `json:"old-sections,omitempty"` + Made map[string]Made `json:"made,omitempty"` // Drifts are the local names a later watched branch asks with other settings, as last said (design 47 G §532). Drifts map[string]Drift `json:"drifts,omitempty"` At time.Time `json:"at"` @@ -259,7 +264,8 @@ type Limits struct { } // CapSum is the sum, in bytes, of the caps of every object the entries made hold, but for the entry of skipModule and -// skipLocal (design 47 G §547): what the bus's limits are read against. An entry never made, or refused, holds none. +// skipLocal (design 47 G §547): what the bus's limits are read against. An entry never made, or refused, holds none, and +// one an old section keeps is counted once, in the old sections' caps (design 47 H H-A-229). func CapSum(held map[string]Asked, skipModule, skipLocal string) int64 { var sum int64 for module, a := range held { @@ -267,6 +273,9 @@ func CapSum(held map[string]Asked, skipModule, skipLocal string) int64 { if (module == skipModule && local == skipLocal) || !(m.Created || m.Orphaned) { continue } + if _, kept := oldKept(a.Old, local, m); kept { + continue + } for _, o := range m.Plan.Objects { sum += o.Settings.MaxBytes } @@ -596,6 +605,15 @@ func (k *Keeper) Heard(a Accepted) { held.Made = map[string]Made{} } digest := EntriesDigest(a.BusState) + if len(a.Old) > 0 { + // The old sections' entries are planned too (design 47 H H-A-229): a module that declares none keeps its digest. + raw, _ := json.Marshal(struct { + BusState []catalogue.BusStateEntry `json:"bus-state"` + Old []Plan `json:"old-sections"` + }{a.BusState, a.Old}) + sum := sha256.Sum256(raw) + digest = "sha256:" + hex.EncodeToString(sum[:]) + } if p, ok := k.planned(a.Module); ok && found && p.Digest == digest { if held.Digest != a.Digest || held.Revision != a.Revision { held.Digest, held.Revision, held.At = a.Digest, a.Revision, k.now() @@ -603,13 +621,18 @@ func (k *Keeper) Heard(a Accepted) { } return } - held.Digest, held.Entries, held.Revision, held.At = a.Digest, a.BusState, a.Revision, k.now() + held.Digest, held.Entries, held.Old, held.Revision, held.At = a.Digest, a.BusState, a.Old, a.Revision, k.now() defer k.writePlan(a.Module, digest, held.Revision, a.BusState) asked := map[string]bool{} for _, e := range a.BusState { asked[e.Name] = true k.makeEntry(&held, e) } + for _, local := range sortedKeys(held.Made) { + if !asked[local] && k.keepOld(&held, local) { + asked[local] = true + } + } for _, local := range sortedKeys(held.Made) { m := held.Made[local] if asked[local] || m.Orphaned || local == SentLocal { @@ -650,6 +673,27 @@ func (k *Keeper) Sends(module string) { k.write(held) } +// keepOld keeps an entry the keeper made that an old section of the module declares under the same bus name (design 47 +// H H-A-229, H-A-230, H-A-231): never an orphan (one that was is asked for again, its condition cleared), compared with +// the bus and grown to the declared cap, and rebuilt on request; the keeper creates none of its objects the bus lacks and +// says no created for it, as the grants part makes and binds them. It answers whether an old section keeps it. An entry +// never made is none of the keeper's: every other old-section entry is the grants part's alone. +func (k *Keeper) keepOld(held *Asked, local string) bool { + m := held.Made[local] + p, ok := oldKept(held.Old, local, m) + if !ok || !m.Created || local == SentLocal { + return false + } + if m.Orphaned { + m.Orphaned = false + k.clear(conditionOrphaned, held.Module, local) + } + m.Plan.Objects = p.Objects + k.ensureMade(held, &m, false) + held.Made[local] = m + return true +} + // makeEntry makes one asked entry where the bus lacks it, compares it where it holds it, and says what it did. func (k *Keeper) makeEntry(held *Asked, e catalogue.BusStateEntry) { module := held.Module @@ -679,7 +723,11 @@ func (k *Keeper) makeEntry(held *Asked, e catalogue.BusStateEntry) { // ensure brings one planned entry onto the bus: each object the bus lacks created, a held one compared. A difference // that only grows is applied; any other is a drift, said and never fixed quietly. -func (k *Keeper) ensure(held *Asked, m *Made) { +func (k *Keeper) ensure(held *Asked, m *Made) { k.ensureMade(held, m, true) } + +// ensureMade is ensure; with create false an object the bus lacks is left to the part that makes it (an old section's, +// the grants part: design 47 H H-A-230) and nothing is created. +func (k *Keeper) ensureMade(held *Asked, m *Made, create bool) { ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) defer cancel() asked, holds := map[string]Settings{}, map[string]Settings{} @@ -694,6 +742,9 @@ func (k *Keeper) ensure(held *Asked, m *Made) { m.Waiting = fmt.Sprintf("%s cannot be read: %v", o.Stream(), err) return } + if !found && !create { + continue + } if !found { if err := k.capRoom(ctx, held, m); err != nil { if errors.Is(err, ErrRetry) { @@ -794,11 +845,16 @@ func (k *Keeper) CheckAll() []CheckLine { out = append(out, lineOf(module, local, m)) continue } + asked := false for _, e := range held.Entries { if e.Name == local { + asked = true k.makeEntry(&held, e) } } + if !asked { + k.keepOld(&held, local) + } out = append(out, lineOf(module, local, held.Made[local])) } k.write(held) diff --git a/modules/nats/internal/keeper/keeper_test.go b/modules/nats/internal/keeper/keeper_test.go index 944ed4fc6..068447d3d 100644 --- a/modules/nats/internal/keeper/keeper_test.go +++ b/modules/nats/internal/keeper/keeper_test.go @@ -1112,6 +1112,54 @@ func TestTheKeeperMakesWhatAVerdictAsksForAndSaysIt(t *testing.T) { t.Errorf("the hand acts: %v", acts) } }}, + // Design 47 H H-A-229, H-A-230, H-A-231: an entry the keeper made, now declared in the module's old sections under + // the same bus name, is asked for: its orphan cleared, grown to the declared cap, rebuilt on request; the keeper + // creates nothing an old section declares and says no created for it. + {"an entry an old section declares is no orphan and is rebuilt, nothing of the old sections made", func(t *testing.T, k *Keeper, bus *fakeBus, out *said) { + store := k.Store.(*memStore) + incoming := entry("incoming", catalogue.StorageObjectStore, catalogue.TemplateObjects, map[string]string{"max-mib": "8"}) + k.Heard(Accepted{Module: "m", Revision: 1, BusState: []catalogue.BusStateEntry{drafts, incoming}}) + k.Heard(Accepted{Module: "m", Revision: 2}) + if a := k.Held()["m"]; !a.Made["incoming"].Orphaned || !a.Made["drafts"].Orphaned { + t.Fatalf("held %+v: both orphans once no section asks for them", a.Made) + } + delete(bus.held, "OBJ_m_drafts-objects") + made := fmt.Sprint(bus.created) + out.reset() + old := OldPlansOf(catalogue.Manifest{Module: "m", State: []catalogue.StateDeclaration{{Name: "drafts"}, {Name: "bound"}}, + Objects: []catalogue.ObjectsDeclaration{{Name: "incoming", MaxMiB: 16}}}) + k.Heard(Accepted{Module: "m", Revision: 3, Old: old}) + a := k.Held()["m"] + if a.Made["incoming"].Orphaned || a.Made["drafts"].Orphaned || len(a.Made) != 2 { + t.Errorf("held %+v: incoming and drafts asked for by the old sections, bound none of the keeper's", a.Made) + } + if fmt.Sprint(bus.created) != made || len(out.events) != 0 || bus.held["OBJ_m_incoming"].MaxBytes != 16*MiB { + t.Errorf("created %v (was %s), said %v, incoming held %+v: nothing made or said, grown to the declared 16 MiB", + bus.created, made, out.events, bus.held["OBJ_m_incoming"]) + } + if fmt.Sprint(out.conds) != "[cleared nats.orphaned.m_drafts cleared nats.orphaned.m_incoming]" { + t.Errorf("conditions %v: both orphans cleared", out.conds) + } + k.CheckAll() + if fmt.Sprint(bus.created) != made { + t.Errorf("the check created %v (was %s): the grants part makes an old section's objects", bus.created, made) + } + binds, _ := occ.ActDigest(occ.Act{"verb": "recreate", "module": "m", "local": "incoming"}) + ask := oc.Ask{ID: "bus-9", Who: occ.Operator, Expires: occ.FormatTime(k.now().Add(time.Hour)), Options: []oc.Option{{ID: "go", Label: "Rebuild", Level: occ.Destroy, Binds: binds}}} + w := &oc.Warrant{Ask: "bus-9", Asker: Module, Outcome: occ.OutcomeChosen, By: &oc.Person{Who: occ.Operator}, + Option: "go", Label: "Rebuild", Level: occ.Destroy, At: occ.FormatTime(k.now()), AskDigest: occ.Digest(ask)} + k.Warrant = func(string) (*oc.Ask, *oc.Warrant, error) { return &ask, w, nil } + out.reset() + raw, _ := json.Marshal(Request{ID: "r9", Verb: VerbRecreate, Module: "m", Local: "incoming", Ask: "bus-9"}) + _, _ = store.Put(StateRequests, "r9", raw) + k.ActOnRequests() + raw, _, _, _ = store.Get(StateRequests, "r9") + var got Request + _ = json.Unmarshal(raw, &got) + if got.Error != "" || fmt.Sprint(out.events) != "[recreated m incoming]" || bus.held["OBJ_m_incoming"].MaxBytes != 16*MiB { + t.Errorf("request %+v, said %v, held %+v: rebuilt at the declared cap", got, out.events, bus.held["OBJ_m_incoming"]) + } + }}, {"a recreate rebuilds a drifted entry after a snapshot", func(t *testing.T, k *Keeper, bus *fakeBus, out *said) { store := k.Store.(*memStore) k.Heard(Accepted{Module: "m", Revision: 1, BusState: []catalogue.BusStateEntry{log}}) diff --git a/modules/nats/internal/keeper/plan.go b/modules/nats/internal/keeper/plan.go index 396f8b82c..12883bdfc 100644 --- a/modules/nats/internal/keeper/plan.go +++ b/modules/nats/internal/keeper/plan.go @@ -423,3 +423,70 @@ func Differs(asked, held Settings) string { add("key-ttl", asked.KeyTTL, held.KeyTTL) return strings.Join(out, "; ") } + +// OldPlansOf are the entries a manifest declares in its old sections (state, objects, logs, streams), each named on the +// bus and capped as the grants part composes it, by the SDK's one naming per section (design 47 H H-A-229, H-A-230): a +// state `_` with its object store `-objects` beside it (none for a state only read, or one whose +// store's name is one of the module's own object buckets), an objects section `_`, a log +// `LOG__` and a stream its local name in capitals. They are asked for: an entry the keeper made under one +// of their bus names is never an orphan, is kept, compared and grown to the declared cap, and rebuilt on request; the +// keeper creates none of them and says no created for one (the grants part makes and binds them). Pure. +func OldPlansOf(m catalogue.Manifest) []Plan { + module := m.Module + var out []Plan + own := map[string]bool{} + for _, o := range m.Objects { + own[o.Name] = true + } + for _, s := range m.State { + capMiB := int64(s.MaxMiB) + if capMiB <= 0 { + capMiB = StateCap / MiB + } + p := Plan{Module: module, Local: s.Name, Storage: catalogue.StorageKeyValue, Template: catalogue.TemplateState, + Objects: []Object{{Kind: KindBucket, Name: buscompose.BucketName(module, s.Name), + Settings: Settings{MaxBytes: capMiB * MiB, MaxAgeSeconds: int64(s.TTLSeconds), History: int64(max(s.History, 1)), + Discard: DiscardNew, MaxMsgSize: ValueMost, KeyTTL: s.KeyTTL}}}} + if objects := catalogue.StateObjectsName(s.Name); !s.ReadOnly && !own[objects] { + objCap := int64(s.MaxMiB) + if objCap <= 0 { + objCap = StateObjectsCapMiB + } + objCap = min(max(objCap, catalogue.ObjectsLeastMiB), catalogue.ObjectsMostMiB) + p.Objects = append(p.Objects, Object{Kind: KindObjects, Name: catalogue.ObjectsBucket(module, objects), + Settings: Settings{MaxBytes: objCap * MiB, Discard: DiscardNew}}) + } + out = append(out, p) + } + for _, o := range m.Objects { + out = append(out, Plan{Module: module, Local: o.Name, Storage: catalogue.StorageObjectStore, Template: catalogue.TemplateObjects, + Objects: []Object{{Kind: KindObjects, Name: o.Bucket(module), Settings: Settings{MaxBytes: int64(o.MaxMiB) * MiB, Discard: DiscardNew}}}}) + } + for _, l := range m.Logs { + out = append(out, Plan{Module: module, Local: l.Name, Storage: catalogue.StorageStream, Template: catalogue.TemplateLog, + Objects: []Object{{Kind: KindStream, Name: buscompose.LogStreamName(module, l.Name), Subjects: []string{buscompose.LogSubject(module, l.Name) + ".>"}, + Settings: Settings{MaxBytes: int64(l.Cap()) * MiB, MaxAgeSeconds: days(int64(l.MaxAgeDays)), Discard: DiscardNew, MaxMsgSize: buscompose.LogMaxMessageBytes}}}}) + } + for _, s := range m.Streams { + discard := DiscardOld + if s.KeepsHistory() { + discard = DiscardNew + } + out = append(out, Plan{Module: module, Local: s.Name, Storage: catalogue.StorageStream, + Objects: []Object{{Kind: KindStream, Name: s.BusName(), Settings: Settings{MaxBytes: int64(s.Cap()) * MiB, + MaxAgeSeconds: days(int64(s.Days())), Discard: discard, WorkQueue: s.Retention == catalogue.StreamRetentionWorkQueue}}}}) + } + return out +} + +// oldKept is the old-section plan that keeps the entry made under local, or false: one of olds of the same local name +// whose objects are on the bus under the same names as the entry's (design 47 H H-A-229, H-A-230). +func oldKept(olds []Plan, local string, m Made) (Plan, bool) { + for _, p := range olds { + if p.Local != local || len(p.Objects) == 0 || len(m.Plan.Objects) == 0 || p.Objects[0].Stream() != m.Plan.Objects[0].Stream() { + continue + } + return p, true + } + return Plan{}, false +}