mesh-delivery/modules/mesh-delivery-assigner/internal/assigngraph/compute.go

// Package assigngraph is the assigner's assignment graph (design 47, *Two graphs, one source of truth*; ADR 0656): the
// module versions placed on nodes, with the edges between versions, computed from the catalog graph of the branch each
// placement names, the placements and the nodes' capability readings, and kept per revision as objects of the seat
// mesh-wants' kept data assignment-revisions.
package assigngraph

import (
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"maps"
	"slices"
	"strings"

	mma "git.novox.be/novox/mesh-contracts/go/seats/meshmoduleassigner"
	"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/clients/meshcatalogclient"
	"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshwants"
	"git.novox.be/novox/mesh-sdk/go/keys"

	"mesh-delivery-assigner/internal/assignment"
)

// The kinds of an edge of the assignment graph (ADR 0656; the seat's Edge).
const (
	EdgeProvisioning = "provisioning"
	EdgeActing       = "acting"
)

// Inputs are what a revision is computed from, and nothing else (design 47 lines 1353-1356).
type Inputs struct {
	// Halves is the catalog graph revision held of each watched branch, by branch.
	Halves map[string]meshcatalogclient.Half
	// Placements is every node's placement key, by node.
	Placements map[string]mma.Assignments
	// FirstBranch is the first watched branch of a module's registration, the branch a placement naming none runs
	// (design 47 lines 522-523); "" when no registration is known for it.
	FirstBranch func(module string) string
	// Capabilities is each node's capability reading, by its digest.
	Capabilities []meshwants.AssignmentRevisionCapabilitiesItem
}

// Computed is one assignment graph revision as computed, before it is numbered and kept.
type Computed struct {
	Revision meshwants.AssignmentRevision
	// Entries is every entry the revision lists, by its digest.
	Entries map[string]meshwants.AssignmentEntry
	// Uncomputed is each placed module whose entry could not be computed, as "<node>/<module>: why", sorted: it is said,
	// never left out in silence.
	Uncomputed []string
}

// placedAt is one placed module with what its entry is computed from.
type placedAt struct {
	node   string
	placed mma.PlacedModule
	branch string
	entry  meshwants.AssignmentEntry
	langs  map[string]bool
	acts   []actingRule
}

type actingRule struct{ seat, step, on, bound string }

