Read the controller's stores once into mesh-sdk's composition input: the nodes and the network (issue 1382)
readComposeInput asks the stores for the Input's mesh-wide and per-node fields (the shelf, each node's place, assignments, capabilities, accounts, pins, bindings, settings, ports, sealing key, taken modules, links, networks, order and builds, the recorded modules it keeps at the build it runs, its node-engine's contract) and writes nothing. A node's kept manifests are its own: the Input's Catalogue stays the current shelf (R4a review round 1, finding 1). Settings are read for the modules each node resolves to, as planFor read them. keepRecorded is split so the adapter reads the kept manifests with its refusals in the same words (applyKept). The credential and build half is issue 1383; vendor/modules.txt now lists go/compose and no longer the mesh-host validator.
This commit is contained in:
@@ -0,0 +1,392 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"os"
|
||||
"sort"
|
||||
"strings"
|
||||
|
||||
"git.novox.be/novox/mesh-sdk/go/catalogue"
|
||||
"git.novox.be/novox/mesh-sdk/go/compose"
|
||||
"git.novox.be/novox/mesh-sdk/go/overlay"
|
||||
"github.com/novox/mesh-controller/internal/inventory"
|
||||
)
|
||||
|
||||
// The controller's adapter from its stores to mesh-sdk's composition input (novox/hq ADR 0453 clause 3, design 47 R4b,
|
||||
// issues 1382 and 1383).
|
||||
//
|
||||
// **The adapter reads, and perform writes.** readComposeInput asks the stores once for everything the composition reads
|
||||
// and returns compose.Input, which the composition never changes; it makes, seals, allocates and records nothing. A
|
||||
// pair credential, a port, an own secret or a core box that the next send would make is not made here: the composition
|
||||
// names it foreseen, and compose_perform.go makes it for a send, then reads the stores again and composes again. A
|
||||
// question (status, facts, probes, the merge gate's reading) never performs.
|
||||
//
|
||||
// **The Input is built once per operation.** A verb that composes every node reads the stores once and hands the Input to
|
||||
// each node's composition of it.
|
||||
|
||||
// composeInputBuilt is called once for each Input the adapter builds: the seam a test counts the reads of an operation by
|
||||
// (issue 1382, criterion 5).
|
||||
var composeInputBuilt = func() {}
|
||||
|
||||
// readComposeInput reads the stores once and returns what the composition needs. ctx carries what a send keeps (the
|
||||
// recorded modules kept at the build their machine runs, recorded_kept.go): the same contexts every send composes under.
|
||||
func readComposeInput(ctx context.Context, open *stores) (*meshInput, error) {
|
||||
in, shape, err := readMeshAndNodes(ctx, open)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
// What each node resolves to, with no credential and no settings given: the modules whose settings are read, and the
|
||||
// needs whose pair credentials are asked of the stores. Nothing is written by it.
|
||||
plans := map[string]compose.Resolved{}
|
||||
for _, n := range in.Nodes {
|
||||
resolved, err := compose.Resolve(in, n.Name)
|
||||
switch {
|
||||
case compose.IsUnresolvable(err):
|
||||
// Their set does not compose: nothing of theirs is read further, as the controller never read a thing for a
|
||||
// node that did not resolve.
|
||||
continue
|
||||
case err != nil:
|
||||
return nil, err
|
||||
}
|
||||
plans[n.Name] = resolved
|
||||
}
|
||||
if err := readSettings(ctx, open, &in, plans); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := readCredentialsAndBuilds(ctx, open, &in, plans, shape); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
composeInputBuilt()
|
||||
return &meshInput{Input: in}, nil
|
||||
}
|
||||
|
||||
// readCredentialsAndBuilds is the credential and build half of the Input, which issue 1383 fills.
|
||||
func readCredentialsAndBuilds(context.Context, *stores, *compose.Input, map[string]compose.Resolved, inputShape) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
// meshInput is the Input an operation composes over.
|
||||
type meshInput struct {
|
||||
compose.Input
|
||||
}
|
||||
|
||||
// nodeOf is the node of that name in an Input.
|
||||
func nodeOf(in compose.Input, name string) (compose.Node, bool) {
|
||||
for _, n := range in.Nodes {
|
||||
if n.Name == name {
|
||||
return n, true
|
||||
}
|
||||
}
|
||||
return compose.Node{}, false
|
||||
}
|
||||
|
||||
// inputShape is what the first half of the reading found that the second half needs.
|
||||
type inputShape struct {
|
||||
sent map[string]map[string]string // by node: module to the commit last sent
|
||||
kept map[string]map[string]string // by node: module to the commit kept
|
||||
current map[string]inventory.CurrentBuild
|
||||
}
|
||||
|
||||
// readMeshAndNodes is the mesh-wide and per-node half of the Input (issue 1382).
|
||||
func readMeshAndNodes(ctx context.Context, open *stores) (compose.Input, inputShape, error) {
|
||||
inv := open.inventory
|
||||
var in compose.Input
|
||||
shape := inputShape{sent: map[string]map[string]string{}, kept: map[string]map[string]string{}}
|
||||
|
||||
shelf, err := inv.Catalogue(ctx)
|
||||
if err != nil {
|
||||
return in, shape, err
|
||||
}
|
||||
in.Catalogue = shelf
|
||||
if in.Holdings, err = inv.Holdings(ctx); err != nil {
|
||||
return in, shape, err
|
||||
}
|
||||
if in.Licences, err = readLicences(ctx, open); err != nil {
|
||||
return in, shape, err
|
||||
}
|
||||
|
||||
nodes, err := inv.Nodes(ctx)
|
||||
if err != nil {
|
||||
return in, shape, err
|
||||
}
|
||||
places, err := inv.Overlays(ctx)
|
||||
if err != nil {
|
||||
return in, shape, err
|
||||
}
|
||||
placed := map[string]inventory.Overlay{}
|
||||
for _, p := range places {
|
||||
placed[p.Name] = p
|
||||
}
|
||||
if shape.current, err = inv.CurrentBuilds(ctx); err != nil {
|
||||
return in, shape, err
|
||||
}
|
||||
|
||||
// The range the mesh allocates from and what its internal names end in, read from the environment here and nowhere else.
|
||||
in.OverlayCIDR = strings.TrimSpace(os.Getenv(OverlayCIDRVar))
|
||||
in.InternalSuffix = overlay.Suffix()
|
||||
if in.Tunnels, err = readTunnels(ctx, inv); err != nil {
|
||||
return in, shape, err
|
||||
}
|
||||
if in.Adopted, err = readAdopted(ctx, inv); err != nil {
|
||||
return in, shape, err
|
||||
}
|
||||
carried, err := inv.CarriedPeers(ctx)
|
||||
if err != nil {
|
||||
return in, shape, err
|
||||
}
|
||||
for _, c := range carried {
|
||||
in.CarriedPeers = append(in.CarriedPeers, compose.CarriedPeer{
|
||||
PublicKey: c.PublicKey, Address: c.Address, EnrolledAs: c.EnrolledAs, Named: c.Named})
|
||||
}
|
||||
if in.Joining, err = inv.NodesWithALiveToken(ctx); err != nil {
|
||||
return in, shape, err
|
||||
}
|
||||
|
||||
keepsSecrets := false
|
||||
for _, m := range shelf {
|
||||
keepsSecrets = keepsSecrets || m.Keeps != ""
|
||||
}
|
||||
|
||||
for _, n := range nodes {
|
||||
node, err := readNode(ctx, open, n, placed[n.Name])
|
||||
if err != nil {
|
||||
return in, shape, err
|
||||
}
|
||||
shape.sent[n.Name], shape.kept[n.Name] = node.SentBuilds, node.KeptBuilds
|
||||
in.Nodes = append(in.Nodes, node)
|
||||
}
|
||||
if keepsSecrets {
|
||||
if in.OperatorExport, err = inv.OperatorExport(ctx); err != nil {
|
||||
return in, shape, err
|
||||
}
|
||||
}
|
||||
return in, shape, nil
|
||||
}
|
||||
|
||||
// readNode is one node of the Input: everything the composition reads about it, in the order the controller read it.
|
||||
func readNode(ctx context.Context, open *stores, n inventory.Node, place inventory.Overlay) (compose.Node, error) {
|
||||
inv := open.inventory
|
||||
out := compose.Node{
|
||||
Name: n.Name,
|
||||
Place: compose.Place{Key: place.Key, Endpoint: place.Endpoint, Site: place.Site, Hub: place.Hub,
|
||||
Address: place.Address},
|
||||
Account: n.Account, AccountHome: n.AccountHome, AgentAccount: n.AgentAccount, AgentAccountHome: n.AgentAccountHome,
|
||||
Adopted: n.Adopted,
|
||||
}
|
||||
var err error
|
||||
if out.Assigned, err = inv.Assigned(ctx, n.Name); err != nil {
|
||||
return out, err
|
||||
}
|
||||
if out.Capabilities, err = inv.ProfileOf(ctx, n.Name); err != nil {
|
||||
return out, err
|
||||
}
|
||||
if out.PublicDomain, err = inv.PublicDomainOf(ctx, n.Name); err != nil {
|
||||
return out, err
|
||||
}
|
||||
if out.Pins, err = inv.PinsFor(ctx, n.Name); err != nil {
|
||||
return out, err
|
||||
}
|
||||
if out.Bound, err = inv.BindingsFor(ctx, n.Name); err != nil {
|
||||
return out, err
|
||||
}
|
||||
given, err := inv.PortsFor(ctx, n.Name)
|
||||
if err != nil {
|
||||
return out, err
|
||||
}
|
||||
for _, a := range given {
|
||||
if out.Ports == nil {
|
||||
out.Ports = map[string]map[int]int{}
|
||||
}
|
||||
if out.Ports[a.Module] == nil {
|
||||
out.Ports[a.Module] = map[int]int{}
|
||||
}
|
||||
out.Ports[a.Module][a.Wanted] = a.Machine
|
||||
}
|
||||
if out.SealingKey, err = inv.SealingKeyOf(ctx, n.Name); err != nil {
|
||||
return out, err
|
||||
}
|
||||
if n.Adopted {
|
||||
if out.Taken, err = inv.Taken(ctx, n.Name); err != nil {
|
||||
return out, err
|
||||
}
|
||||
}
|
||||
if out.OutwardLinks, err = inv.OutwardLinksOf(ctx, n.Name); err != nil {
|
||||
return out, err
|
||||
}
|
||||
account, had, err := inv.MachineOf(ctx, n.Name)
|
||||
if err != nil {
|
||||
return out, err
|
||||
}
|
||||
if had && account.Machine != nil {
|
||||
out.NetworksSaid = true
|
||||
for _, a := range account.Machine.Networks {
|
||||
out.Networks = append(out.Networks, catalogue.AttachedNetwork{Link: a.Link, Network: a.Network})
|
||||
}
|
||||
}
|
||||
if out.Sequence, err = inv.Sequence(ctx, n.ID); err != nil {
|
||||
return out, err
|
||||
}
|
||||
if out.Epoch, err = inv.SentEpoch(ctx, n.ID); err != nil {
|
||||
return out, err
|
||||
}
|
||||
if out.Generation, err = inv.SentGeneration(ctx, n.ID); err != nil {
|
||||
return out, err
|
||||
}
|
||||
if out.ReadsModules, err = inv.ReadsModules(ctx, n.ID); err != nil {
|
||||
return out, err
|
||||
}
|
||||
if out.SentBuilds, out.SentKnown, err = inv.SentBuilds(ctx, n.Name); err != nil {
|
||||
return out, err
|
||||
}
|
||||
runs, err := inv.AssignmentRuns(ctx, n.Name)
|
||||
if err != nil {
|
||||
return out, err
|
||||
}
|
||||
if len(runs) > 0 {
|
||||
out.Runs = make(map[string]compose.Run, len(runs))
|
||||
for module, ref := range runs {
|
||||
out.Runs[module] = compose.Run{Commit: ref.Commit, Build: ref.Build}
|
||||
}
|
||||
}
|
||||
// A recorded module kept at the build this machine runs, in the context a send composes under (recorded_kept.go): its
|
||||
// manifest and the commit, applied to this node's own resolution only.
|
||||
kept, err := recordedKept(ctx, open, n.Name)
|
||||
if err != nil {
|
||||
return out, err
|
||||
}
|
||||
if len(kept) > 0 {
|
||||
out.KeptBuilds = kept
|
||||
if out.Kept, err = keptManifests(ctx, open, n.Name, kept); err != nil {
|
||||
return out, err
|
||||
}
|
||||
}
|
||||
stated, has, err := inv.HealthOf(ctx, n.Name)
|
||||
if err != nil {
|
||||
return out, err
|
||||
}
|
||||
out.Stated = has
|
||||
if has {
|
||||
out.Contract = stated.Contract
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// keptManifests is the manifest of each module kept at the build a machine runs: keepRecorded's reads, and its refusals in its
|
||||
// words, without putting any of it into a shelf (that is the node's own Kept, applied by the composition).
|
||||
func keptManifests(ctx context.Context, open *stores, node string, kept map[string]string) (map[string]catalogue.Manifest, error) {
|
||||
// applyKept puts each manifest into the shelf it is given and refuses a build that cannot be read; the shelf here is a
|
||||
// scratch one, whose entries are the kept manifests.
|
||||
scratch := map[string]catalogue.Manifest{}
|
||||
if err := applyKept(ctx, open, node, kept, scratch); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return scratch, nil
|
||||
}
|
||||
|
||||
func readTunnels(ctx context.Context, inv *inventory.Inventory) (map[string]compose.FoundTunnel, error) {
|
||||
found, err := inv.Tunnels(ctx)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if len(found) == 0 {
|
||||
return nil, nil
|
||||
}
|
||||
out := make(map[string]compose.FoundTunnel, len(found))
|
||||
for name, t := range found {
|
||||
out[name] = compose.FoundTunnel{Tunnel: tunnelOf(t.Tunnel), NodeAdopted: t.NodeAdopted}
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func readAdopted(ctx context.Context, inv *inventory.Inventory) (*compose.AdoptedTunnel, error) {
|
||||
tunnel, hub, adopted, err := inv.AdoptedTunnel(ctx)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if hub == "" {
|
||||
return nil, nil
|
||||
}
|
||||
return &compose.AdoptedTunnel{Tunnel: tunnelOf(tunnel), Hub: hub, Adopted: adopted}, nil
|
||||
}
|
||||
|
||||
func tunnelOf(t inventory.Tunnel) compose.Tunnel {
|
||||
out := compose.Tunnel{Interface: t.Interface, Unit: t.Unit, Config: t.Config, Port: t.Port, MTU: t.MTU,
|
||||
Address: t.Address, Range: t.Range, PublicKey: t.PublicKey}
|
||||
for _, p := range t.Peers {
|
||||
out.Peers = append(out.Peers, compose.TunnelPeer{PublicKey: p.PublicKey, Address: p.Address})
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// readLicences is every licence the mesh holds, with who uses it and the key sealed to each holder: given even where empty,
|
||||
// so a holder the mesh holds no key for composes as that, and not as a key that was not asked for.
|
||||
func readLicences(ctx context.Context, open *stores) ([]compose.Licence, error) {
|
||||
held, err := open.Licences(ctx)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
all, err := held.All(ctx)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
var out []compose.Licence
|
||||
for _, one := range all {
|
||||
l := compose.Licence{Name: one.Name, Serves: one.Serves, Keys: map[compose.Holder]string{}}
|
||||
holders, err := held.HoldersOf(ctx, one.Name)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
for _, h := range holders {
|
||||
holder := compose.Holder{Node: h.Node, Module: h.Module}
|
||||
l.Holders = append(l.Holders, holder)
|
||||
key, err := held.KeyFor(ctx, one.Name, h.Node, h.Module)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
l.Keys[holder] = key
|
||||
}
|
||||
node, module, err := held.ManagerOf(ctx, one.Name)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
l.Manager = compose.Holder{Node: node, Module: module}
|
||||
out = append(out, l)
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// readSettings is each node's settings layers for the modules it resolves to: the ones the composition reads for it and for
|
||||
// the rest of the mesh, and no module nothing resolves (a module's settings may fail to read where nothing runs it).
|
||||
func readSettings(ctx context.Context, open *stores, in *compose.Input, plans map[string]compose.Resolved) error {
|
||||
modules := map[string]map[string]bool{}
|
||||
for node, resolved := range plans {
|
||||
modules[node] = map[string]bool{}
|
||||
for _, m := range resolved.Plan.Modules {
|
||||
modules[node][m.Module] = true
|
||||
}
|
||||
}
|
||||
// The rest of the mesh reads the settings of the modules that offer something on another node (servedOnNode), which are
|
||||
// among the modules that node resolves to.
|
||||
for i := range in.Nodes {
|
||||
n := &in.Nodes[i]
|
||||
names := make([]string, 0, len(modules[n.Name]))
|
||||
for m := range modules[n.Name] {
|
||||
names = append(names, m)
|
||||
}
|
||||
sort.Strings(names)
|
||||
for _, module := range names {
|
||||
layers, err := open.inventory.SettingsFor(ctx, n.Name, module)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if len(layers) == 0 {
|
||||
continue
|
||||
}
|
||||
if n.Settings == nil {
|
||||
n.Settings = map[string][]catalogue.Layer{}
|
||||
}
|
||||
n.Settings[module] = layers
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
Reference in New Issue
Block a user