mesh-controller/cmd/mesh-controller/held_back_test.go

package main

import (
	"context"
	"encoding/json"
	"strings"
	"testing"
	"time"

	"git.novox.be/novox/mesh-sdk/go/catalogue"
	"git.novox.be/novox/mesh-sdk/go/overlay"
	"github.com/novox/mesh-controller/internal/inventory"
)

// novox/hq issue 259, ADR 0221: a push that did not name a machine does not send it a build its
// upgrade policy records rather than rolls out, nor one an open plan has not sent it yet. Anything
// else that moved is still a consequence the push sends (ADR 0083).
func TestAHeldBuildHoldsAMachineANamedPushDidNotName(t *testing.T) {
	current := map[string]inventory.CurrentBuild{
		"resolver": {Commit: "c2c2c2c2c2"},
		"agent":    {Commit: "a2", RollOut: true},
		"network":  {},
	}
	modules := []string{"network", "resolver", "agent"}
	sent := map[string]string{"network": "", "resolver": "c1c1c1c1c1", "agent": "a2"}

	// A module whose policy records moved: held, naming it, both builds and why.
	why := heldBack("laptop", modules, sent, true, current, nil)
	if len(why) != 1 || !strings.Contains(why[0], "resolver would move from c1c1c1c1 to c2c2c2c2") ||
		!strings.Contains(why[0], "upgrade policy records") {
		t.Fatalf("a recorded upgrade did not hold the machine: %v", why)
	}

	// Nothing moved — what differs is a grant, a peer, a setting: not held (issue 057).
	sent["resolver"] = "c2c2c2c2c2"
	if why := heldBack("laptop", modules, sent, true, current, nil); len(why) != 0 {
		t.Fatalf("a machine whose builds are all current was held: %v", why)
	}

	// A module whose policy rolls out moved, and no plan holds it: sent, as before.
	sent["agent"] = "a1"
	if why := heldBack("laptop", modules, sent, true, current, nil); len(why) != 0 {
		t.Fatalf("a rolled-out upgrade no plan holds was held: %v", why)
	}

	// The last send's builds are not known: held whole.
	if why := heldBack("laptop", modules, nil, false, current, nil); len(why) != 1 ||
		!strings.Contains(why[0], "not known") {
		t.Fatalf("a machine whose last send was not recorded was not held: %v", why)
	}

	// A module the machine was never sent, under a recording policy: held, and said so.
	delete(sent, "resolver")
	sent["agent"] = "a2"
	if why := heldBack("laptop", modules, sent, true, current, nil); len(why) != 1 ||
		!strings.Contains(why[0], "resolver would move (never sent it) to c2c2c2c2") {
		t.Fatalf("a module never sent under a recording policy: %v", why)
	}
}

// ADR 0218 meets ADR 0083: a plan waiting on its first machine has not sent the rest, and a push
// naming some other machine must not send them for it.
func TestAPlanWaitingOnItsFirstMachineHoldsTheRest(t *testing.T) {
	at := time.Now()
	current := map[string]inventory.CurrentBuild{"agent": {Commit: "a2", RollOut: true}}
	sent := map[string]string{"agent": "a1"}
	waiting := []inventory.Plan{{ID: "plan-7", State: inventory.PlanRolling, Modules: map[string]*inventory.PlanModule{
		"agent": {State: "built", First: []string{"ace"}, FirstAt: &at}}}}

	why := heldBack("g14", []string{"agent"}, sent, true, current, waiting)
	if len(why) != 1 || !strings.Contains(why[0], "plan-7 has not sent it yet") {
		t.Fatalf("a machine the plan has not reached was not held: %v", why)
	}
	// The first machine itself was sent by the plan: not held by it.
	if why := heldBack("ace", []string{"agent"}, sent, true, current, waiting); len(why) != 0 {
		t.Fatalf("the plan's first machine was held: %v", why)
	}
	// Built but not yet sent anywhere, or not yet built: the plan has it still to send.
	for what, s := range map[string]*inventory.PlanModule{"built, unsent": {State: "built"}, "unasked": nil} {
		plans := []inventory.Plan{{ID: "plan-8", State: inventory.PlanBuilding,
			Modules: map[string]*inventory.PlanModule{"agent": s}}}
		if why := heldBack("ace", []string{"agent"}, sent, true, current, plans); len(why) != 1 {
			t.Errorf("%s: not held: %v", what, why)
		}
	}
	// Sent everywhere, failed, or a plan no longer open: the plan holds nothing back.
	for what, plans := range map[string][]inventory.Plan{
		"sent everywhere": {{ID: "p", State: inventory.PlanRolling, Modules: map[string]*inventory.PlanModule{
			"agent": {State: "built", First: []string{"ace"}, FirstAt: &at, SentAt: &at}}}},
		"failed": {{ID: "p", State: inventory.PlanRolling, Modules: map[string]*inventory.PlanModule{
			"agent": {State: "failed"}}}},
		"closed": {{ID: "p", State: inventory.PlanDone, Modules: map[string]*inventory.PlanModule{
			"agent": {State: "built"}}}},
	} {
		if why := heldBack("g14", []string{"agent"}, sent, true, current, plans); len(why) != 0 {
			t.Errorf("%s: held: %v", what, why)
		}
	}
}

