mesh-host/internal/compose/frombus/export.go

package frombus

import (
	"fmt"
	"git.novox.be/novox/mesh-contracts/go/seats/meshmoduleassigner"
	sdkkeys "git.novox.be/novox/mesh-sdk/go/keys"
	"sort"
	"strconv"

	"git.novox.be/novox/mesh-sdk/go/catalogue"
	"github.com/novox/mesh-host/internal/compose"
)

// Export is one node's assignment as the composition input the controller fills says it (novox/hq ADR 0555 §6, ADR 0567
// §7): the inverse of Input for what a person decides, so the controller's one read-only export verb
// answers, from its own store by its own code, exactly what the seat's adopt proposes as the seed. Its answer must stay
// stable for the same store, since adopt checks its digest again at the warrant.
// What the machine observes (its record) is not in it.
func Export(in compose.Input, node string) (meshmoduleassigner.Assignments, error) {
	var n *compose.Node
	for i := range in.Nodes {
		if in.Nodes[i].Name == node {
			n = &in.Nodes[i]
		}
	}
	if n == nil {
		return meshmoduleassigner.Assignments{}, fmt.Errorf("frombus: the input has no node %q", node)
	}
	// At the version a assignment key is read at, with a list of modules even when none is placed: the export is the
	// seed's value, and the reader refuses a value of version 0 or without its modules.
	p := meshmoduleassigner.Assignments{V: sdkkeys.Version, Node: node, Modules: []meshmoduleassigner.PlacedModule{}, Decided: meshmoduleassigner.NodeDecided{
		Endpoint: n.Place.Endpoint, Site: n.Place.Site, Hub: n.Place.Hub, Address: n.Place.Address,
		PublicDomain: n.PublicDomain, Account: n.Account, AccountHome: n.AccountHome, AgentAccount: n.AgentAccount,
		AgentAccountHome: n.AgentAccountHome, Adopted: n.Adopted, Taken: n.Taken}}
	// The tunnel found at the node's adoption: the one its private network took over, or, on the hub, the mesh's adopted
	// one whether or not the hub took it; and the names a person gave the hub's carried peers.
	if t, ok := in.Tunnels[node]; ok {
		rt := recordTunnelOf(t.Tunnel)
		p.Decided.Tunnel = &rt
	} else if in.Adopted != nil && in.Adopted.Hub == node {
		rt := recordTunnelOf(in.Adopted.Tunnel)
		p.Decided.Tunnel = &rt
	}
	if n.Place.Hub {
		for _, c := range in.CarriedPeers {
			if c.Named != "" {
				if p.Decided.PeerNames == nil {
					p.Decided.PeerNames = map[string]string{}
				}
				p.Decided.PeerNames[c.PublicKey] = c.Named
			}
		}
	}
	for _, module := range n.Assigned {
		m := meshmoduleassigner.PlacedModule{Module: module}
		for port, at := range n.Ports[module] {
			if m.Ports == nil {
				m.Ports = map[string]int64{}
			}
			m.Ports[strconv.Itoa(port)] = int64(at)
		}
		for provision, to := range n.Bound[module] {
			if m.Bindings == nil {
				m.Bindings = map[string]meshmoduleassigner.Provider{}
			}
			m.Bindings[provision] = meshmoduleassigner.Provider{Node: to.Node, Module: to.Module}
		}
		// A module in the settings form keeps its config values in its layers, not in mesh-config: they are exported with
		// the assignment. A module in the config form has mesh-config's values laid into its layer, which are not.
		settingsForm := !in.Catalogue[module].DeclaresConfig()
		for _, layer := range n.Settings[module] {
			if layer.From == catalogue.MeshWideLayer {
				m.HasMeshWide, m.MeshWide = true, layer.Placement
				if settingsForm && len(layer.Values) > 0 {
					m.MeshWideValues = layer.Values
				}
			} else {
				m.HasLayer, m.Layer = true, layer.Placement
				if settingsForm && len(layer.Values) > 0 {
					m.Values = layer.Values
				}
			}
		}
		p.Modules = append(p.Modules, m)
	}
	for provision, to := range n.Pins {
		if p.Pins == nil {
			p.Pins = map[string]meshmoduleassigner.Provider{}
		}
		p.Pins[provision] = meshmoduleassigner.Provider{Node: to.Node, Module: to.Module}
	}
	for _, h := range in.Holdings {
		if h.Node == node {
			p.Holds = append(p.Holds, meshmoduleassigner.Holding{Claim: h.Claim, Scope: h.Scope, Module: h.Module, Site: h.Site, Kind: h.Kind})
		}
	}
	sort.SliceStable(p.Holds, func(i, j int) bool {
		if p.Holds[i].Claim != p.Holds[j].Claim {
			return p.Holds[i].Claim < p.Holds[j].Claim
		}
		return p.Holds[i].Module < p.Holds[j].Module
	})
	return p, nil
}

func recordTunnelOf(t compose.Tunnel) meshmoduleassigner.FoundTunnel {
	out := meshmoduleassigner.FoundTunnel{Interface: t.Interface, Unit: t.Unit, Config: t.Config, Port: int64(t.Port), Mtu: int64(t.MTU),
		Address: t.Address, Range: t.Range, PublicKey: t.PublicKey}
	for _, peer := range t.Peers {
		out.Peers = append(out.Peers, meshmoduleassigner.FoundTunnelPeer{PublicKey: peer.PublicKey, Address: peer.Address})
	}
	return out
}