From 21b53f5dfb789528e114a59bf76225751a27a61d Mon Sep 17 00:00:00 2001 From: jochen Date: Sat, 14 Nov 2026 02:01:49 +0100 Subject: [PATCH] mesh-grants: read the loaded list one user per answer, so no answer exceeds one bus message lead: principle 7, live hold 02:0x (nats_users for the whole list was 1086642 bytes, over 1048576). Builds: design 47 G, lead's handover (no design line beyond principle 7) Claude-Session: https://claude.ai/code/session_01NcbgfGKaxw984XyAPfLm4h --- .../internal/grants/loadedusers_size_test.go | 61 +++++++++++++++++++ .../mesh-grants/internal/grants/userlist.go | 7 +-- 2 files changed, 63 insertions(+), 5 deletions(-) create mode 100644 modules/mesh-grants/internal/grants/loadedusers_size_test.go diff --git a/modules/mesh-grants/internal/grants/loadedusers_size_test.go b/modules/mesh-grants/internal/grants/loadedusers_size_test.go new file mode 100644 index 00000000..2c09853d --- /dev/null +++ b/modules/mesh-grants/internal/grants/loadedusers_size_test.go @@ -0,0 +1,61 @@ +package grants + +import ( + "encoding/json" + "errors" + "fmt" + "strings" + "testing" +) + +// sizeBus answers nats_users as the bus module does, and refuses an answer over one bus message. +type sizeBus struct { + users []User + limit int +} + +func (b sizeBus) Call(key string, body any) (json.RawMessage, error) { + part, _ := body.(map[string]any)["user"].(string) + if part == "" { + var names []map[string]any + for _, u := range b.users { + names = append(names, map[string]any{"user": u.User, "publish_grants": len(u.Publish)}) + } + return json.Marshal(map[string]any{"users": names}) + } + var out []User + for _, u := range b.users { + if strings.Contains(u.User, part) { + out = append(out, u) + } + } + raw, _ := json.Marshal(map[string]any{"users": out}) + if len(raw) > b.limit { + return nil, errors.New("the answer is more than the bus carries in one message: ask for less") + } + return raw, nil +} + +// lead: principle 7, live hold 02:0x: the loaded list is read one user per answer, never the whole list in one. +func TestLoadedUsersReadsOneUserPerAnswer(t *testing.T) { + var users []User + for i := 0; i < 20; i++ { + var pub []string + for j := 0; j < 50; j++ { + pub = append(pub, fmt.Sprintf("subject.%d.%d.>", i, j)) + } + users = append(users, User{User: fmt.Sprintf("mod.u%02d", i), Publish: pub, Subscribe: []string{"x.>"}}) + } + users = append(users, User{User: "controller", Publish: []string{"a"}}) + got, err := LoadedUsers(sizeBus{users: users, limit: 5000}) + if err != nil { + t.Fatal(err) + } + if len(got) != len(users) { + t.Fatalf("read %d users, want %d", len(got), len(users)) + } + // a user whose own answer is too large stays a loud hold + if _, err := LoadedUsers(sizeBus{users: users, limit: 100}); err == nil { + t.Fatal("an unreadable user must hold loudly") + } +} diff --git a/modules/mesh-grants/internal/grants/userlist.go b/modules/mesh-grants/internal/grants/userlist.go index 85bf01c7..7bed9387 100644 --- a/modules/mesh-grants/internal/grants/userlist.go +++ b/modules/mesh-grants/internal/grants/userlist.go @@ -151,7 +151,7 @@ func Digest(users []User) string { } // LoadedUsers is the list the bus loaded, as its module's nats_users reads it from the file: every user by name, then -// each one's grants in full. +// each one's grants in full, one user per answer so no answer exceeds one bus message. func LoadedUsers(c Caller) ([]User, error) { raw, err := c.Call(CallUsers, map[string]any{}) if err != nil { @@ -183,12 +183,9 @@ func LoadedUsers(c Caller) ([]User, error) { } return nil } - // Every name with a dot in one call; each name without one (the controller) alone. - if err := ask("."); err != nil { - return nil, err - } out := make([]User, 0, len(names.Users)) for _, n := range names.Users { + // One user per answer: the whole list is more than one bus message (the live hold, 2026-11-14). if _, ok := full[n.User]; !ok { if err := ask(n.User); err != nil { return nil, err