Mesh: sonene melder seg selv; mDNS på LAN, NetBird-provisjonering

Sonene trenger ikke stå i [zones] på sentralen. En sone sender hjerteslag
hvert 30. s (POST /api/mesh/register med navn, egen adresse og
mesh-nøkkelen), dukker opp i lista med en gang, og tas ut etter 90 s uten
slag. Riktig nøkkel er godkjenningen. Statisk [zones] vinner over et navn
som melder seg (409) – en skrivefeil i config skal ikke kunne overstyres av
en boks på nettet.

Hvorfor push og ikke pull fra NetBird: netbird status --json gir navn, IP og
status per peer, men ikke grupper. Pull ville krevd en service-token mot
management-serveren og virket bare over NetBird. Push virker likt over
NetBird og LAN, uten token, og gir liveness gratis.

Sonen finner sentralen lagvis: ANNOUNCER_SENTRAL hvis satt (NetBird-DNS-navn,
konvensjon announcer-<navn>.skynet.corp), ellers mDNS (_announcer._tcp,
discovery.py). Egen adresse regnes ut som ruten mot sentralen – over NetBird
blir det wt0-adressen, på LAN LAN-adressen – med ANNOUNCER_URL som
overstyring. Hjerteslag hvert 5. s til første OK, så oppstart ikke tar et
halvt minutt.

Containeren bruker nå vertens nett. mDNS-multicast når ikke LAN-et fra
bridge-nettet, så det var ingen vei utenom – og det ga tilbake ufw: det
gamle Docker-smutthullet er borte, portregler virker igjen, og BIND_IP er
appens eget --host. Appen lytter alltid også på 127.0.0.1 for helsesjekken.

install.sh tar NETBIRD_SETUP_KEY: installerer NetBird, melder maskina inn
som announcer-<navn>, venter på wt0, binder til NetBird-adressen.
Management-URL leses fra /etc/netbird/config.json når den finnes.

Rollen avgjøres av config (Config.role): sentral hvis [zones] eller
ANNOUNCER_ROLE=sentral, sone hvis bare nøkkelen er satt, ellers som før.
Dispatcher og ZonePoller slår opp soner ved hver bruk, siden de kommer og
går. register følger, som play, aldri med «alt åpent». Flask sorterte
JSON-nøkler alfabetisk, så sonene kom i feil rekkefølge i /api/status –
app.json.sort_keys = False.

25 nye tester, 173 totalt. Verifisert i compose på host-nett: to soner
meldte seg innen 4 s uten noe [zones], fordeling til en av dem havnet i kø,
avahi-browse på verten ser sentralen, en stoppet sone ble tatt ut etter 90 s
og var tilbake 2 s etter start. Underveis fant live-testen at testkonfigen
fortsatt hadde statiske a/b – og sentralen avviste hjerteslagene med 409,
som den skal.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

tests/test_mesh.py

@@ -238,3 +238,138 @@ def test_send_til_sone_som_ikke_finnes(tmp_path):
 def test_status_fra_sone_som_ikke_finnes():
     r = mesh.fetch_zone_status(mesh.Zone("z", "http://127.0.0.1:1"), secret="s", timeout=1)
     assert r["reachable"] is False and r["error"]
