From cd3ef2fd41e3b4c66d1aa5ffa68ceedbe7aa13cb Mon Sep 17 00:00:00 2001 From: jochen Date: Thu, 19 Nov 2026 22:42:28 +0100 Subject: [PATCH] =?UTF-8?q?mesh-config:=20remove=20the=20pull=20request=20?= =?UTF-8?q?path=20(issue=201982;=20ADR=200681=20=C2=A71,=20=C2=A73,=20?= =?UTF-8?q?=C2=A75,=20=C2=A76)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The mesh knows no pull request (design 47 G, G-1 §38-39). Removed: - the states `pulls` and `kept` and all code that reads or writes them (pulls.go, the held values a proposal holds, the listing of held values), SweepPulls, settlePull, HeardPull and the forge call; - the consumes of git.pull-merged and git.pull-closed, the invoke of seat:git.pull; - the config verb's `pull`, `head`, `declares` and `pulls` arguments and its actions `pull-declares` and `held`; - the indexer's config candidates, which only that path used: the consume of mesh-delivery-indexer.views.config-candidates and the invoke of indexer_read_config_candidates (the indexer's state goes in the same group). A stored proposal that names a pull request is judged not one this module makes, so nothing is set on it. Builds: ADR 0681 §1 (no pulls or kept, no git events, no seat:git.pull, no `pull` argument, no pull-declares or held), §3, §5, §6; lead answer A-490l (a stored proposal naming a pull request is refused on its approval). Claude-Session: https://claude.ai/code/session_01JG73KHUnBze48rdua8u2sy --- modules/mesh-config/README.md | 5 +- modules/mesh-config/cmd/mesh-config/config.go | 24 +- .../mesh-config/cmd/mesh-config/delivery.go | 34 + modules/mesh-config/cmd/mesh-config/list.go | 6 - modules/mesh-config/cmd/mesh-config/main.go | 71 +- .../cmd/mesh-config/manifest_test.go | 6 +- .../mesh-config/cmd/mesh-config/ownerviews.go | 8 +- .../mesh-config/cmd/mesh-config/ownstates.go | 5 +- .../mesh-config/cmd/mesh-config/proposals.go | 88 +-- .../cmd/mesh-config/pullforge_test.go | 54 -- modules/mesh-config/cmd/mesh-config/pulls.go | 644 ------------------ .../mesh-config/cmd/mesh-config/pulls_test.go | 504 -------------- .../cmd/mesh-config/quiet_integration_test.go | 11 +- .../mesh-config/cmd/mesh-config/quiet_test.go | 39 +- .../mesh-config/cmd/mesh-config/resolve.go | 4 - .../mesh-config/cmd/mesh-config/sources.go | 12 +- .../mesh-config/cmd/mesh-config/takeover.go | 90 +-- .../cmd/mesh-config/takeover_test.go | 26 +- .../cmd/mesh-config/whole_integration_test.go | 5 +- modules/mesh-config/module.json | 7 - 20 files changed, 113 insertions(+), 1530 deletions(-) delete mode 100644 modules/mesh-config/cmd/mesh-config/pullforge_test.go delete mode 100644 modules/mesh-config/cmd/mesh-config/pulls.go delete mode 100644 modules/mesh-config/cmd/mesh-config/pulls_test.go diff --git a/modules/mesh-config/README.md b/modules/mesh-config/README.md index df2bc093a..5e5e3dd22 100644 --- a/modules/mesh-config/README.md +++ b/modules/mesh-config/README.md @@ -87,8 +87,9 @@ Each directory or archive this module declares says how it treats a file it did - `mesh-config_declared`: each placed module's declarations at the trunk, with the manifest and commit they come from, written only when they differ. - Its own sources hold always (novox/hq ADR 0590): declarations from the modules' own manifests, the list from the - indexer's `predefined`, pull requests' config from the indexer's `config-candidates`. The controller's - `pull-declares`, the take-over, compare and hand-back went with the controller. `config_declared` and + indexer's `predefined`. The controller's `pull-declares`, the take-over, compare and hand-back went with the + controller, and so did every pull request path (`pulls`, `kept`, `held`, a proposal's `pull`): the mesh knows no pull + request (design 47 G, ADR 0502 ended by the operator's word, record pending). `config_declared` and `config_resync` read and write again what it keeps. - A trusted value is set only through propose and the operator's Approve: no controller relay is trusted (issue 1126). - Its sets, clears and warrants are recorded in the hand-act log of the seat `mesh-hand-acts` alone. diff --git a/modules/mesh-config/cmd/mesh-config/config.go b/modules/mesh-config/cmd/mesh-config/config.go index e50109780..84542fd7a 100644 --- a/modules/mesh-config/cmd/mesh-config/config.go +++ b/modules/mesh-config/cmd/mesh-config/config.go @@ -73,10 +73,6 @@ type Change struct { Approved string `json:"approved,omitempty"` At time.Time `json:"at"` Moved []Moved `json:"moved"` - // Pull and Head name the pull request a value is held for, dropped from, or applied from at its merge (novox/hq - // ADR 0502): the actions hold and drop are always about one, and a set with a pull is its merge. - Pull string `json:"pull,omitempty"` - Head string `json:"head,omitempty"` } // Config is the module: its store, its clock, and one lock, so a set and a resolution never interleave. @@ -94,8 +90,6 @@ type Config struct { // Asks is the operator channel as this module asks on it (proposals.go); nil, nothing can be proposed. Asks AskBus - // Forge is the forge as pulls are asked of it (pulls.go); nil, a merge or a close is heard from its events alone. - Forge PullForge // Delivery is what the delivery parts answer (renames.go, retiring.go); nil, no window closes and nothing retires. Delivery Delivery // Catalog is the catalog half: which modules exist and the manifest each entry carries, and the entry of a build's @@ -130,13 +124,6 @@ type Call struct { // Clear asks a proposal to clear the value instead of setting it; Proposal names one proposal to read. Clear bool Proposal string - // Pull names the open pull request that introduces the key, for propose (a held value) and pull-declares; Head is - // the commit its declarations are read at; Declares the config declarations the head adds or changes, by module; - // Pulls the pull requests held asks about, each at a head. - Pull string - Head string - Declares map[string]any - Pulls []PullAt // approval is the operator's warrant a set or a clear is made on: given by a decided proposal alone, never by // a call's arguments. @@ -177,13 +164,8 @@ func (c *Config) Do(call Call) (any, error) { return c.Propose(call) case "proposals": return c.Proposals(call) - case "pull-declares": - return c.PullDeclares(call) - case "held": - return c.Held(call) } - return nil, fmt.Errorf("config does set, clear, list, history, propose, proposals, pull-declares or held; %q is "+ - "none of them", call.Action) + return nil, fmt.Errorf("config does set, clear, list, history, propose or proposals; %q is none of them", call.Action) } // level is the level a call names, refused as ADR 0348 §3 says: a module's own value is for one node. @@ -211,10 +193,6 @@ func (c *Config) Change(call Call) (*SetAnswer, error) { if call.Clear || call.Proposal != "" { return nil, fmt.Errorf("clear and proposal are a proposal's: %s takes neither", call.Action) } - if call.Pull != "" { - return nil, fmt.Errorf("pull names the pull request a value is held for, which only a proposal does: %s takes "+ - "none", call.Action) - } call.approval = nil // only a decided proposal gives one c.mu.Lock() defer c.mu.Unlock() diff --git a/modules/mesh-config/cmd/mesh-config/delivery.go b/modules/mesh-config/cmd/mesh-config/delivery.go index 2ab1babe1..8490cad49 100644 --- a/modules/mesh-config/cmd/mesh-config/delivery.go +++ b/modules/mesh-config/cmd/mesh-config/delivery.go @@ -131,3 +131,37 @@ func (v toolVault) Retire(r RetireRequest) error { _, err = v.ask(VaultRetireAsk, map[string]any{"node": r.Node, "module": r.Module, "name": r.Name, "warrant": rec.Act.ID, "ask": r.Ask}) return err } + +// unwrapAnswer reads a tool's answer whatever wraps it: the protocol's content list, or {output, ok, answer}. +func unwrapAnswer(raw json.RawMessage) (json.RawMessage, string, bool) { + var s string + if json.Unmarshal(raw, &s) == nil { + return unwrapAnswer(json.RawMessage(s)) + } + var m map[string]json.RawMessage + if json.Unmarshal(raw, &m) != nil { + return raw, string(raw), true + } + if content, has := m["content"]; has { + var items []struct { + Text string `json:"text"` + } + var e struct { + IsError bool `json:"isError"` + } + _ = json.Unmarshal(raw, &e) + if json.Unmarshal(content, &items) == nil && len(items) > 0 { + inner, out, ok := unwrapAnswer(json.RawMessage(items[0].Text)) + return inner, out, ok && !e.IsError + } + } + var v struct { + Output string `json:"output"` + OK *bool `json:"ok"` + Answer json.RawMessage `json:"answer"` + } + if json.Unmarshal(raw, &v) == nil && v.OK != nil { + return v.Answer, v.Output, *v.OK + } + return raw, string(raw), true +} diff --git a/modules/mesh-config/cmd/mesh-config/list.go b/modules/mesh-config/cmd/mesh-config/list.go index 099bafaf9..4aa8912c4 100644 --- a/modules/mesh-config/cmd/mesh-config/list.go +++ b/modules/mesh-config/cmd/mesh-config/list.go @@ -19,8 +19,6 @@ type Listed struct { Withheld string `json:"withheld,omitempty"` // Unresolved is each placed module the call narrows to whose declarations cannot be read, with why (issue 1953). Unresolved []Unresolved `json:"unresolved,omitempty"` - // Held is the approved values held for open pull requests, not yet set (novox/hq ADR 0502). - Held []HeldValue `json:"held,omitempty"` } // SetValue is one value set, at its level. @@ -95,10 +93,6 @@ func (c *Config) List(call Call) (*Listed, error) { if call.Module == "" { out.Predefined = s.Predefined } - out.Held = heldListed(s, call) - if len(out.Held) == 0 { - out.Held = nil - } return out, nil } diff --git a/modules/mesh-config/cmd/mesh-config/main.go b/modules/mesh-config/cmd/mesh-config/main.go index b0d927dd8..3c05a9130 100644 --- a/modules/mesh-config/cmd/mesh-config/main.go +++ b/modules/mesh-config/cmd/mesh-config/main.go @@ -144,7 +144,7 @@ func main() { } } } - c := &Config{Store: runtimeStore{own: own}, Logf: logf, Asks: runtimeAsks{}, Forge: toolForge{ask: stdio.Ask}, + c := &Config{Store: runtimeStore{own: own}, Logf: logf, Asks: runtimeAsks{}, Delivery: toolDelivery{ask: stdio.Ask}, Vault: toolVault{ask: stdio.Ask, recorder: recorder}} // The module's one held writer (design 47 G §689, A-16, A-29, A-32): the renames' and retirements' findings and the views reader's go through it. w, err := views.NewStdioHeldWriter(views.WriterConfig[meshconditions.Finding, meshconditions.FindingCleared, meshconditions.FindingsStated, meshconditions.FindingsAskedEvent]{ @@ -214,15 +214,10 @@ func main() { } // resolving resolves at start and again whenever a source moves: an assignment, a want, a catalog revision, an entry -// answered, the predefined list or a config candidate (each reaches `moved` through its view, ownerviews.go and main). It -// reads the forge once for each pull request it keeps something for, so a merge or a close said while this module was down is -// found (ADR 0502); after that it is heard on git.pull-merged and git.pull-closed (hearing), never asked again on a timer +// answered or the predefined list (each reaches `moved` through its view, ownerviews.go and main), and never on a timer // (novox/hq principle 1, issue 1982). The runtime answers only once Serve runs. func resolving(c *Config, moved chan struct{}) { <-stdio.Served() - for _, s := range c.SweepPulls() { - logf("[mesh-config] %s", s) - } for { r, err := c.Reconcile() switch { @@ -249,8 +244,7 @@ func resolving(c *Config, moved chan struct{}) { } } -// hearing takes the router's word on this module's asks, asked again until the runtime takes the subscription, and the -// forge's word on a pull request's merge or close. +// hearing takes the router's word on this module's asks, asked again until the runtime takes the subscription. func hearing(c *Config) { go func() { <-stdio.Served() // subscribed as soon as the runtime serves, never after a guessed wait: an event sent meanwhile is heard @@ -272,29 +266,6 @@ func hearing(c *Config) { time.Sleep(wait) } }() - for _, pattern := range []string{"git.pull-merged", "git.pull-closed"} { - go func(pattern string) { - <-stdio.Served() // subscribed as soon as the runtime serves, never after a guessed wait: an event sent meanwhile is heard - for wait := 2 * time.Second; ; wait = min(wait*2, time.Minute) { - err := stdio.Subscribe(pattern, func(e stdio.Envelope) error { - p, ok := pullEventOf(e.Body) - if !ok { - logf("[mesh-config] %s is not readable", pattern) - return nil - } - for _, s := range c.HeardPull(p, pattern == "git.pull-merged") { - logf("[mesh-config] %s", s) - } - return nil - }) - if err == nil { - return - } - logf("[mesh-config] does not hear %s yet (%v); asking again in %s", pattern, err, wait) - time.Sleep(wait) - } - }(pattern) - } } // deciding reads the router's record of every waiting ask once at start, which finds an answer said while this module was @@ -422,13 +393,10 @@ func Tools(c *Config) []stdio.Tool { "who and why. A trusted value is set only on the operator's Approve: " + "propose asks the operator, under mesh-config's own name on a channel that proves who answered, and sets " + "the value on Approve if what it was shown against still stands; proposals lists them, or one with " + - "proposal. A proposal naming the open pull request that introduces its key (pull) is judged against what " + - "that pull request declares and asked of the operator, and on Approve is held until the pull request " + - "merges, then set; list shows the held values. pull-declares and held are the controller's. list and " + - "history are narrowed by module, node and key.", + "proposal. list and history are narrowed by module, node and key.", Input: map[string]any{"type": "object", "properties": map[string]any{ "action": map[string]any{"type": "string", - "enum": []string{"list", "set", "clear", "history", "propose", "proposals", "pull-declares", "held"}, + "enum": []string{"list", "set", "clear", "history", "propose", "proposals"}, "description": "list when not given"}, "key": map[string]any{"type": "string", "description": "the config key"}, "value": map[string]any{"description": "for set: the value, of the key's declared type"}, @@ -441,14 +409,6 @@ func Tools(c *Config) []stdio.Tool { "clear": map[string]any{"type": "boolean", "description": "for propose: propose clearing the value at its level instead of setting one"}, "proposal": map[string]any{"type": "string", "description": "for proposals: one proposal's id, read whole"}, - "pull": map[string]any{"type": "string", "description": "owner/repository#number: for propose, the open " + - "pull request that introduces the key, so the value is judged against what it declares and held until " + - "it merges (a module's own value on one node); for pull-declares, the pull request declared for"}, - "head": map[string]any{"type": "string", "description": "for pull-declares: the commit the declarations are read at"}, - "declares": map[string]any{"type": "object", "description": "for pull-declares (the controller's): the " + - "config declarations the head adds or changes against its base, by module and key"}, - "pulls": map[string]any{"type": "array", "description": "for held (the controller's): the pull requests " + - "asked about, each {pull, head}", "items": map[string]any{"type": "object"}}, }}, Run: func(args map[string]any) (any, error) { call, err := callOf(args) @@ -464,8 +424,7 @@ func Tools(c *Config) []stdio.Tool { // callOf reads a call's arguments strictly: an argument it does not know is refused, not ignored. func callOf(args map[string]any) (Call, error) { known := map[string]bool{"action": true, "key": true, "value": true, "module": true, "node": true, "why": true, - "by": true, "limit": true, "clear": true, "proposal": true, "pull": true, "head": true, "declares": true, - "pulls": true} + "by": true, "limit": true, "clear": true, "proposal": true} var unknown []string for k := range args { if !known[k] { @@ -474,7 +433,7 @@ func callOf(args map[string]any) (Call, error) { } if len(unknown) > 0 { return Call{}, fmt.Errorf("config takes no %s; it takes action, key, value, module, node, why, by, limit, "+ - "clear, proposal, pull, head, declares and pulls", + "clear and proposal", strings.Join(unknown, ", ")) } str := func(k string) (string, error) { @@ -491,8 +450,7 @@ func callOf(args map[string]any) (Call, error) { var call Call var problems []error for k, into := range map[string]*string{"action": &call.Action, "key": &call.Key, "module": &call.Module, - "node": &call.Node, "why": &call.Why, "by": &call.By, "proposal": &call.Proposal, "pull": &call.Pull, - "head": &call.Head} { + "node": &call.Node, "why": &call.Why, "by": &call.By, "proposal": &call.Proposal} { s, err := str(k) problems = append(problems, err) *into = s @@ -511,19 +469,6 @@ func callOf(args map[string]any) (Call, error) { } call.Clear = b } - if v, ok := args["declares"]; ok && v != nil { - m, ok := v.(map[string]any) - if !ok { - problems = append(problems, errors.New("declares is an object: a module to its keys' declarations")) - } - call.Declares = m - } - if v, ok := args["pulls"]; ok && v != nil { - raw, _ := json.Marshal(v) - if err := json.Unmarshal(raw, &call.Pulls); err != nil { - problems = append(problems, errors.New("pulls is a list of {pull, head}")) - } - } if v, ok := args["value"]; ok { // The value as given, a JSON value: a number for a number, never its text; the validation judges it. call.Value = v diff --git a/modules/mesh-config/cmd/mesh-config/manifest_test.go b/modules/mesh-config/cmd/mesh-config/manifest_test.go index e561cba26..f2dc32240 100644 --- a/modules/mesh-config/cmd/mesh-config/manifest_test.go +++ b/modules/mesh-config/cmd/mesh-config/manifest_test.go @@ -50,10 +50,10 @@ func TestEveryStateAndActHasItsTool(t *testing.T) { } via := map[string]string{ ValuesState: "config list", ResolvedState: "config list", PredefinedState: "config list", - ProposalsState: "config proposals", PullsState: "config list", KeptState: "config list", HistoryLog: "config history", + ProposalsState: "config proposals", HistoryLog: "config history", DeclaredState: DeclaredTool, - AssignmentsRead: "config list", WantsRead: "config list", IndexerPredefinedRead: "config list", CandidatesRead: ResyncTool, - "a resolution": ResyncTool, "the indexer's candidates taken": ResyncTool, + AssignmentsRead: "config list", WantsRead: "config list", IndexerPredefinedRead: "config list", + "a resolution": ResyncTool, // design 32: each new state with the tool that reads it, each act with the tool that starts it. RenamesState: RenamesTool, RetiringState: RetiringTool, FindingsState: "config_renames and config_retiring", "a move refused": RenameAgainTool, "a window dropped": RenameCloseTool, "an ask again": RetiringTool, diff --git a/modules/mesh-config/cmd/mesh-config/ownerviews.go b/modules/mesh-config/cmd/mesh-config/ownerviews.go index a677a0e8c..8ff66ee26 100644 --- a/modules/mesh-config/cmd/mesh-config/ownerviews.go +++ b/modules/mesh-config/cmd/mesh-config/ownerviews.go @@ -1,8 +1,8 @@ package main // What mesh-config reads of the delivery owners' state, through their tools and views families (novox/hq ADR 0615 §1, -// §4 to §6, ADR 0596): never a bucket of theirs. For each of the four states it follows (the indexer's predefined and -// config-candidates, the assigner's assignments and wants) it asks the owner's read tool for the whole +// §4 to §6, ADR 0596): never a bucket of theirs. For each of the three states it follows (the indexer's predefined, the +// assigner's assignments and wants) it asks the owner's read tool for the whole // state at its start, keeps the picture from the owner's `views.` events, and asks again only on a gap. Started // while an owner is down it keeps asking, and past two minutes writes a finding naming the owner and the tool. // @@ -28,7 +28,6 @@ import ( // The tools of the owners that mesh-config asks, by the state they read. const ( IndexerPredefTool = "indexer_read_predefined" - IndexerCandidatesTool = "indexer_read_config_candidates" AssignerAssignmentsTool = "assigner_read_assignments" AssignerWantsTool = "assigner_read_wants" @@ -40,7 +39,6 @@ const ( // state and its tool. var followed = []struct{ Read, Owner, State, Tool string }{ {IndexerPredefinedRead, indexerModule, catalog.StatePredefined, IndexerPredefTool}, - {CandidatesRead, indexerModule, catalog.StateConfigCandidates, IndexerCandidatesTool}, {AssignmentsRead, assignerModule, "assignments", AssignerAssignmentsTool}, {WantsRead, assignerModule, "wants", AssignerWantsTool}, } @@ -189,7 +187,7 @@ func viewTools(c *Config, o func() *ownerViews) []stdio.Tool { return []stdio.Tool{ {Name: FirstViewsTool, Description: "mesh-config's first views of the delivery owners' state: for each of the indexer's " + - "predefined and config-candidates, the assigner's assignments and wants and the catalog half's registrations and " + + "predefined, the assigner's assignments and wants and the catalog half's registrations and " + "each watched branch's revision, the tool it asks, the revision its " + "picture holds, when it asked and was answered, how many asks (and by hand), and whether its condition is raised.", Run: func(map[string]any) (any, error) { diff --git a/modules/mesh-config/cmd/mesh-config/ownstates.go b/modules/mesh-config/cmd/mesh-config/ownstates.go index 642976427..b27778d50 100644 --- a/modules/mesh-config/cmd/mesh-config/ownstates.go +++ b/modules/mesh-config/cmd/mesh-config/ownstates.go @@ -7,7 +7,7 @@ import ( ) // The module's own states are read from a copy each one's watch keeps, never key by key (novox/hq ADR 0580 §1, issue 1982): -// a resolution reads every key of values, resolved, pulls, declared and the rest, and a get per key for each of them, once per +// a resolution reads every key of values, resolved, declared and the rest, and a get per key for each of them, once per // pass and once per delivery event, was about 4,000 requests to the bus every time. A state is watched on its first read, the // watch hands every current value over before the read is answered, and this process's own writes are taken into the copy // as they are made, so a read right after a write sees it. @@ -15,8 +15,7 @@ import ( // ownStates are the states this module keeps and reads through its store (its manifest's `state`, but the findings, which its // held writer alone reads and writes): the ones read from the copy. var ownStates = map[string]bool{ - ValuesState: true, ResolvedState: true, PredefinedState: true, ProposalsState: true, PullsState: true, KeptState: true, - DeclaredState: true, RenamesState: true, RetiringState: true, + ValuesState: true, ResolvedState: true, PredefinedState: true, ProposalsState: true, DeclaredState: true, RenamesState: true, RetiringState: true, } // ownCopy is the copy of the module's own states over a bus: watch hands every current value of a state and then each change, diff --git a/modules/mesh-config/cmd/mesh-config/proposals.go b/modules/mesh-config/cmd/mesh-config/proposals.go index 358f636e8..33895c2f8 100644 --- a/modules/mesh-config/cmd/mesh-config/proposals.go +++ b/modules/mesh-config/cmd/mesh-config/proposals.go @@ -98,11 +98,9 @@ type Proposal struct { HadValue bool `json:"had-value"` WasDigest string `json:"was-digest"` Trusted bool `json:"trusted,omitempty"` - // Pull is the open pull request the value is held for, when it is (novox/hq ADR 0502): the value is then not set - // on Approve but kept apart until the pull request merges, and DeclDigest is the digest of the pull request's - // declaration of the key it was judged and shown against. - Pull string `json:"pull,omitempty"` - DeclDigest string `json:"declaration,omitempty"` + // Pull is read only: a proposal an earlier mesh-config kept for a pull request (ADR 0502, ended by the operator's word, + // record pending). It is never set on an Approve now, and judged not to be one this module makes (problem). + Pull string `json:"pull,omitempty"` // Reaches is each module on each node whose value it moves, as it was judged when proposed. Reaches []string `json:"reaches"` // From is who proposed it, as the bus proved the caller; Why is theirs; At is when. @@ -175,9 +173,6 @@ func (p Proposal) Fingerprint() string { // about is what its ask is about: the value's place, so a newer proposal for it replaces an older one still open // (ADR 0277 §10, at a level, a key). func (p Proposal) about() string { - if p.Pull != "" { - return "config.held." + pullKey(p.Pull) + "." + p.Level.ValueKey(p.Key) - } return "config." + p.Level.ValueKey(p.Key) } @@ -188,9 +183,6 @@ func (p Proposal) Act(option string) occ.Act { "level": p.Level.Kind, "node": p.Level.Node, "module": p.Level.Module, "key": p.Key, "value": p.Digest, "was": p.WasDigest, "had-value": strconv.FormatBool(p.HadValue), "from": p.From, "at": p.At.UTC().Format(time.RFC3339Nano)} - if p.Pull != "" { - act["pull"], act["declaration"] = p.Pull, p.DeclDigest - } return act } @@ -270,16 +262,6 @@ func (p Proposal) summary() string { if p.Trusted { trusted = ", a trusted value," } - if p.Pull != "" { - s := fmt.Sprintf("Holds %s for %s on %s for %s; approved, it takes effect when that pull request merges, "+ - "and is dropped if it closes unmerged. Nothing reaches a machine before the merge.", p.Key, p.Level.Module, - p.Level.Node, p.Pull) - if len([]rune(s)) > occ.SummaryLength { - s = fmt.Sprintf("Holds %s for %s on %s for %s until it merges; dropped if it closes unmerged.", p.Key, - p.Level.Module, p.Level.Node, p.Pull) - } - return s - } reach := p.reaches() s := fmt.Sprintf("%s%s at %s; approved, it takes effect at once on every node it reaches: %s.", verb, trusted, p.Level, reach) @@ -305,9 +287,6 @@ func (p Proposal) headline() string { if p.Action == "clear" { verb = "Clear" } - if p.Pull != "" { - verb = "Hold" - } where := "for the whole mesh" switch p.Level.Kind { case LevelNode: @@ -359,9 +338,6 @@ func (p Proposal) Ask() oc.Ask { a.WholeDetails = w } does := "the value is set at once, and every node it reaches takes it" - if p.Pull != "" { - does = "the value is held for " + p.Pull + ": it is set when that pull request merges, and dropped if it closes unmerged" - } if p.Action == "clear" { does = "the value is cleared at once, and every node it reaches takes what is below it" } @@ -392,8 +368,8 @@ func (p Proposal) problem() string { return "its value is not the value its digest names: it changed after it was asked" case p.Action == "clear" && (len(p.Value) != 0 || p.Digest != valueDigest(nil, false)): return "a clear carries no value" - case p.Pull != "" && (p.Action != "set" || p.Level.Kind != LevelModule || p.DeclDigest == ""): - return "a value held for a pull request is a set of a module's own value, judged against its declaration" + case p.Pull != "": + return "it was held for a pull request, which the mesh knows no more: nothing is set on it" case valueDigest(p.Was, p.HadValue) != p.WasDigest: return "the value it was shown against is not the one its digest names: it changed after it was asked" } @@ -559,39 +535,16 @@ func (c *Config) propose(call Call, action string) (Proposal, oc.Ask, []string, // **Judged as a set judges it, before anyone is asked** (ADR 0277 §4): no ask for a value the verb would refuse. var r rule var trusted bool - var declDigest string vk := level.ValueKey(call.Key) was, had := s.Values[vk] - if call.Pull != "" { - // **A value held for the open pull request that introduces its key** (novox/hq ADR 0502): judged against what - // the pull request declares at its head, as the controller told it, and asked of the operator whatever the - // key's trust. - if action != "set" { - return fail("a clear is not held for a pull request: only a value to set is") - } - if _, _, _, err := parsePull(call.Pull); err != nil { - return fail("%v", err) - } - call.Pull = strings.TrimSpace(call.Pull) - var herr error - r, _, declDigest, herr = heldRule(s, call, level) - if herr != nil { - return fail("%v", herr) - } - trusted = false - k, kept := s.Kept[keptKey(call.Pull, level.Node, level.Module, call.Key)] - was, had = Value{Value: heldValue(k)}, kept - } else { - var derr error - r, trusted, derr = c.declared(s, level, call.Key) - if derr != nil { - return fail("%v", derr) - } + r, trusted, derr := c.declared(s, level, call.Key) + if derr != nil { + return fail("%v", derr) } now := c.now() prop := Proposal{ID: newProposalID(), Action: action, Level: level, Key: call.Key, HadValue: had, WasDigest: valueDigest(was.Value, had), Trusted: trusted, From: call.Caller, Why: why, At: now, - State: ProposalWaiting, Digest: valueDigest(nil, false), Pull: call.Pull, DeclDigest: declDigest} + State: ProposalWaiting, Digest: valueDigest(nil, false)} if had { prop.Was = compact(was.Value) } @@ -618,19 +571,15 @@ func (c *Config) propose(call Call, action string) (Proposal, oc.Ask, []string, if had && string(compact(was.Value)) == string(prop.Value) { return fail("%s at %s already holds exactly %s", call.Key, level, prop.Value) } - if call.Pull == "" { - after.Values[vk] = Value{Value: prop.Value} - } + after.Values[vk] = Value{Value: prop.Value} case "clear": if !had { return fail("nothing is set for %s at %s, so there is nothing to clear", call.Key, level) } delete(after.Values, vk) } - if call.Pull == "" { - for _, m := range diff(Resolve(s), Resolve(after)) { - prop.Reaches = append(prop.Reaches, m.Module+" on "+m.Node) - } + for _, m := range diff(Resolve(s), Resolve(after)) { + prop.Reaches = append(prop.Reaches, m.Module+" on "+m.Node) } if prop.Reaches == nil { prop.Reaches = []string{} @@ -830,14 +779,6 @@ func (c *Config) decide(p Proposal, w oc.Warrant) string { return fmt.Sprintf("proposal %s: approved by the operator, and not set: the decision could not be kept (%v); "+ "it is read again on the next look", p.ID, err) } - if p.Pull != "" { - // **A held value is kept apart, never set on Approve** (ADR 0502 clause 3). - said, err := c.keep(p) - if err != nil { - return keep(ProposalRefused, "approved by the operator, and refused on Approve, so nothing is held: "+err.Error()) - } - return keep(ProposalApproved, "approved by the operator and held: "+said) - } call := Call{Action: p.Action, Key: p.Key, Module: p.Level.Module, Node: p.Level.Node, Why: p.Why, Caller: p.From, approval: &approval{Proposal: p.ID, By: "the operator", Says: p.Approved, Was: p.Was, HadValue: p.HadValue, WasDigest: p.WasDigest}} @@ -972,8 +913,6 @@ type ProposalRow struct { Expires time.Time `json:"expires"` Fingerprint string `json:"fingerprint"` Approved string `json:"approved,omitempty"` - // Pull is the pull request a value is held for, when it is. - Pull string `json:"pull,omitempty"` // What one proposal read whole says besides. Value json.RawMessage `json:"value,omitempty"` Was json.RawMessage `json:"was,omitempty"` @@ -1002,8 +941,7 @@ func (c *Config) Proposals(call Call) ([]ProposalRow, error) { continue } row := ProposalRow{ID: p.ID, Action: p.Action, Level: p.Level, Key: p.Key, State: p.State, Outcome: p.Outcome, - From: p.From, At: p.At, Expires: p.At.Add(ProposalLasts), Fingerprint: p.Fingerprint(), Approved: p.Approved, - Pull: p.Pull} + From: p.From, At: p.At, Expires: p.At.Add(ProposalLasts), Fingerprint: p.Fingerprint(), Approved: p.Approved} if p.State == ProposalWaiting && c.now().After(row.Expires) { row.State = "expired, not yet heard" } diff --git a/modules/mesh-config/cmd/mesh-config/pullforge_test.go b/modules/mesh-config/cmd/mesh-config/pullforge_test.go deleted file mode 100644 index e2418e65c..000000000 --- a/modules/mesh-config/cmd/mesh-config/pullforge_test.go +++ /dev/null @@ -1,54 +0,0 @@ -package main - -import ( - "encoding/json" - "testing" -) - -// toolForge.Pull reads the seat git's answer of the verb pull (design 47 G §654), bare or in the wrappings the runtime puts -// around an answer; pullEventOf reads the seat's pull-merged and pull-closed bodies. -func TestToolForgePullReadsTheSeatGitAnswersAndEventsAreRead(t *testing.T) { - var asked struct { - key string - body map[string]any - } - for _, tc := range []struct { - answer string - open, merged bool - head string - }{ - {`{"pull":{"repository":"novox/mesh-catalog","number":435,"state":"merged","head":"7b5f7f84acb73aaf8189200548ff69fd9aac04b2"}}`, false, true, "7b5f7f84acb73aaf8189200548ff69fd9aac04b2"}, - {`{"pull":{"repository":"novox/mesh-catalog","number":434,"state":"open","head":"c948f3a61c74257e6e3147effb396d9d6434f491"}}`, true, false, "c948f3a61c74257e6e3147effb396d9d6434f491"}, - {`{"pull":{"state":"closed","head":"c948f3a61c74257e6e3147effb396d9d6434f491"}}`, false, false, "c948f3a61c74257e6e3147effb396d9d6434f491"}, - } { - raw := json.RawMessage(tc.answer) - content, _ := json.Marshal(map[string]any{"content": []map[string]any{{"type": "text", "text": tc.answer}}}) - ok, _ := json.Marshal(map[string]any{"ok": true, "output": "", "answer": raw}) - for name, answer := range map[string]json.RawMessage{"bare": raw, "content list": content, "ok answer": ok} { - f := toolForge{ask: func(key string, body any) (json.RawMessage, error) { - asked.key, asked.body = key, body.(map[string]any) - return answer, nil - }} - open, merged, head, err := f.Pull("novox", "mesh-catalog", 434) - if err != nil || open != tc.open || merged != tc.merged || head != tc.head { - t.Errorf("%s (%s): open %v merged %v head %q, err %v", tc.answer, name, open, merged, head, err) - } - if asked.key != "seat:git.pull" || asked.body["repository"] != "novox/mesh-catalog" || asked.body["number"] != 434 { - t.Errorf("asked %+v", asked) - } - } - } - failed := toolForge{ask: func(string, any) (json.RawMessage, error) { - return json.RawMessage(`{"error":"no such pull request","error-kind":"not-found"}`), nil - }} - if _, _, _, err := failed.Pull("novox", "mesh-catalog", 9); err == nil { - t.Error("an error answer was read as a pull request") - } - p, ok := pullEventOf([]byte(`{"repository":"novox/mesh-catalog","number":435,"branch":"fix/a","head":"7b5f7f84acb73aaf8189200548ff69fd9aac04b2","base":"main"}`)) - if !ok || p.Owner != "novox" || p.Repo != "mesh-catalog" || p.Number != 435 || p.HeadSHA != "7b5f7f84acb73aaf8189200548ff69fd9aac04b2" { - t.Errorf("%+v %v", p, ok) - } - if _, ok := pullEventOf([]byte(`{"repository":"norepo","number":1}`)); ok { - t.Error("a repository with no owner was read") - } -} diff --git a/modules/mesh-config/cmd/mesh-config/pulls.go b/modules/mesh-config/cmd/mesh-config/pulls.go deleted file mode 100644 index 3508a95bf..000000000 --- a/modules/mesh-config/cmd/mesh-config/pulls.go +++ /dev/null @@ -1,644 +0,0 @@ -package main - -import ( - "crypto/sha256" - "encoding/hex" - "encoding/json" - "errors" - "fmt" - "regexp" - "strconv" - "strings" - "time" - - "git.novox.be/novox/mesh-contracts/go/clients/meshconfigclient" -) - -// A config value held for the open pull request that introduces its key (novox/hq ADR 0502, issue 1826). -// -// A key a pull request adds is declared by no registered manifest until it merges, so a value for it, which the -// pull request's composed check needs, was refused. The controller reads each pull request's manifests from the -// forge at its head and tells this module the config declarations the head adds or changes (PullDeclares); mesh-config -// reads no manifest itself (ADR 0495 §1). A proposal that names the pull request is judged against those, asked of the -// operator whatever the key's trust, and on Approve kept apart (KeptState) from the values it resolves. The -// controller asks for the approved held values of a check's pull requests (Held) and hands them to the composed -// check. At the merge the value is written as the module's own value on its node (PullMerged), where it resolves -// once the trunk declares the key; a pull request closed unmerged drops it (PullClosed). Nothing reaches a machine -// before the merge. - -// The states of held values, and the actions their changes carry in the history and in `config-changed`. -const ( - PullsState = "pulls" - KeptState = "kept" - - ActionHold = "hold" - ActionDrop = "drop" -) - -// pullName is a pull request as it is named: owner/repository#number. -var pullName = regexp.MustCompile(`^([A-Za-z0-9_.-]+)/([A-Za-z0-9_.-]+)#([0-9]+)$`) - -func parsePull(s string) (owner, repo string, number int, err error) { - m := pullName.FindStringSubmatch(strings.TrimSpace(s)) - if m == nil { - return "", "", 0, fmt.Errorf("%q is not a pull request: name it owner/repository#number", s) - } - n, _ := strconv.Atoi(m[3]) - if n <= 0 { - return "", "", 0, fmt.Errorf("%q is not a pull request: its number is above zero", s) - } - return m[1], m[2], n, nil -} - -// pullKey is a pull request's key in the states. -func pullKey(pull string) string { - return strings.NewReplacer("/", ".", "#", ".").Replace(strings.TrimSpace(pull)) -} - -// PullDecl is what the controller told: the config declarations a pull request's head adds or changes, by module. -type PullDecl struct { - Pull string `json:"pull"` - Head string `json:"head"` - Declares map[string]map[string]Declaration `json:"declares"` - At time.Time `json:"at"` -} - -// KeptValue is an approved held value, kept apart from the values mesh-config resolves, in the layout of the seat's state -// `kept`, which the checker and the assigner's composition check read (novox/hq ADR 0565 §5, ADR 0634 §4). -type KeptValue = meshconfigclient.Kept - -// keptKey is a held value's key in `kept`: the pull request's key form (pullKey), the node, the module and the config -// key, joined by dots. -func keptKey(pull, node, module, key string) string { - k, _ := meshconfigclient.HeldValueKey(pull, node, module, key) // a held value of no pull request has no key, and is found by none - return k -} - -// heldValue is the value held, as the operator approved it, in its JSON form. -func heldValue(k KeptValue) json.RawMessage { - raw, _ := meshconfigclient.ValueOf(k) // a value that was read from JSON writes as JSON - return raw -} - -func heldAt(t time.Time) *time.Time { return &t } - -func keptStateKey(k KeptValue) string { return keptKey(k.Pull, k.Node, k.Module, k.Key) } - -func keptLevel(k KeptValue) Level { return Level{Kind: LevelModule, Node: k.Node, Module: k.Module} } - -// declDigest is the digest of what a declaration holds a value to: a held value stays only while it is the same. -func declDigest(d Declaration) string { - d.Description, d.Why, d.Kind, d.Runtime = "", "", "", false - if !d.HasDefault() { - d.Default = nil - } else { - d.Default = compact(d.Default) - } - raw, _ := json.Marshal(d) - sum := sha256.Sum256(raw) - return "sha256:" + hex.EncodeToString(sum[:]) -} - -// PullForge is the forge as this module asks it of a pull request: its state, and whether it merged. -type PullForge interface { - Pull(owner, repo string, number int) (open, merged bool, head string, err error) -} - -// pulls reads what is kept for pull requests, and the held values. -func (c *Config) readPulls(s *Sources) error { - s.Pulls, s.Kept = map[string]PullDecl{}, map[string]KeptValue{} - if err := c.each(PullsState, func(key string, raw []byte) error { - var p PullDecl - if err := json.Unmarshal(raw, &p); err != nil || p.Pull == "" { - return nil // not one this module wrote - } - s.Pulls[pullKey(p.Pull)] = p - return nil - }); err != nil { - return fmt.Errorf("the pull requests' declarations cannot be read: %w", err) - } - if err := c.each(KeptState, func(key string, raw []byte) error { - k, err := meshconfigclient.DecodeKept(key, raw) - if err != nil { - return nil // not a held value of the seat's layout under its own key - } - s.Kept[key] = k - return nil - }); err != nil { - return fmt.Errorf("the held values cannot be read: %w", err) - } - return nil -} - -// ---- pull-declares --------------------------------------------------------------------------------------- - -// PullDeclaresAnswer is what pull-declares answers. -type PullDeclaresAnswer struct { - Said string `json:"said"` - Pull string `json:"pull"` - Head string `json:"head"` - Modules []string `json:"modules"` - Dropped []string `json:"dropped,omitempty"` - Unsaid []string `json:"unsaid,omitempty"` -} - -// PullDeclares is gone: a pull request's config declarations are read from the indexer's config-candidates -// (takeCandidates), and the controller that told them is not placed (novox/hq ADR 0565 §4, ADR 0590). -func (c *Config) PullDeclares(Call) (*PullDeclaresAnswer, error) { - return nil, errors.New("pull-declares is gone: mesh-config reads a pull request's config declarations from the " + - "indexer's config-candidates (novox/hq ADR 0565 §4, ADR 0590)") -} - -// declarePull keeps what a pull request's head declares and judges again the values held for it, from the indexer's -// config candidates. The caller holds the lock. -func (c *Config) declarePull(pull, head string, declares map[string]map[string]Declaration) (*PullDeclaresAnswer, error) { - if err := c.Store.Put(PullsState, pullKey(pull), PullDecl{Pull: pull, Head: head, Declares: declares, - At: c.now()}); err != nil { - return nil, fmt.Errorf("the declarations were not kept: %v", err) - } - a := &PullDeclaresAnswer{Pull: pull, Head: head, Modules: sortedKeys(declares)} - var s Sources - if err := c.readPulls(&s); err != nil { - return nil, err - } - for _, k := range sortedKeys(s.Kept) { - kv := s.Kept[k] - if pullKey(kv.Pull) != pullKey(pull) { - continue - } - why := "" - d, declared := declares[kv.Module][kv.Key] - switch { - case !declared: - why = "the head no longer adds or changes its declaration" - case declDigest(d) != kv.Declaration: - why = "the head declares the key otherwise than the value was approved against" - default: - var v any - _ = json.Unmarshal(heldValue(kv), &v) - if p := d.rule().check(v); len(p) > 0 { - why = "the value no longer passes: " + strings.Join(p, "; ") - } - } - if why != "" { - a.Unsaid = append(a.Unsaid, c.dropKept(kv, "the new head "+short(head)+": "+why)...) - a.Dropped = append(a.Dropped, fmt.Sprintf("%s for %s on %s: %s", kv.Key, kv.Module, kv.Node, why)) - continue - } - if kv.Head != head { - kv.Head = head - if err := c.Store.Put(KeptState, k, kv); err != nil { - a.Unsaid = append(a.Unsaid, "the held value "+k+" was not moved to the new head: "+err.Error()) - } - } - } - a.Said = fmt.Sprintf("keeps what %s declares at %s for %d module(s)", pull, short(head), len(declares)) - if len(a.Dropped) > 0 { - a.Said += fmt.Sprintf("; %d held value(s) dropped", len(a.Dropped)) - } - return a, nil -} - -// heldChange records a hold, a drop or a merge's set of a held value in the history, the hand-act log and -// config-changed; what could not be done is answered, not dropped. -func (c *Config) heldChange(kv KeptValue, action, why, approved string) []string { - level := keptLevel(kv) - ch := Change{Action: action, Level: &level, Key: kv.Key, Value: heldValue(kv), By: kv.By, Via: kv.Via, Why: why, - Approved: approved, Pull: kv.Pull, Head: kv.Head, At: c.now(), Moved: []Moved{}} - unsaid := c.record(level.ValueKey(kv.Key), ch) - cause := "a value held for " + kv.Pull - what := fmt.Sprintf("config %s %s of %s for %s, held for %s", action, kv.Key, kv.Module, kv.Node, kv.Pull) - if action != ActionDrop { - what += " (" + string(heldValue(kv)) + ")" - } - if err := c.Store.HandAct(what, why, cause); err != nil { - unsaid = append(unsaid, "the hand-act log does not hold it: "+err.Error()) - } - return unsaid -} - -// dropKept removes a held value, saying why. -func (c *Config) dropKept(kv KeptValue, why string) []string { - if err := c.Store.Delete(KeptState, keptStateKey(kv)); err != nil { - return []string{"the held value " + keptStateKey(kv) + " was not dropped: " + err.Error()} - } - c.logf("[mesh-config] dropped %s of %s on %s held for %s: %s", kv.Key, kv.Module, kv.Node, kv.Pull, why) - return c.heldChange(kv, ActionDrop, "dropped, nothing was set: "+why, "") -} - -// ---- held ------------------------------------------------------------------------------------------------ - -// HeldAnswer is what held answers: the approved held values of the pull requests asked, at the heads asked. -type HeldAnswer struct { - Held []HeldValue `json:"held"` - Skipped []HeldSkipped `json:"skipped"` -} - -// HeldValue is one approved held value as it is handed to a composed check and listed. -type HeldValue struct { - Pull string `json:"pull"` - Head string `json:"head"` - Node string `json:"node"` - Module string `json:"module"` - Key string `json:"key"` - Value json.RawMessage `json:"value"` - Approved string `json:"approved"` - By string `json:"by,omitempty"` - Why string `json:"why,omitempty"` - At time.Time `json:"at"` -} - -// HeldSkipped is a pull request asked for whose held values are not answered, and why. -type HeldSkipped struct { - Pull string `json:"pull"` - Why string `json:"why"` -} - -func heldValueOf(k KeptValue) HeldValue { - return HeldValue{Pull: k.Pull, Head: k.Head, Node: k.Node, Module: k.Module, Key: k.Key, Value: compact(heldValue(k)), - Approved: k.Approved, By: k.By, Why: k.Why, At: timeOf(k.At)} -} - -// Held answers the approved held values for the pull requests asked, at the heads asked, to the controller alone: a -// pull request at another head than the one kept is skipped and said (ADR 0502 clause 4). -func (c *Config) Held(call Call) (*HeldAnswer, error) { - if call.Caller != ControllerCaller { - return nil, fmt.Errorf("held is the controller's: it hands the held values to a composed check; %s is not "+ - "the controller", call.Caller) - } - asked := map[string]string{} - var order []string - for _, p := range call.Pulls { - if _, _, _, err := parsePull(p.Pull); err != nil { - return nil, err - } - if strings.TrimSpace(p.Head) == "" { - return nil, fmt.Errorf("name the head of %s", p.Pull) - } - if _, dup := asked[pullKey(p.Pull)]; !dup { - order = append(order, strings.TrimSpace(p.Pull)) - } - asked[pullKey(p.Pull)] = strings.TrimSpace(p.Head) - } - c.mu.Lock() - defer c.mu.Unlock() - var s Sources - if err := c.readPulls(&s); err != nil { - return nil, err - } - out := &HeldAnswer{Held: []HeldValue{}, Skipped: []HeldSkipped{}} - for _, p := range order { - head := asked[pullKey(p)] - var mine []KeptValue - for _, k := range sortedKeys(s.Kept) { - if pullKey(s.Kept[k].Pull) == pullKey(p) { - mine = append(mine, s.Kept[k]) - } - } - for _, k := range mine { - if k.Head != head { - out.Skipped = append(out.Skipped, HeldSkipped{Pull: p, Why: fmt.Sprintf("%s for %s on %s is held "+ - "at head %s, not %s", k.Key, k.Module, k.Node, short(k.Head), short(head))}) - continue - } - out.Held = append(out.Held, heldValueOf(k)) - } - } - return out, nil -} - -// HeldListed is the held values a listing shows, narrowed by module, node and key. -func heldListed(s Sources, call Call) []HeldValue { - out := []HeldValue{} - for _, k := range sortedKeys(s.Kept) { - kv := s.Kept[k] - if (call.Module == "" || kv.Module == call.Module) && (call.Node == "" || kv.Node == call.Node) && - (call.Key == "" || kv.Key == call.Key) { - out = append(out, heldValueOf(kv)) - } - } - return out -} - -// ---- the proposal's rule ------------------------------------------------------------------------------- - -// heldRule is the rule a value held for a pull request is judged by: the pull request's declaration of the key for -// the module at its head, and the module's assignment to the node. Refused, saying what the pull request does -// declare, when it declares none. -func heldRule(s Sources, call Call, level Level) (rule, PullDecl, string, error) { - if level.Kind != LevelModule { - return rule{}, PullDecl{}, "", fmt.Errorf("a value held for a pull request is a module's own value on one "+ - "node, and %s is not one: a predefined key a pull request adds is set after its merge (novox/hq ADR 0502)", - level) - } - pd, ok := s.Pulls[pullKey(call.Pull)] - if !ok { - return rule{}, PullDecl{}, "", fmt.Errorf("mesh-config holds no declaration for %s: the controller tells it "+ - "what a pull request declares when its head is announced, and none has been", strings.TrimSpace(call.Pull)) - } - d, ok := pd.Declares[level.Module][call.Key] - if !ok { - return rule{}, PullDecl{}, "", fmt.Errorf("%s does not add or change a value %q for %s at %s; it declares "+ - "for %s: %s", pd.Pull, call.Key, level.Module, short(pd.Head), level.Module, joinKeys(pd.Declares[level.Module])) - } - if _, reg := s.Declared[level.Module]; !reg { - return rule{}, PullDecl{}, "", fmt.Errorf("%s is not a registered module, so a value cannot be held for it", level.Module) - } - if !assigned(s, level.Node, level.Module) { - return rule{}, PullDecl{}, "", fmt.Errorf("%s is not placed on %s, and a module's own value is set for a node "+ - "it is placed on (novox/hq ADR 0348 §3); it is placed on: %s", level.Module, level.Node, - strings.Join(nodesOf(s, level.Module), ", ")) - } - return d.rule(), pd, declDigest(d), nil -} - -// keep holds an approved proposal's value apart. The caller holds the lock. -func (c *Config) keep(p Proposal) (string, error) { - var s Sources - if err := c.readPulls(&s); err != nil { - return "", err - } - pd, ok := s.Pulls[pullKey(p.Pull)] - if !ok { - return "", fmt.Errorf("mesh-config holds no declaration for %s any more", p.Pull) - } - d, ok := pd.Declares[p.Level.Module][p.Key] - if !ok || declDigest(d) != p.DeclDigest { - return "", fmt.Errorf("%s declares %s otherwise than the operator was shown, or no longer declares it: "+ - "propose it again", p.Pull, p.Key) - } - was, had := s.Kept[keptKey(p.Pull, p.Level.Node, p.Level.Module, p.Key)] - if had != p.HadValue || valueDigest(heldValue(was), had) != p.WasDigest { - return "", fmt.Errorf("the value held for %s changed since the operator was shown the change: propose it "+ - "again", p.Pull) - } - kv := KeptValue{Pull: p.Pull, Head: pd.Head, Declaration: p.DeclDigest, Node: p.Level.Node, Module: p.Level.Module, - Key: p.Key, Value: p.Value, By: "the operator", Via: p.From, Why: p.Why, Approved: p.Approved, Proposal: p.ID, - At: heldAt(c.now())} - if err := c.Store.Put(KeptState, keptStateKey(kv), kv); err != nil { - return "", fmt.Errorf("the value was not kept: %v", err) - } - unsaid := c.heldChange(kv, ActionHold, "held for "+p.Pull+" until it merges: "+p.Why, p.Approved) - said := fmt.Sprintf("%s of %s on %s is held at %s for %s until it merges", p.Key, p.Level.Module, p.Level.Node, - short(pd.Head), p.Pull) - if len(unsaid) > 0 { - said += " (" + strings.Join(unsaid, "; ") + ")" - } - return said, nil -} - -// ---- the merge and the close --------------------------------------------------------------------------- - -// PullMerged writes each value held for a pull request as the module's own value on its node, with the approval kept -// beside it; it resolves once the trunk declares the key. It answers a line for each. -func (c *Config) PullMerged(pull, head string) []string { - return c.settlePull(pull, true, head) -} - -// PullClosed drops the values held for a pull request closed unmerged, and says that nothing was set. -func (c *Config) PullClosed(pull string) []string { - return c.settlePull(pull, false, "") -} - -func (c *Config) settlePull(pull string, merged bool, head string) []string { - c.mu.Lock() - defer c.mu.Unlock() - var s Sources - if err := c.readPulls(&s); err != nil { - return []string{err.Error()} - } - var said []string - wrote := false - for _, k := range sortedKeys(s.Kept) { - kv := s.Kept[k] - if pullKey(kv.Pull) != pullKey(pull) { - continue - } - if !merged { - said = append(said, fmt.Sprintf("%s of %s on %s was held for %s, which closed unmerged: dropped, "+ - "nothing was set", kv.Key, kv.Module, kv.Node, kv.Pull)) - said = append(said, c.dropKept(kv, kv.Pull+" closed unmerged")...) - continue - } - // **Only a value held at the merged head, whose key that head declares as it was approved** (ADR 0502 clause 7). - why := "" - pd, known := s.Pulls[pullKey(pull)] - d, declared := pd.Declares[kv.Module][kv.Key] - switch { - case head == "": - why = "the merged head is not known, so the value cannot be held to it" - case !strings.EqualFold(head, kv.Head): - why = fmt.Sprintf("it is held at head %s and the pull request merged at %s", short(kv.Head), short(head)) - case !known || !declared || declDigest(d) != kv.Declaration: - why = "the merged head does not declare the key as the operator was shown" - } - if why != "" { - said = append(said, fmt.Sprintf("%s of %s on %s was held for %s, which merged: dropped, nothing was set (%s)", - kv.Key, kv.Module, kv.Node, kv.Pull, why)) - said = append(said, c.dropKept(kv, kv.Pull+" merged, but "+why)...) - continue - } - vk := keptLevel(kv).ValueKey(kv.Key) - v := Value{Value: compact(heldValue(kv)), By: kv.By, Via: kv.Via, Why: kv.Why + " (held for " + kv.Pull + - ", merged)", Approved: kv.Approved, At: c.now()} - if err := c.Store.Put(ValuesState, vk, v); err != nil { - said = append(said, fmt.Sprintf("%s of %s on %s held for %s is not written yet: %v; it is tried "+ - "again", kv.Key, kv.Module, kv.Node, kv.Pull, err)) - continue - } - if err := c.Store.Delete(KeptState, k); err != nil { - said = append(said, "the held value "+k+" is written but not removed: "+err.Error()) - } - wrote = true - said = append(said, c.heldChange(kv, "set", kv.Pull+" merged: the held value is the module's own value now", - kv.Approved)...) - said = append(said, fmt.Sprintf("%s of %s on %s held for %s is set: %s", kv.Key, kv.Module, kv.Node, - kv.Pull, kv.Value)) - } - if wrote { - if s2, err := c.sources(); err == nil { - if _, err := c.writeResolved(s2); err != nil { - said = append(said, "the resolved values are not all written yet ("+err.Error()+"); the next "+ - "resolution writes them") - } - } - } - left := 0 - for _, k := range sortedKeys(s.Kept) { - if pullKey(s.Kept[k].Pull) != pullKey(pull) { - continue - } - if e, err := c.Store.Get(KeptState, k); err != nil || e != nil { - left++ - } - } - if left == 0 { - if err := c.Store.Delete(PullsState, pullKey(pull)); err != nil { - said = append(said, "the declarations of "+pull+" were not removed: "+err.Error()) - } - } - return said -} - -// PullEvent is a pull request merged or closed, as far as this module reads it: the seat `git`'s `pull-merged` or `pull-closed` -// (design 47 G §654), read by pullEventOf. -type PullEvent struct { - Owner string - Repo string - Number int - Merged bool - // HeadSHA is the head the pull request merged at. - HeadSHA string -} - -// pullEventOf reads the seat `git`'s `pull-merged` or `pull-closed` body: the repository `/`, the number and the head. -func pullEventOf(body []byte) (PullEvent, bool) { - var e struct { - Repository string `json:"repository"` - Number int `json:"number"` - Head string `json:"head"` - } - if json.Unmarshal(body, &e) != nil { - return PullEvent{}, false - } - owner, repo, ok := strings.Cut(e.Repository, "/") - return PullEvent{Owner: owner, Repo: repo, Number: e.Number, HeadSHA: e.Head}, ok -} - -func (p PullEvent) name() string { return fmt.Sprintf("%s/%s#%d", p.Owner, p.Repo, p.Number) } - -// HeardPull takes the forge's word that a pull request merged or closed. A close is asked of the forge when it can -// be, because a merged pull request may be announced as closed too. -func (c *Config) HeardPull(p PullEvent, merged bool) []string { - if p.Owner == "" || p.Repo == "" || p.Number <= 0 { - return nil - } - head := p.HeadSHA - if !merged && !p.Merged && c.Forge != nil { - // A close is told from a merge by the forge; when it cannot be asked nothing is dropped, and the five-minute - // look finds it. - open, m, h, err := c.Forge.Pull(p.Owner, p.Repo, p.Number) - if err != nil { - c.logf("[mesh-config] %s closed, and the forge does not say whether it merged (%v); the next look decides", p.name(), err) - return nil - } - if open { - return nil - } - merged = m - if head == "" { - head = h - } - } - return c.settlePull(p.name(), merged || p.Merged, head) -} - -// SweepPulls looks at the forge for every pull request it keeps something for, so a merge or a close it did not hear -// is found: run once at start (resolving). -func (c *Config) SweepPulls() []string { - if c.Forge == nil { - return nil - } - c.mu.Lock() - var s Sources - err := c.readPulls(&s) - c.mu.Unlock() - if err != nil { - return []string{err.Error()} - } - seen := map[string]string{} - for _, p := range s.Pulls { - seen[pullKey(p.Pull)] = p.Pull - } - for _, k := range s.Kept { - seen[pullKey(k.Pull)] = k.Pull - } - var said []string - for _, key := range sortedKeys(seen) { - pull := seen[key] - owner, repo, n, err := parsePull(pull) - if err != nil { - continue - } - open, merged, head, err := c.Forge.Pull(owner, repo, n) - if err != nil { - said = append(said, fmt.Sprintf("the forge does not say whether %s is open: %v", pull, err)) - continue - } - if !open { - said = append(said, c.settlePull(pull, merged, head)...) - } - } - return said -} - -// PullAt is a pull request at a head, as held asks about it. -type PullAt struct { - Pull string `json:"pull"` - Head string `json:"head"` -} - -// toolForge asks the forge's holder through its tools. -type toolForge struct { - ask func(key string, body any) (json.RawMessage, error) -} - -// Pull asks the seat `git`'s verb `pull` whether a pull request is open, and whether it merged. -func (f toolForge) Pull(owner, repo string, number int) (bool, bool, string, error) { - raw, err := f.ask(GitPullAsk, map[string]any{"repository": owner + "/" + repo, "number": number}) - if err != nil { - return false, false, "", err - } - answer, output, ok := unwrapAnswer(raw) - if !ok { - return false, false, "", fmt.Errorf("the seat git refused pull: %s", output) - } - var a struct { - Pull struct { - State string `json:"state"` - Head string `json:"head"` - } `json:"pull"` - Error string `json:"error"` - } - if err := json.Unmarshal(answer, &a); err != nil || a.Error != "" || a.Pull.State == "" { - return false, false, "", fmt.Errorf("the seat git's pull is not readable: %s", output) - } - return a.Pull.State == "open", a.Pull.State == "merged", a.Pull.Head, nil -} - -// GitPullAsk is the seat `git`'s verb that answers one pull request. -const GitPullAsk = "seat:git.pull" - -// unwrapAnswer reads a tool's answer whatever wraps it: the protocol's content list, or {output, ok, answer}. -func unwrapAnswer(raw json.RawMessage) (json.RawMessage, string, bool) { - var s string - if json.Unmarshal(raw, &s) == nil { - return unwrapAnswer(json.RawMessage(s)) - } - var m map[string]json.RawMessage - if json.Unmarshal(raw, &m) != nil { - return raw, string(raw), true - } - if content, has := m["content"]; has { - var items []struct { - Text string `json:"text"` - } - var e struct { - IsError bool `json:"isError"` - } - _ = json.Unmarshal(raw, &e) - if json.Unmarshal(content, &items) == nil && len(items) > 0 { - inner, out, ok := unwrapAnswer(json.RawMessage(items[0].Text)) - return inner, out, ok && !e.IsError - } - } - var v struct { - Output string `json:"output"` - OK *bool `json:"ok"` - Answer json.RawMessage `json:"answer"` - } - if json.Unmarshal(raw, &v) == nil && v.OK != nil { - return v.Answer, v.Output, *v.OK - } - return raw, string(raw), true -} diff --git a/modules/mesh-config/cmd/mesh-config/pulls_test.go b/modules/mesh-config/cmd/mesh-config/pulls_test.go deleted file mode 100644 index 23f0ea9b8..000000000 --- a/modules/mesh-config/cmd/mesh-config/pulls_test.go +++ /dev/null @@ -1,504 +0,0 @@ -package main - -import ( - "encoding/json" - "errors" - "strings" - "testing" - "time" - - "git.novox.be/novox/mesh-contracts/go/clients/meshconfigclient" - - occ "git.novox.be/novox/mesh-contracts/operator-and-conversation/go/clients/operatorchannelclient" -) - -// Issue 1826 (novox/hq ADR 0502): a value held for the open pull request that introduces its key. - -const thePull = "novox/mesh-catalog#434" - -// n8nPullDeclares is what the controller tells of the pull request: n8n gets a required number media-gid. -func n8nPullDeclares() map[string]any { - return map[string]any{"n8n": map[string]any{"media-gid": map[string]any{"type": "number", - "description": "the media group", "required": true, "minimum": 1, "maximum": 65535}}} -} - -// aHoldingMesh is a proposing mesh with n8n assigned to ace and declaring nothing on the trunk (the case of the -// issue), and a stand-in forge. -func aHoldingMesh(t *testing.T) (*Config, *memStore, *standIn, *standForge) { - t.Helper() - c, m, r := aProposingMesh(t) - m.declare(t, "n8n", `{"module":"n8n","settings":{}}`) - m.assign(t, "ace", "n8n") - f := &standForge{state: map[string][2]bool{}} - c.Forge = f - if _, err := c.Reconcile(); err != nil { - t.Fatal(err) - } - m.events, m.handActs = nil, nil - return c, m, r, f -} - -type standForge struct { - state map[string][2]bool // pull -> open, merged - head string - err error -} - -func (f *standForge) Pull(owner, repo string, n int) (bool, bool, string, error) { - if f.err != nil { - return false, false, "", f.err - } - st, ok := f.state[(PullEvent{Owner: owner, Repo: repo, Number: n}).name()] - if !ok { - return true, false, f.head, nil - } - return st[0], st[1], f.head, nil -} - -// tell keeps what a pull request's head declares as the indexer's candidate is taken (takeCandidates). -func tell(t *testing.T, c *Config, pull, head string, declares map[string]any) *PullDeclaresAnswer { - t.Helper() - raw, _ := json.Marshal(declares) - d := map[string]map[string]Declaration{} - if err := json.Unmarshal(raw, &d); err != nil { - t.Fatal(err) - } - c.mu.Lock() - defer c.mu.Unlock() - a, err := c.declarePull(pull, head, d) - if err != nil { - t.Fatalf("declare: %v", err) - } - return a -} - -// holdIt proposes media-gid=2000 for n8n on ace held for the pull request and has the operator approve it. -func holdIt(t *testing.T, c *Config, m *memStore, r *standIn) string { - t.Helper() - a := propose(t, c, Call{Module: "n8n", Node: "ace", Key: "media-gid", Value: 2000.0, Pull: thePull, - Why: "n8n's container joins the media group, held for #434"}) - r.choose(t, a.Proposal, OptionApprove, nil) - said, err := c.Decide() - if err != nil || len(said) != 1 || !strings.Contains(said[0], "approved by the operator and held") { - t.Fatalf("the Approve decided %v (%v)", said, err) - } - return a.Proposal -} - -func keptCount(m *memStore) int { k, _ := m.Keys(KeptState); return len(k) } - -// 1826/K1: mesh-config keeps what a pull request declares per pull request; pull-declares is gone (ADR 0590). -func TestAPullRequestsDeclarationsAreKeptPerPullRequest(t *testing.T) { - c, m, _, _ := aHoldingMesh(t) - for _, caller := range []string{"g14.node-tools", Unproven, "", ControllerCaller} { - if _, err := c.Do(Call{Action: "pull-declares", Pull: thePull, Head: "abc1234", Declares: n8nPullDeclares(), - Caller: caller}); err == nil || !strings.Contains(err.Error(), "config-candidates") { - t.Errorf("pull-declares from %q: %v", caller, err) - } - } - a := tell(t, c, thePull, "abc1234def", n8nPullDeclares()) - if len(a.Modules) != 1 || a.Modules[0] != "n8n" { - t.Errorf("answered %+v", a) - } - e, _ := m.Get(PullsState, "novox.mesh-catalog.434") - var pd PullDecl - if e == nil || json.Unmarshal(e.Value, &pd) != nil || pd.Head != "abc1234def" || - pd.Declares["n8n"]["media-gid"].Type != "number" || !pd.Declares["n8n"]["media-gid"].Required { - t.Errorf("kept %s", func() string { - if e == nil { - return "nothing" - } - return string(e.Value) - }()) - } - // Nothing is resolved from a pull request's declaration. - if r, _ := m.Get(ResolvedState, ResolvedKey("ace", "n8n", "media-gid")); r != nil { - t.Errorf("a pull request's declaration was resolved: %s", r.Value) - } -} - -// 1826/K2: a proposal for a key only the pull request declares is refused without its declaration, for a mesh or -// node level, for a clear, for an undeclared key, and for a module not placed on the node; and trunk-only -// proposals are judged as before. -func TestAProposalNamingAPullRequestIsJudgedAgainstItsDeclaration(t *testing.T) { - c, m, _, _ := aHoldingMesh(t) - try := func(call Call) error { - call.Action, call.Caller, call.Why = "propose", "g14.node-tools", "held for 434" - _, err := c.Propose(call) - return err - } - base := Call{Module: "n8n", Node: "ace", Key: "media-gid", Value: 2000.0, Pull: thePull} - if err := try(base); err == nil || !strings.Contains(err.Error(), "holds no declaration for "+thePull) { - t.Errorf("without the pull request's declaration: %v", err) - } - // And without the pull argument it is the trunk's refusal, as before. - plain := base - plain.Pull = "" - if err := try(plain); err == nil || !strings.Contains(err.Error(), `n8n declares no value "media-gid"`) { - t.Errorf("the trunk's refusal changed: %v", err) - } - tell(t, c, thePull, "abc1234def", n8nPullDeclares()) - for name, tc := range map[string]struct { - mutate func(*Call) - want string - }{ - "a mesh level": {func(c *Call) { c.Module, c.Node = "", "" }, "a module's own value on one node"}, - "a node level": {func(c *Call) { c.Module = "" }, "a module's own value on one node"}, - "a clear": {func(c *Call) { c.Clear, c.Value = true, nil }, "a clear is not held"}, - "a key not added": {func(c *Call) { c.Key = "other" }, "does not add or change a value"}, - "a bad value": {func(c *Call) { c.Value = 0.0 }, "below the minimum"}, - "a wrong type": {func(c *Call) { c.Value = "2000" }, "is not a number"}, - "another node": {func(c *Call) { c.Node = "g14" }, "is not placed on g14"}, - "another pull": {func(c *Call) { c.Pull = "novox/mesh-catalog#435" }, "holds no declaration for"}, - "a malformed pull": {func(c *Call) { c.Pull = "434" }, "owner/repository#number"}, - } { - call := base - tc.mutate(&call) - if err := try(call); err == nil || !strings.Contains(err.Error(), tc.want) { - t.Errorf("%s: %v, want %q", name, err, tc.want) - } - } - // A set or a clear through the verb takes no pull request. - if _, err := c.Change(Call{Action: "set", Module: "n8n", Node: "ace", Key: "media-gid", Value: 2000.0, Pull: thePull, - Caller: "g14.node-tools", Why: "w"}); err == nil || !strings.Contains(err.Error(), "only a proposal") { - t.Errorf("a set naming a pull request: %v", err) - } - if keptCount(m) != 0 { - t.Error("something was held") - } -} - -// 1826/K2: every held value is asked whatever the key's trust; the ask says it is held and dropped on a close; on -// Approve the value is kept apart, never set or resolved; history, event and hand-act say it; held answers it. -func TestAHeldValueIsAskedAndKeptApartOnApprove(t *testing.T) { - c, m, r, _ := aHoldingMesh(t) - tell(t, c, thePull, "abc1234def", n8nPullDeclares()) - a := propose(t, c, Call{Module: "n8n", Node: "ace", Key: "media-gid", Value: 2000.0, Pull: thePull, Why: "held for #434"}) - if len(a.Reaches) != 0 { - t.Errorf("a held value reaches %v", a.Reaches) - } - ask := r.asks[a.Proposal] - if err := occ.Check(ask, c.now()); err != nil { - t.Fatalf("the ask: %v", err) - } - for _, want := range []string{thePull, "merges", "dropped if it closes unmerged", "media-gid", "n8n", "ace"} { - if !strings.Contains(ask.Explanation, want) { - t.Errorf("the ask does not say %q:\n%s", want, ask.Explanation) - } - } - if strings.Contains(ask.Explanation, "takes effect at once") || !strings.Contains(ask.Headline, "Hold") { - t.Errorf("the ask: %q\n%s", ask.Headline, ask.Explanation) - } - if ap := ask.Options[0]; !strings.Contains(ap.Does, thePull) || ap.Level == "" { - t.Errorf("the approve option does %q", ap.Does) - } - if keptCount(m) != 0 { - t.Fatal("a proposal held something") - } - r.choose(t, a.Proposal, OptionApprove, nil) - said, _ := c.Decide() - if len(said) != 1 || !strings.Contains(said[0], "held at abc1234d for "+thePull) { - t.Fatalf("decided %v", said) - } - // Kept apart: not a value, not resolved. - if _, set := storedValue(t, m, "module.ace.n8n.media-gid"); set { - t.Error("an Approve set the value") - } - if e, _ := m.Get(ResolvedState, ResolvedKey("ace", "n8n", "media-gid")); e != nil { - t.Errorf("an Approve resolved the value: %s", e.Value) - } - if keptCount(m) != 1 { - t.Fatalf("%d values held", keptCount(m)) - } - if len(m.events) != 1 || m.events[0].Action != ActionHold || m.events[0].Pull != thePull || - m.events[0].Key != "media-gid" || m.events[0].Head != "abc1234def" || len(m.events[0].Moved) != 0 || - !strings.Contains(m.events[0].Approved, "approved by the operator") { - t.Errorf("raised %+v", m.events) - } - if len(m.handActs) != 1 || !strings.Contains(m.handActs[0], thePull) { - t.Errorf("hand-acts %q", m.handActs) - } - h, _ := c.History(Call{Module: "n8n", Node: "ace"}) - if len(h) != 1 || h[0].Action != ActionHold || h[0].Pull != thePull { - t.Errorf("history %+v", h) - } - // held answers it, at the head it is kept at, to the controller alone. - if _, err := c.Do(Call{Action: "held", Caller: "g14.node-tools", Pulls: []PullAt{{thePull, "abc1234def"}}}); err == nil { - t.Error("held answered a caller that is not the controller") - } - got, err := c.Do(Call{Action: "held", Caller: ControllerCaller, Pulls: []PullAt{{thePull, "abc1234def"}}}) - if err != nil { - t.Fatal(err) - } - ha := got.(*HeldAnswer) - if len(ha.Held) != 1 || ha.Held[0].Module != "n8n" || ha.Held[0].Node != "ace" || ha.Held[0].Key != "media-gid" || - string(ha.Held[0].Value) != "2000" || !strings.Contains(ha.Held[0].Approved, "approved by the operator") || - ha.Held[0].Pull != thePull || len(ha.Skipped) != 0 { - t.Errorf("held answered %+v", ha) - } - // Another head, and another pull request, are not answered. - got, _ = c.Do(Call{Action: "held", Caller: ControllerCaller, - Pulls: []PullAt{{thePull, "ffff0000"}, {"novox/mesh-catalog#435", "abc"}}}) - if ha = got.(*HeldAnswer); len(ha.Held) != 0 || len(ha.Skipped) != 1 || !strings.Contains(ha.Skipped[0].Why, "held at") { - t.Errorf("held at another head answered %+v", ha) - } - // The listing shows it as held, and the proposal as held for the pull request. - l, _ := c.List(Call{Module: "n8n"}) - if len(l.Held) != 1 || len(l.Set) != 0 { - t.Errorf("the listing: held %+v set %+v", l.Held, l.Set) - } - rows, _ := c.Proposals(Call{}) - if len(rows) != 1 || rows[0].Pull != thePull || rows[0].State != ProposalApproved { - t.Errorf("proposals %+v", rows) - } -} - -// 1826/K2: an Approve is refused when the pull request's declaration changed after the operator was shown it. -func TestAnApproveOfAHeldValueIsRefusedWhenTheDeclarationChanged(t *testing.T) { - c, m, r, _ := aHoldingMesh(t) - tell(t, c, thePull, "abc1234def", n8nPullDeclares()) - a := propose(t, c, Call{Module: "n8n", Node: "ace", Key: "media-gid", Value: 2000.0, Pull: thePull, Why: "w"}) - changed := n8nPullDeclares() - changed["n8n"].(map[string]any)["media-gid"].(map[string]any)["maximum"] = 1000.0 - tell(t, c, thePull, "def5678abc", changed) - r.choose(t, a.Proposal, OptionApprove, nil) - said, _ := c.Decide() - if len(said) != 1 || !strings.Contains(said[0], "nothing is held") || keptCount(m) != 0 { - t.Errorf("decided %v; %d held", said, keptCount(m)) - } -} - -// 1826/K1: at a new head a held value is kept if its key is declared the same and it still passes; otherwise it is -// dropped, recorded, raised and said. -func TestANewHeadKeepsAHeldValueOnlyWhileItsDeclarationIsUnchanged(t *testing.T) { - c, m, r, _ := aHoldingMesh(t) - tell(t, c, thePull, "abc1234def", n8nPullDeclares()) - holdIt(t, c, m, r) - m.events = nil - - // The same declaration at a new head (the description may differ): kept, moved to the new head. - same := n8nPullDeclares() - same["n8n"].(map[string]any)["media-gid"].(map[string]any)["description"] = "reworded" - if a := tell(t, c, thePull, "1111111111", same); len(a.Dropped) != 0 { - t.Errorf("an unchanged declaration dropped %v", a.Dropped) - } - got, _ := c.Do(Call{Action: "held", Caller: ControllerCaller, Pulls: []PullAt{{thePull, "1111111111"}}}) - if len(got.(*HeldAnswer).Held) != 1 || len(m.events) != 0 { - t.Errorf("after an unchanged head: %+v, events %+v", got, m.events) - } - - // A changed declaration: dropped. - changed := n8nPullDeclares() - changed["n8n"].(map[string]any)["media-gid"].(map[string]any)["maximum"] = 1000.0 - a := tell(t, c, thePull, "2222222222", changed) - if len(a.Dropped) != 1 || !strings.Contains(a.Dropped[0], "declares the key otherwise") || keptCount(m) != 0 { - t.Fatalf("a changed declaration: %+v, %d held", a, keptCount(m)) - } - if len(m.events) != 1 || m.events[0].Action != ActionDrop || m.events[0].Pull != thePull { - t.Errorf("raised %+v", m.events) - } - got, _ = c.Do(Call{Action: "held", Caller: ControllerCaller, Pulls: []PullAt{{thePull, "2222222222"}}}) - if len(got.(*HeldAnswer).Held) != 0 { - t.Error("a dropped value was answered") - } - - // A head that no longer adds the key drops it too. - tell(t, c, thePull, "3333333333", n8nPullDeclares()) - holdIt(t, c, m, r) - if a = tell(t, c, thePull, "4444444444", map[string]any{}); len(a.Dropped) != 1 || - !strings.Contains(a.Dropped[0], "no longer adds or changes") { - t.Errorf("a head without the key: %+v", a) - } -} - -// 1826/K3: the merge writes the held value as the module's own value with its approval kept, before the trunk -// declares the key; it resolves right after the declared-config mirror moves. -func TestTheMergeAppliesAHeldValueAndItResolvesOnceTheTrunkDeclaresTheKey(t *testing.T) { - c, m, r, _ := aHoldingMesh(t) - tell(t, c, thePull, "abc1234def", n8nPullDeclares()) - holdIt(t, c, m, r) - approved := func() string { - raw, _ := m.Get(KeptState, "novox.mesh-catalog.434.ace.n8n.media-gid") - // the state kept is the seat's layout, under the seat's key: the checker and the assigner read it with this - k, err := meshconfigclient.DecodeKept("novox.mesh-catalog.434.ace.n8n.media-gid", raw.Value) - if err != nil || string(heldValue(k)) != "2000" || k.Declaration == "" || k.At == nil { - t.Fatalf("the held value is not the seat's: %+v, %v", k, err) - } - return k.Approved - }() - m.events, m.handActs = nil, nil - - said := c.HeardPull(PullEvent{Owner: "novox", Repo: "mesh-catalog", Number: 434, Merged: true, HeadSHA: "abc1234def"}, true) - if len(said) == 0 { - t.Fatal("the merge said nothing") - } - v, set := storedValue(t, m, "module.ace.n8n.media-gid") - if !set || string(v.Value) != "2000" || v.Approved != approved || v.Approved == "" || v.By != "the operator" || - !strings.Contains(v.Why, thePull) { - t.Fatalf("the merge wrote %+v", v) - } - if keptCount(m) != 0 { - t.Error("the value is still held after the merge") - } - if p, _ := m.Keys(PullsState); len(p) != 0 { - t.Errorf("the pull request's declarations are still kept: %v", p) - } - if len(m.events) != 1 || m.events[0].Action != "set" || m.events[0].Pull != thePull || - m.events[0].Approved != approved || len(m.handActs) != 1 { - t.Errorf("raised %+v, recorded %q", m.events, m.handActs) - } - // Not resolved before the trunk declares it. - if e, _ := m.Get(ResolvedState, ResolvedKey("ace", "n8n", "media-gid")); e != nil { - t.Errorf("resolved before the trunk declares the key: %s", e.Value) - } - m.declare(t, "n8n", `{"module":"n8n","settings":{"media-gid":{"kind":"","default":null,"why":"",`+ - `"type":"number","required":true,"minimum":1,"maximum":65535}}}`) - if _, err := c.Reconcile(); err != nil { - t.Fatal(err) - } - if res := m.resolved(t, "ace", "n8n", "media-gid"); string(res.Value) != "2000" || res.Source != SourceModule { - t.Errorf("media-gid resolves as %+v", res) - } - l, _ := c.List(Call{Module: "n8n", Node: "ace"}) - if len(l.Set) != 1 || l.Set[0].Approved != approved || len(l.Held) != 0 { - t.Errorf("the listing: set %+v held %+v", l.Set, l.Held) - } - // A merge heard twice sets nothing twice. - m.events = nil - c.HeardPull(PullEvent{Owner: "novox", Repo: "mesh-catalog", Number: 434, Merged: true, HeadSHA: "abc1234def"}, true) - if len(m.events) != 0 { - t.Errorf("a second merge raised %+v", m.events) - } -} - -// 1826/K3: a pull request closed unmerged drops its held values and says so; nothing is set or resolved. -func TestAClosedPullRequestDropsItsHeldValuesAndSaysSo(t *testing.T) { - c, m, r, f := aHoldingMesh(t) - tell(t, c, thePull, "abc1234def", n8nPullDeclares()) - holdIt(t, c, m, r) - m.events = nil - f.state[thePull] = [2]bool{false, false} - said := c.HeardPull(PullEvent{Owner: "novox", Repo: "mesh-catalog", Number: 434}, false) - if len(said) == 0 || !strings.Contains(strings.Join(said, "\n"), "closed unmerged: dropped, nothing was set") { - t.Errorf("said %v", said) - } - if _, set := storedValue(t, m, "module.ace.n8n.media-gid"); set || keptCount(m) != 0 { - t.Error("a closed pull request left a value") - } - if len(m.events) != 1 || m.events[0].Action != ActionDrop || m.events[0].Pull != thePull || - !strings.Contains(m.events[0].Why, "closed unmerged") { - t.Errorf("raised %+v", m.events) - } - if p, _ := m.Keys(PullsState); len(p) != 0 { - t.Errorf("declarations of a closed pull request kept: %v", p) - } -} - -// 1826/K3: a close event for a pull request the forge says merged is the merge. -func TestACloseEventForAMergedPullRequestIsItsMerge(t *testing.T) { - c, m, r, f := aHoldingMesh(t) - tell(t, c, thePull, "abc1234def", n8nPullDeclares()) - holdIt(t, c, m, r) - f.state[thePull] = [2]bool{false, true} - f.head = "abc1234def" - c.HeardPull(PullEvent{Owner: "novox", Repo: "mesh-catalog", Number: 434}, false) - if v, set := storedValue(t, m, "module.ace.n8n.media-gid"); !set || string(v.Value) != "2000" { - t.Errorf("the merge of a pull request announced closed set %+v", v) - } -} - -// 1826/K3: the five-minute look finds a merge, a close, and an open pull request, and says a forge that does not -// answer. -func TestTheLookAtTheForgeFindsAMissedMergeOrCloseAndLeavesAnOpenPullRequest(t *testing.T) { - c, m, r, f := aHoldingMesh(t) - tell(t, c, thePull, "abc1234def", n8nPullDeclares()) - holdIt(t, c, m, r) - if said := c.SweepPulls(); len(said) != 0 || keptCount(m) != 1 { - t.Errorf("an open pull request: said %v, %d held", said, keptCount(m)) - } - f.err = errors.New("the forge is down") - if said := c.SweepPulls(); len(said) != 1 || !strings.Contains(said[0], "does not say whether") || keptCount(m) != 1 { - t.Errorf("a silent forge: said %v", said) - } - f.err = nil - f.head = "abc1234def" - f.state[thePull] = [2]bool{false, true} - c.SweepPulls() - if v, set := storedValue(t, m, "module.ace.n8n.media-gid"); !set || string(v.Value) != "2000" || keptCount(m) != 0 { - t.Errorf("a missed merge: %+v", v) - } - // A missed close. - tell(t, c, "novox/mesh-catalog#440", "abc", n8nPullDeclares()) - f.state["novox/mesh-catalog#440"] = [2]bool{false, false} - c.SweepPulls() - if p, _ := m.Keys(PullsState); len(p) != 0 { - t.Errorf("a missed close left %v", p) - } -} - -// 1826/K1: the new arguments are read strictly and the new actions are the verb's. -func TestThePullArgumentsAreRead(t *testing.T) { - call, err := callOf(map[string]any{"action": "pull-declares", "pull": " " + thePull + " ", "head": "abc", - "declares": map[string]any{"n8n": map[string]any{}}, "pulls": []any{map[string]any{"pull": thePull, "head": "h"}}}) - if err != nil || call.Pull != thePull || call.Head != "abc" || len(call.Declares) != 1 || len(call.Pulls) != 1 || - call.Pulls[0].Head != "h" { - t.Errorf("read %+v (%v)", call, err) - } - if _, err := callOf(map[string]any{"declares": "x"}); err == nil { - t.Error("declares that is not an object was read") - } - if _, err := callOf(map[string]any{"pulls": "x"}); err == nil { - t.Error("pulls that is not a list was read") - } - if _, err := callOf(map[string]any{"bogus": 1}); err == nil || !strings.Contains(err.Error(), "pull") { - t.Errorf("an unknown argument: %v", err) - } - _ = time.Second -} - -// 1826 review r1: the merge applies a value only if it is held at the merged head; otherwise it is dropped and said. -func TestTheMergeAppliesOnlyAValueHeldAtTheMergedHead(t *testing.T) { - for name, head := range map[string]string{"another head": "9999999999", "no head told": ""} { - c, m, r, _ := aHoldingMesh(t) - tell(t, c, thePull, "abc1234def", n8nPullDeclares()) - holdIt(t, c, m, r) - said := c.HeardPull(PullEvent{Owner: "novox", Repo: "mesh-catalog", Number: 434, Merged: true, HeadSHA: head}, true) - if _, set := storedValue(t, m, "module.ace.n8n.media-gid"); set || keptCount(m) != 0 || - !strings.Contains(strings.Join(said, "\n"), "dropped, nothing was set") { - t.Errorf("%s: set=%v held=%d said %v", name, set, keptCount(m), said) - } - if len(m.events) == 0 || m.events[len(m.events)-1].Action != ActionDrop { - t.Errorf("%s: raised %+v", name, m.events) - } - } -} - -// 1826 review r1: a later head without the declaration drops the value, so the merge has nothing to apply. -func TestALaterHeadWithoutTheDeclarationLeavesNothingToApplyAtTheMerge(t *testing.T) { - c, m, r, _ := aHoldingMesh(t) - tell(t, c, thePull, "abc1234def", n8nPullDeclares()) - holdIt(t, c, m, r) - tell(t, c, thePull, "bbbbbbbbbb", map[string]any{}) - c.HeardPull(PullEvent{Owner: "novox", Repo: "mesh-catalog", Number: 434, Merged: true, HeadSHA: "bbbbbbbbbb"}, true) - if _, set := storedValue(t, m, "module.ace.n8n.media-gid"); set { - t.Error("a value held for a declaration the merged head lacks was set") - } -} - -// 1826 review r1: a close the forge cannot be asked about drops nothing; the five-minute look decides. -func TestACloseThatTheForgeCannotBeAskedAboutDropsNothing(t *testing.T) { - c, m, r, f := aHoldingMesh(t) - tell(t, c, thePull, "abc1234def", n8nPullDeclares()) - holdIt(t, c, m, r) - f.err = errors.New("the forge is down") - c.HeardPull(PullEvent{Owner: "novox", Repo: "mesh-catalog", Number: 434}, false) - if keptCount(m) != 1 { - t.Fatal("a close the forge could not confirm dropped the value") - } - f.err = nil - f.state[thePull] = [2]bool{false, false} - c.SweepPulls() - if keptCount(m) != 0 { - t.Error("the look did not drop it") - } -} diff --git a/modules/mesh-config/cmd/mesh-config/quiet_integration_test.go b/modules/mesh-config/cmd/mesh-config/quiet_integration_test.go index deb93d759..335e23949 100644 --- a/modules/mesh-config/cmd/mesh-config/quiet_integration_test.go +++ b/modules/mesh-config/cmd/mesh-config/quiet_integration_test.go @@ -58,9 +58,8 @@ func TestConfigWholeAsksTheBusForNothingWhileNoInputChanges(t *testing.T) { if err != nil { t.Fatal(err) } - buckets := []string{"mesh-delivery-assigner_assignments", "mesh-delivery-assigner_wants", "mesh-delivery-indexer_predefined", - "mesh-delivery-indexer_config-candidates"} - for _, s := range []string{ValuesState, ResolvedState, PredefinedState, ProposalsState, PullsState, KeptState, DeclaredState, + buckets := []string{"mesh-delivery-assigner_assignments", "mesh-delivery-assigner_wants", "mesh-delivery-indexer_predefined"} + for _, s := range []string{ValuesState, ResolvedState, PredefinedState, ProposalsState, DeclaredState, RenamesState, RetiringState, FindingsState} { buckets = append(buckets, Module+"_"+s) } @@ -93,19 +92,17 @@ func TestConfigWholeAsksTheBusForNothingWhileNoInputChanges(t *testing.T) { t.Fatal(err) } - // No input changes: the delivery says it delivered, a node-engine says what it reads, the forge says a pull request nothing is - // kept for closed, and the catalog says a manifest was accepted that no retirement waits on. Each is heard and none is a pass: + // No input changes: the delivery says it delivered, a node-engine says what it reads, and the catalog says a manifest was accepted that no retirement waits on. Each is heard and none is a pass: // nothing is asked of the bus. (The module has no timer: no minute, five or otherwise, asks it anything.) before, putsBefore := p.snapshot() for i := 0; i < 20; i++ { p.event("mesh-delivery-view.delivered", map[string]any{"revision": "r"}) p.event("node-engine.manifest-reads-changed", map[string]any{"node": "g14"}) - p.event("git.pull-closed", map[string]any{"owner": "novox", "repo": "mesh-catalog", "number": 700 + i}) } after, putsAfter := p.snapshot() if n := asked(before, after, "mesh/state.get", "mesh/state.keys", "mesh/state.watch", "mesh/state.put", "mesh/state.create", "mesh/state.update", "mesh/state.delete", "mesh/ask"); n != 0 || len(putsAfter) != len(putsBefore) { - t.Errorf("60 events that move nothing asked %d requests of the bus (%v); wrote %v", n, after, putsAfter[len(putsBefore):]) + t.Errorf("40 events that move nothing asked %d requests of the bus (%v); wrote %v", n, after, putsAfter[len(putsBefore):]) } // One input changes: player's manifest declares a second value. Only player's values on its two nodes are written, and `declared` diff --git a/modules/mesh-config/cmd/mesh-config/quiet_test.go b/modules/mesh-config/cmd/mesh-config/quiet_test.go index d6f89e77c..d5e25c429 100644 --- a/modules/mesh-config/cmd/mesh-config/quiet_test.go +++ b/modules/mesh-config/cmd/mesh-config/quiet_test.go @@ -5,6 +5,7 @@ package main import ( "encoding/json" + "strings" "sync" "testing" "time" @@ -193,19 +194,19 @@ func (b *busOf) ownCopy() *ownCopy { // **The module's own states are read from a copy, never key by key** (ADR 0580 §1, issue 1982): a whole state read of 1,176 // keys is one watch and no get, again and again; this process's write is in the copy at once, another's arrives by the watch. func TestAnOwnStateIsReadFromItsWatchedCopyNotKeyByKey(t *testing.T) { - b := &busOf{held: map[string]map[string][]byte{PullsState: {}}, handles: map[string]func(stdio.StateChange) error{}} + b := &busOf{held: map[string]map[string][]byte{ValuesState: {}}, handles: map[string]func(stdio.StateChange) error{}} for i := 0; i < 1176; i++ { - b.held[PullsState][pullKey("novox/mesh-catalog#"+string(rune('a'+i%26))+time.Duration(i).String())] = []byte(`{"pull":"x"}`) + b.held[ValuesState]["mesh.key-"+time.Duration(i).String()] = []byte(`{"value":1}`) } - n := len(b.held[PullsState]) + n := len(b.held[ValuesState]) own := b.ownCopy() for pass := 0; pass < 3; pass++ { - keys, err := own.keys(PullsState) + keys, err := own.keys(ValuesState) if err != nil || len(keys) != n { t.Fatalf("keys %d, %v; want %d", len(keys), err, n) } for _, k := range keys { - if e, err := own.get(PullsState, k); err != nil || e == nil { + if e, err := own.get(ValuesState, k); err != nil || e == nil { t.Fatalf("get %s: %v, %v", k, e, err) } } @@ -214,23 +215,23 @@ func TestAnOwnStateIsReadFromItsWatchedCopyNotKeyByKey(t *testing.T) { t.Errorf("3 passes over %d keys asked the bus for %d watches and %d gets; want 1 and 0", n, b.watches, b.gets) } // Its own write and removal are in the copy at once. - if err := own.write(PullsState, "mine", map[string]string{"pull": "mine"}); err != nil { + if err := own.write(ValuesState, "mine", map[string]string{"x": "mine"}); err != nil { t.Fatal(err) } - if e, _ := own.get(PullsState, "mine"); e == nil { + if e, _ := own.get(ValuesState, "mine"); e == nil { t.Error("a key just written is not read") } - if err := own.remove(PullsState, "mine"); err != nil { + if err := own.remove(ValuesState, "mine"); err != nil { t.Fatal(err) } - if e, _ := own.get(PullsState, "mine"); e != nil { + if e, _ := own.get(ValuesState, "mine"); e != nil { t.Error("a key just removed is still read") } // Another writer's change arrives by the watch. - if err := b.handles[PullsState](stdio.StateChange{State: PullsState, Key: "theirs", Op: stdio.OpPut, Value: []byte(`{"pull":"t"}`), Revision: 99}); err != nil { + if err := b.handles[ValuesState](stdio.StateChange{State: ValuesState, Key: "theirs", Op: stdio.OpPut, Value: []byte(`{"value":2}`), Revision: 99}); err != nil { t.Fatal(err) } - if e, _ := own.get(PullsState, "theirs"); e == nil { + if e, _ := own.get(ValuesState, "theirs"); e == nil { t.Error("a change another wrote is not read") } if b.gets != 0 { @@ -254,3 +255,19 @@ func TestAWriteTellsWhatWaitsOnADeadline(t *testing.T) { t.Errorf("told %v", told) } } + +// The mesh knows no pull request (design 47 G; ADR 0502 ended by the operator's word, record pending): the verb takes no `pull`, +// `head`, `declares` or `pulls`, and does neither `pull-declares` nor `held`. +func TestTheVerbKnowsNoPullRequest(t *testing.T) { + for _, arg := range []string{"pull", "head", "declares", "pulls"} { + if _, err := callOf(map[string]any{"action": "propose", arg: "x"}); err == nil || !strings.Contains(err.Error(), arg) { + t.Errorf("an argument %s was taken: %v", arg, err) + } + } + c, _ := aMesh(t) + for _, action := range []string{"pull-declares", "held"} { + if _, err := c.Do(Call{Action: action}); err == nil || !strings.Contains(err.Error(), action) { + t.Errorf("the action %s was done: %v", action, err) + } + } +} diff --git a/modules/mesh-config/cmd/mesh-config/resolve.go b/modules/mesh-config/cmd/mesh-config/resolve.go index 93cd8191d..070383dff 100644 --- a/modules/mesh-config/cmd/mesh-config/resolve.go +++ b/modules/mesh-config/cmd/mesh-config/resolve.go @@ -140,10 +140,6 @@ type Sources struct { Unresolved []Unresolved Predefined map[string]Published Values map[string]Value - // Pulls is what the controller told of each open pull request's declarations, and Kept the approved values held - // for them (pulls.go); neither is resolved. - Pulls map[string]PullDecl - Kept map[string]KeptValue // Renames are the renames kept, by `.`, whose open windows answer the old name (renames.go). Renames map[string]Rename } diff --git a/modules/mesh-config/cmd/mesh-config/sources.go b/modules/mesh-config/cmd/mesh-config/sources.go index 6a05643c7..a63d1e914 100644 --- a/modules/mesh-config/cmd/mesh-config/sources.go +++ b/modules/mesh-config/cmd/mesh-config/sources.go @@ -51,9 +51,6 @@ func (c *Config) sources() (Sources, error) { }); err != nil { return s, fmt.Errorf("the values cannot be read: %w", err) } - if err := c.readPulls(&s); err != nil { - return s, err - } if renames, err := c.readRenames(); err != nil { return s, fmt.Errorf("the renames cannot be read: %w", err) } else { @@ -339,10 +336,8 @@ type Resolution struct { Moved []Moved `json:"moved"` Published string `json:"published,omitempty"` Withheld string `json:"withheld,omitempty"` - // Declared are the modules whose `declared` key was written, and Candidates what the indexer's config candidates - // did after the take-over. - Declared []string `json:"declared,omitempty"` - Candidates []string `json:"candidates,omitempty"` + // Declared are the modules whose `declared` key was written. + Declared []string `json:"declared,omitempty"` // Renamed is what the renames did in this pass. Renamed []string `json:"renamed,omitempty"` // SourceGone is said while the stored switch still names the controller, whose records are no longer read. @@ -383,9 +378,6 @@ func (c *Config) reconcileLocked() (Resolution, error) { } else if len(written) > 0 { r.Declared = written } - if sw, serr := c.source(); serr == nil && sw.Source == SourceIndexer { - r.Candidates = c.takeCandidates() - } return r, err } diff --git a/modules/mesh-config/cmd/mesh-config/takeover.go b/modules/mesh-config/cmd/mesh-config/takeover.go index cc22ce6d4..f08bb27dd 100644 --- a/modules/mesh-config/cmd/mesh-config/takeover.go +++ b/modules/mesh-config/cmd/mesh-config/takeover.go @@ -2,7 +2,7 @@ package main // Config's records out of the controller (novox/hq ADR 0565 §3, §15, and the progressive insight of 2026-10-29): // mesh-config keeps each placed module's declarations in its own state `declared`, reads the list of predefined keys -// from the indexer's `predefined` and a pull request's config from the indexer's `config-candidates`. +// from the indexer's `predefined`. A pull request's config is not read: the mesh knows no pull request (design 47 G). // // **Its own sources hold always** (ADR 0590, issue 1126): the controller ended by its unassignment, so its pull-declares, // the take-over that switched away from them, compare and hand-back are gone, and the switch is the indexer's whatever @@ -23,12 +23,11 @@ const ( // DeclaredState is each placed module's declarations at the trunk, one key per module (ADR 0565 §3). DeclaredState = "declared" - // IndexerPredefinedRead and CandidatesRead are the indexer's states (ADR 0565 §2). + // IndexerPredefinedRead is the indexer's state of the predefined list (ADR 0565 §2). IndexerPredefinedRead = indexerModule + "." + catalog.StatePredefined - CandidatesRead = indexerModule + "." + catalog.StateConfigCandidates ) -// SourceIndexer is the one source of a pull request's config and of the predefined list: the indexer's. +// SourceIndexer is the one source of the predefined list: the indexer's. const SourceIndexer = "indexer" // Switch is which source holds: the indexer's, always, since the controller ended (ADR 0590). @@ -105,7 +104,7 @@ func (c *Config) writeDeclared(s Sources) ([]string, error) { return written, errors.Join(problems...) } -// ---- the predefined list and the pull requests from the indexer ------------------------------------------ +// ---- the predefined list from the indexer ----------------------------------------------------------------------------------------- // indexerList is the indexer's predefined list as the mirror's list holds one: the keys, and the commit. func (c *Config) indexerList() (PredefinedList, bool, error) { @@ -128,75 +127,6 @@ func (c *Config) indexerList() (PredefinedList, bool, error) { return list, true, nil } -// candidates is every open pull request's config declarations as the indexer keeps them, by pull key. -func (c *Config) candidates() (map[string]PullDecl, error) { - out := map[string]PullDecl{} - err := c.each(CandidatesRead, func(key string, raw []byte) error { - var cand catalog.ConfigCandidatesByPullValue - if err := json.Unmarshal(raw, &cand); err != nil || cand.Pull == "" { - return fmt.Errorf("the indexer's config candidate %s is not one", key) - } - p := PullDecl{Pull: cand.Pull, Head: cand.Head, Declares: map[string]map[string]Declaration{}, At: timeOf(cand.At)} - for module, keys := range cand.Declares { - raw, _ := json.Marshal(keys) - var d map[string]Declaration - if err := json.Unmarshal(raw, &d); err != nil { - return fmt.Errorf("the indexer's config candidate %s declares %s unreadably", key, module) - } - for k, decl := range d { - if !decl.HasDefault() { - decl.Default = nil - } - d[k] = decl - } - p.Declares[module] = d - } - out[pullKey(cand.Pull)] = p - return nil - }) - return out, err -} - -// takeCandidates is the indexer's config candidates taken in place of pull-declares, after the take-over: each one -// whose head or declarations differ from what `pulls` holds is declared again, its held values judged again (ADR 0502 -// §6). The caller holds the lock. -func (c *Config) takeCandidates() []string { - cands, err := c.candidates() - if err != nil { - return []string{"the indexer's config candidates cannot be read: " + err.Error()} - } - var s Sources - if err := c.readPulls(&s); err != nil { - return []string{err.Error()} - } - var said []string - for _, k := range sortedKeys(cands) { - p := cands[k] - if have, ok := s.Pulls[k]; ok && have.Head == p.Head && declaresDigest(have.Declares) == declaresDigest(p.Declares) { - continue - } - a, err := c.declarePull(p.Pull, p.Head, p.Declares) - if err != nil { - said = append(said, fmt.Sprintf("%s from the indexer: %v", p.Pull, err)) - continue - } - said = append(said, a.Said+" (from the indexer)") - } - return said -} - -// declaresDigest is what a pull request's declarations hold a value to, in one encoding. -func declaresDigest(d map[string]map[string]Declaration) string { - flat := map[string]string{} - for m, keys := range d { - for k, decl := range keys { - flat[m+"."+k] = declDigest(decl) - } - } - raw, _ := json.Marshal(flat) - return string(raw) -} - // Declared is the read of `declared`: every module's key, or one whole. func (c *Config) Declared(module string) (any, error) { if module != "" { @@ -221,20 +151,14 @@ func (c *Config) Declared(module string) (any, error) { return map[string]any{"declared": rows, "count": len(rows), "source": sw}, err } -// Resync reads every source again and writes what differs: the published list, the resolved values, `declared`, and -// the indexer's config candidates (ADR 0565 §15). +// Resync reads every source again and writes what differs: the published list, the resolved values and `declared` +// (ADR 0565 §15). func (c *Config) Resync() (any, error) { r, err := c.Reconcile() if err != nil { return r, err } - c.mu.Lock() - defer c.mu.Unlock() - out := map[string]any{"resolution": r} - if sw, err := c.source(); err == nil && sw.Source == SourceIndexer { - out["candidates"] = c.takeCandidates() - } - return out, nil + return map[string]any{"resolution": r}, nil } // timeOf is an optional time of a seat's value as a time, the zero time when it is absent. diff --git a/modules/mesh-config/cmd/mesh-config/takeover_test.go b/modules/mesh-config/cmd/mesh-config/takeover_test.go index 4f5d6bd62..e05fd48ea 100644 --- a/modules/mesh-config/cmd/mesh-config/takeover_test.go +++ b/modules/mesh-config/cmd/mesh-config/takeover_test.go @@ -15,7 +15,7 @@ const ( oldDeclared = `{"module":"old","settings":{"workers":{"kind":"preference","default":4,"why":"two per core"}}}` ) -// anAgreeingMesh is aProposingMesh with the indexer's predefined list in place and no open pull request. +// anAgreeingMesh is aProposingMesh with the indexer's predefined list in place. func anAgreeingMesh(t *testing.T) (*Config, *memStore, *standIn) { t.Helper() c, m, r := aProposingMesh(t) @@ -34,19 +34,9 @@ func indexerList(t *testing.T, m *memStore, commit, list string) { m.mirror(t, IndexerPredefinedRead, catalog.PredefinedByListKey(), string(raw)) } -// candidate is the indexer's config candidate of a pull request. -func candidate(t *testing.T, m *memStore, pull, head, declares string) { - t.Helper() - key, err := catalog.ConfigCandidatesByPullKey(pullKey(pull)), error(nil) - if err != nil { - t.Fatal(err) - } - m.mirror(t, CandidatesRead, key, `{"v":1,"pull":"`+pull+`","head":"`+head+`","declares":`+declares+`}`) -} - // ADR 0590 (issue 1126): config reads its own sources always, with no take-over: declared is written once per -// manifest, pull-declares is refused naming the indexer's candidates, and the list and a pull request's config come from -// the indexer. compare, take-over and hand-back went with the controller. +// manifest, and the list comes from the indexer. compare, take-over, hand-back and a pull request's config went (the +// mesh knows no pull request, design 47 G). func TestConfigReadsItsOwnSourcesAlways(t *testing.T) { c, m, _ := anAgreeingMesh(t) steps := []struct { @@ -60,11 +50,6 @@ func TestConfigReadsItsOwnSourcesAlways(t *testing.T) { again, _ := c.Reconcile() return strings.Join(first.Declared, ",") + "|" + strings.Join(again.Declared, ","), err }, "dunst|"}, - {"pull-declares refused, naming the indexer", func() (string, error) { - _, err := c.PullDeclares(Call{Caller: ControllerCaller, Pull: "novox/mesh-catalog#8", Head: "h1", - Declares: map[string]any{}}) - return "", err - }, "config-candidates"}, {"the list comes from the indexer", func() (string, error) { indexerList(t, m, "cccccccccccc", `{"font-size":{"type":"number","description":"text size","minimum":6,"maximum":72}, "agent-managed-settings":{"type":"object","description":"managed settings","trusted":true}, @@ -72,11 +57,6 @@ func TestConfigReadsItsOwnSourcesAlways(t *testing.T) { res, err := c.Reconcile() return res.Published, err }, "theme"}, - {"a pull request's config comes from the indexer", func() (string, error) { - candidate(t, m, "novox/mesh-catalog#9", "h9", `{"dunst":{"gap":{"kind":"","type":"number","default":2}}}`) - res, err := c.Reconcile() - return strings.Join(res.Candidates, "; "), err - }, "from the indexer"}, } for _, s := range steps { got, err := s.do() diff --git a/modules/mesh-config/cmd/mesh-config/whole_integration_test.go b/modules/mesh-config/cmd/mesh-config/whole_integration_test.go index 83d9af240..f004ff88c 100644 --- a/modules/mesh-config/cmd/mesh-config/whole_integration_test.go +++ b/modules/mesh-config/cmd/mesh-config/whole_integration_test.go @@ -721,9 +721,8 @@ func TestConfigWholeRenamesAndRetiresAgainstTheBus(t *testing.T) { t.Fatal(err) } buckets := []string{"mesh-delivery-assigner_assignments", "mesh-delivery-assigner_wants", - "mesh-delivery-indexer_predefined", - "mesh-delivery-indexer_config-candidates"} - for _, s := range []string{ValuesState, ResolvedState, PredefinedState, ProposalsState, PullsState, KeptState, DeclaredState, + "mesh-delivery-indexer_predefined"} + for _, s := range []string{ValuesState, ResolvedState, PredefinedState, ProposalsState, DeclaredState, RenamesState, RetiringState, FindingsState} { buckets = append(buckets, Module+"_"+s) } diff --git a/modules/mesh-config/module.json b/modules/mesh-config/module.json index 827c0f7cb..c6d12e565 100644 --- a/modules/mesh-config/module.json +++ b/modules/mesh-config/module.json @@ -19,13 +19,10 @@ "operator-channel" ], "consumes": [ - "git.pull-merged", - "git.pull-closed", "mesh-delivery-view.delivered", "node-engine.manifest-reads-changed", "mesh-catalog.manifest-accepted", "mesh-delivery-indexer.views.predefined", - "mesh-delivery-indexer.views.config-candidates", "mesh-delivery-assigner.views.assignments", "mesh-delivery-assigner.views.wants", "mesh-catalog.catalog-revision", @@ -36,13 +33,11 @@ "invokes": [ "seat:mesh-hand-acts.hand-act", "seat:mesh-hand-acts.warranted", - "seat:git.pull", "mesh-delivery-view.node_haves", "seat:node-engine.manifest-reads", "mesh-delivery-indexer.indexer_config_readers", "seat:mesh-vault.retire", "mesh-delivery-indexer.indexer_read_predefined", - "mesh-delivery-indexer.indexer_read_config_candidates", "mesh-delivery-assigner.assigner_read_assignments", "mesh-delivery-assigner.assigner_read_wants", "seat:mesh-catalog.revision", @@ -66,8 +61,6 @@ "resolved", "predefined", "proposals", - "pulls", - "kept", "declared", "renames", "retiring",