From 5108c28e2241e7d6bced132fa5437cb56cd76846 Mon Sep 17 00:00:00 2001 From: jochen Date: Sun, 8 Nov 2026 15:31:32 +0100 Subject: [PATCH] The node-engine composes seat passes with the SDK's one rule instead of its own copy (issue 1966, ADR 0660) Claude-Session: https://claude.ai/code/session_01NcbgfFfQ4Z9UE5jK32PmE5 --- internal/compose/resolution/seat_pass.go | 74 ----------------- internal/compose/resolution/seat_pass_test.go | 80 ------------------- internal/compose/rest.go | 6 +- internal/compose/rest_test.go | 39 ++++++++- 4 files changed, 40 insertions(+), 159 deletions(-) delete mode 100644 internal/compose/resolution/seat_pass.go delete mode 100644 internal/compose/resolution/seat_pass_test.go diff --git a/internal/compose/resolution/seat_pass.go b/internal/compose/resolution/seat_pass.go deleted file mode 100644 index 5f80658..0000000 --- a/internal/compose/resolution/seat_pass.go +++ /dev/null @@ -1,74 +0,0 @@ -package resolution - -import ( - "fmt" - "sort" - - mcat "git.novox.be/novox/mesh-sdk/go/catalogue" -) - -// SeatsToPassOn reads the mesh for seats held once whose holder on record has left (novox/hq ADR 0449 §4). -// -// **A holder on record that is assigned on no machine holds nothing, and a seat that answers nothing is -// the day a delivery removed its module.** Of such a seat, exactly one assignment in the mesh able to hold -// it (it claims the seat at its scope and CanHold accepts it) takes it over: that is a pass, and the caller -// records it and writes the hand act. With no such assignment the record stays; with two or more nothing is -// recorded and the answer says so, naming both and the `seat --to` that settles it. A holder still assigned -// anywhere changes nothing: the other claimants stand beside it, eligible and silent (ADR 0131). Only mesh -// seats held once are read: a replicated seat's holders are added by an act (ADR 0223), a kinded bench is held -// by its claims, and a seat with several holders on record is a store that disagrees with the mesh (refused -// by the resolver). -func SeatsToPassOn(holdings []mcat.Held, assignments []mcat.Assignment) ([]mcat.SeatPass, []string) { - assigned := map[string]bool{} - for _, a := range assignments { - assigned[a.Manifest.Module] = true - } - bySeat := map[string][]mcat.Held{} - var order []string - for _, h := range holdings { - s, ok := mcat.SeatNamed(h.Claim) - if !ok || s.Replicated || s.Scope != mcat.ScopeMesh || h.Scope != mcat.ScopeMesh || mcat.KindedBenches[s.Name] { - continue - } - if _, seen := bySeat[s.Name]; !seen { - order = append(order, s.Name) - } - bySeat[s.Name] = append(bySeat[s.Name], h) - } - sort.Strings(order) - - var passes []mcat.SeatPass - var said []string - for _, name := range order { - recs := bySeat[name] - if len(recs) != 1 || assigned[recs[0].Module] { - continue - } - seat, _ := mcat.SeatNamed(name) - var claimants []mcat.Held - for _, a := range assignments { - if mcat.CanHold(a.Manifest, seat) != nil { - continue - } - claimants = append(claimants, mcat.Held{Claim: seat.Name, Scope: seat.Scope, Node: a.Node, Module: a.Manifest.Module}) - } - sort.Slice(claimants, func(i, j int) bool { - if claimants[i].Node != claimants[j].Node { - return claimants[i].Node < claimants[j].Node - } - return claimants[i].Module < claimants[j].Module - }) - switch len(claimants) { - case 0: - case 1: - passes = append(passes, mcat.SeatPass{Seat: seat, From: recs[0], To: claimants[0]}) - default: - said = append(said, fmt.Sprintf( - "%s on %s is on record as the holder of %q and is assigned nowhere, and %s on %s and %s on %s both claim it "+ - "— nothing is recorded; `seat %s --to /` records the one that holds it", - recs[0].Module, recs[0].Node, seat.Name, claimants[0].Module, claimants[0].Node, - claimants[1].Module, claimants[1].Node, seat.Name)) - } - } - return passes, said -} diff --git a/internal/compose/resolution/seat_pass_test.go b/internal/compose/resolution/seat_pass_test.go deleted file mode 100644 index 347defd..0000000 --- a/internal/compose/resolution/seat_pass_test.go +++ /dev/null @@ -1,80 +0,0 @@ -package resolution - -import ( - "strings" - "testing" - - mcat "git.novox.be/novox/mesh-sdk/go/catalogue" -) - -func onRecord(node, module string) []mcat.Held { - return []mcat.Held{{Claim: "mesh-broker", Scope: mcat.ScopeMesh, Node: node, Module: module}} -} - -// 1317/AC1 -func TestASeatWhoseHolderIsAssignedNowhereIsPassedToItsOnlyClaimant(t *testing.T) { - busSeatDelivering(t, "mesh-bus") - passes, said := SeatsToPassOn(onRecord("novox", "old-broker"), - []mcat.Assignment{{Node: "novox", Manifest: newBroker()}}) - if len(said) != 0 || len(passes) != 1 { - t.Fatalf("the only claimant was not given the seat: passes=%v said=%v", passes, said) - } - p := passes[0] - if p.Seat.Name != "mesh-broker" || p.From.Module != "old-broker" || p.From.Node != "novox" || - p.To.Module != "new-broker" || p.To.Node != "novox" { - t.Fatalf("the pass does not name the seat, the former holder and the new one: %+v", p) - } -} - -// 1317/AC2 -func TestWithTwoClaimantsAndTheHolderGoneNothingIsPassedAndTheRefusalNamesBoth(t *testing.T) { - busSeatDelivering(t, "mesh-bus") - passes, said := SeatsToPassOn(onRecord("novox", "gone"), []mcat.Assignment{ - {Node: "novox", Manifest: newBroker()}, {Node: "ace", Manifest: oldBroker()}}) - if len(passes) != 0 || len(said) != 1 { - t.Fatalf("two claimants: passes=%v said=%v", passes, said) - } - for _, want := range []string{"old-broker", "new-broker", "seat mesh-broker --to"} { - if !strings.Contains(said[0], want) { - t.Fatalf("the refusal does not say %q: %s", want, said[0]) - } - } -} - -// 1317/AC3 -func TestAHolderStillAssignedSomewhereChangesNothing(t *testing.T) { - busSeatDelivering(t, "mesh-bus") - // Assigned on another machine than the record names: still assigned somewhere. - passes, said := SeatsToPassOn(onRecord("novox", "old-broker"), []mcat.Assignment{ - {Node: "ace", Manifest: oldBroker()}, {Node: "novox", Manifest: newBroker()}}) - if len(passes) != 0 || len(said) != 0 { - t.Fatalf("a holder still assigned lost its seat: passes=%v said=%v", passes, said) - } -} - -// 1317/AC4 -func TestWithNoClaimantTheRecordStays(t *testing.T) { - busSeatDelivering(t, "mesh-bus") - passes, said := SeatsToPassOn(onRecord("novox", "old-broker"), []mcat.Assignment{ - {Node: "novox", Manifest: mcat.Manifest{Module: "other"}}}) - if len(passes) != 0 || len(said) != 0 { - t.Fatalf("with no claimant: passes=%v said=%v", passes, said) - } - // A claimant that cannot hold the seat (it does not provide what the seat delivers) is no claimant. - bad := mcat.Manifest{Module: "no-bus", Claims: []mcat.Claim{{Name: "mesh-broker", Scope: mcat.ScopeMesh}}} - passes, said = SeatsToPassOn(onRecord("novox", "old-broker"), []mcat.Assignment{{Node: "novox", Manifest: bad}}) - if len(passes) != 0 || len(said) != 0 { - t.Fatalf("a module that cannot hold the seat was passed it: passes=%v said=%v", passes, said) - } -} - -// A replicated seat is never passed: its holders are added by an act (ADR 0223). -func TestAReplicatedSeatIsNeverPassed(t *testing.T) { - record := []mcat.Held{{Claim: "mesh-dns-resolver", Scope: mcat.ScopeMesh, Node: "novox", Module: "gone"}} - resolver := mcat.Manifest{Module: "resolver", Provides: []mcat.Offer{{Name: "wildcard-resolution", Scope: mcat.ScopeMesh}}, - Claims: []mcat.Claim{{Name: "mesh-dns-resolver", Scope: mcat.ScopeMesh}}} - passes, _ := SeatsToPassOn(record, []mcat.Assignment{{Node: "novox", Manifest: resolver}}) - if len(passes) != 0 { - t.Fatalf("a replicated seat was passed: %v", passes) - } -} diff --git a/internal/compose/rest.go b/internal/compose/rest.go index c2e4708..002820e 100644 --- a/internal/compose/rest.go +++ b/internal/compose/rest.go @@ -179,7 +179,7 @@ func (c *composer) theRestOfTheMeshNow(exclude string) (catalogue.World, Passes, // assigned nowhere and which has exactly one claimant able to hold it (novox/hq ADR 0449 clause 4), and answers the // holdings as they are after it, with the passes. Nothing is recorded. func passSeatsOn(holdings []catalogue.Held, assignments []catalogue.Assignment) ([]catalogue.Held, Passes) { - passes, said := resolution.SeatsToPassOn(holdings, assignments) + passes, said := catalogue.SeatsToPassOn(holdings, assignments) out := Passes{Said: said} for _, p := range passes { out.Passes = append(out.Passes, p) @@ -197,7 +197,7 @@ func passSeatsOn(holdings []catalogue.Held, assignments []catalogue.Assignment) } // assignmentsOf are the assignments of every machine, as the passing of a seat reads them. A module assigned and -// missing from the shelf is still assigned: an assignment with no claims, so its holder is not taken for gone. +// missing from the shelf is still assigned: an assignment marked unread, so its holder is not taken for gone. func assignmentsOf(shelf map[string]catalogue.Manifest, assigned map[string][]string) []catalogue.Assignment { var out []catalogue.Assignment names := make([]string, 0, len(assigned)) @@ -211,7 +211,7 @@ func assignmentsOf(shelf map[string]catalogue.Manifest, assigned map[string][]st if !ok { m = catalogue.Manifest{Module: module} } - out = append(out, catalogue.Assignment{Node: node, Manifest: m}) + out = append(out, catalogue.Assignment{Node: node, Manifest: m, Unread: !ok}) } } return out diff --git a/internal/compose/rest_test.go b/internal/compose/rest_test.go index d0b0d2b..952cc3c 100644 --- a/internal/compose/rest_test.go +++ b/internal/compose/rest_test.go @@ -6,7 +6,6 @@ import ( "git.novox.be/novox/mesh-networking/modules/mesh-wireguard/go/overlay" "git.novox.be/novox/mesh-sdk/go/catalogue" - "github.com/novox/mesh-host/internal/compose/resolution" ) // objects and files are the provider and consumer of mesh-controller's facts_test.go aMeshWithSecrets (cmd/mesh-controller at @@ -186,7 +185,7 @@ func TestAHolderAssignedButNotOnTheShelfIsNotTakenForGone(t *testing.T) { withSeat(t) as := assignmentsOf(map[string]catalogue.Manifest{"gate": aBrokerClaiming("gate")}, map[string][]string{"novox": {"gate", "old-broker"}}) - passes, _ := resolution.SeatsToPassOn( + passes, _ := catalogue.SeatsToPassOn( []catalogue.Held{{Claim: "mesh-broker", Scope: catalogue.ScopeMesh, Node: "novox", Module: "old-broker"}}, as) if len(passes) != 0 { t.Fatalf("a holder missing from the shelf lost its seat: %+v", passes) @@ -230,3 +229,39 @@ func TestEachNodeIsResolvedWithItsOwnPinsInTheRestOfTheMesh(t *testing.T) { t.Fatalf("a pin to a provider that does not answer did not leave the consumer out: %v %v", left, err) } } + +// ADR 0660: a holder on record that is still assigned, whose manifest no longer claims the seat, has left it; the seat is +// composed with the one claimant, the pass is returned and said, and Input's holdings (the record) are not written. +func TestAHolderWhoseManifestDroppedTheSeatGoesToItsOnlyClaimant(t *testing.T) { + withSeat(t) + mk := func(claimants ...string) Input { + cat := map[string]catalogue.Manifest{"old-broker": {Module: "old-broker"}} + assigned := []string{"old-broker"} + for _, c := range claimants { + cat[c] = aBrokerClaiming(c) + assigned = append(assigned, c) + } + return Input{Catalogue: cat, + Nodes: []Node{{Name: "novox", Place: Place{Site: "here"}, Assigned: assigned}}, + Holdings: []catalogue.Held{{Claim: "mesh-broker", Scope: catalogue.ScopeMesh, Node: "novox", Module: "old-broker", Site: "here"}}} + } + in := mk("gate") + w, passes, _, err := TheRestOfTheMesh(in, "") + if err != nil || len(passes.Passes) != 1 || passes.Passes[0].To.Module != "gate" || passes.Passes[0].From.Module != "old-broker" { + t.Fatalf("%v %+v", err, passes) + } + if len(w.Holdings) != 1 || w.Holdings[0].Module != "gate" { + t.Fatalf("the composition does not hold the pass: %+v", w.Holdings) + } + unchanged(t, func() Input { return mk("gate") }, func(in Input) { + if _, _, _, err := TheRestOfTheMesh(in, ""); err != nil { + t.Fatal(err) + } + }) + _, passes, _, err = TheRestOfTheMesh(mk("gate", "other"), "") + said := strings.Join(passes.Said, "\n") + if err != nil || len(passes.Passes) != 0 || !strings.Contains(said, "gate") || !strings.Contains(said, "other") || + !strings.Contains(said, "seat mesh-broker --to /") { + t.Fatalf("two claimants: %v %+v", err, passes) + } +}