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) diff --git a/modules/mesh-config/README.md b/modules/mesh-config/README.md index 99f368a43..5e5e3dd22 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 @@ -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 09f0b32dd..aadd6c207 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() } @@ -119,8 +134,22 @@ 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() { - 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 armsDeadline(state) { + select { + case rearm <- struct{}{}: + default: + } + } + } + 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]{ @@ -181,6 +210,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 +218,12 @@ 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 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{}) { - // 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 { r, err := c.Reconcile() switch { case err != nil: @@ -215,21 +234,22 @@ 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. 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 @@ -251,32 +271,32 @@ 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) +} + +// 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 } - tick := time.NewTicker(time.Minute) - defer tick.Stop() - for range tick.C { + 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 +// 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) @@ -284,6 +304,25 @@ func hearing(c *Config) { 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 { + at, ok := c.NextDeadline() + if !ok { + <-rearm + continue + } + // 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() + case <-rearm: + timer.Stop() + } } } @@ -379,13 +418,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"}, @@ -398,14 +434,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) @@ -421,8 +449,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] { @@ -431,7 +458,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) { @@ -448,8 +475,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 @@ -468,19 +494,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 new file mode 100644 index 000000000..b27778d50 --- /dev/null +++ b/modules/mesh-config/cmd/mesh-config/ownstates.go @@ -0,0 +1,77 @@ +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, 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, 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..59d31ac8f 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, 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"` // 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}} @@ -910,19 +851,63 @@ 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, 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() + 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)) + } + } + } + // 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() } // ---- the list ---------------------------------------------------------------------------------------------- @@ -940,8 +925,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"` @@ -970,8 +953,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/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/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 50f01da94..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 with each five-minute resolution. -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 new file mode 100644 index 000000000..3070fd7e9 --- /dev/null +++ b/modules/mesh-config/cmd/mesh-config/quiet_integration_test.go @@ -0,0 +1,134 @@ +//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"} + for _, s := range []string{ValuesState, ResolvedState, PredefinedState, ProposalsState, 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 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):]) + } + + // 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..0abf7b72e --- /dev/null +++ b/modules/mesh-config/cmd/mesh-config/quiet_test.go @@ -0,0 +1,353 @@ +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" + "errors" + "strings" + "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{ValuesState: {}}, handles: map[string]func(stdio.StateChange) error{}} + for i := 0; i < 1176; i++ { + b.held[ValuesState]["mesh.key-"+time.Duration(i).String()] = []byte(`{"value":1}`) + } + n := len(b.held[ValuesState]) + own := b.ownCopy() + for pass := 0; pass < 3; pass++ { + 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(ValuesState, 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(ValuesState, "mine", map[string]string{"x": "mine"}); err != nil { + t.Fatal(err) + } + if e, _ := own.get(ValuesState, "mine"); e == nil { + t.Error("a key just written is not read") + } + if err := own.remove(ValuesState, "mine"); err != nil { + t.Fatal(err) + } + 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[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(ValuesState, "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) + } +} + +// 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) + } + } +} + +// 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") + } +} + +// 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") + } +} diff --git a/modules/mesh-config/cmd/mesh-config/renames.go b/modules/mesh-config/cmd/mesh-config/renames.go index f7338a38a..f82a03879 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 { @@ -475,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/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/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/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 9cc30a578..a32671dc3 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,12 @@ 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 + 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() } // ownedState is one state of an owner (the indexer's modules, the assigner's wants...), kept from its bucket. @@ -232,6 +238,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": @@ -357,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")) @@ -675,14 +690,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{}, asks: 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 @@ -708,9 +725,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) } @@ -785,6 +801,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 { @@ -869,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/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 diff --git a/modules/mesh-config/module.json b/modules/mesh-config/module.json index 827c0f7cb..c54954179 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", @@ -132,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 + } + } }