diff --git a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/pass.go b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/pass.go index b9a59b6e..fde4a066 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/pass.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/pass.go @@ -87,6 +87,7 @@ type passer struct { // laid again is not ended on a seat it does not name (ADR 0636 ยง1). Nil reads nothing. seats *seatlist.Part seatWaitSaid sync.Once + derivedSaid map[string]bool // each seat-holders key last written as derived from a claim (A-400), so each is said once publish publisher saidProposed map[string]bool // copied says the retired state was copied into `assignments` by this process, or found empty (copyRetired). @@ -276,7 +277,7 @@ func (p *passer) wants(ctx context.Context) { missing := map[string]bool{} defer func() { p.provisionsMissing(ctx, missing) }() defer p.unplacedFindings() - defer p.seatHolders(ctx) + defer func() { p.seatHolders(ctx, viewOf(p.w.trunkName()).manifests) }() p.clearStaleCalls() placed := p.w.placedNodes() puts := p.putsByModule() @@ -1319,7 +1320,10 @@ func (p *passer) unplacedFindings() { // seat held once, ``, and one per node of a node seat, `.`, written only where it differs, and a key no // assignments holds any more deleted. A pass follows each assignments change and each manifest the indexer takes in, so no // timer writes it. -func (p *passer) seatHolders(ctx context.Context) { +// +// A seat no assignments holds is held by the first assigned module whose manifest of the trunk claims it (lead answer A-400): +// manifests is the trunk's, by module. Each holder so derived is said once while it stays derived. +func (p *passer) seatHolders(ctx context.Context, manifests map[string]catalogue.Manifest) { kv := p.kvs[plc.SeatHoldersBucket()] if kv == nil { return @@ -1336,7 +1340,20 @@ func (p *passer) seatHolders(ctx context.Context) { } return } - want := plc.SeatHoldersOf(assignments) + want, derived := plc.SeatHoldersWithClaimants(assignments, manifests) + now := map[string]bool{} + for _, d := range derived { + now[d] = true + if !p.derivedSaid[d] { + p.logf("seat-holders: the seat %s: no holding on record, written as held by the assigned module whose manifest claims it (A-400)", d) + } + } + for d := range p.derivedSaid { + if !now[d] { + p.logf("seat-holders: the seat %s is no longer derived (a holding is on record, or nobody assigned claims it)", d) + } + } + p.derivedSaid = now have := p.w.read(plc.SeatHoldersBucket()) for key, sh := range want { value, err := json.Marshal(sh) diff --git a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/seat_tools_test.go b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/seat_tools_test.go index f1a25eaf..792268a6 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/seat_tools_test.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/seat_tools_test.go @@ -325,11 +325,11 @@ func TestTheSeatsVerbs(t *testing.T) { place("ace", mma.Holding{Claim: "mesh-broker", Scope: "mesh", Module: "nats"}, mma.Holding{Claim: "node-shell", Scope: "node", Module: "web"}) place("g14", mma.Holding{Claim: "node-shell", Scope: "node", Module: "web"}) ctx := context.Background() - if p.seatHolders(ctx); writes != 0 { + if p.seatHolders(ctx, nil); writes != 0 { t.Fatalf("seat-holders was written from an unread seat list: %v", kv.values) } p.seats = gateOver(t, false) - p.seatHolders(ctx) + p.seatHolders(ctx, nil) var broker mma.SeatHolders if err := json.Unmarshal(kv.values["mesh-broker"], &broker); err != nil || broker.Outside { t.Errorf("mesh-broker's holders %+v, %v: a seat the list names is no seat outside it", broker, err) @@ -337,12 +337,12 @@ func TestTheSeatsVerbs(t *testing.T) { if writes != 3 || kv.values["mesh-broker"] == nil || kv.values["node-shell.ace"] == nil || kv.values["node-shell.g14"] == nil { t.Fatalf("%d writes: %v", writes, kv.values) } - p.seatHolders(ctx) + p.seatHolders(ctx, nil) if writes != 3 { t.Errorf("an unchanged assignments wrote %d keys", writes-3) } place("g14") // g14 holds nothing now - p.seatHolders(ctx) + p.seatHolders(ctx, nil) if writes != 3 || kv.values["node-shell.g14"] != nil || kv.values["node-shell.ace"] == nil { t.Errorf("after g14's change: %d writes, %v", writes, kv.values) } diff --git a/modules/mesh-delivery-assigner/internal/assignment/assignments_test.go b/modules/mesh-delivery-assigner/internal/assignment/assignments_test.go index 33a30427..c6e336ba 100644 --- a/modules/mesh-delivery-assigner/internal/assignment/assignments_test.go +++ b/modules/mesh-delivery-assigner/internal/assignment/assignments_test.go @@ -11,6 +11,7 @@ import ( client "git.novox.be/novox/mesh-contracts/go/clients/meshmoduleassignerclient" seat "git.novox.be/novox/mesh-contracts/go/seats/meshmoduleassigner" + "git.novox.be/novox/mesh-sdk/go/catalogue" "git.novox.be/novox/mesh-sdk/go/keys" ) @@ -356,5 +357,30 @@ func TestAssignments(t *testing.T) { if h, _ := client.HoldersOf(keyed, "node-files", "novox"); h != nil { t.Errorf("a node seat nobody holds there is held by %v", h) } + + // A-400: a seat no holding names is held by the first assigned module whose manifest claims it; a holding on record wins. + assigned := map[string]seat.Assignments{ + "ace": {Node: "ace", Modules: []seat.PlacedModule{{Module: "mesh-delivery-assigner"}, {Module: "mesh-files"}}}, + "novox": {Node: "novox", Modules: []seat.PlacedModule{{Module: "nats"}, {Module: "mesh-files"}}, Holds: []seat.Holding{{Claim: "mesh-broker", Scope: "mesh", Module: "nats"}}}, + } + manifests := map[string]catalogue.Manifest{ + "mesh-delivery-assigner": {Claims: []catalogue.Claim{{Name: "mesh-module-assigner", Scope: "mesh"}}}, + "nats": {Claims: []catalogue.Claim{{Name: "mesh-broker", Scope: "mesh"}}}, + "mesh-files": {Claims: []catalogue.Claim{{Name: "node-files"}}}, + } + with, derived := SeatHoldersWithClaimants(assigned, manifests) + keyed = map[string][]byte{} + for k, v := range with { + keyed[k], _ = json.Marshal(v) + } + if h, err := client.HoldersOf(keyed, "mesh-module-assigner", ""); err != nil || len(h) != 1 || h[0].Module != "mesh-delivery-assigner" || h[0].Node != "ace" { + t.Errorf("an unheld seat's claimant is %v, %v", h, err) + } + if h, _ := client.HoldersOf(keyed, "node-files", "novox"); len(h) != 1 || h[0].Module != "mesh-files" { + t.Errorf("a node seat's claimant on novox is %v", h) + } + if h, _ := client.HoldersOf(keyed, "mesh-broker", ""); len(h) != 1 || h[0].Node != "novox" || len(derived) != 3 { + t.Errorf("a held seat is %v; derived %v", h, derived) + } }) } diff --git a/modules/mesh-delivery-assigner/internal/assignment/check.go b/modules/mesh-delivery-assigner/internal/assignment/check.go index 3e6a6a3a..a4f5d82a 100644 --- a/modules/mesh-delivery-assigner/internal/assignment/check.go +++ b/modules/mesh-delivery-assigner/internal/assignment/check.go @@ -252,3 +252,54 @@ func sortedKeys[V any](m map[string]V) []string { sort.Strings(out) return out } + +// SeatHoldersWithClaimants is SeatHoldersOf over the assignments with, for each seat no holding names (a seat held once: +// on no node; a seat of every node: on that node), the first module assigned to a node (nodes and modules in order) whose +// manifest claims it, as its holder (lead answer A-400, the same rule as grants' A-398; the operator, 2026-11-14: who holds +// a seat follows from the module graph and the assignments). derived lists each key so held, for its writer to say. Pure. +func SeatHoldersWithClaimants(assignments map[string]seat.Assignments, manifests map[string]catalogue.Manifest) (out map[string]seat.SeatHolders, derived []string) { + held := map[string]bool{} // "" for a seat held once, "." for a seat of every node + keyOf := func(claim, scope, node string) string { + name := claim + if s, ok := catalogue.SeatNamed(claim); ok { + name = s.Name + } + if scope == catalogue.ScopeNode { + return name + "." + node + } + return name + } + for _, n := range sortedKeys(assignments) { + for _, h := range assignments[n].Holds { + held[keyOf(h.Claim, h.Scope, n)] = true + } + } + with := map[string]seat.Assignments{} + var added []string + for _, n := range sortedKeys(assignments) { + a := assignments[n] + a.Holds = append([]seat.Holding(nil), a.Holds...) + modules := make([]string, 0, len(a.Modules)) + for _, m := range a.Modules { + modules = append(modules, m.Module) + } + sort.Strings(modules) + for _, module := range modules { + m, ok := manifests[module] + if !ok { + continue + } + for _, c := range m.Claims { + k := keyOf(c.Name, c.At(), n) + if held[k] { + continue + } + held[k] = true + a.Holds = append(a.Holds, seat.Holding{Claim: c.Name, Module: module, Scope: c.At()}) + added = append(added, k+" by "+module+" on "+n) + } + } + with[n] = a + } + return SeatHoldersOf(with), added +}