+
+
+# --------------------------------------------------------------------------
+# Registry: sonene som melder seg
+# --------------------------------------------------------------------------
+
+
+def test_register_og_rekkefolge():
+    r = mesh.Registry({"fast": mesh.Zone("fast", "http://fast")}, local=mesh.Zone("her"), stale_seconds=90)
+    r.register("b", "http://b:8090/", "0.3")
+    r.register("a", "http://a:8090")
+    z = r.zones()
+    assert list(z) == ["her", "fast", "a", "b"]          # lokal, statisk, så registrerte sortert
+    assert z["b"].url == "http://b:8090"                  # uten skråstrek
+    info = r.info()
+    assert info["her"]["source"] == "local"
+    assert info["fast"]["source"] == "static"
+    assert info["b"]["source"] == "registered" and info["b"]["version"] == "0.3" and info["b"]["last_seen"]
+
+
+def test_statisk_og_lokal_vinner_over_den_som_melder_seg():
+    r = mesh.Registry({"fast": mesh.Zone("fast", "http://fast")}, local=mesh.Zone("her"))
+    with pytest.raises(ValueError, match="er satt i"):
+        r.register("fast", "http://ond")
+    with pytest.raises(ValueError, match="eget navn"):
+        r.register("her", "http://ond")
+    assert r.zones()["fast"].url == "http://fast"
+
+
+@pytest.mark.parametrize("name, url, feil", [
+    ("", "http://x", "ugyldig sonenavn"),
+    ("har mellomrom", "http://x", "ugyldig sonenavn"),
+    ("ok", "10.0.0.5:8090", "http"),
+    ("ok", "", "http"),
+])
+def test_register_avviser_tull(name, url, feil):
+    with pytest.raises(ValueError, match=feil):
+        mesh.Registry({}).register(name, url)
+
+
+def test_hjerteslag_oppdaterer_sist_sett_og_bytte_av_adresse():
+    r = mesh.Registry({}, stale_seconds=90)
+    r.register("a", "http://a")
+    t1 = r.registered["a"].last_seen
+    time.sleep(0.01)
+    r.register("a", "http://a")
+    assert r.registered["a"].last_seen > t1
+    assert r.registered["a"].first_seen <= t1
+    r.register("a", "http://a-ny")                        # sonen fikk ny IP
+    assert r.zones()["a"].url == "http://a-ny"
+
+
+def test_sone_som_slutter_a_sla_tas_ut():
+    r = mesh.Registry({}, stale_seconds=90)
+    r.register("a", "http://a")
+    r.register("b", "http://b")
+    now = time.time()
+    r.registered["a"].last_seen = now - 100
+    assert r.prune(now) == ["a"]
+    assert list(r.zones()) == ["b"]
+    assert r.prune(now) == []
+
+
+def test_dispatcher_med_dynamiske_soner(tmp_path):
+    """Sonen forsvinner mellom innlevering og fordeling."""
+    r = mesh.Registry({}, local=None)
+    r.register("a", "http://a")
+    wav = tmp_path / "x.wav"; wav.write_bytes(b"RIFF")
+    disp = mesh.Dispatcher(r.zones, synthesize=lambda *a: wav, play_local=lambda d, p: 1,
+                           send=lambda z, p, d: ("queued", 1, ""), timeout=1)
+    assert disp.names() == ["a"]
+    d = disp.submit("x", "finn", 1.0, "none", ["a"])
+    r.registered.clear()                                   # meldt av
+    disp.run_once(timeout=1)
+    assert d.zones["a"].status == "unreachable" and "borte" in d.zones["a"].error
+
+
+def test_poller_glemmer_soner_som_er_borte():
+    r = mesh.Registry({})
+    r.register("a", "http://a")
+    p = mesh.ZonePoller(r.zones, fetch=lambda z: {"reachable": True, "queued": 0, "current": None}, interval=99)
+    p.poll_once()
+    assert "a" in p.snapshot()
+    r.registered.clear()
+    p.poll_once()
+    assert p.snapshot() == {} and p.cache == {}
+
+
+# --------------------------------------------------------------------------
+# Heartbeat: sonens side
+# --------------------------------------------------------------------------
+
+
+def test_local_ip_towards_loopback():
+    assert mesh.local_ip_towards("127.0.0.1", 8090) == "127.0.0.1"
+
+
+def test_hjerteslag_uten_kjent_sentral_venter():
+    calls = []
+    hb = mesh.Heartbeat(name="a", port=8093, secret="s", sentral=lambda: None,
+                        post=lambda *a, **k: calls.append(k) or (True, ""))
+    assert hb.beat_once() is False
+    assert calls == [] and "ingen sentral" in hb.last_error
+    assert hb.status()["sentral"] is None
+
+
+def test_hjerteslag_melder_seg_med_riktig_adresse():
+    calls = []
+    hb = mesh.Heartbeat(name="a", port=8093, secret="s", sentral=lambda: "http://127.0.0.1:8091/",
+                        version="0.3", post=lambda sentral, **k: calls.append((sentral, k)) or (True, ""))
+    assert hb.beat_once() is True
+    url, k = calls[0]
+    assert url == "http://127.0.0.1:8091/"
+    assert k == {"name": "a", "url": "http://127.0.0.1:8093", "secret": "s", "version": "0.3"}
+    assert hb.last_ok and hb.last_error == "" and hb.status()["sentral"] == "http://127.0.0.1:8091/"
+
+
+def test_hjerteslag_med_fast_egen_url():
+    calls = []
+    hb = mesh.Heartbeat(name="a", port=8093, secret="s", sentral=lambda: "http://s:8090",
+                        url="http://10.9.9.9:8093/", post=lambda sentral, **k: calls.append(k) or (True, ""))
+    hb.beat_once()
+    assert calls[0]["url"] == "http://10.9.9.9:8093"
+
+
+def test_hjerteslag_husker_feil():
+    hb = mesh.Heartbeat(name="a", port=8093, secret="s", sentral=lambda: "http://127.0.0.1:8091",
+                        post=lambda *a, **k: (False, "401 Feil mesh-nøkkel"))
+    assert hb.beat_once() is False
+    assert hb.last_ok is None and "401" in hb.status()["error"]
+
+
+def test_post_register_mot_noe_som_ikke_finnes():
+    ok, err = mesh.post_register("http://127.0.0.1:1", name="a", url="http://x", secret="s", timeout=1)
+    assert ok is False and err