jschoubben
175a5567b8
The grants part writes its list as an object of its own bucket, sealed to the bus node's key, and names it in user-list.sealed; the node-engine of the node holding mesh-broker is granted that one key and an object by name, the grants part its bucket (the controller's copy carries the same grants, byte for byte, golden regenerated there). A state may name its readers (announce, NamedReaders): mesh-vault.bus-accounts is read by mesh-grants alone.
98 lines
4.0 KiB
Go
98 lines
4.0 KiB
Go
package buscompose
|
|
|
|
import (
|
|
"sort"
|
|
"strings"
|
|
|
|
"git.novox.be/novox/mesh-sdk/go/announce"
|
|
)
|
|
|
|
// Who may read a module's state is what the module announced (novox/hq ADR 0495 clauses 2 and 3, ADR 0513 §3; issue
|
|
// 1790). A module says on the bus which states it keeps and which others may read (announce.Subject); the controller
|
|
// keeps the last word of each (announce.KeptBucket) and grants a reader's `reads: <owner>.<name>` only when the owner
|
|
// announced that state readable. An owner that has announced nothing yet is read as before, from the reader's `reads`
|
|
// (the transition, until every module announces), and is named as not yet announced.
|
|
|
|
// StatesAnnouncedBucket is the controller's bucket of the last announcement of each module (announce.KeptBucket).
|
|
const StatesAnnouncedBucket = announce.KeptBucket
|
|
|
|
// controllerReadable are the controller's states others may read: the record mirrors (the packages each node declares
|
|
// among them, which the pacman module reads, ADR 0507 §5), the chain's buckets, and the grants issued and the
|
|
// compositions' digests, which the assigner reads (ADR 0528 clause 2, ADR 0539 clause 6).
|
|
var controllerReadable = []string{MirrorAssignments, MirrorDeclaredConfig, MirrorPredefined, ChainBuilds, ChainRollouts,
|
|
MirrorDeclaredPackages, ControllerGrants, ControllerComposed}
|
|
|
|
// ControllerAnnouncement is what the controller announces it keeps (ADR 0495 clause 2): every bucket of its own by its local
|
|
// name, the ones others may read marked readable. It announces itself, as any module does from its code.
|
|
func ControllerAnnouncement(node string) announce.States {
|
|
s := announce.States{Module: ControllerSeat, Node: node}
|
|
readable := map[string]bool{}
|
|
for _, n := range controllerReadable {
|
|
readable[n] = true
|
|
}
|
|
for _, bucket := range ControllerBuckets() {
|
|
local, mine := strings.CutPrefix(bucket, ControllerSeat+"_")
|
|
if !mine {
|
|
continue
|
|
}
|
|
s.States = append(s.States, announce.State{Name: local, Readable: readable[local]})
|
|
}
|
|
sort.Slice(s.States, func(i, j int) bool { return s.States[i].Name < s.States[j].Name })
|
|
return s
|
|
}
|
|
|
|
// ReadsAnnounced splits a reader's `reads` (`<owner>.<name>`) by what each owner announced: granted when the owner
|
|
// announced the state readable, or announced nothing yet (the transition); refused when the owner announced and did
|
|
// not announce that state readable.
|
|
func ReadsAnnounced(reads []string, announced map[string]announce.States) (granted, refused []string) {
|
|
return ReadsAnnouncedBy("", reads, announced)
|
|
}
|
|
|
|
// ReadsAnnouncedBy is ReadsAnnounced for one reader module, which also honours the readers an owner named for a state
|
|
// (announce.State.Readers) and the composer's named readers (NamedReaders, ADR 0547 clause 9): a read named for other
|
|
// modules is refused. An empty reader is judged by the readable mark alone.
|
|
func ReadsAnnouncedBy(reader string, reads []string, announced map[string]announce.States) (granted, refused []string) {
|
|
for _, r := range reads {
|
|
owner, name, ok := strings.Cut(r, ".")
|
|
s, said := announced[owner]
|
|
switch {
|
|
case reader != "" && !ReaderMay(reader, r):
|
|
refused = append(refused, r)
|
|
case reader != "" && ok && said && s.Keeps(name):
|
|
if s.ReadableBy(name, reader) {
|
|
granted = append(granted, r)
|
|
} else {
|
|
refused = append(refused, r)
|
|
}
|
|
case !ok || !said || s.Readable(name):
|
|
granted = append(granted, r)
|
|
default:
|
|
refused = append(refused, r)
|
|
}
|
|
}
|
|
return granted, refused
|
|
}
|
|
|
|
// NotAnnounced are the owners some module reads the state of and that have announced nothing yet, sorted: read from the
|
|
// readers' `reads` as before, until they announce.
|
|
func NotAnnounced(r Records) []string {
|
|
seen := map[string]bool{}
|
|
var out []string
|
|
for _, ds := range r.Assigned {
|
|
for _, d := range ds {
|
|
for _, read := range append(append([]string(nil), d.Reads...), d.ReadsRefused...) {
|
|
owner, _, ok := strings.Cut(read, ".")
|
|
if !ok || seen[owner] {
|
|
continue
|
|
}
|
|
if _, said := r.Announced[owner]; !said {
|
|
seen[owner] = true
|
|
out = append(out, owner)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
sort.Strings(out)
|
|
return out
|
|
}
|