From b75481733bdc15e46f34a61f8ac2d168373a373a Mon Sep 17 00:00:00 2001 From: jochen Date: Thu, 19 Nov 2026 22:21:06 +0100 Subject: [PATCH 1/6] mesh-config: read its own states from a watched copy and wake only on an input (issue 1982) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit mesh-config sent about 262 requests a second and received about 1,540 since its start: every sources() call (a resolution pass, and a `delivered`, `manifest-reads-changed` or `manifest-accepted` event, each of which read the sources whether or not a window or a retirement was open) read every key of its own states by one get each (pulls 1,176 keys, resolved 447, declared 168, values 101...: about 1,200 requests for an event, 2,800 for a pass), serialised by one lock, so a delivery's burst of events kept it asking the bus back to back. - The module's own states are read from mesh-sdk's WatchedStates (one watch per state, its own writes taken into the copy) instead of a get per key (ownstates.go, main.go runtimeStore). - An event judges what it names: `delivered` and `manifest-reads-changed` read no source when no rename window is open, `manifest-accepted` reads none when every row is already marked or read again (renames.go windowOpen, retiring.go). - Open windows and retirements are judged again after each pass, since an entry that answers after the judgement was made moves the pass, not the event; the slow reads had hidden that race. - No timer polls: the five-minute resolution and sweep of every pull request on the forge, and the minute's read of the router's record, are gone. The sweep and Decide run once at start (an event said while the module was down is not said again), then on git.pull-merged/-closed and operator-channel.decided.mesh-config; an ask ended with no choice also takes the retirements from the router's record. One timer is left, a deadline: for the earliest waiting proposal (ProposalLasts + 1 h) or unanswered retirement (HeldFinding), set again when either is written (NextDeadline). Wake-ups kept, each by its record: `delivered` and `manifest-reads-changed` close a rename window (design 32 *A config value renamed*, ADR 0609 §4); `manifest-accepted` judges one module's retirements (design 32 *A value no longer read*); `git.pull-merged` and `-closed` settle one pull request's held values (ADR 0502 §7); `decided.mesh-config` takes one ask's warrant (ADR 0259); a changed view (assignment, want, predefined list, config candidate, catalog revision, entry) moves a resolution that writes only what moved (ADR 0565 §3). Builds: ADR 0681 §1 (no polling of the forge: the five-minute look ends); ADR 0580 §1; ADR 0426 §3; design 32 (*A config value renamed*, *A value no longer read*); lead answer A-490l (hq main, 03-DESIGN/01-to-be/47-milestones/G-22-lead-answers-2.md) for the wake-ups and the one deadline timer. Claude-Session: https://claude.ai/code/session_01JG73KHUnBze48rdua8u2sy --- modules/mesh-config/README.md | 2 +- modules/mesh-config/cmd/mesh-config/main.go | 113 +++++--- .../mesh-config/cmd/mesh-config/ownstates.go | 78 ++++++ .../mesh-config/cmd/mesh-config/proposals.go | 38 ++- modules/mesh-config/cmd/mesh-config/pulls.go | 2 +- .../cmd/mesh-config/quiet_integration_test.go | 135 +++++++++ .../mesh-config/cmd/mesh-config/quiet_test.go | 256 ++++++++++++++++++ .../mesh-config/cmd/mesh-config/renames.go | 16 +- .../mesh-config/cmd/mesh-config/retiring.go | 12 +- .../cmd/mesh-config/whole_integration_test.go | 18 +- 10 files changed, 623 insertions(+), 47 deletions(-) create mode 100644 modules/mesh-config/cmd/mesh-config/ownstates.go create mode 100644 modules/mesh-config/cmd/mesh-config/quiet_integration_test.go create mode 100644 modules/mesh-config/cmd/mesh-config/quiet_test.go diff --git a/modules/mesh-config/README.md b/modules/mesh-config/README.md index 99f368a43..df2bc093a 100644 --- a/modules/mesh-config/README.md +++ b/modules/mesh-config/README.md @@ -30,7 +30,7 @@ module none of whose manifests can be read is listed under `unresolved` with why values last resolved for it. Then: the manifest's default; mesh config for the predefined key the value falls back to; node config for that key on the node; the module's own value on that node, the most specific winning. A value naming no predefined key resolves from its default and the module's own value only (ADR 0348 §2). It resolves at -start, whenever an assignment, a want or a trunk module moves, and every five minutes, writing only the values that moved. +start, whenever an assignment, a want or a trunk module moves, writing only the values that moved. ## The verb diff --git a/modules/mesh-config/cmd/mesh-config/main.go b/modules/mesh-config/cmd/mesh-config/main.go index 09f0b32dd..b0d927dd8 100644 --- a/modules/mesh-config/cmd/mesh-config/main.go +++ b/modules/mesh-config/cmd/mesh-config/main.go @@ -38,15 +38,19 @@ func logf(format string, a ...any) { fmt.Fprintf(os.Stderr, format+"\n", a...) } var theViews *ownerViews // runtimeStore is the bus, through the runtime that launched this bundle. A state of the delivery owners that the -// owners' tools answer is read from the picture those keep (ownerviews.go), the rest from the bus. -type runtimeStore struct{} +// owners' tools answer is read from the picture those keep (ownerviews.go), this module's own states from the copy their +// watches keep (ownstates.go), the rest from the bus. +type runtimeStore struct{ own *ownCopy } -func (runtimeStore) Get(state, key string) (*Entry, error) { +func (r runtimeStore) Get(state, key string) (*Entry, error) { if theViews != nil { if e, followed, err := theViews.get(state, key); followed { return e, err } } + if r.own != nil && ownStates[state] { + return r.own.get(state, key) + } e, err := stdio.State(state).Get(key) if err != nil || e == nil { return nil, err @@ -54,19 +58,30 @@ func (runtimeStore) Get(state, key string) (*Entry, error) { return &Entry{Key: e.Key, Value: e.Value, Revision: e.Revision}, nil } -func (runtimeStore) Put(state, key string, value any) error { +func (r runtimeStore) Put(state, key string, value any) error { + if r.own != nil && ownStates[state] { + return r.own.write(state, key, value) + } _, err := stdio.State(state).Put(key, value) return err } -func (runtimeStore) Delete(state, key string) error { return stdio.State(state).Delete(key) } +func (r runtimeStore) Delete(state, key string) error { + if r.own != nil && ownStates[state] { + return r.own.remove(state, key) + } + return stdio.State(state).Delete(key) +} -func (runtimeStore) Keys(state string) ([]string, error) { +func (r runtimeStore) Keys(state string) ([]string, error) { if theViews != nil { if keys, followed, err := theViews.keys(state); followed { return keys, err } } + if r.own != nil && ownStates[state] { + return r.own.keys(state) + } return stdio.State(state).Keys() } @@ -120,7 +135,16 @@ func (runtimeAsks) Warranted(ask string) error { } func main() { - c := &Config{Store: runtimeStore{}, Logf: logf, Asks: runtimeAsks{}, Forge: toolForge{ask: stdio.Ask}, + own, rearm := newOwnCopy(), make(chan struct{}, 1) + own.changed = func(state string) { + if state == ProposalsState || state == RetiringState { + select { + case rearm <- struct{}{}: + default: + } + } + } + c := &Config{Store: runtimeStore{own: own}, Logf: logf, Asks: runtimeAsks{}, Forge: toolForge{ask: stdio.Ask}, Delivery: toolDelivery{ask: stdio.Ask}, Vault: toolVault{ask: stdio.Ask, recorder: recorder}} // The module's one held writer (design 47 G §689, A-16, A-29, A-32): the renames' and retirements' findings and the views reader's go through it. w, err := views.NewStdioHeldWriter(views.WriterConfig[meshconditions.Finding, meshconditions.FindingCleared, meshconditions.FindingsStated, meshconditions.FindingsAskedEvent]{ @@ -181,6 +205,7 @@ func main() { theViews.Start(context.Background()) go resolving(c, moved) go hearing(c) + go deciding(c, rearm) go hearingDelivery(c) if err := stdio.Serve("", append(Tools(c), branches.EntryAgainTool("config", c.Store.HandAct))); err != nil { logf("%v", err) @@ -188,23 +213,17 @@ func main() { } } -// resolving resolves at start and again whenever a source moves, and every five minutes besides, so a change -// heard nowhere is still resolved. The runtime answers only once Serve runs, so the watches are asked again -// until they are taken. +// resolving resolves at start and again whenever a source moves: an assignment, a want, a catalog revision, an entry +// answered, the predefined list or a config candidate (each reaches `moved` through its view, ownerviews.go and main). It +// reads the forge once for each pull request it keeps something for, so a merge or a close said while this module was down is +// found (ADR 0502); after that it is heard on git.pull-merged and git.pull-closed (hearing), never asked again on a timer +// (novox/hq principle 1, issue 1982). The runtime answers only once Serve runs. func resolving(c *Config, moved chan struct{}) { - // The owners' states reach `moved` through their views (ownerviews.go); the builder's builds, which has no tool yet, - // is read when a want moves, and nothing else is watched. - tick := time.NewTicker(5 * time.Minute) - defer tick.Stop() - time.Sleep(time.Second) - for sweep := true; ; { - if sweep { - // A merge or a close of a pull request a value is held for, heard nowhere, is found here (ADR 0502). - for _, s := range c.SweepPulls() { - logf("[mesh-config] %s", s) - } - } - sweep = false + <-stdio.Served() + for _, s := range c.SweepPulls() { + logf("[mesh-config] %s", s) + } + for { r, err := c.Reconcile() switch { case err != nil: @@ -215,21 +234,23 @@ func resolving(c *Config, moved chan struct{}) { if r.Published != "" { logf("[mesh-config] published %s", r.Published) } + // A window or a retirement judged while the entry of the build it waits on was still asked stays open until the + // entry answers: the answer moves this pass, and the open ones are judged again here (design 32 *A config value + // renamed*). It reads nothing from the bus when none is open. + for _, s := range c.Windows("") { + logf("[mesh-config] %s", s) + } + <-moved + time.Sleep(500 * time.Millisecond) // a burst of writes is one resolution select { case <-moved: - time.Sleep(500 * time.Millisecond) // a burst of writes is one resolution - select { - case <-moved: - default: - } - case <-tick.C: - sweep = true + default: } } } -// hearing takes the router's word on this module's asks, asked again until the runtime takes the subscription, and -// reads the router's record of every waiting ask once a minute besides, so an answer heard nowhere is still taken. +// hearing takes the router's word on this module's asks, asked again until the runtime takes the subscription, and the +// forge's word on a pull request's merge or close. func hearing(c *Config) { go func() { <-stdio.Served() // subscribed as soon as the runtime serves, never after a guessed wait: an event sent meanwhile is heard @@ -274,9 +295,15 @@ func hearing(c *Config) { } }(pattern) } - tick := time.NewTicker(time.Minute) - defer tick.Stop() - for range tick.C { +} + +// deciding reads the router's record of every waiting ask once at start, which finds an answer said while this module was +// down, and then when the router says an ask ended (hearing's `decided` subscription calls Decide itself) or the next +// deadline of a waiting proposal or retirement passes: one timer for the earliest, set again whenever a proposal or a +// retirement is written (issue 1982; novox/hq ADR 0426 §3: a timer is a deadline, never a poll). +func deciding(c *Config, rearm chan struct{}) { + <-stdio.Served() + decide := func() { said, err := c.Decide() if err != nil { logf("[mesh-config] reading the operator's answers: %v", err) @@ -285,6 +312,22 @@ func hearing(c *Config) { logf("[mesh-config] %s", s) } } + decide() + for { + at, ok := c.NextDeadline() + if !ok { + <-rearm + continue + } + // Not sooner than a minute: a deadline that passed and was not settled (an ask the router refused) is tried again, not spun on. + timer := time.NewTimer(max(time.Until(at), time.Minute)) + select { + case <-timer.C: + decide() + case <-rearm: + timer.Stop() + } + } } // hearingDelivery takes the delivery parts' words that close a rename window or retire a value, each asked again until diff --git a/modules/mesh-config/cmd/mesh-config/ownstates.go b/modules/mesh-config/cmd/mesh-config/ownstates.go new file mode 100644 index 000000000..642976427 --- /dev/null +++ b/modules/mesh-config/cmd/mesh-config/ownstates.go @@ -0,0 +1,78 @@ +package main + +import ( + "encoding/json" + + stdio "git.novox.be/novox/mesh-sdk/go" +) + +// The module's own states are read from a copy each one's watch keeps, never key by key (novox/hq ADR 0580 §1, issue 1982): +// a resolution reads every key of values, resolved, pulls, declared and the rest, and a get per key for each of them, once per +// pass and once per delivery event, was about 4,000 requests to the bus every time. A state is watched on its first read, the +// watch hands every current value over before the read is answered, and this process's own writes are taken into the copy +// as they are made, so a read right after a write sees it. + +// ownStates are the states this module keeps and reads through its store (its manifest's `state`, but the findings, which its +// held writer alone reads and writes): the ones read from the copy. +var ownStates = map[string]bool{ + ValuesState: true, ResolvedState: true, PredefinedState: true, ProposalsState: true, PullsState: true, KeptState: true, + DeclaredState: true, RenamesState: true, RetiringState: true, +} + +// ownCopy is the copy of the module's own states over a bus: watch hands every current value of a state and then each change, +// get reads one key, put and del write one. +type ownCopy struct { + copy *stdio.WatchedStates + put func(state, key string, value any) (uint64, error) + del func(state, key string) error + // changed, when not nil, is told of each write or removal after it is in the copy: what waits on a deadline is judged again. + changed func(state string) +} + +// newOwnCopy is the copy over this bundle's runtime. +func newOwnCopy() *ownCopy { + return &ownCopy{copy: stdio.NewWatchedStates(), + put: func(state, key string, value any) (uint64, error) { return stdio.State(state).Put(key, value) }, + del: func(state, key string) error { return stdio.State(state).Delete(key) }} +} + +func (o *ownCopy) get(state, key string) (*Entry, error) { + raw, ok, err := o.copy.Get(state, key) + if err != nil || !ok { + return nil, err + } + return &Entry{Key: key, Value: raw}, nil +} + +func (o *ownCopy) keys(state string) ([]string, error) { return o.copy.Keys(state) } + +// write puts a key and takes it into the copy at the revision the bus answered. +func (o *ownCopy) write(state, key string, value any) error { + rev, err := o.put(state, key, value) + if err != nil { + return err + } + raw, err := json.Marshal(value) + if err != nil { + return err + } + err = o.copy.Wrote(state, key, raw, rev) + o.told(state) + return err +} + +func (o *ownCopy) told(state string) { + if o.changed != nil { + o.changed(state) + } +} + +// remove deletes a key and takes that into the copy. +func (o *ownCopy) remove(state, key string) error { + if err := o.del(state, key); err != nil { + return err + } + err := o.copy.Removed(state, key) + o.told(state) + return err +} diff --git a/modules/mesh-config/cmd/mesh-config/proposals.go b/modules/mesh-config/cmd/mesh-config/proposals.go index e38bee873..358f636e8 100644 --- a/modules/mesh-config/cmd/mesh-config/proposals.go +++ b/modules/mesh-config/cmd/mesh-config/proposals.go @@ -910,19 +910,51 @@ func (c *Config) HeardEnd(w oc.Warrant) []string { c.mu.Lock() defer c.mu.Unlock() defer c.tellEnded(w.Ask, endedWord{Outcome: w.Outcome, Words: w.Words}) + // A retirement's ask ended with no choice is taken from the router's record the same way (retiring.go): the router's word + // is the only thing that moves it, and no timer looks. + said := c.decideRetirements() e, err := c.Store.Get(ProposalsState, w.Ask) if err != nil || e == nil { - return nil + return said } var p Proposal if json.Unmarshal(e.Value, &p) != nil || p.ID != w.Ask || p.State != ProposalWaiting { - return nil + return said } why := "the ask " + string(w.Outcome) if w.Words != "" { why += " (" + w.Words + ")" } - return []string{c.end(p, why+"; nothing was set")} + return append(said, c.end(p, why+"; nothing was set")) +} + +// NextDeadline is when a waiting proposal or retirement is next judged for want of an answer: a proposal with no record +// at the router ends an hour after its ask lapses (Decide), and a retirement left unanswered is asked once more after +// HeldFinding. The earliest of them; false when nothing waits on a time. +func (c *Config) NextDeadline() (time.Time, bool) { + c.mu.Lock() + defer c.mu.Unlock() + var at time.Time + earlier := func(t time.Time) { + if at.IsZero() || t.Before(at) { + at = t + } + } + if all, err := c.proposals(); err == nil { + for _, p := range all { + if p.State == ProposalWaiting { + earlier(p.At.Add(ProposalLasts + time.Hour)) + } + } + } + if held, err := c.readRetiring(); err == nil { + for _, e := range held { + if e.State == RetireUnanswered && !e.AskedAgain { + earlier(e.Asked.Add(HeldFinding)) + } + } + } + return at, !at.IsZero() } // ---- the list ---------------------------------------------------------------------------------------------- diff --git a/modules/mesh-config/cmd/mesh-config/pulls.go b/modules/mesh-config/cmd/mesh-config/pulls.go index 50f01da94..3508a95bf 100644 --- a/modules/mesh-config/cmd/mesh-config/pulls.go +++ b/modules/mesh-config/cmd/mesh-config/pulls.go @@ -534,7 +534,7 @@ func (c *Config) HeardPull(p PullEvent, merged bool) []string { } // SweepPulls looks at the forge for every pull request it keeps something for, so a merge or a close it did not hear -// is found: run with each five-minute resolution. +// is found: run once at start (resolving). func (c *Config) SweepPulls() []string { if c.Forge == nil { return nil diff --git a/modules/mesh-config/cmd/mesh-config/quiet_integration_test.go b/modules/mesh-config/cmd/mesh-config/quiet_integration_test.go new file mode 100644 index 000000000..deb93d759 --- /dev/null +++ b/modules/mesh-config/cmd/mesh-config/quiet_integration_test.go @@ -0,0 +1,135 @@ +//go:build integration + +package main + +// Issue 1982, against a real bus: mesh-config whole asks the bus for nothing while no input of it changes, and a changed input +// resolves only what it touches. The binary runs as the node's tool runtime plays it (whole_integration_test.go), and every +// request it makes of the runtime is counted: what a state read, a watch and a write ask of the bus. + +import ( + "context" + "os" + "os/exec" + "path/filepath" + "slices" + "strings" + "testing" + + "github.com/nats-io/nats.go" + "github.com/nats-io/nats.go/jetstream" + + "git.novox.be/novox/mesh-sdk/go/testbus" +) + +func (p *player) snapshot() (calls map[string]int, puts []string) { + p.mu.Lock() + defer p.mu.Unlock() + calls = map[string]int{} + for k, v := range p.calls { + calls[k] = v + } + return calls, slices.Clone(p.puts) +} + +// asked is how many requests of these methods the module made between two snapshots. +func asked(before, after map[string]int, methods ...string) int { + n := 0 + for _, m := range methods { + n += after[m] - before[m] + } + return n +} + +func TestConfigWholeAsksTheBusForNothingWhileNoInputChanges(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + t.Cleanup(cancel) + bin := filepath.Join(t.TempDir(), Module) + build := exec.Command("go", "build", "-o", bin, ".") + build.Stderr = os.Stderr + if err := build.Run(); err != nil { + t.Fatalf("mesh-config does not build: %v", err) + } + nc, err := nats.Connect(testbus.URL(t)) + if err != nil { + t.Fatal(err) + } + t.Cleanup(nc.Close) + js, err := jetstream.New(nc) + if err != nil { + t.Fatal(err) + } + buckets := []string{"mesh-delivery-assigner_assignments", "mesh-delivery-assigner_wants", "mesh-delivery-indexer_predefined", + "mesh-delivery-indexer_config-candidates"} + for _, s := range []string{ValuesState, ResolvedState, PredefinedState, ProposalsState, PullsState, KeptState, DeclaredState, + RenamesState, RetiringState, FindingsState} { + buckets = append(buckets, Module+"_"+s) + } + for _, b := range buckets { + if _, err := js.CreateKeyValue(ctx, jetstream.KeyValueConfig{Bucket: b, History: 2}); err != nil { + t.Fatal(err) + } + } + haves := map[string]string{"g14.player": fpOf("player", fp1), "novox.player": fpOf("player", fp1), "g14.radio": fpOf("radio", fp1)} + p := start(t, bin, js, newStandIn(), haves, nil) + p.viewsReady() + + const radio = `{"module":"radio","config":{"band":{"type":"number","default":1}}}` + p.manifestIn("player", oldPlayer) + p.manifestIn("radio", radio) + p.buildIn("g14", "player", fpOf("player", fp1), oldPlayer) + p.buildIn("novox", "player", fpOf("player", fp1), oldPlayer) + p.buildIn("g14", "radio", fpOf("radio", fp1), radio) + p.placed("g14", "player", "radio") + p.placed("novox", "player") + p.hearsTheViews() + eventually(t, "every value is resolved", func() bool { + a, okA := resolvedValue(p, "g14", "player", "volume") + b, okB := resolvedValue(p, "novox", "player", "volume") + c, okC := resolvedValue(p, "g14", "radio", "band") + return okA && okB && okC && a == "5" && b == "5" && c == "1" + }) + // The passes the setup moved have ended when the module answers a tool: it takes its lock for none. + if _, err := p.call(ResyncTool, nil); err != nil { + t.Fatal(err) + } + + // No input changes: the delivery says it delivered, a node-engine says what it reads, the forge says a pull request nothing is + // kept for closed, and the catalog says a manifest was accepted that no retirement waits on. Each is heard and none is a pass: + // nothing is asked of the bus. (The module has no timer: no minute, five or otherwise, asks it anything.) + before, putsBefore := p.snapshot() + for i := 0; i < 20; i++ { + p.event("mesh-delivery-view.delivered", map[string]any{"revision": "r"}) + p.event("node-engine.manifest-reads-changed", map[string]any{"node": "g14"}) + p.event("git.pull-closed", map[string]any{"owner": "novox", "repo": "mesh-catalog", "number": 700 + i}) + } + after, putsAfter := p.snapshot() + if n := asked(before, after, "mesh/state.get", "mesh/state.keys", "mesh/state.watch", "mesh/state.put", "mesh/state.create", + "mesh/state.update", "mesh/state.delete", "mesh/ask"); n != 0 || len(putsAfter) != len(putsBefore) { + t.Errorf("60 events that move nothing asked %d requests of the bus (%v); wrote %v", n, after, putsAfter[len(putsBefore):]) + } + + // One input changes: player's manifest declares a second value. Only player's values on its two nodes are written, and `declared` + // for player; radio's resolved values are not written again, and nothing is read key by key. + before, putsBefore = p.snapshot() + const gain = `{"module":"player","config":{"volume":{"type":"number","default":5},"gain":{"type":"number","default":2}}}` + p.manifestIn("player", gain) + eventually(t, "the new value is resolved on both nodes", func() bool { + a, okA := resolvedValue(p, "g14", "player", "gain") + b, okB := resolvedValue(p, "novox", "player", "gain") + return okA && okB && a == "2" && b == "2" + }) + after, putsAfter = p.snapshot() + var wrote []string + for _, w := range putsAfter[len(putsBefore):] { + wrote = append(wrote, strings.TrimPrefix(w, "mesh/state.")) + } + for _, w := range wrote { + if !strings.Contains(w, ResolvedState+"/g14.player.") && !strings.Contains(w, ResolvedState+"/novox.player.") && + !strings.Contains(w, DeclaredState+"/player") { + t.Errorf("a changed manifest of player wrote %q, which is not player's", w) + } + } + if n := asked(before, after, "mesh/state.get", "mesh/state.keys", "mesh/state.watch"); n != 0 { + t.Errorf("a changed manifest read %d keys of the bus's states one by one (%v)", n, after) + } +} diff --git a/modules/mesh-config/cmd/mesh-config/quiet_test.go b/modules/mesh-config/cmd/mesh-config/quiet_test.go new file mode 100644 index 000000000..d6f89e77c --- /dev/null +++ b/modules/mesh-config/cmd/mesh-config/quiet_test.go @@ -0,0 +1,256 @@ +package main + +// What mesh-config asks of the bus per input (issue 1982): its own states are read from the copy their watches keep, an event +// that moves nothing reads nothing, and the one timer left is a deadline. + +import ( + "encoding/json" + "sync" + "testing" + "time" + + occ "git.novox.be/novox/mesh-contracts/operator-and-conversation/go/clients/operatorchannelclient" + oc "git.novox.be/novox/mesh-contracts/operator-and-conversation/go/seats/operatorchannel" + stdio "git.novox.be/novox/mesh-sdk/go" +) + +// countingStore counts the reads of the states by state: what the bus would be asked. +type countingStore struct { + *memStore + mu sync.Mutex + reads map[string]int +} + +func (s *countingStore) Get(state, key string) (*Entry, error) { + s.mu.Lock() + s.reads[state]++ + s.mu.Unlock() + return s.memStore.Get(state, key) +} + +func (s *countingStore) Keys(state string) ([]string, error) { + s.mu.Lock() + s.reads[state]++ + s.mu.Unlock() + return s.memStore.Keys(state) +} + +// readsOf is the reads of every state but those named. +func (s *countingStore) readsExcept(states ...string) map[string]int { + s.mu.Lock() + defer s.mu.Unlock() + out := map[string]int{} + for k, n := range s.reads { + out[k] = n + } + for _, k := range states { + delete(out, k) + } + return out +} + +// **An event that moves nothing reads nothing but what it judges** (design 32 *A config value renamed*, *A value no longer +// read*): with no rename window open, `delivered` and `manifest-reads-changed` read no source, and a `manifest-accepted` +// whose rows are all marked or read again reads none either. Each was a read of every key of every state of the module +// (about 4,000 requests) under a delivery's burst of events. +func TestAnEventThatMovesNothingReadsNoSource(t *testing.T) { + c, m, d, _, _, _ := retiringMesh(t) + cs := &countingStore{memStore: m, reads: map[string]int{}} + c.Store = cs + d.rows = []ReaderRow{{Module: "player", Key: "volume", Kind: KindValue, Readers: []string{"g14"}}} // read: nothing to retire + for name, event := range map[string]func(){ + "delivered": func() { c.Windows("") }, + "manifest-reads-changed": func() { c.Windows("g14") }, + "manifest-accepted": func() { c.Retirements("player") }, + } { + cs.reads = map[string]int{} + event() + if got := cs.readsExcept(RenamesState, RetiringState); len(got) != 0 { + t.Errorf("%s read %v", name, got) + } + } +} + +// An open window is judged, and reads what judging it needs: the same event with a window open reads the sources. +func TestAnEventWithAWindowOpenJudgesIt(t *testing.T) { + c, m, _, _ := aRenamingMesh(t) + m.declare(t, "player", newPlayer) + if _, err := c.Reconcile(); err != nil { + t.Fatal(err) + } + cs := &countingStore{memStore: m, reads: map[string]int{}} + c.Store = cs + c.Windows("") + if cs.reads[ValuesState] == 0 { + t.Errorf("an open window was judged on no source: %v", cs.reads) + } +} + +// **An ask of a retirement that ends with no choice is taken when the router says so** (design 32 *A value no longer read*): +// with no minute's look at the router's record, the `decided` event of an ask that expired moves the retirement. +func TestARetirementWhoseAskExpiredIsTakenOnTheRoutersWord(t *testing.T) { + c, m, d, r, _, _ := retiringMesh(t) + for _, node := range []string{"g14", "novox"} { + m.want(t, node, "player", fp3, donePlayer) + d.haves[node+".player"] = fp3 + } + c.Windows("") + c.Retirements("player") + rows := retiringOf(t, c) + if len(rows) != 1 || rows[0].State != RetireAsked { + t.Fatalf("retiring %+v, want asked", rows) + } + r.choose(t, rows[0].Ask, OptionApprove, func(w *oc.Warrant) { w.Outcome = occ.OutcomeExpired }) + c.HeardEnd(oc.Warrant{Ask: rows[0].Ask, Asker: Module, Outcome: occ.OutcomeExpired}) + if rows = retiringOf(t, c); rows[0].State != RetireUnanswered { + t.Errorf("after the router said the ask expired: %+v", rows) + } +} + +// The next deadline is the earliest of a waiting proposal's (an hour past its ask lapsing, with no record at the router) +// and an unanswered retirement's (asked once more after HeldFinding); none when nothing waits on a time. +func TestTheNextDeadlineIsTheEarliestOfWhatWaitsOnATime(t *testing.T) { + m := newStore() + c := &Config{Store: m, Catalog: m, Logf: t.Logf} + if _, ok := c.NextDeadline(); ok { + t.Fatal("a deadline with nothing waiting") + } + t0 := time.Date(2026, 11, 19, 10, 0, 0, 0, time.UTC) + put := func(state, key string, v any) { + if err := m.Put(state, key, v); err != nil { + t.Fatal(err) + } + } + put(ProposalsState, "p1", Proposal{ID: "p1", State: ProposalWaiting, At: t0.Add(48 * time.Hour)}) + put(ProposalsState, "p2", Proposal{ID: "p2", State: ProposalEnded, At: t0}) + want := t0.Add(48*time.Hour + ProposalLasts + time.Hour) + if at, ok := c.NextDeadline(); !ok || !at.Equal(want) { + t.Errorf("deadline %v, %v; want %v", at, ok, want) + } + put(RetiringState, "player.volume", Retiring{Module: "player", Key: "volume", State: RetireUnanswered, Asked: t0.Add(-6 * 24 * time.Hour)}) + want = t0.Add(HeldFinding - 6*24*time.Hour) + if at, ok := c.NextDeadline(); !ok || !at.Equal(want) { + t.Errorf("deadline %v, %v; want the retirement's %v", at, ok, want) + } +} + +// busOf is a bus of states for the copy's tests: what each state holds, the watches handed out and the requests asked. +type busOf struct { + mu sync.Mutex + held map[string]map[string][]byte + handles map[string]func(stdio.StateChange) error + watches int + gets int + writes int + revision uint64 +} + +func (b *busOf) ownCopy() *ownCopy { + return &ownCopy{ + copy: stdio.WatchedStatesOver(func(state string, handle func(stdio.StateChange) error) error { + b.mu.Lock() + b.watches++ + b.handles[state] = handle + current := map[string][]byte{} + for k, v := range b.held[state] { + current[k] = v + } + b.mu.Unlock() + for k, v := range current { + if err := handle(stdio.StateChange{State: state, Key: k, Op: stdio.OpPut, Value: v, Revision: 1, Current: true}); err != nil { + return err + } + } + return nil + }, func(state, key string) ([]byte, bool, error) { + b.mu.Lock() + defer b.mu.Unlock() + b.gets++ + v, ok := b.held[state][key] + return v, ok, nil + }), + put: func(state, key string, value any) (uint64, error) { + raw, _ := json.Marshal(value) + b.mu.Lock() + defer b.mu.Unlock() + b.writes++ + b.revision++ + if b.held[state] == nil { + b.held[state] = map[string][]byte{} + } + b.held[state][key] = raw + return b.revision + 1, nil + }, + del: func(state, key string) error { + b.mu.Lock() + defer b.mu.Unlock() + b.writes++ + delete(b.held[state], key) + return nil + }} +} + +// **The module's own states are read from a copy, never key by key** (ADR 0580 §1, issue 1982): a whole state read of 1,176 +// keys is one watch and no get, again and again; this process's write is in the copy at once, another's arrives by the watch. +func TestAnOwnStateIsReadFromItsWatchedCopyNotKeyByKey(t *testing.T) { + b := &busOf{held: map[string]map[string][]byte{PullsState: {}}, handles: map[string]func(stdio.StateChange) error{}} + for i := 0; i < 1176; i++ { + b.held[PullsState][pullKey("novox/mesh-catalog#"+string(rune('a'+i%26))+time.Duration(i).String())] = []byte(`{"pull":"x"}`) + } + n := len(b.held[PullsState]) + own := b.ownCopy() + for pass := 0; pass < 3; pass++ { + keys, err := own.keys(PullsState) + if err != nil || len(keys) != n { + t.Fatalf("keys %d, %v; want %d", len(keys), err, n) + } + for _, k := range keys { + if e, err := own.get(PullsState, k); err != nil || e == nil { + t.Fatalf("get %s: %v, %v", k, e, err) + } + } + } + if b.watches != 1 || b.gets != 0 { + t.Errorf("3 passes over %d keys asked the bus for %d watches and %d gets; want 1 and 0", n, b.watches, b.gets) + } + // Its own write and removal are in the copy at once. + if err := own.write(PullsState, "mine", map[string]string{"pull": "mine"}); err != nil { + t.Fatal(err) + } + if e, _ := own.get(PullsState, "mine"); e == nil { + t.Error("a key just written is not read") + } + if err := own.remove(PullsState, "mine"); err != nil { + t.Fatal(err) + } + if e, _ := own.get(PullsState, "mine"); e != nil { + t.Error("a key just removed is still read") + } + // Another writer's change arrives by the watch. + if err := b.handles[PullsState](stdio.StateChange{State: PullsState, Key: "theirs", Op: stdio.OpPut, Value: []byte(`{"pull":"t"}`), Revision: 99}); err != nil { + t.Fatal(err) + } + if e, _ := own.get(PullsState, "theirs"); e == nil { + t.Error("a change another wrote is not read") + } + if b.gets != 0 { + t.Errorf("%d gets", b.gets) + } +} + +// A write and a removal tell what waits on a deadline, once each. +func TestAWriteTellsWhatWaitsOnADeadline(t *testing.T) { + b := &busOf{held: map[string]map[string][]byte{}, handles: map[string]func(stdio.StateChange) error{}} + own := b.ownCopy() + var told []string + own.changed = func(state string) { told = append(told, state) } + if err := own.write(ProposalsState, "p", Proposal{ID: "p"}); err != nil { + t.Fatal(err) + } + if err := own.remove(ProposalsState, "p"); err != nil { + t.Fatal(err) + } + if len(told) != 2 || told[0] != ProposalsState { + t.Errorf("told %v", told) + } +} diff --git a/modules/mesh-config/cmd/mesh-config/renames.go b/modules/mesh-config/cmd/mesh-config/renames.go index f7338a38a..64417796f 100644 --- a/modules/mesh-config/cmd/mesh-config/renames.go +++ b/modules/mesh-config/cmd/mesh-config/renames.go @@ -293,14 +293,26 @@ func (c *Config) Windows(node string) []string { return said } +// windowOpen says whether any rename holds a window open on the node named, or on any node when none is named. +func windowOpen(renames map[string]Rename, only string) bool { + for _, r := range renames { + for _, node := range r.Open() { + if only == "" || only == node { + return true + } + } + } + return false +} + // closeWindows is Windows' rename half; the caller holds the lock. func (c *Config) closeWindows(only string) []string { renames, err := c.readRenames() if err != nil { return []string{"the renames cannot be read: " + err.Error()} } - if c.Delivery == nil { - return nil + if c.Delivery == nil || !windowOpen(renames, only) { + return nil // no window to judge: the delivery's word moves nothing, and no source is read for it (issue 1982) } s, err := c.sources() if err != nil { diff --git a/modules/mesh-config/cmd/mesh-config/retiring.go b/modules/mesh-config/cmd/mesh-config/retiring.go index 6f6bd2c16..3be623f7c 100644 --- a/modules/mesh-config/cmd/mesh-config/retiring.go +++ b/modules/mesh-config/cmd/mesh-config/retiring.go @@ -148,9 +148,15 @@ func (c *Config) Retirements(module string) []string { if err != nil { return []string{"the retirements cannot be read: " + err.Error()} } - s, err := c.sources() - if err != nil { - return []string{"the retirements cannot be judged: " + err.Error()} + // The sources are read only when a row is one to judge: a row already marked, or read again, needs none (issue 1982). + var s Sources + for _, row := range rows { + if _, has := held[retiringKey(module, row.Key)]; (row.Module == "" || row.Module == module) && (len(row.Readers) == 0 && !has) { + if s, err = c.sources(); err != nil { + return []string{"the retirements cannot be judged: " + err.Error()} + } + break + } } var said []string for _, row := range rows { diff --git a/modules/mesh-config/cmd/mesh-config/whole_integration_test.go b/modules/mesh-config/cmd/mesh-config/whole_integration_test.go index 9cc30a578..83d9af240 100644 --- a/modules/mesh-config/cmd/mesh-config/whole_integration_test.go +++ b/modules/mesh-config/cmd/mesh-config/whole_integration_test.go @@ -81,6 +81,11 @@ type player struct { catalog map[string]catalog.CatalogEntry byFp map[string]catalog.CatalogEntry catRev int64 + // calls counts what the module asked of the runtime, by method (and by key for an ask); puts are the keys it wrote, "/". + calls map[string]int + puts []string + // stop ends the module this player runs: the restart of a module is the old process gone and a new one started. + stop func() } // ownedState is one state of an owner (the indexer's modules, the assigner's wants...), kept from its bucket. @@ -232,6 +237,12 @@ func (p *player) handle(m wire) { Bucket string `json:"bucket"` } _ = json.Unmarshal(m.Params, &a) + p.mu.Lock() + p.calls[m.Method]++ + if strings.HasPrefix(m.Method, "mesh/state.") && m.Method != "mesh/state.get" && m.Method != "mesh/state.keys" && m.Method != "mesh/state.watch" { + p.puts = append(p.puts, m.Method+" "+a.State+"/"+a.Key) + } + p.mu.Unlock() kv, kvErr := p.kv(a.State) switch m.Method { case "mesh/state.get": @@ -675,14 +686,16 @@ func start(t *testing.T, bin string, js jetstream.JetStream, router *standIn, ha stdout, _ := cmd.StdoutPipe() cmd.Stderr = os.Stderr p := &player{t: t, ctx: ctx, js: js, router: router, in: stdin, pending: map[string]chan wire{}, haves: haves, readers: readers, - owned: map[string]*ownedState{}, catalog: map[string]catalog.CatalogEntry{}, byFp: map[string]catalog.CatalogEntry{}} + owned: map[string]*ownedState{}, catalog: map[string]catalog.CatalogEntry{}, byFp: map[string]catalog.CatalogEntry{}, + calls: map[string]int{}} for _, f := range followed { p.own(f.Read) } if err := cmd.Start(); err != nil { t.Fatal(err) } - t.Cleanup(func() { _ = stdin.Close(); cancel(); _ = cmd.Wait() }) + p.stop = func() { _ = stdin.Close(); cancel(); _ = cmd.Wait() } + t.Cleanup(p.stop) go p.serve(stdout) t.Cleanup(cancel) return p @@ -785,6 +798,7 @@ func TestConfigWholeRenamesAndRetiresAgainstTheBus(t *testing.T) { // The module restarted inside the window keeps it, and says renamed no more. said := p.publishedCount(EventRenamed) + p.stop() p2 := start(t, bin, js, router, haves, nil) p2.viewsReady() if _, err := p2.call(ResyncTool, nil); err != nil { -- 2.54.0 From cd3ef2fd41e3b4c66d1aa5ffa68ceedbe7aa13cb Mon Sep 17 00:00:00 2001 From: jochen Date: Thu, 19 Nov 2026 22:42:28 +0100 Subject: [PATCH 2/6] =?UTF-8?q?mesh-config:=20remove=20the=20pull=20reques?= =?UTF-8?q?t=20path=20(issue=201982;=20ADR=200681=20=C2=A71,=20=C2=A73,=20?= =?UTF-8?q?=C2=A75,=20=C2=A76)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The mesh knows no pull request (design 47 G, G-1 §38-39). Removed: - the states `pulls` and `kept` and all code that reads or writes them (pulls.go, the held values a proposal holds, the listing of held values), SweepPulls, settlePull, HeardPull and the forge call; - the consumes of git.pull-merged and git.pull-closed, the invoke of seat:git.pull; - the config verb's `pull`, `head`, `declares` and `pulls` arguments and its actions `pull-declares` and `held`; - the indexer's config candidates, which only that path used: the consume of mesh-delivery-indexer.views.config-candidates and the invoke of indexer_read_config_candidates (the indexer's state goes in the same group). A stored proposal that names a pull request is judged not one this module makes, so nothing is set on it. Builds: ADR 0681 §1 (no pulls or kept, no git events, no seat:git.pull, no `pull` argument, no pull-declares or held), §3, §5, §6; lead answer A-490l (a stored proposal naming a pull request is refused on its approval). Claude-Session: https://claude.ai/code/session_01JG73KHUnBze48rdua8u2sy --- modules/mesh-config/README.md | 5 +- modules/mesh-config/cmd/mesh-config/config.go | 24 +- .../mesh-config/cmd/mesh-config/delivery.go | 34 + modules/mesh-config/cmd/mesh-config/list.go | 6 - modules/mesh-config/cmd/mesh-config/main.go | 71 +- .../cmd/mesh-config/manifest_test.go | 6 +- .../mesh-config/cmd/mesh-config/ownerviews.go | 8 +- .../mesh-config/cmd/mesh-config/ownstates.go | 5 +- .../mesh-config/cmd/mesh-config/proposals.go | 88 +-- .../cmd/mesh-config/pullforge_test.go | 54 -- modules/mesh-config/cmd/mesh-config/pulls.go | 644 ------------------ .../mesh-config/cmd/mesh-config/pulls_test.go | 504 -------------- .../cmd/mesh-config/quiet_integration_test.go | 11 +- .../mesh-config/cmd/mesh-config/quiet_test.go | 39 +- .../mesh-config/cmd/mesh-config/resolve.go | 4 - .../mesh-config/cmd/mesh-config/sources.go | 12 +- .../mesh-config/cmd/mesh-config/takeover.go | 90 +-- .../cmd/mesh-config/takeover_test.go | 26 +- .../cmd/mesh-config/whole_integration_test.go | 5 +- modules/mesh-config/module.json | 7 - 20 files changed, 113 insertions(+), 1530 deletions(-) delete mode 100644 modules/mesh-config/cmd/mesh-config/pullforge_test.go delete mode 100644 modules/mesh-config/cmd/mesh-config/pulls.go delete mode 100644 modules/mesh-config/cmd/mesh-config/pulls_test.go diff --git a/modules/mesh-config/README.md b/modules/mesh-config/README.md index df2bc093a..5e5e3dd22 100644 --- a/modules/mesh-config/README.md +++ b/modules/mesh-config/README.md @@ -87,8 +87,9 @@ Each directory or archive this module declares says how it treats a file it did - `mesh-config_declared`: each placed module's declarations at the trunk, with the manifest and commit they come from, written only when they differ. - Its own sources hold always (novox/hq ADR 0590): declarations from the modules' own manifests, the list from the - indexer's `predefined`, pull requests' config from the indexer's `config-candidates`. The controller's - `pull-declares`, the take-over, compare and hand-back went with the controller. `config_declared` and + indexer's `predefined`. The controller's `pull-declares`, the take-over, compare and hand-back went with the + controller, and so did every pull request path (`pulls`, `kept`, `held`, a proposal's `pull`): the mesh knows no pull + request (design 47 G, ADR 0502 ended by the operator's word, record pending). `config_declared` and `config_resync` read and write again what it keeps. - A trusted value is set only through propose and the operator's Approve: no controller relay is trusted (issue 1126). - Its sets, clears and warrants are recorded in the hand-act log of the seat `mesh-hand-acts` alone. diff --git a/modules/mesh-config/cmd/mesh-config/config.go b/modules/mesh-config/cmd/mesh-config/config.go index e50109780..84542fd7a 100644 --- a/modules/mesh-config/cmd/mesh-config/config.go +++ b/modules/mesh-config/cmd/mesh-config/config.go @@ -73,10 +73,6 @@ type Change struct { Approved string `json:"approved,omitempty"` At time.Time `json:"at"` Moved []Moved `json:"moved"` - // Pull and Head name the pull request a value is held for, dropped from, or applied from at its merge (novox/hq - // ADR 0502): the actions hold and drop are always about one, and a set with a pull is its merge. - Pull string `json:"pull,omitempty"` - Head string `json:"head,omitempty"` } // Config is the module: its store, its clock, and one lock, so a set and a resolution never interleave. @@ -94,8 +90,6 @@ type Config struct { // Asks is the operator channel as this module asks on it (proposals.go); nil, nothing can be proposed. Asks AskBus - // Forge is the forge as pulls are asked of it (pulls.go); nil, a merge or a close is heard from its events alone. - Forge PullForge // Delivery is what the delivery parts answer (renames.go, retiring.go); nil, no window closes and nothing retires. Delivery Delivery // Catalog is the catalog half: which modules exist and the manifest each entry carries, and the entry of a build's @@ -130,13 +124,6 @@ type Call struct { // Clear asks a proposal to clear the value instead of setting it; Proposal names one proposal to read. Clear bool Proposal string - // Pull names the open pull request that introduces the key, for propose (a held value) and pull-declares; Head is - // the commit its declarations are read at; Declares the config declarations the head adds or changes, by module; - // Pulls the pull requests held asks about, each at a head. - Pull string - Head string - Declares map[string]any - Pulls []PullAt // approval is the operator's warrant a set or a clear is made on: given by a decided proposal alone, never by // a call's arguments. @@ -177,13 +164,8 @@ func (c *Config) Do(call Call) (any, error) { return c.Propose(call) case "proposals": return c.Proposals(call) - case "pull-declares": - return c.PullDeclares(call) - case "held": - return c.Held(call) } - return nil, fmt.Errorf("config does set, clear, list, history, propose, proposals, pull-declares or held; %q is "+ - "none of them", call.Action) + return nil, fmt.Errorf("config does set, clear, list, history, propose or proposals; %q is none of them", call.Action) } // level is the level a call names, refused as ADR 0348 §3 says: a module's own value is for one node. @@ -211,10 +193,6 @@ func (c *Config) Change(call Call) (*SetAnswer, error) { if call.Clear || call.Proposal != "" { return nil, fmt.Errorf("clear and proposal are a proposal's: %s takes neither", call.Action) } - if call.Pull != "" { - return nil, fmt.Errorf("pull names the pull request a value is held for, which only a proposal does: %s takes "+ - "none", call.Action) - } call.approval = nil // only a decided proposal gives one c.mu.Lock() defer c.mu.Unlock() diff --git a/modules/mesh-config/cmd/mesh-config/delivery.go b/modules/mesh-config/cmd/mesh-config/delivery.go index 2ab1babe1..8490cad49 100644 --- a/modules/mesh-config/cmd/mesh-config/delivery.go +++ b/modules/mesh-config/cmd/mesh-config/delivery.go @@ -131,3 +131,37 @@ func (v toolVault) Retire(r RetireRequest) error { _, err = v.ask(VaultRetireAsk, map[string]any{"node": r.Node, "module": r.Module, "name": r.Name, "warrant": rec.Act.ID, "ask": r.Ask}) return err } + +// unwrapAnswer reads a tool's answer whatever wraps it: the protocol's content list, or {output, ok, answer}. +func unwrapAnswer(raw json.RawMessage) (json.RawMessage, string, bool) { + var s string + if json.Unmarshal(raw, &s) == nil { + return unwrapAnswer(json.RawMessage(s)) + } + var m map[string]json.RawMessage + if json.Unmarshal(raw, &m) != nil { + return raw, string(raw), true + } + if content, has := m["content"]; has { + var items []struct { + Text string `json:"text"` + } + var e struct { + IsError bool `json:"isError"` + } + _ = json.Unmarshal(raw, &e) + if json.Unmarshal(content, &items) == nil && len(items) > 0 { + inner, out, ok := unwrapAnswer(json.RawMessage(items[0].Text)) + return inner, out, ok && !e.IsError + } + } + var v struct { + Output string `json:"output"` + OK *bool `json:"ok"` + Answer json.RawMessage `json:"answer"` + } + if json.Unmarshal(raw, &v) == nil && v.OK != nil { + return v.Answer, v.Output, *v.OK + } + return raw, string(raw), true +} diff --git a/modules/mesh-config/cmd/mesh-config/list.go b/modules/mesh-config/cmd/mesh-config/list.go index 099bafaf9..4aa8912c4 100644 --- a/modules/mesh-config/cmd/mesh-config/list.go +++ b/modules/mesh-config/cmd/mesh-config/list.go @@ -19,8 +19,6 @@ type Listed struct { Withheld string `json:"withheld,omitempty"` // Unresolved is each placed module the call narrows to whose declarations cannot be read, with why (issue 1953). Unresolved []Unresolved `json:"unresolved,omitempty"` - // Held is the approved values held for open pull requests, not yet set (novox/hq ADR 0502). - Held []HeldValue `json:"held,omitempty"` } // SetValue is one value set, at its level. @@ -95,10 +93,6 @@ func (c *Config) List(call Call) (*Listed, error) { if call.Module == "" { out.Predefined = s.Predefined } - out.Held = heldListed(s, call) - if len(out.Held) == 0 { - out.Held = nil - } return out, nil } diff --git a/modules/mesh-config/cmd/mesh-config/main.go b/modules/mesh-config/cmd/mesh-config/main.go index b0d927dd8..3c05a9130 100644 --- a/modules/mesh-config/cmd/mesh-config/main.go +++ b/modules/mesh-config/cmd/mesh-config/main.go @@ -144,7 +144,7 @@ func main() { } } } - c := &Config{Store: runtimeStore{own: own}, Logf: logf, Asks: runtimeAsks{}, Forge: toolForge{ask: stdio.Ask}, + c := &Config{Store: runtimeStore{own: own}, Logf: logf, Asks: runtimeAsks{}, Delivery: toolDelivery{ask: stdio.Ask}, Vault: toolVault{ask: stdio.Ask, recorder: recorder}} // The module's one held writer (design 47 G §689, A-16, A-29, A-32): the renames' and retirements' findings and the views reader's go through it. w, err := views.NewStdioHeldWriter(views.WriterConfig[meshconditions.Finding, meshconditions.FindingCleared, meshconditions.FindingsStated, meshconditions.FindingsAskedEvent]{ @@ -214,15 +214,10 @@ func main() { } // resolving resolves at start and again whenever a source moves: an assignment, a want, a catalog revision, an entry -// answered, the predefined list or a config candidate (each reaches `moved` through its view, ownerviews.go and main). It -// reads the forge once for each pull request it keeps something for, so a merge or a close said while this module was down is -// found (ADR 0502); after that it is heard on git.pull-merged and git.pull-closed (hearing), never asked again on a timer +// answered or the predefined list (each reaches `moved` through its view, ownerviews.go and main), and never on a timer // (novox/hq principle 1, issue 1982). The runtime answers only once Serve runs. func resolving(c *Config, moved chan struct{}) { <-stdio.Served() - for _, s := range c.SweepPulls() { - logf("[mesh-config] %s", s) - } for { r, err := c.Reconcile() switch { @@ -249,8 +244,7 @@ func resolving(c *Config, moved chan struct{}) { } } -// hearing takes the router's word on this module's asks, asked again until the runtime takes the subscription, and the -// forge's word on a pull request's merge or close. +// hearing takes the router's word on this module's asks, asked again until the runtime takes the subscription. func hearing(c *Config) { go func() { <-stdio.Served() // subscribed as soon as the runtime serves, never after a guessed wait: an event sent meanwhile is heard @@ -272,29 +266,6 @@ func hearing(c *Config) { time.Sleep(wait) } }() - for _, pattern := range []string{"git.pull-merged", "git.pull-closed"} { - go func(pattern string) { - <-stdio.Served() // subscribed as soon as the runtime serves, never after a guessed wait: an event sent meanwhile is heard - for wait := 2 * time.Second; ; wait = min(wait*2, time.Minute) { - err := stdio.Subscribe(pattern, func(e stdio.Envelope) error { - p, ok := pullEventOf(e.Body) - if !ok { - logf("[mesh-config] %s is not readable", pattern) - return nil - } - for _, s := range c.HeardPull(p, pattern == "git.pull-merged") { - logf("[mesh-config] %s", s) - } - return nil - }) - if err == nil { - return - } - logf("[mesh-config] does not hear %s yet (%v); asking again in %s", pattern, err, wait) - time.Sleep(wait) - } - }(pattern) - } } // deciding reads the router's record of every waiting ask once at start, which finds an answer said while this module was @@ -422,13 +393,10 @@ func Tools(c *Config) []stdio.Tool { "who and why. A trusted value is set only on the operator's Approve: " + "propose asks the operator, under mesh-config's own name on a channel that proves who answered, and sets " + "the value on Approve if what it was shown against still stands; proposals lists them, or one with " + - "proposal. A proposal naming the open pull request that introduces its key (pull) is judged against what " + - "that pull request declares and asked of the operator, and on Approve is held until the pull request " + - "merges, then set; list shows the held values. pull-declares and held are the controller's. list and " + - "history are narrowed by module, node and key.", + "proposal. list and history are narrowed by module, node and key.", Input: map[string]any{"type": "object", "properties": map[string]any{ "action": map[string]any{"type": "string", - "enum": []string{"list", "set", "clear", "history", "propose", "proposals", "pull-declares", "held"}, + "enum": []string{"list", "set", "clear", "history", "propose", "proposals"}, "description": "list when not given"}, "key": map[string]any{"type": "string", "description": "the config key"}, "value": map[string]any{"description": "for set: the value, of the key's declared type"}, @@ -441,14 +409,6 @@ func Tools(c *Config) []stdio.Tool { "clear": map[string]any{"type": "boolean", "description": "for propose: propose clearing the value at its level instead of setting one"}, "proposal": map[string]any{"type": "string", "description": "for proposals: one proposal's id, read whole"}, - "pull": map[string]any{"type": "string", "description": "owner/repository#number: for propose, the open " + - "pull request that introduces the key, so the value is judged against what it declares and held until " + - "it merges (a module's own value on one node); for pull-declares, the pull request declared for"}, - "head": map[string]any{"type": "string", "description": "for pull-declares: the commit the declarations are read at"}, - "declares": map[string]any{"type": "object", "description": "for pull-declares (the controller's): the " + - "config declarations the head adds or changes against its base, by module and key"}, - "pulls": map[string]any{"type": "array", "description": "for held (the controller's): the pull requests " + - "asked about, each {pull, head}", "items": map[string]any{"type": "object"}}, }}, Run: func(args map[string]any) (any, error) { call, err := callOf(args) @@ -464,8 +424,7 @@ func Tools(c *Config) []stdio.Tool { // callOf reads a call's arguments strictly: an argument it does not know is refused, not ignored. func callOf(args map[string]any) (Call, error) { known := map[string]bool{"action": true, "key": true, "value": true, "module": true, "node": true, "why": true, - "by": true, "limit": true, "clear": true, "proposal": true, "pull": true, "head": true, "declares": true, - "pulls": true} + "by": true, "limit": true, "clear": true, "proposal": true} var unknown []string for k := range args { if !known[k] { @@ -474,7 +433,7 @@ func callOf(args map[string]any) (Call, error) { } if len(unknown) > 0 { return Call{}, fmt.Errorf("config takes no %s; it takes action, key, value, module, node, why, by, limit, "+ - "clear, proposal, pull, head, declares and pulls", + "clear and proposal", strings.Join(unknown, ", ")) } str := func(k string) (string, error) { @@ -491,8 +450,7 @@ func callOf(args map[string]any) (Call, error) { var call Call var problems []error for k, into := range map[string]*string{"action": &call.Action, "key": &call.Key, "module": &call.Module, - "node": &call.Node, "why": &call.Why, "by": &call.By, "proposal": &call.Proposal, "pull": &call.Pull, - "head": &call.Head} { + "node": &call.Node, "why": &call.Why, "by": &call.By, "proposal": &call.Proposal} { s, err := str(k) problems = append(problems, err) *into = s @@ -511,19 +469,6 @@ func callOf(args map[string]any) (Call, error) { } call.Clear = b } - if v, ok := args["declares"]; ok && v != nil { - m, ok := v.(map[string]any) - if !ok { - problems = append(problems, errors.New("declares is an object: a module to its keys' declarations")) - } - call.Declares = m - } - if v, ok := args["pulls"]; ok && v != nil { - raw, _ := json.Marshal(v) - if err := json.Unmarshal(raw, &call.Pulls); err != nil { - problems = append(problems, errors.New("pulls is a list of {pull, head}")) - } - } if v, ok := args["value"]; ok { // The value as given, a JSON value: a number for a number, never its text; the validation judges it. call.Value = v diff --git a/modules/mesh-config/cmd/mesh-config/manifest_test.go b/modules/mesh-config/cmd/mesh-config/manifest_test.go index e561cba26..f2dc32240 100644 --- a/modules/mesh-config/cmd/mesh-config/manifest_test.go +++ b/modules/mesh-config/cmd/mesh-config/manifest_test.go @@ -50,10 +50,10 @@ func TestEveryStateAndActHasItsTool(t *testing.T) { } via := map[string]string{ ValuesState: "config list", ResolvedState: "config list", PredefinedState: "config list", - ProposalsState: "config proposals", PullsState: "config list", KeptState: "config list", HistoryLog: "config history", + ProposalsState: "config proposals", HistoryLog: "config history", DeclaredState: DeclaredTool, - AssignmentsRead: "config list", WantsRead: "config list", IndexerPredefinedRead: "config list", CandidatesRead: ResyncTool, - "a resolution": ResyncTool, "the indexer's candidates taken": ResyncTool, + AssignmentsRead: "config list", WantsRead: "config list", IndexerPredefinedRead: "config list", + "a resolution": ResyncTool, // design 32: each new state with the tool that reads it, each act with the tool that starts it. RenamesState: RenamesTool, RetiringState: RetiringTool, FindingsState: "config_renames and config_retiring", "a move refused": RenameAgainTool, "a window dropped": RenameCloseTool, "an ask again": RetiringTool, diff --git a/modules/mesh-config/cmd/mesh-config/ownerviews.go b/modules/mesh-config/cmd/mesh-config/ownerviews.go index a677a0e8c..8ff66ee26 100644 --- a/modules/mesh-config/cmd/mesh-config/ownerviews.go +++ b/modules/mesh-config/cmd/mesh-config/ownerviews.go @@ -1,8 +1,8 @@ package main // What mesh-config reads of the delivery owners' state, through their tools and views families (novox/hq ADR 0615 §1, -// §4 to §6, ADR 0596): never a bucket of theirs. For each of the four states it follows (the indexer's predefined and -// config-candidates, the assigner's assignments and wants) it asks the owner's read tool for the whole +// §4 to §6, ADR 0596): never a bucket of theirs. For each of the three states it follows (the indexer's predefined, the +// assigner's assignments and wants) it asks the owner's read tool for the whole // state at its start, keeps the picture from the owner's `views.` events, and asks again only on a gap. Started // while an owner is down it keeps asking, and past two minutes writes a finding naming the owner and the tool. // @@ -28,7 +28,6 @@ import ( // The tools of the owners that mesh-config asks, by the state they read. const ( IndexerPredefTool = "indexer_read_predefined" - IndexerCandidatesTool = "indexer_read_config_candidates" AssignerAssignmentsTool = "assigner_read_assignments" AssignerWantsTool = "assigner_read_wants" @@ -40,7 +39,6 @@ const ( // state and its tool. var followed = []struct{ Read, Owner, State, Tool string }{ {IndexerPredefinedRead, indexerModule, catalog.StatePredefined, IndexerPredefTool}, - {CandidatesRead, indexerModule, catalog.StateConfigCandidates, IndexerCandidatesTool}, {AssignmentsRead, assignerModule, "assignments", AssignerAssignmentsTool}, {WantsRead, assignerModule, "wants", AssignerWantsTool}, } @@ -189,7 +187,7 @@ func viewTools(c *Config, o func() *ownerViews) []stdio.Tool { return []stdio.Tool{ {Name: FirstViewsTool, Description: "mesh-config's first views of the delivery owners' state: for each of the indexer's " + - "predefined and config-candidates, the assigner's assignments and wants and the catalog half's registrations and " + + "predefined, the assigner's assignments and wants and the catalog half's registrations and " + "each watched branch's revision, the tool it asks, the revision its " + "picture holds, when it asked and was answered, how many asks (and by hand), and whether its condition is raised.", Run: func(map[string]any) (any, error) { diff --git a/modules/mesh-config/cmd/mesh-config/ownstates.go b/modules/mesh-config/cmd/mesh-config/ownstates.go index 642976427..b27778d50 100644 --- a/modules/mesh-config/cmd/mesh-config/ownstates.go +++ b/modules/mesh-config/cmd/mesh-config/ownstates.go @@ -7,7 +7,7 @@ import ( ) // The module's own states are read from a copy each one's watch keeps, never key by key (novox/hq ADR 0580 §1, issue 1982): -// a resolution reads every key of values, resolved, pulls, declared and the rest, and a get per key for each of them, once per +// a resolution reads every key of values, resolved, declared and the rest, and a get per key for each of them, once per // pass and once per delivery event, was about 4,000 requests to the bus every time. A state is watched on its first read, the // watch hands every current value over before the read is answered, and this process's own writes are taken into the copy // as they are made, so a read right after a write sees it. @@ -15,8 +15,7 @@ import ( // ownStates are the states this module keeps and reads through its store (its manifest's `state`, but the findings, which its // held writer alone reads and writes): the ones read from the copy. var ownStates = map[string]bool{ - ValuesState: true, ResolvedState: true, PredefinedState: true, ProposalsState: true, PullsState: true, KeptState: true, - DeclaredState: true, RenamesState: true, RetiringState: true, + ValuesState: true, ResolvedState: true, PredefinedState: true, ProposalsState: true, DeclaredState: true, RenamesState: true, RetiringState: true, } // ownCopy is the copy of the module's own states over a bus: watch hands every current value of a state and then each change, diff --git a/modules/mesh-config/cmd/mesh-config/proposals.go b/modules/mesh-config/cmd/mesh-config/proposals.go index 358f636e8..33895c2f8 100644 --- a/modules/mesh-config/cmd/mesh-config/proposals.go +++ b/modules/mesh-config/cmd/mesh-config/proposals.go @@ -98,11 +98,9 @@ type Proposal struct { HadValue bool `json:"had-value"` WasDigest string `json:"was-digest"` Trusted bool `json:"trusted,omitempty"` - // Pull is the open pull request the value is held for, when it is (novox/hq ADR 0502): the value is then not set - // on Approve but kept apart until the pull request merges, and DeclDigest is the digest of the pull request's - // declaration of the key it was judged and shown against. - Pull string `json:"pull,omitempty"` - DeclDigest string `json:"declaration,omitempty"` + // Pull is read only: a proposal an earlier mesh-config kept for a pull request (ADR 0502, ended by the operator's word, + // record pending). It is never set on an Approve now, and judged not to be one this module makes (problem). + Pull string `json:"pull,omitempty"` // Reaches is each module on each node whose value it moves, as it was judged when proposed. Reaches []string `json:"reaches"` // From is who proposed it, as the bus proved the caller; Why is theirs; At is when. @@ -175,9 +173,6 @@ func (p Proposal) Fingerprint() string { // about is what its ask is about: the value's place, so a newer proposal for it replaces an older one still open // (ADR 0277 §10, at a level, a key). func (p Proposal) about() string { - if p.Pull != "" { - return "config.held." + pullKey(p.Pull) + "." + p.Level.ValueKey(p.Key) - } return "config." + p.Level.ValueKey(p.Key) } @@ -188,9 +183,6 @@ func (p Proposal) Act(option string) occ.Act { "level": p.Level.Kind, "node": p.Level.Node, "module": p.Level.Module, "key": p.Key, "value": p.Digest, "was": p.WasDigest, "had-value": strconv.FormatBool(p.HadValue), "from": p.From, "at": p.At.UTC().Format(time.RFC3339Nano)} - if p.Pull != "" { - act["pull"], act["declaration"] = p.Pull, p.DeclDigest - } return act } @@ -270,16 +262,6 @@ func (p Proposal) summary() string { if p.Trusted { trusted = ", a trusted value," } - if p.Pull != "" { - s := fmt.Sprintf("Holds %s for %s on %s for %s; approved, it takes effect when that pull request merges, "+ - "and is dropped if it closes unmerged. Nothing reaches a machine before the merge.", p.Key, p.Level.Module, - p.Level.Node, p.Pull) - if len([]rune(s)) > occ.SummaryLength { - s = fmt.Sprintf("Holds %s for %s on %s for %s until it merges; dropped if it closes unmerged.", p.Key, - p.Level.Module, p.Level.Node, p.Pull) - } - return s - } reach := p.reaches() s := fmt.Sprintf("%s%s at %s; approved, it takes effect at once on every node it reaches: %s.", verb, trusted, p.Level, reach) @@ -305,9 +287,6 @@ func (p Proposal) headline() string { if p.Action == "clear" { verb = "Clear" } - if p.Pull != "" { - verb = "Hold" - } where := "for the whole mesh" switch p.Level.Kind { case LevelNode: @@ -359,9 +338,6 @@ func (p Proposal) Ask() oc.Ask { a.WholeDetails = w } does := "the value is set at once, and every node it reaches takes it" - if p.Pull != "" { - does = "the value is held for " + p.Pull + ": it is set when that pull request merges, and dropped if it closes unmerged" - } if p.Action == "clear" { does = "the value is cleared at once, and every node it reaches takes what is below it" } @@ -392,8 +368,8 @@ func (p Proposal) problem() string { return "its value is not the value its digest names: it changed after it was asked" case p.Action == "clear" && (len(p.Value) != 0 || p.Digest != valueDigest(nil, false)): return "a clear carries no value" - case p.Pull != "" && (p.Action != "set" || p.Level.Kind != LevelModule || p.DeclDigest == ""): - return "a value held for a pull request is a set of a module's own value, judged against its declaration" + case p.Pull != "": + return "it was held for a pull request, which the mesh knows no more: nothing is set on it" case valueDigest(p.Was, p.HadValue) != p.WasDigest: return "the value it was shown against is not the one its digest names: it changed after it was asked" } @@ -559,39 +535,16 @@ func (c *Config) propose(call Call, action string) (Proposal, oc.Ask, []string, // **Judged as a set judges it, before anyone is asked** (ADR 0277 §4): no ask for a value the verb would refuse. var r rule var trusted bool - var declDigest string vk := level.ValueKey(call.Key) was, had := s.Values[vk] - if call.Pull != "" { - // **A value held for the open pull request that introduces its key** (novox/hq ADR 0502): judged against what - // the pull request declares at its head, as the controller told it, and asked of the operator whatever the - // key's trust. - if action != "set" { - return fail("a clear is not held for a pull request: only a value to set is") - } - if _, _, _, err := parsePull(call.Pull); err != nil { - return fail("%v", err) - } - call.Pull = strings.TrimSpace(call.Pull) - var herr error - r, _, declDigest, herr = heldRule(s, call, level) - if herr != nil { - return fail("%v", herr) - } - trusted = false - k, kept := s.Kept[keptKey(call.Pull, level.Node, level.Module, call.Key)] - was, had = Value{Value: heldValue(k)}, kept - } else { - var derr error - r, trusted, derr = c.declared(s, level, call.Key) - if derr != nil { - return fail("%v", derr) - } + r, trusted, derr := c.declared(s, level, call.Key) + if derr != nil { + return fail("%v", derr) } now := c.now() prop := Proposal{ID: newProposalID(), Action: action, Level: level, Key: call.Key, HadValue: had, WasDigest: valueDigest(was.Value, had), Trusted: trusted, From: call.Caller, Why: why, At: now, - State: ProposalWaiting, Digest: valueDigest(nil, false), Pull: call.Pull, DeclDigest: declDigest} + State: ProposalWaiting, Digest: valueDigest(nil, false)} if had { prop.Was = compact(was.Value) } @@ -618,19 +571,15 @@ func (c *Config) propose(call Call, action string) (Proposal, oc.Ask, []string, if had && string(compact(was.Value)) == string(prop.Value) { return fail("%s at %s already holds exactly %s", call.Key, level, prop.Value) } - if call.Pull == "" { - after.Values[vk] = Value{Value: prop.Value} - } + after.Values[vk] = Value{Value: prop.Value} case "clear": if !had { return fail("nothing is set for %s at %s, so there is nothing to clear", call.Key, level) } delete(after.Values, vk) } - if call.Pull == "" { - for _, m := range diff(Resolve(s), Resolve(after)) { - prop.Reaches = append(prop.Reaches, m.Module+" on "+m.Node) - } + for _, m := range diff(Resolve(s), Resolve(after)) { + prop.Reaches = append(prop.Reaches, m.Module+" on "+m.Node) } if prop.Reaches == nil { prop.Reaches = []string{} @@ -830,14 +779,6 @@ func (c *Config) decide(p Proposal, w oc.Warrant) string { return fmt.Sprintf("proposal %s: approved by the operator, and not set: the decision could not be kept (%v); "+ "it is read again on the next look", p.ID, err) } - if p.Pull != "" { - // **A held value is kept apart, never set on Approve** (ADR 0502 clause 3). - said, err := c.keep(p) - if err != nil { - return keep(ProposalRefused, "approved by the operator, and refused on Approve, so nothing is held: "+err.Error()) - } - return keep(ProposalApproved, "approved by the operator and held: "+said) - } call := Call{Action: p.Action, Key: p.Key, Module: p.Level.Module, Node: p.Level.Node, Why: p.Why, Caller: p.From, approval: &approval{Proposal: p.ID, By: "the operator", Says: p.Approved, Was: p.Was, HadValue: p.HadValue, WasDigest: p.WasDigest}} @@ -972,8 +913,6 @@ type ProposalRow struct { Expires time.Time `json:"expires"` Fingerprint string `json:"fingerprint"` Approved string `json:"approved,omitempty"` - // Pull is the pull request a value is held for, when it is. - Pull string `json:"pull,omitempty"` // What one proposal read whole says besides. Value json.RawMessage `json:"value,omitempty"` Was json.RawMessage `json:"was,omitempty"` @@ -1002,8 +941,7 @@ func (c *Config) Proposals(call Call) ([]ProposalRow, error) { continue } row := ProposalRow{ID: p.ID, Action: p.Action, Level: p.Level, Key: p.Key, State: p.State, Outcome: p.Outcome, - From: p.From, At: p.At, Expires: p.At.Add(ProposalLasts), Fingerprint: p.Fingerprint(), Approved: p.Approved, - Pull: p.Pull} + From: p.From, At: p.At, Expires: p.At.Add(ProposalLasts), Fingerprint: p.Fingerprint(), Approved: p.Approved} if p.State == ProposalWaiting && c.now().After(row.Expires) { row.State = "expired, not yet heard" } diff --git a/modules/mesh-config/cmd/mesh-config/pullforge_test.go b/modules/mesh-config/cmd/mesh-config/pullforge_test.go deleted file mode 100644 index e2418e65c..000000000 --- a/modules/mesh-config/cmd/mesh-config/pullforge_test.go +++ /dev/null @@ -1,54 +0,0 @@ -package main - -import ( - "encoding/json" - "testing" -) - -// toolForge.Pull reads the seat git's answer of the verb pull (design 47 G §654), bare or in the wrappings the runtime puts -// around an answer; pullEventOf reads the seat's pull-merged and pull-closed bodies. -func TestToolForgePullReadsTheSeatGitAnswersAndEventsAreRead(t *testing.T) { - var asked struct { - key string - body map[string]any - } - for _, tc := range []struct { - answer string - open, merged bool - head string - }{ - {`{"pull":{"repository":"novox/mesh-catalog","number":435,"state":"merged","head":"7b5f7f84acb73aaf8189200548ff69fd9aac04b2"}}`, false, true, "7b5f7f84acb73aaf8189200548ff69fd9aac04b2"}, - {`{"pull":{"repository":"novox/mesh-catalog","number":434,"state":"open","head":"c948f3a61c74257e6e3147effb396d9d6434f491"}}`, true, false, "c948f3a61c74257e6e3147effb396d9d6434f491"}, - {`{"pull":{"state":"closed","head":"c948f3a61c74257e6e3147effb396d9d6434f491"}}`, false, false, "c948f3a61c74257e6e3147effb396d9d6434f491"}, - } { - raw := json.RawMessage(tc.answer) - content, _ := json.Marshal(map[string]any{"content": []map[string]any{{"type": "text", "text": tc.answer}}}) - ok, _ := json.Marshal(map[string]any{"ok": true, "output": "", "answer": raw}) - for name, answer := range map[string]json.RawMessage{"bare": raw, "content list": content, "ok answer": ok} { - f := toolForge{ask: func(key string, body any) (json.RawMessage, error) { - asked.key, asked.body = key, body.(map[string]any) - return answer, nil - }} - open, merged, head, err := f.Pull("novox", "mesh-catalog", 434) - if err != nil || open != tc.open || merged != tc.merged || head != tc.head { - t.Errorf("%s (%s): open %v merged %v head %q, err %v", tc.answer, name, open, merged, head, err) - } - if asked.key != "seat:git.pull" || asked.body["repository"] != "novox/mesh-catalog" || asked.body["number"] != 434 { - t.Errorf("asked %+v", asked) - } - } - } - failed := toolForge{ask: func(string, any) (json.RawMessage, error) { - return json.RawMessage(`{"error":"no such pull request","error-kind":"not-found"}`), nil - }} - if _, _, _, err := failed.Pull("novox", "mesh-catalog", 9); err == nil { - t.Error("an error answer was read as a pull request") - } - p, ok := pullEventOf([]byte(`{"repository":"novox/mesh-catalog","number":435,"branch":"fix/a","head":"7b5f7f84acb73aaf8189200548ff69fd9aac04b2","base":"main"}`)) - if !ok || p.Owner != "novox" || p.Repo != "mesh-catalog" || p.Number != 435 || p.HeadSHA != "7b5f7f84acb73aaf8189200548ff69fd9aac04b2" { - t.Errorf("%+v %v", p, ok) - } - if _, ok := pullEventOf([]byte(`{"repository":"norepo","number":1}`)); ok { - t.Error("a repository with no owner was read") - } -} diff --git a/modules/mesh-config/cmd/mesh-config/pulls.go b/modules/mesh-config/cmd/mesh-config/pulls.go deleted file mode 100644 index 3508a95bf..000000000 --- a/modules/mesh-config/cmd/mesh-config/pulls.go +++ /dev/null @@ -1,644 +0,0 @@ -package main - -import ( - "crypto/sha256" - "encoding/hex" - "encoding/json" - "errors" - "fmt" - "regexp" - "strconv" - "strings" - "time" - - "git.novox.be/novox/mesh-contracts/go/clients/meshconfigclient" -) - -// A config value held for the open pull request that introduces its key (novox/hq ADR 0502, issue 1826). -// -// A key a pull request adds is declared by no registered manifest until it merges, so a value for it, which the -// pull request's composed check needs, was refused. The controller reads each pull request's manifests from the -// forge at its head and tells this module the config declarations the head adds or changes (PullDeclares); mesh-config -// reads no manifest itself (ADR 0495 §1). A proposal that names the pull request is judged against those, asked of the -// operator whatever the key's trust, and on Approve kept apart (KeptState) from the values it resolves. The -// controller asks for the approved held values of a check's pull requests (Held) and hands them to the composed -// check. At the merge the value is written as the module's own value on its node (PullMerged), where it resolves -// once the trunk declares the key; a pull request closed unmerged drops it (PullClosed). Nothing reaches a machine -// before the merge. - -// The states of held values, and the actions their changes carry in the history and in `config-changed`. -const ( - PullsState = "pulls" - KeptState = "kept" - - ActionHold = "hold" - ActionDrop = "drop" -) - -// pullName is a pull request as it is named: owner/repository#number. -var pullName = regexp.MustCompile(`^([A-Za-z0-9_.-]+)/([A-Za-z0-9_.-]+)#([0-9]+)$`) - -func parsePull(s string) (owner, repo string, number int, err error) { - m := pullName.FindStringSubmatch(strings.TrimSpace(s)) - if m == nil { - return "", "", 0, fmt.Errorf("%q is not a pull request: name it owner/repository#number", s) - } - n, _ := strconv.Atoi(m[3]) - if n <= 0 { - return "", "", 0, fmt.Errorf("%q is not a pull request: its number is above zero", s) - } - return m[1], m[2], n, nil -} - -// pullKey is a pull request's key in the states. -func pullKey(pull string) string { - return strings.NewReplacer("/", ".", "#", ".").Replace(strings.TrimSpace(pull)) -} - -// PullDecl is what the controller told: the config declarations a pull request's head adds or changes, by module. -type PullDecl struct { - Pull string `json:"pull"` - Head string `json:"head"` - Declares map[string]map[string]Declaration `json:"declares"` - At time.Time `json:"at"` -} - -// KeptValue is an approved held value, kept apart from the values mesh-config resolves, in the layout of the seat's state -// `kept`, which the checker and the assigner's composition check read (novox/hq ADR 0565 §5, ADR 0634 §4). -type KeptValue = meshconfigclient.Kept - -// keptKey is a held value's key in `kept`: the pull request's key form (pullKey), the node, the module and the config -// key, joined by dots. -func keptKey(pull, node, module, key string) string { - k, _ := meshconfigclient.HeldValueKey(pull, node, module, key) // a held value of no pull request has no key, and is found by none - return k -} - -// heldValue is the value held, as the operator approved it, in its JSON form. -func heldValue(k KeptValue) json.RawMessage { - raw, _ := meshconfigclient.ValueOf(k) // a value that was read from JSON writes as JSON - return raw -} - -func heldAt(t time.Time) *time.Time { return &t } - -func keptStateKey(k KeptValue) string { return keptKey(k.Pull, k.Node, k.Module, k.Key) } - -func keptLevel(k KeptValue) Level { return Level{Kind: LevelModule, Node: k.Node, Module: k.Module} } - -// declDigest is the digest of what a declaration holds a value to: a held value stays only while it is the same. -func declDigest(d Declaration) string { - d.Description, d.Why, d.Kind, d.Runtime = "", "", "", false - if !d.HasDefault() { - d.Default = nil - } else { - d.Default = compact(d.Default) - } - raw, _ := json.Marshal(d) - sum := sha256.Sum256(raw) - return "sha256:" + hex.EncodeToString(sum[:]) -} - -// PullForge is the forge as this module asks it of a pull request: its state, and whether it merged. -type PullForge interface { - Pull(owner, repo string, number int) (open, merged bool, head string, err error) -} - -// pulls reads what is kept for pull requests, and the held values. -func (c *Config) readPulls(s *Sources) error { - s.Pulls, s.Kept = map[string]PullDecl{}, map[string]KeptValue{} - if err := c.each(PullsState, func(key string, raw []byte) error { - var p PullDecl - if err := json.Unmarshal(raw, &p); err != nil || p.Pull == "" { - return nil // not one this module wrote - } - s.Pulls[pullKey(p.Pull)] = p - return nil - }); err != nil { - return fmt.Errorf("the pull requests' declarations cannot be read: %w", err) - } - if err := c.each(KeptState, func(key string, raw []byte) error { - k, err := meshconfigclient.DecodeKept(key, raw) - if err != nil { - return nil // not a held value of the seat's layout under its own key - } - s.Kept[key] = k - return nil - }); err != nil { - return fmt.Errorf("the held values cannot be read: %w", err) - } - return nil -} - -// ---- pull-declares --------------------------------------------------------------------------------------- - -// PullDeclaresAnswer is what pull-declares answers. -type PullDeclaresAnswer struct { - Said string `json:"said"` - Pull string `json:"pull"` - Head string `json:"head"` - Modules []string `json:"modules"` - Dropped []string `json:"dropped,omitempty"` - Unsaid []string `json:"unsaid,omitempty"` -} - -// PullDeclares is gone: a pull request's config declarations are read from the indexer's config-candidates -// (takeCandidates), and the controller that told them is not placed (novox/hq ADR 0565 §4, ADR 0590). -func (c *Config) PullDeclares(Call) (*PullDeclaresAnswer, error) { - return nil, errors.New("pull-declares is gone: mesh-config reads a pull request's config declarations from the " + - "indexer's config-candidates (novox/hq ADR 0565 §4, ADR 0590)") -} - -// declarePull keeps what a pull request's head declares and judges again the values held for it, from the indexer's -// config candidates. The caller holds the lock. -func (c *Config) declarePull(pull, head string, declares map[string]map[string]Declaration) (*PullDeclaresAnswer, error) { - if err := c.Store.Put(PullsState, pullKey(pull), PullDecl{Pull: pull, Head: head, Declares: declares, - At: c.now()}); err != nil { - return nil, fmt.Errorf("the declarations were not kept: %v", err) - } - a := &PullDeclaresAnswer{Pull: pull, Head: head, Modules: sortedKeys(declares)} - var s Sources - if err := c.readPulls(&s); err != nil { - return nil, err - } - for _, k := range sortedKeys(s.Kept) { - kv := s.Kept[k] - if pullKey(kv.Pull) != pullKey(pull) { - continue - } - why := "" - d, declared := declares[kv.Module][kv.Key] - switch { - case !declared: - why = "the head no longer adds or changes its declaration" - case declDigest(d) != kv.Declaration: - why = "the head declares the key otherwise than the value was approved against" - default: - var v any - _ = json.Unmarshal(heldValue(kv), &v) - if p := d.rule().check(v); len(p) > 0 { - why = "the value no longer passes: " + strings.Join(p, "; ") - } - } - if why != "" { - a.Unsaid = append(a.Unsaid, c.dropKept(kv, "the new head "+short(head)+": "+why)...) - a.Dropped = append(a.Dropped, fmt.Sprintf("%s for %s on %s: %s", kv.Key, kv.Module, kv.Node, why)) - continue - } - if kv.Head != head { - kv.Head = head - if err := c.Store.Put(KeptState, k, kv); err != nil { - a.Unsaid = append(a.Unsaid, "the held value "+k+" was not moved to the new head: "+err.Error()) - } - } - } - a.Said = fmt.Sprintf("keeps what %s declares at %s for %d module(s)", pull, short(head), len(declares)) - if len(a.Dropped) > 0 { - a.Said += fmt.Sprintf("; %d held value(s) dropped", len(a.Dropped)) - } - return a, nil -} - -// heldChange records a hold, a drop or a merge's set of a held value in the history, the hand-act log and -// config-changed; what could not be done is answered, not dropped. -func (c *Config) heldChange(kv KeptValue, action, why, approved string) []string { - level := keptLevel(kv) - ch := Change{Action: action, Level: &level, Key: kv.Key, Value: heldValue(kv), By: kv.By, Via: kv.Via, Why: why, - Approved: approved, Pull: kv.Pull, Head: kv.Head, At: c.now(), Moved: []Moved{}} - unsaid := c.record(level.ValueKey(kv.Key), ch) - cause := "a value held for " + kv.Pull - what := fmt.Sprintf("config %s %s of %s for %s, held for %s", action, kv.Key, kv.Module, kv.Node, kv.Pull) - if action != ActionDrop { - what += " (" + string(heldValue(kv)) + ")" - } - if err := c.Store.HandAct(what, why, cause); err != nil { - unsaid = append(unsaid, "the hand-act log does not hold it: "+err.Error()) - } - return unsaid -} - -// dropKept removes a held value, saying why. -func (c *Config) dropKept(kv KeptValue, why string) []string { - if err := c.Store.Delete(KeptState, keptStateKey(kv)); err != nil { - return []string{"the held value " + keptStateKey(kv) + " was not dropped: " + err.Error()} - } - c.logf("[mesh-config] dropped %s of %s on %s held for %s: %s", kv.Key, kv.Module, kv.Node, kv.Pull, why) - return c.heldChange(kv, ActionDrop, "dropped, nothing was set: "+why, "") -} - -// ---- held ------------------------------------------------------------------------------------------------ - -// HeldAnswer is what held answers: the approved held values of the pull requests asked, at the heads asked. -type HeldAnswer struct { - Held []HeldValue `json:"held"` - Skipped []HeldSkipped `json:"skipped"` -} - -// HeldValue is one approved held value as it is handed to a composed check and listed. -type HeldValue struct { - Pull string `json:"pull"` - Head string `json:"head"` - Node string `json:"node"` - Module string `json:"module"` - Key string `json:"key"` - Value json.RawMessage `json:"value"` - Approved string `json:"approved"` - By string `json:"by,omitempty"` - Why string `json:"why,omitempty"` - At time.Time `json:"at"` -} - -// HeldSkipped is a pull request asked for whose held values are not answered, and why. -type HeldSkipped struct { - Pull string `json:"pull"` - Why string `json:"why"` -} - -func heldValueOf(k KeptValue) HeldValue { - return HeldValue{Pull: k.Pull, Head: k.Head, Node: k.Node, Module: k.Module, Key: k.Key, Value: compact(heldValue(k)), - Approved: k.Approved, By: k.By, Why: k.Why, At: timeOf(k.At)} -} - -// Held answers the approved held values for the pull requests asked, at the heads asked, to the controller alone: a -// pull request at another head than the one kept is skipped and said (ADR 0502 clause 4). -func (c *Config) Held(call Call) (*HeldAnswer, error) { - if call.Caller != ControllerCaller { - return nil, fmt.Errorf("held is the controller's: it hands the held values to a composed check; %s is not "+ - "the controller", call.Caller) - } - asked := map[string]string{} - var order []string - for _, p := range call.Pulls { - if _, _, _, err := parsePull(p.Pull); err != nil { - return nil, err - } - if strings.TrimSpace(p.Head) == "" { - return nil, fmt.Errorf("name the head of %s", p.Pull) - } - if _, dup := asked[pullKey(p.Pull)]; !dup { - order = append(order, strings.TrimSpace(p.Pull)) - } - asked[pullKey(p.Pull)] = strings.TrimSpace(p.Head) - } - c.mu.Lock() - defer c.mu.Unlock() - var s Sources - if err := c.readPulls(&s); err != nil { - return nil, err - } - out := &HeldAnswer{Held: []HeldValue{}, Skipped: []HeldSkipped{}} - for _, p := range order { - head := asked[pullKey(p)] - var mine []KeptValue - for _, k := range sortedKeys(s.Kept) { - if pullKey(s.Kept[k].Pull) == pullKey(p) { - mine = append(mine, s.Kept[k]) - } - } - for _, k := range mine { - if k.Head != head { - out.Skipped = append(out.Skipped, HeldSkipped{Pull: p, Why: fmt.Sprintf("%s for %s on %s is held "+ - "at head %s, not %s", k.Key, k.Module, k.Node, short(k.Head), short(head))}) - continue - } - out.Held = append(out.Held, heldValueOf(k)) - } - } - return out, nil -} - -// HeldListed is the held values a listing shows, narrowed by module, node and key. -func heldListed(s Sources, call Call) []HeldValue { - out := []HeldValue{} - for _, k := range sortedKeys(s.Kept) { - kv := s.Kept[k] - if (call.Module == "" || kv.Module == call.Module) && (call.Node == "" || kv.Node == call.Node) && - (call.Key == "" || kv.Key == call.Key) { - out = append(out, heldValueOf(kv)) - } - } - return out -} - -// ---- the proposal's rule ------------------------------------------------------------------------------- - -// heldRule is the rule a value held for a pull request is judged by: the pull request's declaration of the key for -// the module at its head, and the module's assignment to the node. Refused, saying what the pull request does -// declare, when it declares none. -func heldRule(s Sources, call Call, level Level) (rule, PullDecl, string, error) { - if level.Kind != LevelModule { - return rule{}, PullDecl{}, "", fmt.Errorf("a value held for a pull request is a module's own value on one "+ - "node, and %s is not one: a predefined key a pull request adds is set after its merge (novox/hq ADR 0502)", - level) - } - pd, ok := s.Pulls[pullKey(call.Pull)] - if !ok { - return rule{}, PullDecl{}, "", fmt.Errorf("mesh-config holds no declaration for %s: the controller tells it "+ - "what a pull request declares when its head is announced, and none has been", strings.TrimSpace(call.Pull)) - } - d, ok := pd.Declares[level.Module][call.Key] - if !ok { - return rule{}, PullDecl{}, "", fmt.Errorf("%s does not add or change a value %q for %s at %s; it declares "+ - "for %s: %s", pd.Pull, call.Key, level.Module, short(pd.Head), level.Module, joinKeys(pd.Declares[level.Module])) - } - if _, reg := s.Declared[level.Module]; !reg { - return rule{}, PullDecl{}, "", fmt.Errorf("%s is not a registered module, so a value cannot be held for it", level.Module) - } - if !assigned(s, level.Node, level.Module) { - return rule{}, PullDecl{}, "", fmt.Errorf("%s is not placed on %s, and a module's own value is set for a node "+ - "it is placed on (novox/hq ADR 0348 §3); it is placed on: %s", level.Module, level.Node, - strings.Join(nodesOf(s, level.Module), ", ")) - } - return d.rule(), pd, declDigest(d), nil -} - -// keep holds an approved proposal's value apart. The caller holds the lock. -func (c *Config) keep(p Proposal) (string, error) { - var s Sources - if err := c.readPulls(&s); err != nil { - return "", err - } - pd, ok := s.Pulls[pullKey(p.Pull)] - if !ok { - return "", fmt.Errorf("mesh-config holds no declaration for %s any more", p.Pull) - } - d, ok := pd.Declares[p.Level.Module][p.Key] - if !ok || declDigest(d) != p.DeclDigest { - return "", fmt.Errorf("%s declares %s otherwise than the operator was shown, or no longer declares it: "+ - "propose it again", p.Pull, p.Key) - } - was, had := s.Kept[keptKey(p.Pull, p.Level.Node, p.Level.Module, p.Key)] - if had != p.HadValue || valueDigest(heldValue(was), had) != p.WasDigest { - return "", fmt.Errorf("the value held for %s changed since the operator was shown the change: propose it "+ - "again", p.Pull) - } - kv := KeptValue{Pull: p.Pull, Head: pd.Head, Declaration: p.DeclDigest, Node: p.Level.Node, Module: p.Level.Module, - Key: p.Key, Value: p.Value, By: "the operator", Via: p.From, Why: p.Why, Approved: p.Approved, Proposal: p.ID, - At: heldAt(c.now())} - if err := c.Store.Put(KeptState, keptStateKey(kv), kv); err != nil { - return "", fmt.Errorf("the value was not kept: %v", err) - } - unsaid := c.heldChange(kv, ActionHold, "held for "+p.Pull+" until it merges: "+p.Why, p.Approved) - said := fmt.Sprintf("%s of %s on %s is held at %s for %s until it merges", p.Key, p.Level.Module, p.Level.Node, - short(pd.Head), p.Pull) - if len(unsaid) > 0 { - said += " (" + strings.Join(unsaid, "; ") + ")" - } - return said, nil -} - -// ---- the merge and the close --------------------------------------------------------------------------- - -// PullMerged writes each value held for a pull request as the module's own value on its node, with the approval kept -// beside it; it resolves once the trunk declares the key. It answers a line for each. -func (c *Config) PullMerged(pull, head string) []string { - return c.settlePull(pull, true, head) -} - -// PullClosed drops the values held for a pull request closed unmerged, and says that nothing was set. -func (c *Config) PullClosed(pull string) []string { - return c.settlePull(pull, false, "") -} - -func (c *Config) settlePull(pull string, merged bool, head string) []string { - c.mu.Lock() - defer c.mu.Unlock() - var s Sources - if err := c.readPulls(&s); err != nil { - return []string{err.Error()} - } - var said []string - wrote := false - for _, k := range sortedKeys(s.Kept) { - kv := s.Kept[k] - if pullKey(kv.Pull) != pullKey(pull) { - continue - } - if !merged { - said = append(said, fmt.Sprintf("%s of %s on %s was held for %s, which closed unmerged: dropped, "+ - "nothing was set", kv.Key, kv.Module, kv.Node, kv.Pull)) - said = append(said, c.dropKept(kv, kv.Pull+" closed unmerged")...) - continue - } - // **Only a value held at the merged head, whose key that head declares as it was approved** (ADR 0502 clause 7). - why := "" - pd, known := s.Pulls[pullKey(pull)] - d, declared := pd.Declares[kv.Module][kv.Key] - switch { - case head == "": - why = "the merged head is not known, so the value cannot be held to it" - case !strings.EqualFold(head, kv.Head): - why = fmt.Sprintf("it is held at head %s and the pull request merged at %s", short(kv.Head), short(head)) - case !known || !declared || declDigest(d) != kv.Declaration: - why = "the merged head does not declare the key as the operator was shown" - } - if why != "" { - said = append(said, fmt.Sprintf("%s of %s on %s was held for %s, which merged: dropped, nothing was set (%s)", - kv.Key, kv.Module, kv.Node, kv.Pull, why)) - said = append(said, c.dropKept(kv, kv.Pull+" merged, but "+why)...) - continue - } - vk := keptLevel(kv).ValueKey(kv.Key) - v := Value{Value: compact(heldValue(kv)), By: kv.By, Via: kv.Via, Why: kv.Why + " (held for " + kv.Pull + - ", merged)", Approved: kv.Approved, At: c.now()} - if err := c.Store.Put(ValuesState, vk, v); err != nil { - said = append(said, fmt.Sprintf("%s of %s on %s held for %s is not written yet: %v; it is tried "+ - "again", kv.Key, kv.Module, kv.Node, kv.Pull, err)) - continue - } - if err := c.Store.Delete(KeptState, k); err != nil { - said = append(said, "the held value "+k+" is written but not removed: "+err.Error()) - } - wrote = true - said = append(said, c.heldChange(kv, "set", kv.Pull+" merged: the held value is the module's own value now", - kv.Approved)...) - said = append(said, fmt.Sprintf("%s of %s on %s held for %s is set: %s", kv.Key, kv.Module, kv.Node, - kv.Pull, kv.Value)) - } - if wrote { - if s2, err := c.sources(); err == nil { - if _, err := c.writeResolved(s2); err != nil { - said = append(said, "the resolved values are not all written yet ("+err.Error()+"); the next "+ - "resolution writes them") - } - } - } - left := 0 - for _, k := range sortedKeys(s.Kept) { - if pullKey(s.Kept[k].Pull) != pullKey(pull) { - continue - } - if e, err := c.Store.Get(KeptState, k); err != nil || e != nil { - left++ - } - } - if left == 0 { - if err := c.Store.Delete(PullsState, pullKey(pull)); err != nil { - said = append(said, "the declarations of "+pull+" were not removed: "+err.Error()) - } - } - return said -} - -// PullEvent is a pull request merged or closed, as far as this module reads it: the seat `git`'s `pull-merged` or `pull-closed` -// (design 47 G §654), read by pullEventOf. -type PullEvent struct { - Owner string - Repo string - Number int - Merged bool - // HeadSHA is the head the pull request merged at. - HeadSHA string -} - -// pullEventOf reads the seat `git`'s `pull-merged` or `pull-closed` body: the repository `/`, the number and the head. -func pullEventOf(body []byte) (PullEvent, bool) { - var e struct { - Repository string `json:"repository"` - Number int `json:"number"` - Head string `json:"head"` - } - if json.Unmarshal(body, &e) != nil { - return PullEvent{}, false - } - owner, repo, ok := strings.Cut(e.Repository, "/") - return PullEvent{Owner: owner, Repo: repo, Number: e.Number, HeadSHA: e.Head}, ok -} - -func (p PullEvent) name() string { return fmt.Sprintf("%s/%s#%d", p.Owner, p.Repo, p.Number) } - -// HeardPull takes the forge's word that a pull request merged or closed. A close is asked of the forge when it can -// be, because a merged pull request may be announced as closed too. -func (c *Config) HeardPull(p PullEvent, merged bool) []string { - if p.Owner == "" || p.Repo == "" || p.Number <= 0 { - return nil - } - head := p.HeadSHA - if !merged && !p.Merged && c.Forge != nil { - // A close is told from a merge by the forge; when it cannot be asked nothing is dropped, and the five-minute - // look finds it. - open, m, h, err := c.Forge.Pull(p.Owner, p.Repo, p.Number) - if err != nil { - c.logf("[mesh-config] %s closed, and the forge does not say whether it merged (%v); the next look decides", p.name(), err) - return nil - } - if open { - return nil - } - merged = m - if head == "" { - head = h - } - } - return c.settlePull(p.name(), merged || p.Merged, head) -} - -// SweepPulls looks at the forge for every pull request it keeps something for, so a merge or a close it did not hear -// is found: run once at start (resolving). -func (c *Config) SweepPulls() []string { - if c.Forge == nil { - return nil - } - c.mu.Lock() - var s Sources - err := c.readPulls(&s) - c.mu.Unlock() - if err != nil { - return []string{err.Error()} - } - seen := map[string]string{} - for _, p := range s.Pulls { - seen[pullKey(p.Pull)] = p.Pull - } - for _, k := range s.Kept { - seen[pullKey(k.Pull)] = k.Pull - } - var said []string - for _, key := range sortedKeys(seen) { - pull := seen[key] - owner, repo, n, err := parsePull(pull) - if err != nil { - continue - } - open, merged, head, err := c.Forge.Pull(owner, repo, n) - if err != nil { - said = append(said, fmt.Sprintf("the forge does not say whether %s is open: %v", pull, err)) - continue - } - if !open { - said = append(said, c.settlePull(pull, merged, head)...) - } - } - return said -} - -// PullAt is a pull request at a head, as held asks about it. -type PullAt struct { - Pull string `json:"pull"` - Head string `json:"head"` -} - -// toolForge asks the forge's holder through its tools. -type toolForge struct { - ask func(key string, body any) (json.RawMessage, error) -} - -// Pull asks the seat `git`'s verb `pull` whether a pull request is open, and whether it merged. -func (f toolForge) Pull(owner, repo string, number int) (bool, bool, string, error) { - raw, err := f.ask(GitPullAsk, map[string]any{"repository": owner + "/" + repo, "number": number}) - if err != nil { - return false, false, "", err - } - answer, output, ok := unwrapAnswer(raw) - if !ok { - return false, false, "", fmt.Errorf("the seat git refused pull: %s", output) - } - var a struct { - Pull struct { - State string `json:"state"` - Head string `json:"head"` - } `json:"pull"` - Error string `json:"error"` - } - if err := json.Unmarshal(answer, &a); err != nil || a.Error != "" || a.Pull.State == "" { - return false, false, "", fmt.Errorf("the seat git's pull is not readable: %s", output) - } - return a.Pull.State == "open", a.Pull.State == "merged", a.Pull.Head, nil -} - -// GitPullAsk is the seat `git`'s verb that answers one pull request. -const GitPullAsk = "seat:git.pull" - -// unwrapAnswer reads a tool's answer whatever wraps it: the protocol's content list, or {output, ok, answer}. -func unwrapAnswer(raw json.RawMessage) (json.RawMessage, string, bool) { - var s string - if json.Unmarshal(raw, &s) == nil { - return unwrapAnswer(json.RawMessage(s)) - } - var m map[string]json.RawMessage - if json.Unmarshal(raw, &m) != nil { - return raw, string(raw), true - } - if content, has := m["content"]; has { - var items []struct { - Text string `json:"text"` - } - var e struct { - IsError bool `json:"isError"` - } - _ = json.Unmarshal(raw, &e) - if json.Unmarshal(content, &items) == nil && len(items) > 0 { - inner, out, ok := unwrapAnswer(json.RawMessage(items[0].Text)) - return inner, out, ok && !e.IsError - } - } - var v struct { - Output string `json:"output"` - OK *bool `json:"ok"` - Answer json.RawMessage `json:"answer"` - } - if json.Unmarshal(raw, &v) == nil && v.OK != nil { - return v.Answer, v.Output, *v.OK - } - return raw, string(raw), true -} diff --git a/modules/mesh-config/cmd/mesh-config/pulls_test.go b/modules/mesh-config/cmd/mesh-config/pulls_test.go deleted file mode 100644 index 23f0ea9b8..000000000 --- a/modules/mesh-config/cmd/mesh-config/pulls_test.go +++ /dev/null @@ -1,504 +0,0 @@ -package main - -import ( - "encoding/json" - "errors" - "strings" - "testing" - "time" - - "git.novox.be/novox/mesh-contracts/go/clients/meshconfigclient" - - occ "git.novox.be/novox/mesh-contracts/operator-and-conversation/go/clients/operatorchannelclient" -) - -// Issue 1826 (novox/hq ADR 0502): a value held for the open pull request that introduces its key. - -const thePull = "novox/mesh-catalog#434" - -// n8nPullDeclares is what the controller tells of the pull request: n8n gets a required number media-gid. -func n8nPullDeclares() map[string]any { - return map[string]any{"n8n": map[string]any{"media-gid": map[string]any{"type": "number", - "description": "the media group", "required": true, "minimum": 1, "maximum": 65535}}} -} - -// aHoldingMesh is a proposing mesh with n8n assigned to ace and declaring nothing on the trunk (the case of the -// issue), and a stand-in forge. -func aHoldingMesh(t *testing.T) (*Config, *memStore, *standIn, *standForge) { - t.Helper() - c, m, r := aProposingMesh(t) - m.declare(t, "n8n", `{"module":"n8n","settings":{}}`) - m.assign(t, "ace", "n8n") - f := &standForge{state: map[string][2]bool{}} - c.Forge = f - if _, err := c.Reconcile(); err != nil { - t.Fatal(err) - } - m.events, m.handActs = nil, nil - return c, m, r, f -} - -type standForge struct { - state map[string][2]bool // pull -> open, merged - head string - err error -} - -func (f *standForge) Pull(owner, repo string, n int) (bool, bool, string, error) { - if f.err != nil { - return false, false, "", f.err - } - st, ok := f.state[(PullEvent{Owner: owner, Repo: repo, Number: n}).name()] - if !ok { - return true, false, f.head, nil - } - return st[0], st[1], f.head, nil -} - -// tell keeps what a pull request's head declares as the indexer's candidate is taken (takeCandidates). -func tell(t *testing.T, c *Config, pull, head string, declares map[string]any) *PullDeclaresAnswer { - t.Helper() - raw, _ := json.Marshal(declares) - d := map[string]map[string]Declaration{} - if err := json.Unmarshal(raw, &d); err != nil { - t.Fatal(err) - } - c.mu.Lock() - defer c.mu.Unlock() - a, err := c.declarePull(pull, head, d) - if err != nil { - t.Fatalf("declare: %v", err) - } - return a -} - -// holdIt proposes media-gid=2000 for n8n on ace held for the pull request and has the operator approve it. -func holdIt(t *testing.T, c *Config, m *memStore, r *standIn) string { - t.Helper() - a := propose(t, c, Call{Module: "n8n", Node: "ace", Key: "media-gid", Value: 2000.0, Pull: thePull, - Why: "n8n's container joins the media group, held for #434"}) - r.choose(t, a.Proposal, OptionApprove, nil) - said, err := c.Decide() - if err != nil || len(said) != 1 || !strings.Contains(said[0], "approved by the operator and held") { - t.Fatalf("the Approve decided %v (%v)", said, err) - } - return a.Proposal -} - -func keptCount(m *memStore) int { k, _ := m.Keys(KeptState); return len(k) } - -// 1826/K1: mesh-config keeps what a pull request declares per pull request; pull-declares is gone (ADR 0590). -func TestAPullRequestsDeclarationsAreKeptPerPullRequest(t *testing.T) { - c, m, _, _ := aHoldingMesh(t) - for _, caller := range []string{"g14.node-tools", Unproven, "", ControllerCaller} { - if _, err := c.Do(Call{Action: "pull-declares", Pull: thePull, Head: "abc1234", Declares: n8nPullDeclares(), - Caller: caller}); err == nil || !strings.Contains(err.Error(), "config-candidates") { - t.Errorf("pull-declares from %q: %v", caller, err) - } - } - a := tell(t, c, thePull, "abc1234def", n8nPullDeclares()) - if len(a.Modules) != 1 || a.Modules[0] != "n8n" { - t.Errorf("answered %+v", a) - } - e, _ := m.Get(PullsState, "novox.mesh-catalog.434") - var pd PullDecl - if e == nil || json.Unmarshal(e.Value, &pd) != nil || pd.Head != "abc1234def" || - pd.Declares["n8n"]["media-gid"].Type != "number" || !pd.Declares["n8n"]["media-gid"].Required { - t.Errorf("kept %s", func() string { - if e == nil { - return "nothing" - } - return string(e.Value) - }()) - } - // Nothing is resolved from a pull request's declaration. - if r, _ := m.Get(ResolvedState, ResolvedKey("ace", "n8n", "media-gid")); r != nil { - t.Errorf("a pull request's declaration was resolved: %s", r.Value) - } -} - -// 1826/K2: a proposal for a key only the pull request declares is refused without its declaration, for a mesh or -// node level, for a clear, for an undeclared key, and for a module not placed on the node; and trunk-only -// proposals are judged as before. -func TestAProposalNamingAPullRequestIsJudgedAgainstItsDeclaration(t *testing.T) { - c, m, _, _ := aHoldingMesh(t) - try := func(call Call) error { - call.Action, call.Caller, call.Why = "propose", "g14.node-tools", "held for 434" - _, err := c.Propose(call) - return err - } - base := Call{Module: "n8n", Node: "ace", Key: "media-gid", Value: 2000.0, Pull: thePull} - if err := try(base); err == nil || !strings.Contains(err.Error(), "holds no declaration for "+thePull) { - t.Errorf("without the pull request's declaration: %v", err) - } - // And without the pull argument it is the trunk's refusal, as before. - plain := base - plain.Pull = "" - if err := try(plain); err == nil || !strings.Contains(err.Error(), `n8n declares no value "media-gid"`) { - t.Errorf("the trunk's refusal changed: %v", err) - } - tell(t, c, thePull, "abc1234def", n8nPullDeclares()) - for name, tc := range map[string]struct { - mutate func(*Call) - want string - }{ - "a mesh level": {func(c *Call) { c.Module, c.Node = "", "" }, "a module's own value on one node"}, - "a node level": {func(c *Call) { c.Module = "" }, "a module's own value on one node"}, - "a clear": {func(c *Call) { c.Clear, c.Value = true, nil }, "a clear is not held"}, - "a key not added": {func(c *Call) { c.Key = "other" }, "does not add or change a value"}, - "a bad value": {func(c *Call) { c.Value = 0.0 }, "below the minimum"}, - "a wrong type": {func(c *Call) { c.Value = "2000" }, "is not a number"}, - "another node": {func(c *Call) { c.Node = "g14" }, "is not placed on g14"}, - "another pull": {func(c *Call) { c.Pull = "novox/mesh-catalog#435" }, "holds no declaration for"}, - "a malformed pull": {func(c *Call) { c.Pull = "434" }, "owner/repository#number"}, - } { - call := base - tc.mutate(&call) - if err := try(call); err == nil || !strings.Contains(err.Error(), tc.want) { - t.Errorf("%s: %v, want %q", name, err, tc.want) - } - } - // A set or a clear through the verb takes no pull request. - if _, err := c.Change(Call{Action: "set", Module: "n8n", Node: "ace", Key: "media-gid", Value: 2000.0, Pull: thePull, - Caller: "g14.node-tools", Why: "w"}); err == nil || !strings.Contains(err.Error(), "only a proposal") { - t.Errorf("a set naming a pull request: %v", err) - } - if keptCount(m) != 0 { - t.Error("something was held") - } -} - -// 1826/K2: every held value is asked whatever the key's trust; the ask says it is held and dropped on a close; on -// Approve the value is kept apart, never set or resolved; history, event and hand-act say it; held answers it. -func TestAHeldValueIsAskedAndKeptApartOnApprove(t *testing.T) { - c, m, r, _ := aHoldingMesh(t) - tell(t, c, thePull, "abc1234def", n8nPullDeclares()) - a := propose(t, c, Call{Module: "n8n", Node: "ace", Key: "media-gid", Value: 2000.0, Pull: thePull, Why: "held for #434"}) - if len(a.Reaches) != 0 { - t.Errorf("a held value reaches %v", a.Reaches) - } - ask := r.asks[a.Proposal] - if err := occ.Check(ask, c.now()); err != nil { - t.Fatalf("the ask: %v", err) - } - for _, want := range []string{thePull, "merges", "dropped if it closes unmerged", "media-gid", "n8n", "ace"} { - if !strings.Contains(ask.Explanation, want) { - t.Errorf("the ask does not say %q:\n%s", want, ask.Explanation) - } - } - if strings.Contains(ask.Explanation, "takes effect at once") || !strings.Contains(ask.Headline, "Hold") { - t.Errorf("the ask: %q\n%s", ask.Headline, ask.Explanation) - } - if ap := ask.Options[0]; !strings.Contains(ap.Does, thePull) || ap.Level == "" { - t.Errorf("the approve option does %q", ap.Does) - } - if keptCount(m) != 0 { - t.Fatal("a proposal held something") - } - r.choose(t, a.Proposal, OptionApprove, nil) - said, _ := c.Decide() - if len(said) != 1 || !strings.Contains(said[0], "held at abc1234d for "+thePull) { - t.Fatalf("decided %v", said) - } - // Kept apart: not a value, not resolved. - if _, set := storedValue(t, m, "module.ace.n8n.media-gid"); set { - t.Error("an Approve set the value") - } - if e, _ := m.Get(ResolvedState, ResolvedKey("ace", "n8n", "media-gid")); e != nil { - t.Errorf("an Approve resolved the value: %s", e.Value) - } - if keptCount(m) != 1 { - t.Fatalf("%d values held", keptCount(m)) - } - if len(m.events) != 1 || m.events[0].Action != ActionHold || m.events[0].Pull != thePull || - m.events[0].Key != "media-gid" || m.events[0].Head != "abc1234def" || len(m.events[0].Moved) != 0 || - !strings.Contains(m.events[0].Approved, "approved by the operator") { - t.Errorf("raised %+v", m.events) - } - if len(m.handActs) != 1 || !strings.Contains(m.handActs[0], thePull) { - t.Errorf("hand-acts %q", m.handActs) - } - h, _ := c.History(Call{Module: "n8n", Node: "ace"}) - if len(h) != 1 || h[0].Action != ActionHold || h[0].Pull != thePull { - t.Errorf("history %+v", h) - } - // held answers it, at the head it is kept at, to the controller alone. - if _, err := c.Do(Call{Action: "held", Caller: "g14.node-tools", Pulls: []PullAt{{thePull, "abc1234def"}}}); err == nil { - t.Error("held answered a caller that is not the controller") - } - got, err := c.Do(Call{Action: "held", Caller: ControllerCaller, Pulls: []PullAt{{thePull, "abc1234def"}}}) - if err != nil { - t.Fatal(err) - } - ha := got.(*HeldAnswer) - if len(ha.Held) != 1 || ha.Held[0].Module != "n8n" || ha.Held[0].Node != "ace" || ha.Held[0].Key != "media-gid" || - string(ha.Held[0].Value) != "2000" || !strings.Contains(ha.Held[0].Approved, "approved by the operator") || - ha.Held[0].Pull != thePull || len(ha.Skipped) != 0 { - t.Errorf("held answered %+v", ha) - } - // Another head, and another pull request, are not answered. - got, _ = c.Do(Call{Action: "held", Caller: ControllerCaller, - Pulls: []PullAt{{thePull, "ffff0000"}, {"novox/mesh-catalog#435", "abc"}}}) - if ha = got.(*HeldAnswer); len(ha.Held) != 0 || len(ha.Skipped) != 1 || !strings.Contains(ha.Skipped[0].Why, "held at") { - t.Errorf("held at another head answered %+v", ha) - } - // The listing shows it as held, and the proposal as held for the pull request. - l, _ := c.List(Call{Module: "n8n"}) - if len(l.Held) != 1 || len(l.Set) != 0 { - t.Errorf("the listing: held %+v set %+v", l.Held, l.Set) - } - rows, _ := c.Proposals(Call{}) - if len(rows) != 1 || rows[0].Pull != thePull || rows[0].State != ProposalApproved { - t.Errorf("proposals %+v", rows) - } -} - -// 1826/K2: an Approve is refused when the pull request's declaration changed after the operator was shown it. -func TestAnApproveOfAHeldValueIsRefusedWhenTheDeclarationChanged(t *testing.T) { - c, m, r, _ := aHoldingMesh(t) - tell(t, c, thePull, "abc1234def", n8nPullDeclares()) - a := propose(t, c, Call{Module: "n8n", Node: "ace", Key: "media-gid", Value: 2000.0, Pull: thePull, Why: "w"}) - changed := n8nPullDeclares() - changed["n8n"].(map[string]any)["media-gid"].(map[string]any)["maximum"] = 1000.0 - tell(t, c, thePull, "def5678abc", changed) - r.choose(t, a.Proposal, OptionApprove, nil) - said, _ := c.Decide() - if len(said) != 1 || !strings.Contains(said[0], "nothing is held") || keptCount(m) != 0 { - t.Errorf("decided %v; %d held", said, keptCount(m)) - } -} - -// 1826/K1: at a new head a held value is kept if its key is declared the same and it still passes; otherwise it is -// dropped, recorded, raised and said. -func TestANewHeadKeepsAHeldValueOnlyWhileItsDeclarationIsUnchanged(t *testing.T) { - c, m, r, _ := aHoldingMesh(t) - tell(t, c, thePull, "abc1234def", n8nPullDeclares()) - holdIt(t, c, m, r) - m.events = nil - - // The same declaration at a new head (the description may differ): kept, moved to the new head. - same := n8nPullDeclares() - same["n8n"].(map[string]any)["media-gid"].(map[string]any)["description"] = "reworded" - if a := tell(t, c, thePull, "1111111111", same); len(a.Dropped) != 0 { - t.Errorf("an unchanged declaration dropped %v", a.Dropped) - } - got, _ := c.Do(Call{Action: "held", Caller: ControllerCaller, Pulls: []PullAt{{thePull, "1111111111"}}}) - if len(got.(*HeldAnswer).Held) != 1 || len(m.events) != 0 { - t.Errorf("after an unchanged head: %+v, events %+v", got, m.events) - } - - // A changed declaration: dropped. - changed := n8nPullDeclares() - changed["n8n"].(map[string]any)["media-gid"].(map[string]any)["maximum"] = 1000.0 - a := tell(t, c, thePull, "2222222222", changed) - if len(a.Dropped) != 1 || !strings.Contains(a.Dropped[0], "declares the key otherwise") || keptCount(m) != 0 { - t.Fatalf("a changed declaration: %+v, %d held", a, keptCount(m)) - } - if len(m.events) != 1 || m.events[0].Action != ActionDrop || m.events[0].Pull != thePull { - t.Errorf("raised %+v", m.events) - } - got, _ = c.Do(Call{Action: "held", Caller: ControllerCaller, Pulls: []PullAt{{thePull, "2222222222"}}}) - if len(got.(*HeldAnswer).Held) != 0 { - t.Error("a dropped value was answered") - } - - // A head that no longer adds the key drops it too. - tell(t, c, thePull, "3333333333", n8nPullDeclares()) - holdIt(t, c, m, r) - if a = tell(t, c, thePull, "4444444444", map[string]any{}); len(a.Dropped) != 1 || - !strings.Contains(a.Dropped[0], "no longer adds or changes") { - t.Errorf("a head without the key: %+v", a) - } -} - -// 1826/K3: the merge writes the held value as the module's own value with its approval kept, before the trunk -// declares the key; it resolves right after the declared-config mirror moves. -func TestTheMergeAppliesAHeldValueAndItResolvesOnceTheTrunkDeclaresTheKey(t *testing.T) { - c, m, r, _ := aHoldingMesh(t) - tell(t, c, thePull, "abc1234def", n8nPullDeclares()) - holdIt(t, c, m, r) - approved := func() string { - raw, _ := m.Get(KeptState, "novox.mesh-catalog.434.ace.n8n.media-gid") - // the state kept is the seat's layout, under the seat's key: the checker and the assigner read it with this - k, err := meshconfigclient.DecodeKept("novox.mesh-catalog.434.ace.n8n.media-gid", raw.Value) - if err != nil || string(heldValue(k)) != "2000" || k.Declaration == "" || k.At == nil { - t.Fatalf("the held value is not the seat's: %+v, %v", k, err) - } - return k.Approved - }() - m.events, m.handActs = nil, nil - - said := c.HeardPull(PullEvent{Owner: "novox", Repo: "mesh-catalog", Number: 434, Merged: true, HeadSHA: "abc1234def"}, true) - if len(said) == 0 { - t.Fatal("the merge said nothing") - } - v, set := storedValue(t, m, "module.ace.n8n.media-gid") - if !set || string(v.Value) != "2000" || v.Approved != approved || v.Approved == "" || v.By != "the operator" || - !strings.Contains(v.Why, thePull) { - t.Fatalf("the merge wrote %+v", v) - } - if keptCount(m) != 0 { - t.Error("the value is still held after the merge") - } - if p, _ := m.Keys(PullsState); len(p) != 0 { - t.Errorf("the pull request's declarations are still kept: %v", p) - } - if len(m.events) != 1 || m.events[0].Action != "set" || m.events[0].Pull != thePull || - m.events[0].Approved != approved || len(m.handActs) != 1 { - t.Errorf("raised %+v, recorded %q", m.events, m.handActs) - } - // Not resolved before the trunk declares it. - if e, _ := m.Get(ResolvedState, ResolvedKey("ace", "n8n", "media-gid")); e != nil { - t.Errorf("resolved before the trunk declares the key: %s", e.Value) - } - m.declare(t, "n8n", `{"module":"n8n","settings":{"media-gid":{"kind":"","default":null,"why":"",`+ - `"type":"number","required":true,"minimum":1,"maximum":65535}}}`) - if _, err := c.Reconcile(); err != nil { - t.Fatal(err) - } - if res := m.resolved(t, "ace", "n8n", "media-gid"); string(res.Value) != "2000" || res.Source != SourceModule { - t.Errorf("media-gid resolves as %+v", res) - } - l, _ := c.List(Call{Module: "n8n", Node: "ace"}) - if len(l.Set) != 1 || l.Set[0].Approved != approved || len(l.Held) != 0 { - t.Errorf("the listing: set %+v held %+v", l.Set, l.Held) - } - // A merge heard twice sets nothing twice. - m.events = nil - c.HeardPull(PullEvent{Owner: "novox", Repo: "mesh-catalog", Number: 434, Merged: true, HeadSHA: "abc1234def"}, true) - if len(m.events) != 0 { - t.Errorf("a second merge raised %+v", m.events) - } -} - -// 1826/K3: a pull request closed unmerged drops its held values and says so; nothing is set or resolved. -func TestAClosedPullRequestDropsItsHeldValuesAndSaysSo(t *testing.T) { - c, m, r, f := aHoldingMesh(t) - tell(t, c, thePull, "abc1234def", n8nPullDeclares()) - holdIt(t, c, m, r) - m.events = nil - f.state[thePull] = [2]bool{false, false} - said := c.HeardPull(PullEvent{Owner: "novox", Repo: "mesh-catalog", Number: 434}, false) - if len(said) == 0 || !strings.Contains(strings.Join(said, "\n"), "closed unmerged: dropped, nothing was set") { - t.Errorf("said %v", said) - } - if _, set := storedValue(t, m, "module.ace.n8n.media-gid"); set || keptCount(m) != 0 { - t.Error("a closed pull request left a value") - } - if len(m.events) != 1 || m.events[0].Action != ActionDrop || m.events[0].Pull != thePull || - !strings.Contains(m.events[0].Why, "closed unmerged") { - t.Errorf("raised %+v", m.events) - } - if p, _ := m.Keys(PullsState); len(p) != 0 { - t.Errorf("declarations of a closed pull request kept: %v", p) - } -} - -// 1826/K3: a close event for a pull request the forge says merged is the merge. -func TestACloseEventForAMergedPullRequestIsItsMerge(t *testing.T) { - c, m, r, f := aHoldingMesh(t) - tell(t, c, thePull, "abc1234def", n8nPullDeclares()) - holdIt(t, c, m, r) - f.state[thePull] = [2]bool{false, true} - f.head = "abc1234def" - c.HeardPull(PullEvent{Owner: "novox", Repo: "mesh-catalog", Number: 434}, false) - if v, set := storedValue(t, m, "module.ace.n8n.media-gid"); !set || string(v.Value) != "2000" { - t.Errorf("the merge of a pull request announced closed set %+v", v) - } -} - -// 1826/K3: the five-minute look finds a merge, a close, and an open pull request, and says a forge that does not -// answer. -func TestTheLookAtTheForgeFindsAMissedMergeOrCloseAndLeavesAnOpenPullRequest(t *testing.T) { - c, m, r, f := aHoldingMesh(t) - tell(t, c, thePull, "abc1234def", n8nPullDeclares()) - holdIt(t, c, m, r) - if said := c.SweepPulls(); len(said) != 0 || keptCount(m) != 1 { - t.Errorf("an open pull request: said %v, %d held", said, keptCount(m)) - } - f.err = errors.New("the forge is down") - if said := c.SweepPulls(); len(said) != 1 || !strings.Contains(said[0], "does not say whether") || keptCount(m) != 1 { - t.Errorf("a silent forge: said %v", said) - } - f.err = nil - f.head = "abc1234def" - f.state[thePull] = [2]bool{false, true} - c.SweepPulls() - if v, set := storedValue(t, m, "module.ace.n8n.media-gid"); !set || string(v.Value) != "2000" || keptCount(m) != 0 { - t.Errorf("a missed merge: %+v", v) - } - // A missed close. - tell(t, c, "novox/mesh-catalog#440", "abc", n8nPullDeclares()) - f.state["novox/mesh-catalog#440"] = [2]bool{false, false} - c.SweepPulls() - if p, _ := m.Keys(PullsState); len(p) != 0 { - t.Errorf("a missed close left %v", p) - } -} - -// 1826/K1: the new arguments are read strictly and the new actions are the verb's. -func TestThePullArgumentsAreRead(t *testing.T) { - call, err := callOf(map[string]any{"action": "pull-declares", "pull": " " + thePull + " ", "head": "abc", - "declares": map[string]any{"n8n": map[string]any{}}, "pulls": []any{map[string]any{"pull": thePull, "head": "h"}}}) - if err != nil || call.Pull != thePull || call.Head != "abc" || len(call.Declares) != 1 || len(call.Pulls) != 1 || - call.Pulls[0].Head != "h" { - t.Errorf("read %+v (%v)", call, err) - } - if _, err := callOf(map[string]any{"declares": "x"}); err == nil { - t.Error("declares that is not an object was read") - } - if _, err := callOf(map[string]any{"pulls": "x"}); err == nil { - t.Error("pulls that is not a list was read") - } - if _, err := callOf(map[string]any{"bogus": 1}); err == nil || !strings.Contains(err.Error(), "pull") { - t.Errorf("an unknown argument: %v", err) - } - _ = time.Second -} - -// 1826 review r1: the merge applies a value only if it is held at the merged head; otherwise it is dropped and said. -func TestTheMergeAppliesOnlyAValueHeldAtTheMergedHead(t *testing.T) { - for name, head := range map[string]string{"another head": "9999999999", "no head told": ""} { - c, m, r, _ := aHoldingMesh(t) - tell(t, c, thePull, "abc1234def", n8nPullDeclares()) - holdIt(t, c, m, r) - said := c.HeardPull(PullEvent{Owner: "novox", Repo: "mesh-catalog", Number: 434, Merged: true, HeadSHA: head}, true) - if _, set := storedValue(t, m, "module.ace.n8n.media-gid"); set || keptCount(m) != 0 || - !strings.Contains(strings.Join(said, "\n"), "dropped, nothing was set") { - t.Errorf("%s: set=%v held=%d said %v", name, set, keptCount(m), said) - } - if len(m.events) == 0 || m.events[len(m.events)-1].Action != ActionDrop { - t.Errorf("%s: raised %+v", name, m.events) - } - } -} - -// 1826 review r1: a later head without the declaration drops the value, so the merge has nothing to apply. -func TestALaterHeadWithoutTheDeclarationLeavesNothingToApplyAtTheMerge(t *testing.T) { - c, m, r, _ := aHoldingMesh(t) - tell(t, c, thePull, "abc1234def", n8nPullDeclares()) - holdIt(t, c, m, r) - tell(t, c, thePull, "bbbbbbbbbb", map[string]any{}) - c.HeardPull(PullEvent{Owner: "novox", Repo: "mesh-catalog", Number: 434, Merged: true, HeadSHA: "bbbbbbbbbb"}, true) - if _, set := storedValue(t, m, "module.ace.n8n.media-gid"); set { - t.Error("a value held for a declaration the merged head lacks was set") - } -} - -// 1826 review r1: a close the forge cannot be asked about drops nothing; the five-minute look decides. -func TestACloseThatTheForgeCannotBeAskedAboutDropsNothing(t *testing.T) { - c, m, r, f := aHoldingMesh(t) - tell(t, c, thePull, "abc1234def", n8nPullDeclares()) - holdIt(t, c, m, r) - f.err = errors.New("the forge is down") - c.HeardPull(PullEvent{Owner: "novox", Repo: "mesh-catalog", Number: 434}, false) - if keptCount(m) != 1 { - t.Fatal("a close the forge could not confirm dropped the value") - } - f.err = nil - f.state[thePull] = [2]bool{false, false} - c.SweepPulls() - if keptCount(m) != 0 { - t.Error("the look did not drop it") - } -} diff --git a/modules/mesh-config/cmd/mesh-config/quiet_integration_test.go b/modules/mesh-config/cmd/mesh-config/quiet_integration_test.go index deb93d759..335e23949 100644 --- a/modules/mesh-config/cmd/mesh-config/quiet_integration_test.go +++ b/modules/mesh-config/cmd/mesh-config/quiet_integration_test.go @@ -58,9 +58,8 @@ func TestConfigWholeAsksTheBusForNothingWhileNoInputChanges(t *testing.T) { if err != nil { t.Fatal(err) } - buckets := []string{"mesh-delivery-assigner_assignments", "mesh-delivery-assigner_wants", "mesh-delivery-indexer_predefined", - "mesh-delivery-indexer_config-candidates"} - for _, s := range []string{ValuesState, ResolvedState, PredefinedState, ProposalsState, PullsState, KeptState, DeclaredState, + buckets := []string{"mesh-delivery-assigner_assignments", "mesh-delivery-assigner_wants", "mesh-delivery-indexer_predefined"} + for _, s := range []string{ValuesState, ResolvedState, PredefinedState, ProposalsState, DeclaredState, RenamesState, RetiringState, FindingsState} { buckets = append(buckets, Module+"_"+s) } @@ -93,19 +92,17 @@ func TestConfigWholeAsksTheBusForNothingWhileNoInputChanges(t *testing.T) { t.Fatal(err) } - // No input changes: the delivery says it delivered, a node-engine says what it reads, the forge says a pull request nothing is - // kept for closed, and the catalog says a manifest was accepted that no retirement waits on. Each is heard and none is a pass: + // No input changes: the delivery says it delivered, a node-engine says what it reads, and the catalog says a manifest was accepted that no retirement waits on. Each is heard and none is a pass: // nothing is asked of the bus. (The module has no timer: no minute, five or otherwise, asks it anything.) before, putsBefore := p.snapshot() for i := 0; i < 20; i++ { p.event("mesh-delivery-view.delivered", map[string]any{"revision": "r"}) p.event("node-engine.manifest-reads-changed", map[string]any{"node": "g14"}) - p.event("git.pull-closed", map[string]any{"owner": "novox", "repo": "mesh-catalog", "number": 700 + i}) } after, putsAfter := p.snapshot() if n := asked(before, after, "mesh/state.get", "mesh/state.keys", "mesh/state.watch", "mesh/state.put", "mesh/state.create", "mesh/state.update", "mesh/state.delete", "mesh/ask"); n != 0 || len(putsAfter) != len(putsBefore) { - t.Errorf("60 events that move nothing asked %d requests of the bus (%v); wrote %v", n, after, putsAfter[len(putsBefore):]) + t.Errorf("40 events that move nothing asked %d requests of the bus (%v); wrote %v", n, after, putsAfter[len(putsBefore):]) } // One input changes: player's manifest declares a second value. Only player's values on its two nodes are written, and `declared` diff --git a/modules/mesh-config/cmd/mesh-config/quiet_test.go b/modules/mesh-config/cmd/mesh-config/quiet_test.go index d6f89e77c..d5e25c429 100644 --- a/modules/mesh-config/cmd/mesh-config/quiet_test.go +++ b/modules/mesh-config/cmd/mesh-config/quiet_test.go @@ -5,6 +5,7 @@ package main import ( "encoding/json" + "strings" "sync" "testing" "time" @@ -193,19 +194,19 @@ func (b *busOf) ownCopy() *ownCopy { // **The module's own states are read from a copy, never key by key** (ADR 0580 §1, issue 1982): a whole state read of 1,176 // keys is one watch and no get, again and again; this process's write is in the copy at once, another's arrives by the watch. func TestAnOwnStateIsReadFromItsWatchedCopyNotKeyByKey(t *testing.T) { - b := &busOf{held: map[string]map[string][]byte{PullsState: {}}, handles: map[string]func(stdio.StateChange) error{}} + b := &busOf{held: map[string]map[string][]byte{ValuesState: {}}, handles: map[string]func(stdio.StateChange) error{}} for i := 0; i < 1176; i++ { - b.held[PullsState][pullKey("novox/mesh-catalog#"+string(rune('a'+i%26))+time.Duration(i).String())] = []byte(`{"pull":"x"}`) + b.held[ValuesState]["mesh.key-"+time.Duration(i).String()] = []byte(`{"value":1}`) } - n := len(b.held[PullsState]) + n := len(b.held[ValuesState]) own := b.ownCopy() for pass := 0; pass < 3; pass++ { - keys, err := own.keys(PullsState) + keys, err := own.keys(ValuesState) if err != nil || len(keys) != n { t.Fatalf("keys %d, %v; want %d", len(keys), err, n) } for _, k := range keys { - if e, err := own.get(PullsState, k); err != nil || e == nil { + if e, err := own.get(ValuesState, k); err != nil || e == nil { t.Fatalf("get %s: %v, %v", k, e, err) } } @@ -214,23 +215,23 @@ func TestAnOwnStateIsReadFromItsWatchedCopyNotKeyByKey(t *testing.T) { t.Errorf("3 passes over %d keys asked the bus for %d watches and %d gets; want 1 and 0", n, b.watches, b.gets) } // Its own write and removal are in the copy at once. - if err := own.write(PullsState, "mine", map[string]string{"pull": "mine"}); err != nil { + if err := own.write(ValuesState, "mine", map[string]string{"x": "mine"}); err != nil { t.Fatal(err) } - if e, _ := own.get(PullsState, "mine"); e == nil { + if e, _ := own.get(ValuesState, "mine"); e == nil { t.Error("a key just written is not read") } - if err := own.remove(PullsState, "mine"); err != nil { + if err := own.remove(ValuesState, "mine"); err != nil { t.Fatal(err) } - if e, _ := own.get(PullsState, "mine"); e != nil { + if e, _ := own.get(ValuesState, "mine"); e != nil { t.Error("a key just removed is still read") } // Another writer's change arrives by the watch. - if err := b.handles[PullsState](stdio.StateChange{State: PullsState, Key: "theirs", Op: stdio.OpPut, Value: []byte(`{"pull":"t"}`), Revision: 99}); err != nil { + if err := b.handles[ValuesState](stdio.StateChange{State: ValuesState, Key: "theirs", Op: stdio.OpPut, Value: []byte(`{"value":2}`), Revision: 99}); err != nil { t.Fatal(err) } - if e, _ := own.get(PullsState, "theirs"); e == nil { + if e, _ := own.get(ValuesState, "theirs"); e == nil { t.Error("a change another wrote is not read") } if b.gets != 0 { @@ -254,3 +255,19 @@ func TestAWriteTellsWhatWaitsOnADeadline(t *testing.T) { t.Errorf("told %v", told) } } + +// The mesh knows no pull request (design 47 G; ADR 0502 ended by the operator's word, record pending): the verb takes no `pull`, +// `head`, `declares` or `pulls`, and does neither `pull-declares` nor `held`. +func TestTheVerbKnowsNoPullRequest(t *testing.T) { + for _, arg := range []string{"pull", "head", "declares", "pulls"} { + if _, err := callOf(map[string]any{"action": "propose", arg: "x"}); err == nil || !strings.Contains(err.Error(), arg) { + t.Errorf("an argument %s was taken: %v", arg, err) + } + } + c, _ := aMesh(t) + for _, action := range []string{"pull-declares", "held"} { + if _, err := c.Do(Call{Action: action}); err == nil || !strings.Contains(err.Error(), action) { + t.Errorf("the action %s was done: %v", action, err) + } + } +} diff --git a/modules/mesh-config/cmd/mesh-config/resolve.go b/modules/mesh-config/cmd/mesh-config/resolve.go index 93cd8191d..070383dff 100644 --- a/modules/mesh-config/cmd/mesh-config/resolve.go +++ b/modules/mesh-config/cmd/mesh-config/resolve.go @@ -140,10 +140,6 @@ type Sources struct { Unresolved []Unresolved Predefined map[string]Published Values map[string]Value - // Pulls is what the controller told of each open pull request's declarations, and Kept the approved values held - // for them (pulls.go); neither is resolved. - Pulls map[string]PullDecl - Kept map[string]KeptValue // Renames are the renames kept, by `.`, whose open windows answer the old name (renames.go). Renames map[string]Rename } diff --git a/modules/mesh-config/cmd/mesh-config/sources.go b/modules/mesh-config/cmd/mesh-config/sources.go index 6a05643c7..a63d1e914 100644 --- a/modules/mesh-config/cmd/mesh-config/sources.go +++ b/modules/mesh-config/cmd/mesh-config/sources.go @@ -51,9 +51,6 @@ func (c *Config) sources() (Sources, error) { }); err != nil { return s, fmt.Errorf("the values cannot be read: %w", err) } - if err := c.readPulls(&s); err != nil { - return s, err - } if renames, err := c.readRenames(); err != nil { return s, fmt.Errorf("the renames cannot be read: %w", err) } else { @@ -339,10 +336,8 @@ type Resolution struct { Moved []Moved `json:"moved"` Published string `json:"published,omitempty"` Withheld string `json:"withheld,omitempty"` - // Declared are the modules whose `declared` key was written, and Candidates what the indexer's config candidates - // did after the take-over. - Declared []string `json:"declared,omitempty"` - Candidates []string `json:"candidates,omitempty"` + // Declared are the modules whose `declared` key was written. + Declared []string `json:"declared,omitempty"` // Renamed is what the renames did in this pass. Renamed []string `json:"renamed,omitempty"` // SourceGone is said while the stored switch still names the controller, whose records are no longer read. @@ -383,9 +378,6 @@ func (c *Config) reconcileLocked() (Resolution, error) { } else if len(written) > 0 { r.Declared = written } - if sw, serr := c.source(); serr == nil && sw.Source == SourceIndexer { - r.Candidates = c.takeCandidates() - } return r, err } diff --git a/modules/mesh-config/cmd/mesh-config/takeover.go b/modules/mesh-config/cmd/mesh-config/takeover.go index cc22ce6d4..f08bb27dd 100644 --- a/modules/mesh-config/cmd/mesh-config/takeover.go +++ b/modules/mesh-config/cmd/mesh-config/takeover.go @@ -2,7 +2,7 @@ package main // Config's records out of the controller (novox/hq ADR 0565 §3, §15, and the progressive insight of 2026-10-29): // mesh-config keeps each placed module's declarations in its own state `declared`, reads the list of predefined keys -// from the indexer's `predefined` and a pull request's config from the indexer's `config-candidates`. +// from the indexer's `predefined`. A pull request's config is not read: the mesh knows no pull request (design 47 G). // // **Its own sources hold always** (ADR 0590, issue 1126): the controller ended by its unassignment, so its pull-declares, // the take-over that switched away from them, compare and hand-back are gone, and the switch is the indexer's whatever @@ -23,12 +23,11 @@ const ( // DeclaredState is each placed module's declarations at the trunk, one key per module (ADR 0565 §3). DeclaredState = "declared" - // IndexerPredefinedRead and CandidatesRead are the indexer's states (ADR 0565 §2). + // IndexerPredefinedRead is the indexer's state of the predefined list (ADR 0565 §2). IndexerPredefinedRead = indexerModule + "." + catalog.StatePredefined - CandidatesRead = indexerModule + "." + catalog.StateConfigCandidates ) -// SourceIndexer is the one source of a pull request's config and of the predefined list: the indexer's. +// SourceIndexer is the one source of the predefined list: the indexer's. const SourceIndexer = "indexer" // Switch is which source holds: the indexer's, always, since the controller ended (ADR 0590). @@ -105,7 +104,7 @@ func (c *Config) writeDeclared(s Sources) ([]string, error) { return written, errors.Join(problems...) } -// ---- the predefined list and the pull requests from the indexer ------------------------------------------ +// ---- the predefined list from the indexer ----------------------------------------------------------------------------------------- // indexerList is the indexer's predefined list as the mirror's list holds one: the keys, and the commit. func (c *Config) indexerList() (PredefinedList, bool, error) { @@ -128,75 +127,6 @@ func (c *Config) indexerList() (PredefinedList, bool, error) { return list, true, nil } -// candidates is every open pull request's config declarations as the indexer keeps them, by pull key. -func (c *Config) candidates() (map[string]PullDecl, error) { - out := map[string]PullDecl{} - err := c.each(CandidatesRead, func(key string, raw []byte) error { - var cand catalog.ConfigCandidatesByPullValue - if err := json.Unmarshal(raw, &cand); err != nil || cand.Pull == "" { - return fmt.Errorf("the indexer's config candidate %s is not one", key) - } - p := PullDecl{Pull: cand.Pull, Head: cand.Head, Declares: map[string]map[string]Declaration{}, At: timeOf(cand.At)} - for module, keys := range cand.Declares { - raw, _ := json.Marshal(keys) - var d map[string]Declaration - if err := json.Unmarshal(raw, &d); err != nil { - return fmt.Errorf("the indexer's config candidate %s declares %s unreadably", key, module) - } - for k, decl := range d { - if !decl.HasDefault() { - decl.Default = nil - } - d[k] = decl - } - p.Declares[module] = d - } - out[pullKey(cand.Pull)] = p - return nil - }) - return out, err -} - -// takeCandidates is the indexer's config candidates taken in place of pull-declares, after the take-over: each one -// whose head or declarations differ from what `pulls` holds is declared again, its held values judged again (ADR 0502 -// §6). The caller holds the lock. -func (c *Config) takeCandidates() []string { - cands, err := c.candidates() - if err != nil { - return []string{"the indexer's config candidates cannot be read: " + err.Error()} - } - var s Sources - if err := c.readPulls(&s); err != nil { - return []string{err.Error()} - } - var said []string - for _, k := range sortedKeys(cands) { - p := cands[k] - if have, ok := s.Pulls[k]; ok && have.Head == p.Head && declaresDigest(have.Declares) == declaresDigest(p.Declares) { - continue - } - a, err := c.declarePull(p.Pull, p.Head, p.Declares) - if err != nil { - said = append(said, fmt.Sprintf("%s from the indexer: %v", p.Pull, err)) - continue - } - said = append(said, a.Said+" (from the indexer)") - } - return said -} - -// declaresDigest is what a pull request's declarations hold a value to, in one encoding. -func declaresDigest(d map[string]map[string]Declaration) string { - flat := map[string]string{} - for m, keys := range d { - for k, decl := range keys { - flat[m+"."+k] = declDigest(decl) - } - } - raw, _ := json.Marshal(flat) - return string(raw) -} - // Declared is the read of `declared`: every module's key, or one whole. func (c *Config) Declared(module string) (any, error) { if module != "" { @@ -221,20 +151,14 @@ func (c *Config) Declared(module string) (any, error) { return map[string]any{"declared": rows, "count": len(rows), "source": sw}, err } -// Resync reads every source again and writes what differs: the published list, the resolved values, `declared`, and -// the indexer's config candidates (ADR 0565 §15). +// Resync reads every source again and writes what differs: the published list, the resolved values and `declared` +// (ADR 0565 §15). func (c *Config) Resync() (any, error) { r, err := c.Reconcile() if err != nil { return r, err } - c.mu.Lock() - defer c.mu.Unlock() - out := map[string]any{"resolution": r} - if sw, err := c.source(); err == nil && sw.Source == SourceIndexer { - out["candidates"] = c.takeCandidates() - } - return out, nil + return map[string]any{"resolution": r}, nil } // timeOf is an optional time of a seat's value as a time, the zero time when it is absent. diff --git a/modules/mesh-config/cmd/mesh-config/takeover_test.go b/modules/mesh-config/cmd/mesh-config/takeover_test.go index 4f5d6bd62..e05fd48ea 100644 --- a/modules/mesh-config/cmd/mesh-config/takeover_test.go +++ b/modules/mesh-config/cmd/mesh-config/takeover_test.go @@ -15,7 +15,7 @@ const ( oldDeclared = `{"module":"old","settings":{"workers":{"kind":"preference","default":4,"why":"two per core"}}}` ) -// anAgreeingMesh is aProposingMesh with the indexer's predefined list in place and no open pull request. +// anAgreeingMesh is aProposingMesh with the indexer's predefined list in place. func anAgreeingMesh(t *testing.T) (*Config, *memStore, *standIn) { t.Helper() c, m, r := aProposingMesh(t) @@ -34,19 +34,9 @@ func indexerList(t *testing.T, m *memStore, commit, list string) { m.mirror(t, IndexerPredefinedRead, catalog.PredefinedByListKey(), string(raw)) } -// candidate is the indexer's config candidate of a pull request. -func candidate(t *testing.T, m *memStore, pull, head, declares string) { - t.Helper() - key, err := catalog.ConfigCandidatesByPullKey(pullKey(pull)), error(nil) - if err != nil { - t.Fatal(err) - } - m.mirror(t, CandidatesRead, key, `{"v":1,"pull":"`+pull+`","head":"`+head+`","declares":`+declares+`}`) -} - // ADR 0590 (issue 1126): config reads its own sources always, with no take-over: declared is written once per -// manifest, pull-declares is refused naming the indexer's candidates, and the list and a pull request's config come from -// the indexer. compare, take-over and hand-back went with the controller. +// manifest, and the list comes from the indexer. compare, take-over, hand-back and a pull request's config went (the +// mesh knows no pull request, design 47 G). func TestConfigReadsItsOwnSourcesAlways(t *testing.T) { c, m, _ := anAgreeingMesh(t) steps := []struct { @@ -60,11 +50,6 @@ func TestConfigReadsItsOwnSourcesAlways(t *testing.T) { again, _ := c.Reconcile() return strings.Join(first.Declared, ",") + "|" + strings.Join(again.Declared, ","), err }, "dunst|"}, - {"pull-declares refused, naming the indexer", func() (string, error) { - _, err := c.PullDeclares(Call{Caller: ControllerCaller, Pull: "novox/mesh-catalog#8", Head: "h1", - Declares: map[string]any{}}) - return "", err - }, "config-candidates"}, {"the list comes from the indexer", func() (string, error) { indexerList(t, m, "cccccccccccc", `{"font-size":{"type":"number","description":"text size","minimum":6,"maximum":72}, "agent-managed-settings":{"type":"object","description":"managed settings","trusted":true}, @@ -72,11 +57,6 @@ func TestConfigReadsItsOwnSourcesAlways(t *testing.T) { res, err := c.Reconcile() return res.Published, err }, "theme"}, - {"a pull request's config comes from the indexer", func() (string, error) { - candidate(t, m, "novox/mesh-catalog#9", "h9", `{"dunst":{"gap":{"kind":"","type":"number","default":2}}}`) - res, err := c.Reconcile() - return strings.Join(res.Candidates, "; "), err - }, "from the indexer"}, } for _, s := range steps { got, err := s.do() diff --git a/modules/mesh-config/cmd/mesh-config/whole_integration_test.go b/modules/mesh-config/cmd/mesh-config/whole_integration_test.go index 83d9af240..f004ff88c 100644 --- a/modules/mesh-config/cmd/mesh-config/whole_integration_test.go +++ b/modules/mesh-config/cmd/mesh-config/whole_integration_test.go @@ -721,9 +721,8 @@ func TestConfigWholeRenamesAndRetiresAgainstTheBus(t *testing.T) { t.Fatal(err) } buckets := []string{"mesh-delivery-assigner_assignments", "mesh-delivery-assigner_wants", - "mesh-delivery-indexer_predefined", - "mesh-delivery-indexer_config-candidates"} - for _, s := range []string{ValuesState, ResolvedState, PredefinedState, ProposalsState, PullsState, KeptState, DeclaredState, + "mesh-delivery-indexer_predefined"} + for _, s := range []string{ValuesState, ResolvedState, PredefinedState, ProposalsState, DeclaredState, RenamesState, RetiringState, FindingsState} { buckets = append(buckets, Module+"_"+s) } diff --git a/modules/mesh-config/module.json b/modules/mesh-config/module.json index 827c0f7cb..c6d12e565 100644 --- a/modules/mesh-config/module.json +++ b/modules/mesh-config/module.json @@ -19,13 +19,10 @@ "operator-channel" ], "consumes": [ - "git.pull-merged", - "git.pull-closed", "mesh-delivery-view.delivered", "node-engine.manifest-reads-changed", "mesh-catalog.manifest-accepted", "mesh-delivery-indexer.views.predefined", - "mesh-delivery-indexer.views.config-candidates", "mesh-delivery-assigner.views.assignments", "mesh-delivery-assigner.views.wants", "mesh-catalog.catalog-revision", @@ -36,13 +33,11 @@ "invokes": [ "seat:mesh-hand-acts.hand-act", "seat:mesh-hand-acts.warranted", - "seat:git.pull", "mesh-delivery-view.node_haves", "seat:node-engine.manifest-reads", "mesh-delivery-indexer.indexer_config_readers", "seat:mesh-vault.retire", "mesh-delivery-indexer.indexer_read_predefined", - "mesh-delivery-indexer.indexer_read_config_candidates", "mesh-delivery-assigner.assigner_read_assignments", "mesh-delivery-assigner.assigner_read_wants", "seat:mesh-catalog.revision", @@ -66,8 +61,6 @@ "resolved", "predefined", "proposals", - "pulls", - "kept", "declared", "renames", "retiring", -- 2.54.0 From 9d43fa4b2400b0e4fae1443192b7515388bf11b4 Mon Sep 17 00:00:00 2001 From: jochen Date: Thu, 19 Nov 2026 22:50:25 +0100 Subject: [PATCH 3/6] =?UTF-8?q?mesh-cli:=20config=20no=20longer=20passes?= =?UTF-8?q?=20`pull`=20(issue=201982;=20ADR=200681=20=C2=A71)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit mesh-config's verb takes no pull request argument any more, so `nox config` offers none. Builds: ADR 0681 §1 (the verb `config` takes no `pull`). Claude-Session: https://claude.ai/code/session_01JG73KHUnBze48rdua8u2sy --- modules/mesh-cli/cmd/mesh-cli/commands.go | 4 ++-- modules/mesh-cli/cmd/mesh-cli/main_test.go | 1 + 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/modules/mesh-cli/cmd/mesh-cli/commands.go b/modules/mesh-cli/cmd/mesh-cli/commands.go index 71a971df7..53fa35720 100644 --- a/modules/mesh-cli/cmd/mesh-cli/commands.go +++ b/modules/mesh-cli/cmd/mesh-cli/commands.go @@ -289,12 +289,12 @@ var commands = []command{ does: "clear one of a module's config values on one node", allowed: []string{"node", "why"}, build: func(l line) (call, error) { return configChange(l, "clear") }}, {words: []string{"config"}, usage: "[list|set|clear|history|propose|proposals] [--module m] [--node n] [--key k] [--value v] [--why w]", - does: "the mesh's config values, at any level", allowed: []string{"module", "node", "key", "value", "why", "limit", "proposal", "pull", "clear"}, + does: "the mesh's config values, at any level", allowed: []string{"module", "node", "key", "value", "why", "limit", "proposal", "clear"}, build: func(l line) (call, error) { if len(l.pos) > 1 { return call{}, usageErr("give at most one action") } - a := pick(l, "module", "node", "key", "why", "proposal", "pull", "clear", "limit") + a := pick(l, "module", "node", "key", "why", "proposal", "clear", "limit") if len(l.pos) == 1 { a["action"] = l.pos[0] } diff --git a/modules/mesh-cli/cmd/mesh-cli/main_test.go b/modules/mesh-cli/cmd/mesh-cli/main_test.go index 2fca7dfd5..7939ec0f2 100644 --- a/modules/mesh-cli/cmd/mesh-cli/main_test.go +++ b/modules/mesh-cli/cmd/mesh-cli/main_test.go @@ -173,6 +173,7 @@ func TestALineWithNoOwnerOrNotReadCallsNothingAndSaysWhy(t *testing.T) { {"conditions --bogus x", 2, "--bogus is not a flag"}, {"settings set zsh {\"execute\":\"withhold\"} --node g14 --why x", 2, "set each key"}, {"healers --days soon", 2, "takes a number"}, + {"config propose --pull novox/x#1", 2, "--pull is not a flag"}, {"frobnicate", 2, "is not a command"}, } { got := console(t, nil) -- 2.54.0 From 7e96d6126877b8005e12ace3a6c0544d88e0da17 Mon Sep 17 00:00:00 2001 From: jochen Date: Thu, 19 Nov 2026 22:50:57 +0100 Subject: [PATCH 4/6] mesh-config: drop the require of the removed meshconfigclient (issue 1982) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The generated client held only the held values' keys and decoder, which the seat no longer has. Builds: ADR 0681 §1, §6 (the seat keeps no held value, so its generated client goes). Claude-Session: https://claude.ai/code/session_01JG73KHUnBze48rdua8u2sy --- modules/mesh-config/go.mod | 1 - 1 file changed, 1 deletion(-) diff --git a/modules/mesh-config/go.mod b/modules/mesh-config/go.mod index 7c48b3524..b6c257cb8 100644 --- a/modules/mesh-config/go.mod +++ b/modules/mesh-config/go.mod @@ -3,7 +3,6 @@ module mesh-config go 1.26.0 require ( - git.novox.be/novox/mesh-contracts/go/clients/meshconfigclient v0.0.0-00010101000000-000000000000 git.novox.be/novox/mesh-contracts/go/clients/meshmoduleassignerclient v0.0.0-00010101000000-000000000000 git.novox.be/novox/mesh-contracts/go/clients/nodeengineclient v0.0.0-00010101000000-000000000000 git.novox.be/novox/mesh-contracts/go/seats/meshconfig v0.0.0-00010101000000-000000000000 -- 2.54.0 From 7ade318cfac9034cb32ee7ee17d85cdb60780e2f Mon Sep 17 00:00:00 2001 From: jochen Date: Thu, 19 Nov 2026 23:07:09 +0100 Subject: [PATCH 5/6] =?UTF-8?q?mesh-config:=20one=20deadline=20timer=20for?= =?UTF-8?q?=20the=20earliest=20real=20deadline,=20its=20floor=20a=20settin?= =?UTF-8?q?g=20(issue=201982;=20ADR=200681=20=C2=A71;=20A-490l)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The one timer left is set for the earliest of three deadlines: a waiting proposal's end, an unanswered retirement's second ask, and a rename window's seven-day held finding, which is now judged at its deadline (JudgeHeldWindows) so it comes in a quiet mesh too. Its floor is the module's setting deadline-floor-seconds (default 60), not a constant. Tests: an integration test counts asks by key and fails on any `seat:git.*` over the whole run (ADR 0681, How it is checked, clause 1); a unit test shows an approved proposal records a hand act naming no pull request; another that a stored proposal naming a pull request is refused on approval, saying why. Claude-Session: https://claude.ai/code/session_01JG73KHUnBze48rdua8u2sy --- modules/mesh-config/cmd/mesh-config/main.go | 24 ++++++++- .../mesh-config/cmd/mesh-config/proposals.go | 14 +++++- .../cmd/mesh-config/proposals_test.go | 39 +++++++++++++++ .../cmd/mesh-config/quiet_integration_test.go | 6 ++- .../mesh-config/cmd/mesh-config/quiet_test.go | 49 +++++++++++++++++++ .../mesh-config/cmd/mesh-config/renames.go | 14 ++++++ .../cmd/mesh-config/whole_integration_test.go | 21 +++++++- modules/mesh-config/module.json | 13 ++++- 8 files changed, 173 insertions(+), 7 deletions(-) diff --git a/modules/mesh-config/cmd/mesh-config/main.go b/modules/mesh-config/cmd/mesh-config/main.go index 3c05a9130..15d4d8df5 100644 --- a/modules/mesh-config/cmd/mesh-config/main.go +++ b/modules/mesh-config/cmd/mesh-config/main.go @@ -268,6 +268,23 @@ func hearing(c *Config) { }() } +// DeadlineFloorKey is this module's setting for the least wait of its one deadline timer, in seconds (module.json `config`). +const DeadlineFloorKey = "deadline-floor-seconds" + +// DefaultDeadlineFloor is the floor when the setting cannot be read. +const DefaultDeadlineFloor = time.Minute + +// floorOf is the floor a setting's value names: its seconds, or the default for a value that is not a positive number. +func floorOf(raw json.RawMessage, err error) time.Duration { + var seconds float64 + if err != nil || json.Unmarshal(raw, &seconds) != nil || seconds < 1 { + return DefaultDeadlineFloor + } + return time.Duration(seconds * float64(time.Second)) +} + +func deadlineFloor() time.Duration { return floorOf(stdio.Config(DeadlineFloorKey)) } + // deciding reads the router's record of every waiting ask once at start, which finds an answer said while this module was // down, and then when the router says an ask ended (hearing's `decided` subscription calls Decide itself) or the next // deadline of a waiting proposal or retirement passes: one timer for the earliest, set again whenever a proposal or a @@ -282,6 +299,9 @@ func deciding(c *Config, rearm chan struct{}) { for _, s := range said { logf("[mesh-config] %s", s) } + if err := c.JudgeHeldWindows(); err != nil { + logf("[mesh-config] the held windows cannot be judged: %v", err) + } } decide() for { @@ -290,8 +310,8 @@ func deciding(c *Config, rearm chan struct{}) { <-rearm continue } - // Not sooner than a minute: a deadline that passed and was not settled (an ask the router refused) is tried again, not spun on. - timer := time.NewTimer(max(time.Until(at), time.Minute)) + // Not sooner than the floor: a deadline that passed and was not settled (an ask the router refused) is tried again, not spun on. + timer := time.NewTimer(max(time.Until(at), deadlineFloor())) select { case <-timer.C: decide() diff --git a/modules/mesh-config/cmd/mesh-config/proposals.go b/modules/mesh-config/cmd/mesh-config/proposals.go index 33895c2f8..f821555bb 100644 --- a/modules/mesh-config/cmd/mesh-config/proposals.go +++ b/modules/mesh-config/cmd/mesh-config/proposals.go @@ -871,7 +871,8 @@ func (c *Config) HeardEnd(w oc.Warrant) []string { // NextDeadline is when a waiting proposal or retirement is next judged for want of an answer: a proposal with no record // at the router ends an hour after its ask lapses (Decide), and a retirement left unanswered is asked once more after -// HeldFinding. The earliest of them; false when nothing waits on a time. +// HeldFinding, and an open rename window's held finding comes after HeldFinding too (lead answer A-490l). The earliest of +// them; false when nothing waits on a time. func (c *Config) NextDeadline() (time.Time, bool) { c.mu.Lock() defer c.mu.Unlock() @@ -895,6 +896,17 @@ func (c *Config) NextDeadline() (time.Time, bool) { } } } + // An open rename window reaches its held finding after HeldFinding (renames.go): its deadline, while it lies ahead. + if renames, err := c.readRenames(); err == nil { + now := c.now() + for _, r := range renames { + for _, node := range r.Open() { + if d := r.Nodes[node].Since.Add(HeldFinding); d.After(now) { + earlier(d) + } + } + } + } return at, !at.IsZero() } diff --git a/modules/mesh-config/cmd/mesh-config/proposals_test.go b/modules/mesh-config/cmd/mesh-config/proposals_test.go index da09744a5..af8c99587 100644 --- a/modules/mesh-config/cmd/mesh-config/proposals_test.go +++ b/modules/mesh-config/cmd/mesh-config/proposals_test.go @@ -590,3 +590,42 @@ func TestAnOwnersListOfNamesWithDigitsIsProposed(t *testing.T) { t.Fatalf("the owners were not put to the operator: %+v, asked on %v", a, r.subjects) } } + +// **An approved proposal records a hand act that names no pull request** (ADR 0681 clause 1: nothing it records as a hand act is a +// held value). +func TestAnApprovedProposalsHandActNamesNoPullRequest(t *testing.T) { + c, m, r := aProposingMesh(t) + a := propose(t, c, Call{Key: "font-size", Value: 12.0, Node: "g14"}) + r.choose(t, a.Proposal, OptionApprove, nil) + m.handActs = nil + if said, err := c.Decide(); err != nil || len(said) == 0 { + t.Fatalf("decide: %v, %v", said, err) + } + if len(m.handActs) == 0 { + t.Fatal("the approval recorded no hand act") + } + for _, act := range m.handActs { + if strings.Contains(strings.ToLower(act), "pull") || strings.Contains(act, "#") { + t.Errorf("a hand act names a pull request: %q", act) + } + } +} + +// A stored proposal that names a pull request is refused on its approval, saying why, and nothing is set (lead answer A-490l). +func TestAStoredProposalNamingAPullRequestIsRefusedOnApproval(t *testing.T) { + c, m, r := aProposingMesh(t) + a := propose(t, c, Call{Key: "font-size", Value: 12.0, Node: "g14"}) + p := storedProposal(t, m, a.Proposal) + p.Pull = "novox/mesh-catalog#7" + if err := m.Put(ProposalsState, p.ID, p); err != nil { + t.Fatal(err) + } + r.choose(t, a.Proposal, OptionApprove, nil) + said, _ := c.Decide() + if got := storedProposal(t, m, a.Proposal); got.State == ProposalApproved || len(said) == 0 || !strings.Contains(strings.Join(said, " "), "pull request") { + t.Errorf("said %v, proposal %+v", said, got) + } + if _, ok := storedValue(t, m, "node.g14.font-size"); ok { + t.Error("a value was set on a proposal that names a pull request") + } +} diff --git a/modules/mesh-config/cmd/mesh-config/quiet_integration_test.go b/modules/mesh-config/cmd/mesh-config/quiet_integration_test.go index 335e23949..3070fd7e9 100644 --- a/modules/mesh-config/cmd/mesh-config/quiet_integration_test.go +++ b/modules/mesh-config/cmd/mesh-config/quiet_integration_test.go @@ -92,14 +92,16 @@ func TestConfigWholeAsksTheBusForNothingWhileNoInputChanges(t *testing.T) { t.Fatal(err) } - // No input changes: the delivery says it delivered, a node-engine says what it reads, and the catalog says a manifest was accepted that no retirement waits on. Each is heard and none is a pass: - // nothing is asked of the bus. (The module has no timer: no minute, five or otherwise, asks it anything.) + // No input changes: the delivery says it delivered and a node-engine says what it reads, with no rename window open and no retirement + // waiting. Each is heard and none is a pass: nothing is asked of the bus. (The module has no polling timer; its one deadline + // timer is set for a real deadline, and none is near.) before, putsBefore := p.snapshot() for i := 0; i < 20; i++ { p.event("mesh-delivery-view.delivered", map[string]any{"revision": "r"}) p.event("node-engine.manifest-reads-changed", map[string]any{"node": "g14"}) } after, putsAfter := p.snapshot() + p.noGitAsk() if n := asked(before, after, "mesh/state.get", "mesh/state.keys", "mesh/state.watch", "mesh/state.put", "mesh/state.create", "mesh/state.update", "mesh/state.delete", "mesh/ask"); n != 0 || len(putsAfter) != len(putsBefore) { t.Errorf("40 events that move nothing asked %d requests of the bus (%v); wrote %v", n, after, putsAfter[len(putsBefore):]) diff --git a/modules/mesh-config/cmd/mesh-config/quiet_test.go b/modules/mesh-config/cmd/mesh-config/quiet_test.go index d5e25c429..1995523e3 100644 --- a/modules/mesh-config/cmd/mesh-config/quiet_test.go +++ b/modules/mesh-config/cmd/mesh-config/quiet_test.go @@ -5,6 +5,7 @@ package main import ( "encoding/json" + "errors" "strings" "sync" "testing" @@ -271,3 +272,51 @@ func TestTheVerbKnowsNoPullRequest(t *testing.T) { } } } + +// The deadline timer's floor is the setting deadline-floor-seconds, the default for a value that is not a positive number. +func TestTheDeadlineFloorIsTheSettingOrItsDefault(t *testing.T) { + for _, c := range []struct { + raw string + err error + want time.Duration + }{ + {`5`, nil, 5 * time.Second}, {`0`, nil, DefaultDeadlineFloor}, {`"x"`, nil, DefaultDeadlineFloor}, + {``, errors.New("not declared"), DefaultDeadlineFloor}, {`90`, nil, 90 * time.Second}, + } { + if got := floorOf(json.RawMessage(c.raw), c.err); got != c.want { + t.Errorf("floor of %q (%v) = %v, want %v", c.raw, c.err, got, c.want) + } + } +} + +// **A rename window held seven days comes as a finding in a quiet mesh** (lead answer A-490l): the deadline is the window's +// seventh day, the finding is written at it with no resolution pass, and a window that is not yet seven days old writes none. +func TestAHeldWindowIsAFindingAtItsDeadlineWithNoPass(t *testing.T) { + c, m, _, clock := aRenamingMesh(t) + m.declare(t, "player", newPlayer) + if _, err := c.Reconcile(); err != nil { + t.Fatal(err) + } + at, ok := c.NextDeadline() + if !ok || !at.Equal(clock.Add(HeldFinding)) { + t.Fatalf("deadline %v, %v; want the window's seventh day %v", at, ok, clock.Add(HeldFinding)) + } + if err := c.JudgeHeldWindows(); err != nil || len(findingsOf(t, m, FindingWindowHeld)) != 0 { + t.Fatalf("a young window wrote a finding (%v)", err) + } + *clock = at + cs := &countingStore{memStore: m, reads: map[string]int{}} + c.Store = cs + if err := c.JudgeHeldWindows(); err != nil { + t.Fatal(err) + } + if fs := findingsOf(t, m, FindingWindowHeld); len(fs) != 2 { + t.Errorf("findings %+v, want one for each node holding the window", fs) + } + if got := cs.readsExcept(RenamesState); len(got) != 0 { + t.Errorf("judging the held windows read %v", got) + } + if _, ok := c.NextDeadline(); ok { + t.Error("a deadline is still set once the finding is written") + } +} diff --git a/modules/mesh-config/cmd/mesh-config/renames.go b/modules/mesh-config/cmd/mesh-config/renames.go index 64417796f..f82a03879 100644 --- a/modules/mesh-config/cmd/mesh-config/renames.go +++ b/modules/mesh-config/cmd/mesh-config/renames.go @@ -487,6 +487,20 @@ func (c *Config) RenameClose(module, to, node, why string) (any, error) { return map[string]any{"closed": node, "open": r.Open()}, nil } +// JudgeHeldWindows writes the finding of each window held open past HeldFinding, and clears one that is not, from the renames +// kept: run at start and at the deadline the next window reaches (NextDeadline), so the finding comes in a quiet mesh too (lead +// answer A-490l); it reads no source and asks nothing. +func (c *Config) JudgeHeldWindows() error { + c.mu.Lock() + defer c.mu.Unlock() + renames, err := c.readRenames() + if err != nil { + return err + } + c.sweepRenameFindings(&Sources{Renames: renames}, c.now()) + return nil +} + // sweepRenameFindings writes a finding for each window held open past HeldFinding, naming the node, and clears one // whose window closed. func (c *Config) sweepRenameFindings(s *Sources, now time.Time) { diff --git a/modules/mesh-config/cmd/mesh-config/whole_integration_test.go b/modules/mesh-config/cmd/mesh-config/whole_integration_test.go index f004ff88c..a32671dc3 100644 --- a/modules/mesh-config/cmd/mesh-config/whole_integration_test.go +++ b/modules/mesh-config/cmd/mesh-config/whole_integration_test.go @@ -83,6 +83,7 @@ type player struct { catRev int64 // calls counts what the module asked of the runtime, by method (and by key for an ask); puts are the keys it wrote, "/". calls map[string]int + asks map[string]int // the asks of tools and seat verbs, by key puts []string // stop ends the module this player runs: the restart of a module is the old process gone and a new one started. stop func() @@ -368,6 +369,9 @@ func (p *player) handle(m wire) { Body json.RawMessage `json:"body"` } _ = json.Unmarshal(m.Params, &q) + p.mu.Lock() + p.asks[q.Key]++ + p.mu.Unlock() p.answer(m.ID, p.asked(q.Key, q.Body), nil) default: p.answer(m.ID, nil, errors.New("nats: no responders available for request")) @@ -687,7 +691,7 @@ func start(t *testing.T, bin string, js jetstream.JetStream, router *standIn, ha cmd.Stderr = os.Stderr p := &player{t: t, ctx: ctx, js: js, router: router, in: stdin, pending: map[string]chan wire{}, haves: haves, readers: readers, owned: map[string]*ownedState{}, catalog: map[string]catalog.CatalogEntry{}, byFp: map[string]catalog.CatalogEntry{}, - calls: map[string]int{}} + calls: map[string]int{}, asks: map[string]int{}} for _, f := range followed { p.own(f.Read) } @@ -882,6 +886,21 @@ func TestConfigWholeRenamesAndRetiresAgainstTheBus(t *testing.T) { p2.conforms(EventRetiring, &meshconfig.RetiringHolderEvent{}, meshconfig.HolderSubjectRetiring) p2.conforms(EventRetired, &meshconfig.RetiredHolderEvent{}, meshconfig.HolderSubjectRetired) eventually(t, "the retirement is dropped", func() bool { _, ok := p2.get(RetiringState, "radio.band"); return !ok }) + p.noGitAsk() + p2.noGitAsk() +} + +// noGitAsk fails when the module asked the seat git for anything over the whole run (ADR 0681 clause 1: it calls no +// `seat:git.pull`, and no other verb of the seat git is its). +func (p *player) noGitAsk() { + p.t.Helper() + p.mu.Lock() + defer p.mu.Unlock() + for key, n := range p.asks { + if strings.HasPrefix(key, "seat:git.") { + p.t.Errorf("the module asked %s %d times: it holds no value for a pull request", key, n) + } + } } // streamCarries says whether the module's manifest names event among its own streams' events. diff --git a/modules/mesh-config/module.json b/modules/mesh-config/module.json index c6d12e565..c54954179 100644 --- a/modules/mesh-config/module.json +++ b/modules/mesh-config/module.json @@ -125,5 +125,16 @@ "max-age-days": 7, "max-mib": 16 } - ] + ], + "config": { + "deadline-floor-seconds": { + "type": "number", + "description": "the least wait, in seconds, of mesh-config's one deadline timer: it is set for the earliest real deadline it holds (a waiting proposal's end, an unanswered retirement's second ask, a rename window's seven-day held finding) and never sooner than this after a look, so a deadline passed and not settled is tried again, not spun on (lead answer A-490l, ADR 0681).", + "minimum": 1, + "maximum": 3600, + "trusted": false, + "default": 60, + "runtime": true + } + } } -- 2.54.0 From 247d89e152ccde9273653a75b192b9bc4fdc10a1 Mon Sep 17 00:00:00 2001 From: jochen Date: Thu, 19 Nov 2026 23:19:59 +0100 Subject: [PATCH 6/6] =?UTF-8?q?mesh-config:=20a=20rename=20window=20writte?= =?UTF-8?q?n=20after=20start=20rearms=20the=20deadline=20timer=20(issue=20?= =?UTF-8?q?1982;=20ADR=200681=20=C2=A71;=20A-490l)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The timer was rearmed on a write of proposals or retiring only, so a rename window opened after start, with nothing else waiting on a time, left it blocked and its seven-day held finding never came; a window opened under a later armed deadline came late. The condition is now armsDeadline (proposals, retiring, renames), and a test shows a written window rearms it. The comment on Proposal.Pull cites ADR 0681 §5. Builds: ADR 0681 §1; lead answer A-490l (hq main, 03-DESIGN/01-to-be/47-milestones/G-22-lead-answers-2.md: the held finding comes in a quiet mesh too). Claude-Session: https://claude.ai/code/session_01JG73KHUnBze48rdua8u2sy --- modules/mesh-config/cmd/mesh-config/main.go | 7 ++++- .../mesh-config/cmd/mesh-config/proposals.go | 4 +-- .../mesh-config/cmd/mesh-config/quiet_test.go | 31 +++++++++++++++++++ 3 files changed, 39 insertions(+), 3 deletions(-) diff --git a/modules/mesh-config/cmd/mesh-config/main.go b/modules/mesh-config/cmd/mesh-config/main.go index 15d4d8df5..aadd6c207 100644 --- a/modules/mesh-config/cmd/mesh-config/main.go +++ b/modules/mesh-config/cmd/mesh-config/main.go @@ -134,10 +134,15 @@ func (runtimeAsks) Warranted(ask string) error { return err } +// armsDeadline says a write to this state can move the deadline timer: a proposal, a retirement or a rename window (A-490l). +func armsDeadline(state string) bool { + return state == ProposalsState || state == RetiringState || state == RenamesState +} + func main() { own, rearm := newOwnCopy(), make(chan struct{}, 1) own.changed = func(state string) { - if state == ProposalsState || state == RetiringState { + if armsDeadline(state) { select { case rearm <- struct{}{}: default: diff --git a/modules/mesh-config/cmd/mesh-config/proposals.go b/modules/mesh-config/cmd/mesh-config/proposals.go index f821555bb..59d31ac8f 100644 --- a/modules/mesh-config/cmd/mesh-config/proposals.go +++ b/modules/mesh-config/cmd/mesh-config/proposals.go @@ -98,8 +98,8 @@ type Proposal struct { HadValue bool `json:"had-value"` WasDigest string `json:"was-digest"` Trusted bool `json:"trusted,omitempty"` - // Pull is read only: a proposal an earlier mesh-config kept for a pull request (ADR 0502, ended by the operator's word, - // record pending). It is never set on an Approve now, and judged not to be one this module makes (problem). + // Pull is read only: a proposal an earlier mesh-config kept for a pull request (ADR 0502, superseded by ADR 0681 §5). + // It is never set on an Approve now, and judged not to be one this module makes (problem). Pull string `json:"pull,omitempty"` // Reaches is each module on each node whose value it moves, as it was judged when proposed. Reaches []string `json:"reaches"` diff --git a/modules/mesh-config/cmd/mesh-config/quiet_test.go b/modules/mesh-config/cmd/mesh-config/quiet_test.go index 1995523e3..0abf7b72e 100644 --- a/modules/mesh-config/cmd/mesh-config/quiet_test.go +++ b/modules/mesh-config/cmd/mesh-config/quiet_test.go @@ -320,3 +320,34 @@ func TestAHeldWindowIsAFindingAtItsDeadlineWithNoPass(t *testing.T) { t.Error("a deadline is still set once the finding is written") } } + +// A write of a proposal, a retirement or a rename window sets the deadline timer again, and no other state does: a window opened +// after start, with nothing else waiting on a time, must not leave the timer blocked (A-490l). +func TestAWriteOfARenameWindowRearmsTheDeadlineTimer(t *testing.T) { + for state, want := range map[string]bool{ProposalsState: true, RetiringState: true, RenamesState: true, + ValuesState: false, ResolvedState: false, DeclaredState: false} { + if got := armsDeadline(state); got != want { + t.Errorf("a write of %s arms the timer: %v, want %v", state, got, want) + } + } + // Wired as main wires it: the copy's write of a window tells the channel the timer waits on. + b := &busOf{held: map[string]map[string][]byte{}, handles: map[string]func(stdio.StateChange) error{}} + own := b.ownCopy() + rearm := make(chan struct{}, 1) + own.changed = func(state string) { + if armsDeadline(state) { + select { + case rearm <- struct{}{}: + default: + } + } + } + if err := own.write(RenamesState, "player.level", Rename{Module: "player"}); err != nil { + t.Fatal(err) + } + select { + case <-rearm: + default: + t.Error("a rename window written after start did not rearm the timer") + } +} -- 2.54.0