Rename mesh-control -> mesh-controller, substrate -> foundation
One name per thing, per the HQ glossary: the module/container/image/binary/repo becomes mesh-controller, the seat the-controller, and the store+broker pair the foundation (embedded base bundles, default template and example lock renamed with their go:embed directives). No behaviour change — a pure vocabulary rename. Claude-Session: https://claude.ai/code/session_01D6qtiYU3P9jk3pnAXyAFyx
This commit is contained in:
@@ -0,0 +1,186 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"sort"
|
||||
"time"
|
||||
)
|
||||
|
||||
// The same answers, in a shape something other than a person can read.
|
||||
//
|
||||
// A board reads through interfaces and holds nothing (novox/hq 03-DESIGN/01-to-be/11-a-board.md).
|
||||
// Everything it needs is already answered by these commands — as text, for people, which is not
|
||||
// something a page can read. So each of them can say it again as JSON.
|
||||
//
|
||||
// **`--json` rather than a serving API**, because nothing needs one yet: whatever serves a board
|
||||
// runs the command, and the constraint in the design holds either way — the board never touches a
|
||||
// context's store. An API is the larger thing and should wait until something is asking for it.
|
||||
//
|
||||
// **These shapes are hard to change once anything is built against them.** So they stay close to
|
||||
// what the domain already calls things, and carry no summary field that would have to be kept
|
||||
// true. Nothing here is derived that a reader could not derive.
|
||||
|
||||
// meshStatus is what `status --json` says: the three questions, in the order they are asked.
|
||||
type meshStatus struct {
|
||||
// Wrong is every machine whose last declaration was refused or partly failed.
|
||||
Wrong []machineDoing `json:"wrong"`
|
||||
// Quiet is every machine not heard from lately. Not the same as wrong: new, switched off and
|
||||
// unreachable are not "tried and could not".
|
||||
Quiet []machineQuiet `json:"quiet"`
|
||||
// Behind is every module built from something older than its source has.
|
||||
Behind []moduleBehind `json:"behind"`
|
||||
// Waiting is every machine not running what the mesh would send it. The same question as
|
||||
// Behind one level down: that says the catalogue is old, this says a machine is — and only
|
||||
// this one has somebody's change waiting inside it.
|
||||
Waiting []machineWaiting `json:"waiting"`
|
||||
// Reported is every machine's last word beside when it was last sent a declaration. A
|
||||
// machine whose report is newer than its send has acted on the current declaration; one
|
||||
// whose is older is still working — and Waiting cannot tell those apart, because the sent
|
||||
// digest is recorded at send, not at apply.
|
||||
Reported []machineReported `json:"reported"`
|
||||
// Unresolved is every machine that cannot be worked out at all, with what the mesh said when
|
||||
// it tried. **A machine here is in none of the lists above**: nothing was computed for it, so
|
||||
// there is nothing to compare it against and nothing it can be behind — which is why a
|
||||
// document without this field described a wholly blocked mesh as a well one.
|
||||
//
|
||||
// Per machine, and data. One node failing must never take the document away from a reader
|
||||
// asking about the others.
|
||||
Unresolved []machineUnresolved `json:"unresolved"`
|
||||
// Network is why the private network could not be computed, when it could not; absent when it
|
||||
// could. Almost always a consequence of Unresolved: a node that does not resolve is not on the
|
||||
// network, and a mesh whose hub is that node has no hub.
|
||||
Network string `json:"network,omitempty"`
|
||||
// Machines is how many the mesh knows about, so a reader can tell "none wrong" from
|
||||
// "none at all".
|
||||
Machines int `json:"machines"`
|
||||
}
|
||||
|
||||
type machineUnresolved struct {
|
||||
Node string `json:"node"`
|
||||
// Problem is the mesh's own words, whole — newlines and all. It lists every requirement that
|
||||
// could not be met, and a first line alone would name one of them and hide the rest.
|
||||
Problem string `json:"problem"`
|
||||
}
|
||||
|
||||
type machineDoing struct {
|
||||
Node string `json:"node"`
|
||||
// Outcome is refused or failed. Kept distinct all the way out: they are fixed in different
|
||||
// places, and one word for both sends half the readers to the wrong one.
|
||||
Outcome string `json:"outcome"`
|
||||
Refused string `json:"refused,omitempty"`
|
||||
Failed []struct {
|
||||
ID string `json:"id"`
|
||||
Error string `json:"error"`
|
||||
} `json:"failed,omitempty"`
|
||||
Applied int `json:"applied"`
|
||||
At time.Time `json:"at"`
|
||||
}
|
||||
|
||||
type machineReported struct {
|
||||
Node string `json:"node"`
|
||||
Outcome string `json:"outcome"`
|
||||
At *time.Time `json:"at,omitempty"`
|
||||
Sent *time.Time `json:"sent,omitempty"`
|
||||
// Current is whether the last report names the declaration last sent. Not derivable from
|
||||
// the timestamps beside it: an apply begun under the previous declaration reports after the
|
||||
// next send, newer and still about the old words.
|
||||
Current bool `json:"current"`
|
||||
}
|
||||
|
||||
type machineWaiting struct {
|
||||
Node string `json:"node"`
|
||||
// Never is true when nothing has ever been sent to it. Not out of date: nobody has ever asked
|
||||
// this machine to be anything, and the two read differently to whoever is looking.
|
||||
Never bool `json:"never"`
|
||||
Sent *time.Time `json:"sent,omitempty"`
|
||||
}
|
||||
|
||||
type machineQuiet struct {
|
||||
Node string `json:"node"`
|
||||
// LastSeen is absent when the machine has never spoken, which is a different thing from
|
||||
// having been quiet for a while.
|
||||
LastSeen *time.Time `json:"lastSeen,omitempty"`
|
||||
}
|
||||
|
||||
type moduleBehind struct {
|
||||
Module string `json:"module"`
|
||||
BuiltFrom string `json:"builtFrom"`
|
||||
Head string `json:"head"`
|
||||
On []string `json:"on"`
|
||||
}
|
||||
|
||||
// statusAsJSON answers the same questions as the text form, from the same reading.
|
||||
//
|
||||
// **It takes the whole reading rather than a growing argument list**, which is what let a new
|
||||
// answer be added to the text form and forgotten here — the two are one function's output in two
|
||||
// shapes, and they must not be able to differ about what was asked.
|
||||
//
|
||||
// It never fails on account of the mesh. Every per-machine problem in here is a field, so one
|
||||
// machine that cannot be worked out cannot stop a caller reading about the others: a
|
||||
// machine-readable interface that stops being machine-readable exactly when something is wrong is
|
||||
// one nobody can build an alarm on.
|
||||
func statusAsJSON(asked answers) ([]byte, error) {
|
||||
wrong, nodes, quiet := asked.wrong, asked.nodes, asked.quiet
|
||||
behind, sources := asked.behind, asked.sources
|
||||
waiting, reported := asked.waiting, asked.reported
|
||||
|
||||
out := meshStatus{Machines: len(nodes), Wrong: []machineDoing{},
|
||||
Quiet: []machineQuiet{}, Behind: []moduleBehind{}, Waiting: []machineWaiting{},
|
||||
Reported: []machineReported{}, Unresolved: []machineUnresolved{},
|
||||
Network: asked.network}
|
||||
for name := range asked.refused {
|
||||
out.Unresolved = append(out.Unresolved, machineUnresolved{
|
||||
Node: name, Problem: asked.refused[name]})
|
||||
}
|
||||
sort.Slice(out.Unresolved, func(i, j int) bool {
|
||||
return out.Unresolved[i].Node < out.Unresolved[j].Node
|
||||
})
|
||||
for _, r := range reported {
|
||||
out.Reported = append(out.Reported, machineReported{
|
||||
Node: r.Node, Outcome: r.Outcome, At: r.At, Sent: r.Sent, Current: r.Current})
|
||||
}
|
||||
|
||||
for _, m := range waiting {
|
||||
out.Waiting = append(out.Waiting, machineWaiting{
|
||||
Node: m.Node, Never: m.Never, Sent: m.SentAt})
|
||||
}
|
||||
|
||||
for _, d := range wrong {
|
||||
row := machineDoing{
|
||||
Node: d.Node, Outcome: d.Outcome, Refused: d.Refused, Applied: d.Applied, At: d.At,
|
||||
}
|
||||
for _, f := range d.Failed {
|
||||
row.Failed = append(row.Failed, struct {
|
||||
ID string `json:"id"`
|
||||
Error string `json:"error"`
|
||||
}{ID: f.ID, Error: f.Error})
|
||||
}
|
||||
out.Wrong = append(out.Wrong, row)
|
||||
}
|
||||
for _, n := range quiet {
|
||||
row := machineQuiet{Node: n.Name}
|
||||
if !n.LastSeen.IsZero() {
|
||||
seen := n.LastSeen
|
||||
row.LastSeen = &seen
|
||||
}
|
||||
out.Quiet = append(out.Quiet, row)
|
||||
}
|
||||
for module, on := range behind {
|
||||
from := sources[module]
|
||||
out.Behind = append(out.Behind, moduleBehind{
|
||||
Module: module, BuiltFrom: from.BuiltFrom, Head: from.Head, On: on,
|
||||
})
|
||||
}
|
||||
return json.MarshalIndent(out, "", " ")
|
||||
}
|
||||
|
||||
// say prints a value as JSON, for the commands that can answer either way.
|
||||
func say(value any) error {
|
||||
body, err := json.MarshalIndent(value, "", " ")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
fmt.Println(string(body))
|
||||
return nil
|
||||
}
|
||||
Reference in New Issue
Block a user