94 lines
4.8 KiB
Go
94 lines
4.8 KiB
Go
package main
|
|
|
|
import (
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/novox/mesh-controller/internal/lease"
|
|
)
|
|
|
|
// novox/hq issue 201: on 2026-10-02 a plan sent the control node a controller older than the one running there,
|
|
// whose seat row the newer one had already widened; the older binary refused the row and the mesh went quiet for
|
|
// ten minutes. No send but a person's push and a gate's own put-back moves the controller or the node-engine back
|
|
// behind the build its machine was last sent: the send keeps it there, and carries the rest.
|
|
|
|
// askedIn answers a build from a fixed table: module@commit → when it was asked; failed names those that failed
|
|
// their gate.
|
|
func askedIn(table map[string]time.Time, failed ...string) func(module, commit string) (askedBuild, bool, error) {
|
|
return func(module, commit string) (askedBuild, bool, error) {
|
|
at, known := table[module+"@"+commit]
|
|
b := askedBuild{asked: at}
|
|
for _, f := range failed {
|
|
if f == module+"@"+commit {
|
|
b.failedGate = true
|
|
}
|
|
}
|
|
return b, known, nil
|
|
}
|
|
}
|
|
|
|
func TestACoreModuleIsKeptOverAnOlderRecord(t *testing.T) {
|
|
old, now := t0, t0.Add(time.Minute)
|
|
table := map[string]time.Time{
|
|
"mesh-controller@c1": old, "mesh-controller@c2": now,
|
|
"mesh-host@h1": old, "mesh-host@h2": now,
|
|
"app@a1": old, "app@a2": now,
|
|
}
|
|
sent := map[string]string{"mesh-controller": "c2", "mesh-host": "h2", "app": "a2"}
|
|
record := map[string]string{"mesh-controller": "c1", "mesh-host": "h1", "app": "a1"}
|
|
found, err := coreDowngrades("anchor", sent, record, sendScope{judged: map[string]bool{"anchor": true}}, askedIn(table))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(found) != 2 || found[0].module != "mesh-controller" || found[0].component != lease.ComponentController ||
|
|
found[0].sent != "c2" || found[1].module != "mesh-host" || found[1].component != lease.ComponentEngine {
|
|
t.Fatalf("the controller and the node-engine over an older record are kept, and nothing else: %+v", found)
|
|
}
|
|
if said := found[0].String(); !strings.Contains(said, "anchor was last sent mesh-controller c2") ||
|
|
!strings.Contains(said, "`push anchor`") || !strings.Contains(said, "`rebuild mesh-controller`") {
|
|
t.Fatalf("it says the machine, the build kept and the two ways out: %s", said)
|
|
}
|
|
|
|
// The record forward, the same build, or a build the records do not hold: nothing kept.
|
|
for _, c := range [][2]string{{"c1", "c2"}, {"c2", "c2"}, {"c2", "c9"}, {"c9", "c1"}} {
|
|
found, err := coreDowngrades("anchor", map[string]string{"mesh-controller": c[0]},
|
|
map[string]string{"mesh-controller": c[1]}, sendScope{}, askedIn(table))
|
|
if err != nil || len(found) != 0 {
|
|
t.Fatalf("sent %s, record %s: no downgrade proved, nothing kept: %+v %v", c[0], c[1], found, err)
|
|
}
|
|
}
|
|
|
|
// A sent build that failed its gate is never ahead: the record put back before it is sent.
|
|
if found, _ := coreDowngrades("anchor", sent, record, sendScope{}, askedIn(table, "mesh-controller@c2")); len(found) != 1 ||
|
|
found[0].module != "mesh-host" {
|
|
t.Fatalf("a controller that failed its gate was kept over the build put back: %+v", found)
|
|
}
|
|
|
|
// A gate's own put-back carries its own modules back, and nothing else.
|
|
putBack := sendScope{modules: map[string]bool{"mesh-controller": true}, puttingBack: true}
|
|
if found, _ := coreDowngrades("anchor", sent, record, putBack, askedIn(table)); len(found) != 1 || found[0].module != "mesh-host" {
|
|
t.Fatalf("a put-back of the controller carries it back, and not the node-engine: %+v", found)
|
|
}
|
|
if found, _ := coreDowngrades("anchor", sent, record, sendScope{modules: map[string]bool{"mesh-controller": true}},
|
|
askedIn(table)); len(found) != 2 {
|
|
t.Fatalf("a send for the controller that is no put-back carries it back: %+v", found)
|
|
}
|
|
}
|
|
|
|
// core201 is a mesh whose control node, anchor, was sent the newer controller c2 while the mesh's record of the
|
|
// controller is the build before it, c1, which passed its gate when it rolled out.
|
|
|
|
// TestReplay201 replays the race on a store: the control node runs the newer controller and the mesh's record is
|
|
// the build before it. A plan's send there — the node-engine's plan of 2026-10-02 — goes, keeps the newer
|
|
// controller, and says so as a condition; the gate's own put-back carries it back; a send that carries the record,
|
|
// as a person's push does, clears the condition.
|
|
|
|
// The review of #273: a gate failed the newer controller, put the record back, and the put-back's own send was
|
|
// refused. The next automatic send — a healer's, which judges nothing — completes the put-back: a build that
|
|
// failed its gate is never kept.
|
|
|
|
// Review 91 of #273: a gated send to a machine whose controller is kept over an older record leaves the kept
|
|
// controller out of what its gate judges. Judged as moving back to the record, the gate would read the send's own
|
|
// kept controller as another build sent there after it (issue 352) and be superseded, judging nothing.
|