// recordedDelivery sends nothing and records each send as the mesh does, so the next comparison
// reads the machine as current — and writes down which machines it declared.
type recordedDelivery struct {
	inv      *inventory.Inventory
	declared []string
}

func (r *recordedDelivery) grant(context.Context, []readyNode) error { return nil }

func (r *recordedDelivery) declare(ctx context.Context, s readyNode, body []byte) (string, error) {
	r.declared = append(r.declared, s.node)
	return recordSent(ctx, r.inv, s.node, body, s.declared.Builds, s.declared.Epoch, sentRecordOf(ctx, s.declared))
}

// aResolver is a module built from a repository, at a commit, with something on the machine that
// says which build it is.
func aResolver(t *testing.T, open *stores, commit string, asked time.Time) {
	t.Helper()
	m := catalogue.Manifest{Module: "resolver", Version: "1", Resources: []map[string]any{
		{"id": "zones", "type": "file", "path": "/etc/resolver/zones", "content": "built from " + commit},
	}}
	if err := open.inventory.RegisterModule(t.Context(), m, inventory.Source{
		Repository: "novox/mesh-catalog", Path: "modules/resolver", BuiltFrom: commit, Asked: asked}); err != nil {
		t.Fatal(err)
	}
}

// A third machine on the private network: once it is sent, every other machine's peers change with
// it, which is a consequence a push must still send — no build moved.
func aThirdMachine(t *testing.T, open *stores) {
	t.Helper()
	ctx := t.Context()
	record, err := open.inventory.AddNode(ctx, "spare")
	if err != nil {
		t.Fatal(err)
	}
	if err := open.inventory.SetPlace(ctx, "spare", "spare.example:51820", "here", false, "10.77.0.3"); err != nil {
		t.Fatal(err)
	}
	reported, err := json.Marshal(map[string]any{"capabilities": []map[string]any{
		{"name": "container-runtime", "present": true}, {"name": "wireguard", "present": true},
		{"name": "systemd", "present": true}}})
	if err != nil {
		t.Fatal(err)
	}
	var profile map[string]any
	if err := json.Unmarshal(reported, &profile); err != nil {
		t.Fatal(err)
	}
	if err := open.inventory.RecordProfile(ctx, record.ID, profile); err != nil {
		t.Fatal(err)
	}
	if err := open.inventory.RecordSealingKey(ctx, record.ID, aPublicKey(t)); err != nil {
		t.Fatal(err)
	}
	if err := open.inventory.RecordOverlayKey(ctx, record.ID, aPublicKey(t)); err != nil {
		t.Fatal(err)
	}
	if _, err := open.inventory.Assign(ctx, "spare", overlay.Name); err != nil {
		t.Fatal(err)
	}
}

// The issue as it happened, against the real stores: a change merged with the policy `record`, a push
// naming the anchor, and the laptop — running the same module — left with what it had, by name.

// Issue 057's case is unchanged: a machine whose builds are all current and whose declaration moved
// for another reason is sent by a push that names someone else.