Merge pull request 'A machine says what it is made of, and says it once a day unasked (issue 160)' (#92) from fix/160-a-machine-says-what-it-is into main

cmd/mesh-host/machine_refresh_test.go

@@ -0,0 +1,107 @@
+package main
+
+import (
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/novox/mesh-host/internal/link"
+)
+
+// Defends novox/hq issue 160: a machine nobody pushed to still says what it is made of once a day, so the
+// newest of it the mesh holds is no older than a day. Before, the reconcile said it only with something
+// else (a hold, a firewall, an outward link changed), and a converged machine's picture was as old as the
+// last delivery to it.
+func TestAMachineNobodyPushedToSaysWhatItIsOnceADay(t *testing.T) {
+	at := time.Date(2026, 10, 12, 9, 0, 0, 0, time.UTC)
+	w := &adoptionWatch{now: func() time.Time { return at }}
+	quiet := link.Report{Outward: []string{"wlan0"},
+		Profile: map[string]any{"machine": map[string]any{"observed_at": at}}}
+
+	if !w.news(quiet) {
+		t.Fatal("the first reconcile after the engine started did not say what the machine is")
+	}
+	w.said(quiet)
+
+	for _, after := range []time.Duration{5 * time.Minute, 12 * time.Hour, 22*time.Hour + 55*time.Minute} {
+		at = time.Date(2026, 10, 12, 9, 0, 0, 0, time.UTC).Add(after)
+		if w.news(quiet) {
+			t.Errorf("%s after the mesh heard it, an unchanged reconcile was said again", after)
+		}
+	}
+	// The reconcile that falls past 23 hours says it, so it reaches the mesh inside the day.
+	at = time.Date(2026, 10, 12, 9, 0, 0, 0, time.UTC).Add(23*time.Hour + 5*time.Minute)
+	if !w.news(quiet) {
+		t.Fatal("a day on, the reconcile did not say what the machine is")
+	}
+	w.said(quiet)
+	at = at.Add(5 * time.Minute)
+	if w.news(quiet) {
+		t.Error("once said, it was said again at the next reconcile")
+	}
+}
+
+// A delivery's account carries the profile too: heard, it starts the day again.
+func TestADeliveryHeardStartsTheDayAgain(t *testing.T) {
+	at := time.Date(2026, 10, 12, 9, 0, 0, 0, time.UTC)
+	w := &adoptionWatch{now: func() time.Time { return at }}
+	report := link.Report{Outward: []string{"eth0"}, Profile: map[string]any{"capabilities": []any{}}}
+	w.said(report)
+	at = at.Add(20 * time.Hour)
+	w.said(report) // a delivery's apply
+	at = at.Add(20 * time.Hour)
+	if w.news(report) {
+		t.Error("said again unasked 20 hours after a delivery told the mesh")
+	}
+}
+
+// A refusal carries nothing about the machine, so it is never said for being a day old.
+func TestARefusalIsNotSaidForTheMachinesSake(t *testing.T) {
+	at := time.Date(2026, 10, 12, 9, 0, 0, 0, time.UTC)
+	w := &adoptionWatch{now: func() time.Time { return at }}
+	if w.machineDue(link.Report{Refused: "no"}) {
+		t.Error("a refusal was due for what the machine is made of")
+	}
+}
+
+// A laptop that slept still says what it is within a day of wall time (review of mesh-host#92). Go's monotonic
+// clock stops while a machine is suspended, and Sub between two times that both carry a monotonic reading uses
+// it, so a watch that kept one would count a day asleep as almost nothing. Simulated with a clock that first
+// reads now (a monotonic reading), and after the sleep reads the wall time a day on: the watch must keep no
+// monotonic reading, and judge the day as the wall clock says it.
+func TestALaptopThatSleptStillSaysWhatItIsWithinADay(t *testing.T) {
+	before := time.Now() // carries a monotonic reading
+	asleep := before.Add(3 * time.Second)
+	if asleep.Sub(before) != 3*time.Second {
+		t.Fatal("the monotonic reading is not what this test simulates with")
+	}
+	calls := 0
+	w := &adoptionWatch{now: func() time.Time {
+		calls++
+		if calls == 1 {
+			return before
+		}
+		// The wall clock a day on, as a machine's clock reads after waking.
+		return asleep.Round(0).Add(24 * time.Hour)
+	}}
+	report := link.Report{Outward: []string{"wlan0"}, Profile: map[string]any{"capabilities": []any{}}}
+	w.said(report)
+	if strings.Contains(w.machineSaid.String(), "m=") {
+		t.Fatalf("the watch kept a monotonic reading (%s): a sleep would not count toward the day", w.machineSaid)
+	}
+	if !w.news(report) {
+		t.Error("a day of wall time on, a laptop that slept did not say what it is")
+	}
+}
+
+// And the watch's own clock never carries a monotonic reading.
+func TestTheWatchClockIsWallTime(t *testing.T) {
+	w := &adoptionWatch{}
+	if s := w.clock().String(); strings.Contains(s, "m=") {
+		t.Errorf("the watch's clock carries a monotonic reading: %s", s)
+	}
+	w = &adoptionWatch{now: time.Now}
+	if s := w.clock().String(); strings.Contains(s, "m=") {
+		t.Errorf("a given clock's time kept its monotonic reading: %s", s)
+	}
+}

cmd/mesh-host/main.go

@@ -1358,6 +1358,32 @@ type adoptionWatch struct {
 	last string
 	// faulty is whether the last report the mesh heard said an apply refused or failed (novox/hq issue 233).
 	faulty bool
+	// machineSaid is when the mesh last heard what this machine is made of (novox/hq issue 160), and now the
+	// clock it is judged by (time.Now when nil).
+	machineSaid time.Time
+	now         func() time.Time
+}
+
+// machineEvery is how old what a machine said of itself may grow before a reconcile says it again unasked
+// (novox/hq issue 160): a machine nobody pushed to still says it once a day, so no fact the mesh holds of it
+// is older than a day. Under a day by more than one reconcile interval, so the reconcile that says it falls
+// inside the day rather than just past it.
+const machineEvery = 23 * time.Hour
+
+// clock is the wall time, its monotonic reading stripped (Round(0)). **Wall, because a laptop sleeps**: Go's
+// monotonic clock does not advance while the machine is suspended, so a day judged by it on a laptop that slept
+// for half of it is a day and a half of wall time, and what the mesh holds of the machine is older than a day.
+func (w *adoptionWatch) clock() time.Time {
+	if w.now != nil {
+		return w.now().Round(0)
+	}
+	return time.Now().Round(0)
+}
+
+// machineDue is whether a report carries what the machine is made of and the mesh last heard it a day ago
+// or more. A refusal carries none, so it never is.
+func (w *adoptionWatch) machineDue(r link.Report) bool {
+	return r.Refused == "" && len(r.Profile) > 0 && w.clock().Sub(w.machineSaid) >= machineEvery
 }
 
 // fingerprint is what a report says about adoption: each hold and whether it changed, the
@@ -1422,7 +1448,8 @@ func applyState(r link.Report) string {
 // faulty is whether a report says an apply refused or failed.
 func faulty(r link.Report) bool { return r.Refused != "" || len(r.Failed) > 0 }
 
-// news is whether a reconcile's report is worth saying unasked: it says something the last one the mesh heard
+// news is whether a reconcile's report is worth saying unasked: what the machine is made of last reached the
+// mesh a day ago or more (novox/hq issue 160); or it says something the last one the mesh heard
 // did not, and it is about the machine (worthSaying) — or about how the apply went, refused or failed now, or
 // clean after the last one the mesh heard was not (novox/hq issue 233). A refusal says nothing about the
 // machine, but that the machine refuses is what the mesh raises a condition from, and a clean apply after it is
@@ -1430,6 +1457,10 @@ func faulty(r link.Report) bool { return r.Refused != "" || len(r.Failed) > 0 }
 func (w *adoptionWatch) news(r link.Report) bool {
 	w.mu.Lock()
 	defer w.mu.Unlock()
+	// What the machine is made of, once a day whatever else changed (novox/hq issue 160).
+	if w.machineDue(r) {
+		return true
+	}
 	if adoptionFingerprint(r) == w.last {
 		return false
 	}
@@ -1450,6 +1481,9 @@ func (w *adoptionWatch) said(r link.Report) {
 	defer w.mu.Unlock()
 	w.last = adoptionFingerprint(r)
 	w.faulty = faulty(r)
+	if len(r.Profile) > 0 {
+		w.machineSaid = w.clock()
+	}
 }
 
 // changed is differs and said together, for a report published as it is made.