Changeset 7c38a09 in Klonkt for tools

Timestamp:

08/08/2026 09:40:15 PM (4 weeks ago)

Author:

roboburr <roboburr@…>

Branches:

main

Children:

f3c7a05

Parents:

a4b903a

git-author:

Robin <roboburr@…> (08/08/2026 09:40:13 PM)

git-committer:

roboburr <roboburr@…> (08/08/2026 09:40:15 PM)

Message:

De testkudde mag zelf geen bron van twijfel zijn (shaer-6wt)

Barts opdracht: zoeken aan de kant van de daemon. Dat leverde geen fout in de
handshake op, maar wel twee dingen die het ONDERZOEK onbetrouwbaar maakten.

HET BEWIJS KLOPTE ZELF NIET. /log toonde een Follow die state.json niet kende: er
werd alleen weggeschreven in takken die toch al iets bewaarden. Bij een kudde die
je gebruikt om een fout te vinden is dat het ergste wat er is -- dan zoek je in
bewijs dat zelf niet deugt. Elke regel gaat nu meteen naar schijf.

En UITGAAND wordt nu ook genoteerd, met de statuscode erbij. "Hij stuurde een
Accept" was tot dat moment een aanname; nu staat er dat dev er 202 op gaf, en pas
daarmee is de daemon-kant echt uitgesloten.

MIJN ACCEPT WEEK AF VAN KLONKT: ik stuurde het hele Offer als object, Klonkt
stuurt daar een id-string. Het gedrag verandert er niet van, maar een testkudde
die er anders uitziet dan een echte implementatie laat je een verschil
onderzoeken dat je zelf hebt gemaakt.

Wat het spoor nu zegt, en dat is nog een LEAD en geen conclusie: dev commit wel
(het volgt de ward) maar stuurt zijn afsluitende Accept niet, dus de ward houdt
een lege shaer:guardians. In handshake.js doet de uitgaande accept-tak een
recordAccept EN een fanout; de inkomende tak op regel 600 alleen recordAccept en
maybeCommit. Waarom het bij @mee wel lukte is nog onverklaard, en zonder die
verklaring is een fix een gok.

Los daarvan: er staat nu een start.sh. De farm stierf drie keer mee met mijn
ssh-sessie, en twee van die keren zocht ik naar een fout terwijl er domweg niets
draaide.

File:

• tools/ward-farm/farm.mjs (modified) (3 diffs)

tools/ward-farm/farm.mjs

@@ -124 +124 @@
 // bij zodat deze code nooit ergens anders terechtkomt.
 
+/**
+ * Alles wat er gebeurt, en meteen naar schijf.
+ *
+ * Stond eerst los: een push in het geheugen, en wegschrijven alleen in de takken
+ * die toch al iets bewaarden. Gevolg: /log en state.json spraken elkaar tegen --
+ * de een had een Follow die de ander niet kende. Bij een testkudde die je gebruikt
+ * om een fout te vinden is dat het ergste wat je kunt hebben: dan zoek je in
+ * bewijs dat zelf niet klopt.
+ */
+function noteer(w, regel) {
+  w.log.push({ at: new Date().toISOString(), ...regel });
+  if (w.log.length > 80) w.log = w.log.slice(-80);
+  bewaarStaat(staat);
+}
+
 async function verwerkInbox(w, activity) {
   const type = Array.isArray(activity.type) ? activity.type[0] : activity.type;
   const actor = typeof activity.actor === 'string' ? activity.actor : (activity.actor && activity.actor.id);
-  w.log.push({ at: new Date().toISOString(), type, actor });
-  if (w.log.length > 50) w.log = w.log.slice(-50);
+  noteer(w, { type, actor });
 
   const o = activity.object;
@@ -146 +160 @@
       try {
         const inbox = await inboxVan(doel);
-        await bezorg(w, inbox, {
+        const code = await bezorg(w, inbox, {
           '@context': ['https://www.w3.org/ns/activitystreams', { shaer: 'https://shaer.klonkt.com/ns#' }],
           id: `${uriVan(w.naam)}/accepts/${crypto.randomUUID()}`,
-          type: 'Accept', actor: uriVan(w.naam), to: aan, object: activity,
+          // `object` is de OFFER-ID, niet het hele Offer. Zo stuurt Klonkt hem
+          // ook (fanout in handshake.js), en een testkudde die er net anders
+          // uitziet dan een echte implementatie laat je een verschil onderzoeken
+          // dat je zelf gemaakt hebt.
+          type: 'Accept', actor: uriVan(w.naam), to: aan, object: activity.id,
         });
-      } catch (e) { w.log.push({ at: new Date().toISOString(), fout: String(e.message) }); }
+        // De statuscode erbij. "Hij stuurde een Accept" is een aanname zolang je
+        // niet weet wat de andere kant ervan vond.
+        noteer(w, { verstuurd: 'Accept', naar: doel, code });
+      } catch (e) { noteer(w, { fout: String(e.message), naar: doel }); }
     }
     bewaarStaat(staat);
@@ -250 +271 @@
     let uit = 'onleesbaar';
     try { uit = await verwerkInbox(w, JSON.parse(body)); }
-    catch (e) { w.log.push({ at: new Date().toISOString(), fout: String(e.message) }); }
+    catch (e) { noteer(w, { fout: String(e.message) }); }
     // 202 hoe dan ook: een inbox die 4xx geeft op iets dat hij niet kent laat de
     // afzender eindeloos opnieuw proberen.