Files
mesh-catalog/modules/nats/cmd/nats-tools/catalogview.go
T
jschoubben bf60d6a8bb NATS3 (rest): the bus module plans from the catalog half of every watched branch, not from manifest-accepted
The keeper follows meshcatalogclient's branch follower and the seat list on its views reader, and plans again at each
move of a branch's view, the registrations or the seat list. Each local name is planned from the first of the module's
watched branches in its registration's order; another branch asking it with other settings is said drifted, naming
the branch. A module of the new form whose resolved seat definition has a verb or an event gets its sent store; one
including only parts, and a foundation part, none. A module in no watched branch's newest revision loses its plans
key, its entries orphans. The sum of the caps counts the old sections the entries declare. The manifest consumes the
catalog half's and the seat list's events and invokes their verbs; manifest-accepted and indexer_bus_state go.

Builds: design 47 G §344, §433, §532, §533, §537, §538, §547, §591

Claude-Session: https://claude.ai/code/session_01NcbgfGKaxw984XyAPfLm4h
2026-11-12 05:45:49 +01:00

150 lines
5.2 KiB
Go

package main
import (
"cmp"
"crypto/sha256"
"encoding/hex"
"encoding/json"
"fmt"
"maps"
"slices"
catalog "git.novox.be/novox/mesh-delivery/contracts/go/seats/meshcatalog"
"git.novox.be/novox/mesh-sdk/go/catalogue"
"nats-tools/internal/keeper"
)
// The keeper reads a module's asks from the module's entry in the catalog half of each watched branch, not from the
// indexer's event (design 47 G §344, §433, §532).
// Asks is what one catalog graph entry says of a module for the keeper: what its manifest asks of the bus as an accepted
// verdict, the seats it claims, whether it declares an event of its own (the facts keeper.Sends reads), whether it is a
// foundation part (an old `objects` section `sent-objects`, §533), and the caps of its old sections in bytes (§547, §591).
type Asks struct {
Accepted keeper.Accepted
Claims []string
EmitsOwn bool
Foundation bool
OldBytes int64
}
// AsksOf reads one entry. An entry whose manifest is not accepted asks nothing of the bus now, as an accepted verdict of
// no entries does; the digest it carries is of the entries it asks, so an entry changed in nothing the bus module reads
// is not applied again.
func AsksOf(e catalog.CatalogEntry) (Asks, error) {
if e.Module == "" {
return Asks{}, fmt.Errorf("a catalog entry names no module")
}
raw, err := json.Marshal(e.Manifest)
if err != nil {
return Asks{}, fmt.Errorf("the manifest of %s is not readable: %w", e.Module, err)
}
var m catalogue.Manifest
if err := json.Unmarshal(raw, &m); err != nil {
return Asks{}, fmt.Errorf("the manifest of %s is not readable: %w", e.Module, err)
}
state := m.BusState
if e.Verdict != "" && e.Verdict != "accepted" {
state = nil
}
sum := sha256.Sum256(mustJSON(state))
out := Asks{Accepted: keeper.Accepted{Module: e.Module, Digest: hex.EncodeToString(sum[:]), BusState: state},
EmitsOwn: len(m.Emits) > 0 || len(e.Streams) > 0}
for _, c := range m.Claims {
out.Claims = append(out.Claims, c.Name)
}
// The old sections' caps (design 47 G §547, §591): an objects section its max-mib, a log or a stream its max-mib or
// the catalogue's default.
for _, o := range m.Objects {
out.Foundation = out.Foundation || o.Name == keeper.SentLocal
out.OldBytes += int64(o.MaxMiB) * keeper.MiB
}
for _, l := range m.Logs {
out.OldBytes += int64(cmp.Or(l.MaxMiB, catalogue.LogDefaultMiB)) * keeper.MiB
}
for _, st := range m.Streams {
out.OldBytes += int64(cmp.Or(st.MaxMiB, catalogue.StreamDefaultMiB)) * keeper.MiB
}
return out, nil
}
// Branch is one watched branch's newest revision of the catalog half: its name, its revision and its entries by module.
type Branch struct {
Name string
Revision int64
Entries map[string]catalog.CatalogEntry
}
// ViewOf is the catalog half as the keeper plans from it (design 47 G §532): every module some branch's newest revision
// lists, its kept data planned from each such branch, each local name once, from the first of the module's watched
// branches in its registration's order (order: the registration's branches; a branch it does not name comes after, in
// the order given) whose entry asks it; another branch asking that local name with other settings is a drift naming
// the branch, and plans nothing. The module sends when a branch's entry says so; it is a foundation part, and its old
// sections' caps are read, from the first branch.
func ViewOf(branches []Branch, order func(module string) []string) (keeper.CatalogView, error) {
modules := map[string]bool{}
for _, b := range branches {
for m := range b.Entries {
modules[m] = true
}
}
var view keeper.CatalogView
for _, module := range slices.Sorted(maps.Keys(modules)) {
var listing []Branch
var named []string
if order != nil {
named = order(module)
}
for _, name := range named {
for _, b := range branches {
if _, ok := b.Entries[module]; ok && b.Name == name {
listing = append(listing, b)
}
}
}
for _, b := range branches {
if _, ok := b.Entries[module]; ok && !slices.Contains(named, b.Name) {
listing = append(listing, b)
}
}
var cm keeper.CatalogModule
from := map[string]string{}
asked := map[string]string{}
for i, b := range listing {
a, err := AsksOf(b.Entries[module])
if err != nil {
return keeper.CatalogView{}, fmt.Errorf("the branch %s: %w", b.Name, err)
}
if i == 0 {
cm = keeper.CatalogModule{Accepted: keeper.Accepted{Module: module, Digest: b.Entries[module].ManifestDigest, Revision: uint64(max(b.Revision, 0))},
Foundation: a.Foundation, OldBytes: a.OldBytes}
}
cm.EmitsOwn = cm.EmitsOwn || a.EmitsOwn
for _, c := range a.Claims {
if !slices.Contains(cm.Claims, c) {
cm.Claims = append(cm.Claims, c)
}
}
for _, e := range a.Accepted.BusState {
settings := string(mustJSON(e))
if f, ok := from[e.Name]; ok {
if asked[e.Name] != settings {
view.Drifts = append(view.Drifts, keeper.Drift{Module: module, Local: e.Name, Branch: b.Name, From: f})
}
continue
}
from[e.Name], asked[e.Name] = b.Name, settings
cm.BusState = append(cm.BusState, e)
}
}
view.Modules = append(view.Modules, cm)
}
return view, nil
}
func mustJSON(v any) []byte {
b, _ := json.Marshal(v)
return b
}