mesh-config: remove the pull request path (issue 1982; ADR 0681 §1, §3, §5, §6)

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
This commit is contained in:
2026-11-19 22:42:28 +01:00
parent b75481733b
commit cd3ef2fd41
20 changed files with 113 additions and 1530 deletions
+3 -2
View File
@@ -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.
+1 -23
View File
@@ -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()
@@ -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
}
@@ -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
}
+8 -63
View File
@@ -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
@@ -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,
@@ -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.<state>` 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) {
@@ -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,
@@ -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"
}
@@ -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")
}
}
@@ -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 `<owner>/<name>`, 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
}
@@ -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")
}
}
@@ -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`
@@ -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)
}
}
}
@@ -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 `<module>.<to>`, whose open windows answer the old name (renames.go).
Renames map[string]Rename
}
+2 -10
View File
@@ -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
}
@@ -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.
@@ -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()
@@ -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)
}
-7
View File
@@ -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",