mesh-delivery/modules/mesh-delivery-assigner/internal/assign/placement.go

package assign

import (
	"fmt"
	"sort"

	"git.novox.be/novox/mesh-sdk/go/asks"
	"git.novox.be/novox/mesh-sdk/go/delivery"
)

// Until ADR 0547's third milestone two sources name which module runs on which node: the controller's assignments and
// the indexer's placement, read from the catalogue (ADR 0549 §5). The assigner writes wants only for a pair both name:
// for a pair one source names alone it writes no want and touches none it wrote before, so nothing moves and nothing is
// removed on one source's word, and it raises a condition naming the pair until both agree. Before the first placement
// file reaches the indexer (no placement key at all) the controller's assignments are the one source, as before.

// Pair is a module on a node that one source names and the other does not; Only says which: OnlyAssignments or
// OnlyPlacement.
type Pair struct {
	Node, Module, Only string
}

// The source that names a pair alone.
const (
	OnlyAssignments = "the controller's assignments"
	OnlyPlacement   = "the catalogue's placement"
)

// Placed is, by node, the modules both sources name, in name order, and every pair one names alone, by node then
// module. With no placement read yet (seeded false) it is the assignments, and no pair differs.
func Placed(assigned, placed map[string][]string, seeded bool) (map[string][]string, []Pair) {
	if !seeded {
		return assigned, nil
	}
	set := func(m map[string][]string) map[string]bool {
		out := map[string]bool{}
		for node, modules := range m {
			for _, module := range modules {
				out[node+"\x00"+module] = true
			}
		}
		return out
	}
	inAssigned, inPlaced := set(assigned), set(placed)
	both := map[string][]string{}
	var differ []Pair
	for node, modules := range assigned {
		for _, module := range modules {
			if inPlaced[node+"\x00"+module] {
				both[node] = append(both[node], module)
			} else {
				differ = append(differ, Pair{Node: node, Module: module, Only: OnlyAssignments})
			}
		}
	}
	for node, modules := range placed {
		for _, module := range modules {
			if !inAssigned[node+"\x00"+module] {
				differ = append(differ, Pair{Node: node, Module: module, Only: OnlyPlacement})
			}
		}
	}
	for _, modules := range both {
		sort.Strings(modules)
	}
	sort.Slice(differ, func(i, j int) bool {
		if differ[i].Node != differ[j].Node {
			return differ[i].Node < differ[j].Node
		}
		return differ[i].Module < differ[j].Module
	})
	return both, differ
}

// PlacementCondition is the condition of a pair the two sources do not both name: raised while they differ, cleared once
// both name it or neither does.
func PlacementCondition(p Pair, raised bool) asks.Condition {
	key := delivery.AssignerModule + ".placement." + p.Node + "." + p.Module
	subject := asks.Scope{Scope: "module", ID: p.Module, Machine: p.Node}
	if !raised {
		return asks.Condition{Key: key, Subject: subject, State: asks.StateCleared,
			Resolved: fmt.Sprintf("the controller's assignments and the catalogue's placement agree on %s on %s.", p.Module, p.Node)}
	}
	headline := fmt.Sprintf("%s on %s is placed by one source only", p.Module, p.Node)
	if n := len([]rune(headline)); n > asks.HeadlineLength {
		headline = string([]rune(headline)[:asks.HeadlineLength])
	}
	var needs string
	if p.Only == OnlyAssignments {
		needs = fmt.Sprintf("add %s to the catalogue's placement file of %s, or unassign it at the controller", p.Module, p.Node)
	} else {
		needs = fmt.Sprintf("assign %s to %s at the controller, as the merged placement file says", p.Module, p.Node)
	}
	return asks.Condition{Key: key, Severity: asks.SeverityUrgent, Subject: subject, State: asks.StateRaised,
		Summary: headline, Headline: headline, Needs: needs,
		Explanation: fmt.Sprintf("%s%s. %s names %s on %s and the other source does not. Until ADR 0547's third milestone both must "+
			"name a module on a node (ADR 0549 §5): the assigner writes no want for it there and leaves the one it wrote before, so "+
			"nothing moves or is removed. This clears once both name it or neither does.", asks.NeedsYou, needs, p.Only, p.Module, p.Node)}
}