// Compute is the assignment graph revision of in: one entry per module placed on a node whose branch's catalog graph
// holds it, its version the build the placement names or else the catalog entry's fingerprint (design 47 lines 909-914),
// with the edges of provisioning to the providers its placement binds or its node pins, and of acting from each acting
// part's version to each version its rule names (design 47 *An acting part's new version acts first*: "the assigner
// gives an edge from the acting part's version to each version its rule names").
func Compute(in Inputs) Computed {
	out := Computed{Entries: map[string]meshwants.AssignmentEntry{}}
	var placed []*placedAt
	branches := map[string]bool{}
	for _, node := range slices.Sorted(maps.Keys(in.Placements)) {
		mods := slices.Clone(in.Placements[node].Modules)
		slices.SortFunc(mods, func(a, b mma.PlacedModule) int { return strings.Compare(a.Module, b.Module) })
		for _, m := range mods {
			branch := m.Branch
			if branch == "" && in.FirstBranch != nil {
				branch = in.FirstBranch(m.Module)
			}
			if branch == "" {
				out.Uncomputed = append(out.Uncomputed, fmt.Sprintf("%s/%s: no watched branch: its placement names none and no registration of it is known", node, m.Module))
				continue
			}
			half, ok := in.Halves[branch]
			if !ok {
				out.Uncomputed = append(out.Uncomputed, fmt.Sprintf("%s/%s: the catalog graph of the branch %s is not held", node, m.Module, branch))
				continue
			}
			ce, ok := half.Entries[m.Module]
			if !ok {
				out.Uncomputed = append(out.Uncomputed, fmt.Sprintf("%s/%s: the catalog graph revision %d of %s holds no entry of it", node, m.Module, half.Revision.Revision, branch))
				continue
			}
			digest := ""
			for _, ref := range half.Revision.Entries {
				if ref.Module == m.Module {
					digest = ref.Digest
				}
			}
			if digest == "" {
				out.Uncomputed = append(out.Uncomputed, fmt.Sprintf("%s/%s: the catalog graph revision %d of %s lists no digest of its entry", node, m.Module, half.Revision.Revision, branch))
				continue
			}
			fp := ce.Fp
			if m.Build != "" {
				fp = m.Build
			}
			p := &placedAt{node: node, placed: m, branch: branch, langs: map[string]bool{},
				entry: meshwants.AssignmentEntry{V: keys.Version, Node: node, Module: m.Module, Branch: branch, Fp: fp, Catalog: digest}}
			for lang := range ce.Toolchains {
				p.langs[lang] = true
			}
			for _, r := range ce.Acts {
				p.acts = append(p.acts, actingRule{seat: r.Seat, step: r.Step, on: r.On, bound: r.Bound})
			}
			for _, r := range ce.Requires {
				prov, ok := m.Bindings[r]
				if !ok {
					prov, ok = in.Placements[node].Pins[r]
				}
				if ok {
					p.entry.Edges = append(p.entry.Edges, meshwants.Edge{Kind: EdgeProvisioning, Node: prov.Node, Module: prov.Module, Provision: r})
				}
			}
			placed = append(placed, p)
			branches[branch] = true
		}
	}
	at := map[string]*placedAt{}
	for _, p := range placed {
		at[p.node+"/"+p.placed.Module] = p
	}
	for _, p := range placed {
		for i, e := range p.entry.Edges {
			if prov, ok := at[e.Node+"/"+e.Module]; ok {
				p.entry.Edges[i].Fp = prov.entry.Fp
			}
		}
	}
	// Acting: an acting part on the entry's own node acts there (a node's seat is held on every node); else every node it
	// is placed on (a seat held once for the mesh is held on one).
	byModule := map[string][]*placedAt{}
	for _, p := range placed {
		byModule[p.placed.Module] = append(byModule[p.placed.Module], p)
	}
	for _, part := range slices.Sorted(maps.Keys(byModule)) {
		holders := byModule[part]
		for _, rule := range holders[0].acts {
			for _, t := range placed {
				if t.placed.Module == part || (rule.on != "" && rule.on != "every" && !t.langs[rule.on]) {
					continue
				}
				from := holders
				for _, h := range holders {
					if h.node == t.node {
						from = []*placedAt{h}
					}
				}
				for _, h := range from {
					t.entry.Edges = append(t.entry.Edges, meshwants.Edge{Kind: EdgeActing, Node: h.node, Module: part, Fp: h.entry.Fp,
						Seat: rule.seat, Step: rule.step, Bound: rule.bound})
				}
			}
		}
	}
	rev := meshwants.AssignmentRevision{V: keys.Version, Kind: meshcatalogclient.KindTrunk, Placements: assignment.ExportDigest(in.Placements),
		Capabilities: in.Capabilities, Entries: []meshwants.NodeEntryRef{}}
	for _, b := range slices.Sorted(maps.Keys(branches)) {
		h := in.Halves[b]
		rev.Catalogs = append(rev.Catalogs, meshwants.CatalogOf{Branch: b, Revision: h.Revision.Revision, Source: h.Revision.Source})
	}
	for _, p := range placed {
		sortEdges(p.entry.Edges)
		d := EntryDigest(p.entry)
		out.Entries[d] = p.entry
		rev.Entries = append(rev.Entries, meshwants.NodeEntryRef{Node: p.node, Module: p.placed.Module, Digest: d})
	}
	out.Revision = rev
	slices.Sort(out.Uncomputed)
	return out
}

func sortEdges(edges []meshwants.Edge) {
	slices.SortFunc(edges, func(a, b meshwants.Edge) int {
		return strings.Compare(edgeKey(a), edgeKey(b))
	})
}

func edgeKey(e meshwants.Edge) string {
	return strings.Join([]string{e.Kind, e.Node, e.Module, e.Provision, e.Seat, e.Step, e.Fp, e.Bound}, "\x00")
}

// EntryDigest is the digest an entry is stored under: the same entry, the same digest.
func EntryDigest(e meshwants.AssignmentEntry) string {
	raw, _ := json.Marshal(e)
	sum := sha256.Sum256(raw)
	return "sha256:" + hex.EncodeToString(sum[:])
}

// Same says two revisions list the same entries computed from the same inputs, so the second is no new revision.
func Same(a, b meshwants.AssignmentRevision) bool {
	return slices.Equal(a.Entries, b.Entries) && slices.Equal(a.Catalogs, b.Catalogs) && a.Placements == b.Placements &&
		slices.Equal(a.Capabilities, b.Capabilities)
}