@yz-social/kdht 0.1.10 → 0.1.12

package/dht/node.js

@@ -54,11 +54,11 @@ export class Node extends NodeProbe {
   async storeValue(targetKey, value) { // Convert targetKey to a bigint if necessary, and store k copies.
     // Promises the number of nodes that it was stored on.
     targetKey = await this.ensureKey(targetKey);
-    const trace = this.constructor.diagnosticTrace;
+    const trace = this.diagnosticTrace || this.constructor.diagnosticTrace;
 
     // Early exit if this node is no longer running (e.g., disconnected during scheduled replication)
     if (!this.isRunning) {
-      if (trace) this.log(`storeValue(${targetKey}, ${value}): aborted - node disconnected`);
+      if (trace) this.xlog(`storeValue(${targetKey}, ${value}): aborted - node disconnected`);
       return 0;
     }
 
@@ -71,11 +71,11 @@ export class Node extends NodeProbe {
 
     // Check again after the async locateNodes call
     if (!this.isRunning) {
-      if (trace) this.log(`storeValue(${targetKey}, ${value}): aborted after locateNodes - node disconnected`);
+      if (trace) this.xlog(`storeValue(${targetKey}, ${value}): aborted after locateNodes - node disconnected`);
       return 0;
     }
 
-    if (trace) this.log(`storeValue(${targetKey}): locateNodes found ${helpers.length} helpers`);
+    if (trace) this.xlog(`storeValue(${targetKey}): locateNodes found ${helpers.length} helpers`);
     helpers = helpers.reverse(); // So we can save best-first by popping off the end.
     const storedTo = []; // Track where we stored for diagnostics
     // TODO: batches in parallel, if the client and network can handle it. (For now, better to spread it out.)
@@ -88,12 +88,12 @@ export class Node extends NodeProbe {
         storedTo.push(helper.name);
       } else if (!this.isRunning) {
         // Node disconnected mid-replication - no point continuing
-        if (trace) this.log(`storeValue(${targetKey}, ${value}): aborted mid-store - node disconnected`);
+        if (trace) this.xlog(`storeValue(${targetKey}, ${value}): aborted mid-store - node disconnected`);
         return k - remaining;
       }
     }
     const storedCount = k - remaining;
-    if (trace || storedCount < k) {
+    if (trace || (this.debug && storedCount < k)) {
       // Explain why we got fewer than k stores
       let reason = '';
       if (!this.isRunning) {
@@ -101,7 +101,7 @@ export class Node extends NodeProbe {
       } else if (helpers.length === 0 && storedCount < k) {
         reason = ' (insufficient nodes found)';
       }
-      this.log(`storeValue(${targetKey}, ${value}): stored to ${storedCount}/${k} nodes${storedTo.length ? ': ' + storedTo.join(', ') : ''}${reason}`);
+      this.xlog(`storeValue(${targetKey}, ${value}): stored to ${storedCount}/${k} nodes${storedTo.length ? ': ' + storedTo.join(', ') : ''}${reason}`);
     }
     return k - remaining;
   }

package/dht/nodeMessages.js

@@ -60,10 +60,13 @@ export class NodeMessages extends NodeContacts {
   async recursiveSignals(key, signals, forwardingExclusions, expiration, targetNameForDebugging) { // Forward recursively.
     // The target key may not be reachable from here (and might not even still be running).
     // So bound our branching.
-    if (Date.now() > expiration) return null;
     let remainingThisNode = this.constructor.alpha; // If it's good enough for probing, then it's good enough here.
+    if (Date.now() > expiration) {
+      this.xlog('abandoning recursive path towards', targetNameForDebugging, 'by timeout through', forwardingExclusions.join(', '));
+      return null;
+    }
     if (forwardingExclusions.length > this.constructor.maxTries) {
-      this.xlog('abandoning wandering path towards', targetNameForDebugging, 'through', forwardingExclusions.join(', '));
+      this.xlog('abandoning recursive path towards', targetNameForDebugging, 'wandering through', forwardingExclusions.join(', '));
       return {forwardingExclusions};
     }
     const helpers = this.findClosestHelpers(key);
@@ -85,6 +88,7 @@ export class NodeMessages extends NodeContacts {
 	forwardingExclusions.push(contact.name);
       }
     }
+    this.log('Unable to forward recursive signals to', targetNameForDebugging, 'among', contacts.filter(c => c.connection).length, 'available contacts.');
     return null;
   }
 

package/dht/nodeTransports.js

@@ -29,8 +29,11 @@ export class NodeTransports extends NodeStorage {
     
     if (this.nTransports >= this.constructor.maxTransports) { // Determine if we have to drop one first, and do so.
       //console.log(this.name, 'needs to drop a transport');
-      function removeLast(list) { // Remove and return the last element of list that has connction and is NOT sponsor.
-	const index = list.findLastIndex(element => element.connection && !contact.hasSponsor(element.key));
+      function removeLast(list) { // Remove and return the last element of list that has connection and is NOT sponsor.
+	// I have observed cases where a bunch of nodes run over as someone joins, and they all then try to remove the same
+	// most-recently added contact. So here instead of taking the last valid contact from the last, we take the last but [0..3].
+	let randomizer = Math.floor(Math.random() * 4);
+	const index = list.findLastIndex(element => element.connection && !contact.hasSponsor(element.key) && randomizer-- <= 0 );
 	if (index < 0) return null;
 	const sub = list.splice(index, 1);
 	return sub[0];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yz-social/kdht",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "Pure Kademlia base, for testing variations.",
   "exports": {
     ".": "./index.js",
@@ -12,6 +12,7 @@
     "start": "node spec/portal.js --externalBaseURL https://ki1r0y.com/kdht",
     "stop": "pkill kdht",
     "background": "npm stop; (npm start 1>server.log 2>&1 &); sleep 1",
+    "withoutExternal": "node spec/portal.js",
     "bots": "node spec/bots.js",
     "thrashbots": "node spec/bots.js --thrash",
     "testWebrtc": "npx jasmine spec/testWebrtc.js",

package/portals/node.js

@@ -3,7 +3,7 @@ import cluster from 'node:cluster';
 import { v4 as uuidv4 } from 'uuid';
 import { WebContact, Node } from '../index.js';
 
-export async function setup({baseURL, externalBaseURL = '', debug, fixedSpacing, info, variableSpacing}) {
+export async function setup({baseURL, externalBaseURL = '', info = true, debug, fixedSpacing, variableSpacing}) {
   const hostName = uuidv4();
   process.title = 'kdht-portal-' + hostName;
   // For debugging:

package/spec/bots.js

@@ -17,7 +17,7 @@ const argv = yargs(hideBin(process.argv))
 	alias: 'n',
 	alias: 'nbots',
 	type: 'number',
-	default: logicalCores,
+	default: Math.max(2, logicalCores / 2),
 	description: "The number of bots, which can only be reached through the network."
       })
       .option('baseURL', {

package/spec/dhtAcceptanceSpec.js

@@ -154,7 +154,7 @@ describe("DHT", function () {
 	  console.log(new Date(), 'writing');
 	  elapsed = await timed(async _ => nWritten = await serialWriteAll(), // Alt: serial/parallelWriteAll
 				elapsed => `Wrote ${nWritten} / ${elapsed} = ${Math.round(nWritten/elapsed)} nodes/second.`);
-	}, setupTimeMS + runtimeBeforeWriteMS + runtimeBeforeWriteMS + 5 * setupTimeMS);
+	}, 10 * setupTimeMS + 10/*6*/ * runtimeBeforeWriteMS); // Pretty arbitrary. Things slow down when limiting maxTransports.
 	afterAll(async function () {
 	  console.log(new Date(), 'start client shutdown');
 	  //await Node.reportAll();
@@ -175,38 +175,25 @@ describe("DHT", function () {
 	  await timed(async _ => nRead = await serialReadAll(), // alt: serial/parallelReadAll
 		      elapsed => `Read ${nRead} / ${elapsed} = ${Math.round(nRead/elapsed)} values/second.`);
 	  expect(nRead).toBe(nWritten);
-	}, 10 * setupTimeMS + 5 * runtimeBeforeReadMS);
+	}, 10 * setupTimeMS + 6 * runtimeBeforeReadMS);
       });
     });
   }
 
   // Each call here sets up a full suite of tests with the given parameters, which can be useful for development and debugging.
-  // For example:
-  test({maxClientNodes: 10, startThrashingBefore: 'never', runtimeBeforeWriteMS: 0, runtimeBeforeReadMS: 0, notes: "Smoke"});
-  test({pingTimeMS: 0, refreshTimeIntervalMS: 0, startThrashingBefore: 'never', notes: "Runs flat out if probing and disconnects turned off."});
-  test({setupTimeMS: 1e3, pingTimeMS: 0, startThrashingBefore: 'never', notes: "Probing on, but no disconnects or network delay."});
-  test({pingTimeMS: 0, refreshTimeIntervalMS: 5e3, notes: "Small networks allow faster thrash smoke-testing."});
-  test({notes: "Normal ops"});
-  test({setupTimeMS: 40e3, notes: "Bigger network overflowing bucket."});
-  
-  // test({maxClientNodes: 55, setupTimeMS: 240e3, pingTimeMS: 40, maxTransports: 62,
-  // 	//startThrashingBefore: 'never', runtimeBeforeWriteMS: 0, runtimeBeforeReadMS: 0,
-  // 	notes: "Moderate transport-dropping for currently over-constricted contact limits."});
-
+  // For example, in the "small" cases, below, the number of nodes is capped such that everyone knows everyone else.
 
-  //test({maxTransports: 85, maxClientNodes: 90, pingTimeMS: 10, setupTimeMS: 20e3, notes: "Limit number of transports enough to exercise the reconnect logic."});
-  //test({maxClientNodes: 140, setupTimeMS: 60e3, pingTimeMS: 10, notes: "Relatively larger network size."});
+  // Without disconnects (startThrashingBefore: 'never'):
+  test({maxClientNodes: 10, startThrashingBefore: 'never', runtimeBeforeWriteMS: 0, runtimeBeforeReadMS: 0, notes: "Smoke: small stable"});
+  test({setupTimeMS: 50e3, startThrashingBefore: 'never', runtimeBeforeWriteMS: 5e3, notes: "Large stable"}); // On my machine, each node contects to less than the total.
+  // Meaningful maxTransports may depend on circumstances. Ensure "Dropping" logging in noteContactForTransport! Checked-in value is often too easy.
+  test({maxTransports: 30, startThrashingBefore: 'never', runtimeBeforeWriteMS: 5e3, notes: "Limited connections on stable"});
 
-  //test({maxTransports: 95, maxClientNodes: 100, refreshTimeIntervalMS: 0, startThrashingBefore: 'never', notes: 'dev: no refresh, no thrashing'});
-  //test({maxTransports: 95, maxClientNodes: 100, startThrashingBefore: 'never', notes: 'dev: no thrashing'});
-
-  //test({maxClientNodes: 7, nServerNodes: 5, refreshTimeIntervalMS: 3e3, runtimeBeforeWriteMS: 0e3, runtimeBeforeReadMS: 0e3, startThrashingBefore: 'never'});
-  //test({maxClientNodes: 3, nServerNodes: 3, startThrashingBefore: 'never', refreshTimeIntervalMS: 3e3, runtimeBeforeWriteMS: 6e3, runtimeBeforeReadMS: 6e3});
+  // With disconnects:
+  test({pingTimeMS: 0, refreshTimeIntervalMS: 5e3, notes: "Small-network thrashing"});
+  test({notes: "Normal ops"});
+  test({setupTimeMS: 40e3, notes: "Large-network thrashing"});
 
-  
-  // TODO:
-  // Persistence Test that joins+writes one at a time until period, runs 3xperiod, then quits one a time until gone, then one node join and reads all
-  // collect and confirm data from each node on shutdown.
-  // pub/sub
-  // 1k nodes
+  // Not working reliably yet!
+  //test({maxTransports: 30, notes: "Limited connections on thrashing."}); // See comment for "Meansingful maxTransports, above.
 });

package/spec/dhtImplementation.js

@@ -57,7 +57,9 @@ export async function write1(contact, key, value) {
   let stored;
   await serializeAction(contact, async promised => {
     logLevel(promised, true);
+    //promised.node.diagnosticTrace = true;
     stored = await promised.node.storeValue(key, value);
+    promised.node.diagnosticTrace = false;    
     promised.host.ilog('stored', stored, 'copies');
     logLevel(promised, false);
     return promised;

package/spec/node.html

@@ -30,13 +30,14 @@
 	const bootstrapContact = globalThis.bootstrapContact = await contact.ensureRemoteContact(bootstrapName, bootstrapBase);
 	await contact.join(bootstrapContact);
 	update.onclick();
+	return contact;
       }
 
       update.onclick = () => {
         const report = contact.node.report(null);
         display.textContent = report;
       };
-      await connect();
+      window.contact = await connect();
 
       write.onclick = () => contact.storeValue(key.value, writeValue.value);
       read.onclick = () => contact.node.locateValue(key.value).then(value => readValue.value = value);

package/spec/portal.js

@@ -124,7 +124,12 @@ if (cluster.isPrimary) { // Parent process with portal webserver through which c
   if (argv.nWrites) launchWriteRead(argv.nWrites, argv.baseURL, argv.nBots ? 2 * Node.refreshTimeIntervalMS : 0, argv.verbose);
 
 } else { // A portal node through which client's can connect.
-  const portalNode = await import('../portals/node.js');
+  const PortalNode = await import('../portals/node.js');
   const {baseURL, externalBaseURL, fixedSpacing, variableSpacing, info, verbose} = argv;
-  await portalNode.setup({baseURL, externalBaseURL, fixedSpacing, variableSpacing, info, debug: verbose});
+  const contact = await PortalNode.setup({baseURL, externalBaseURL, fixedSpacing, variableSpacing, info, debug: verbose});
+  function report() {
+    contact.host.report();
+    setTimeout(report, 2 * Node.refreshTimeIntervalMS);
+  }
+  //report();
 }

package/spec/testWebrtc.js

@@ -17,7 +17,7 @@ describe("DHT write/read", function () {
   const logicalCores = availableParallelism();
   console.log(`Model description "${cpus()[0].model}", ${logicalCores} logical cores.`);
   const nPortals = Math.max(2, logicalCores - 1);
-  const thrash = false;
+  const thrash = true;
   const nBots = Math.max(2, (thrash ? 0.5 : 1) * logicalCores);
   const fixedSpacing  = 2; // Between portals.
   const variableSpacing = 5; // Additional random between portals.

package/transports/contact.js

@@ -95,7 +95,7 @@ export class Contact {
     if (this.host.refreshTimeIntervalMS)
       this.host.ilog('disconnecting from network');
     if (!this.host.isStopped()) {
-      if (this.host.storage.size) this.host.log('Copying', this.host.storage.size, 'stored values');
+      if (this.host.storage.size) this.host.ilog('Copying', this.host.storage.size, 'stored values');
       await Promise.all(this.host.storage.entries().map(([key, value]) => this.storeValue(key, value)));
     }
     this.host.stopRefresh();
@@ -111,7 +111,7 @@ export class Contact {
     if (andNotify && await this.connection) this.synchronousSend(['-', 'close']);  // May have already send "bye" and closed.
   }
   close() { // The sender is closing their connection, but not necessarilly disconnected entirely (e.g., maybe maxTransports)
-    this.host.log('closing disconnected contact', this.sname);
+    this.host.ilog('closing disconnected contact', this.sname);
     this.disconnectTransport(false);
     this.host.removeLooseTransport(this.key); // If any.
   }
@@ -136,10 +136,9 @@ export class Contact {
   async deserializeResponse(result) { // Inverse of serializeResponse.
     return result;
   }
-  rpcTimeout(method) { // Promise to resolve to null at appriate timeout for RPC method
-    let hops = 15; // recursive calls
-    if (method === 'signals') hops = 2;
-    else if (['ping', 'findNodes', 'findValue', 'store'].includes(method)) hops = 1;
+  rpcTimeout(method, ...rest) { // Promise to resolve to null at appriate timeout for RPC method
+    let hops = 1;
+    if (method === 'signals') hops = rest[3] ? 15 : 2;
     return Node.delay(hops * this.constructor.maxPingMS, null);
   }
   async sendRPC(method, ...rest) { // Promise the result of a network call to node, or null if not possible.
@@ -208,7 +207,10 @@ export class Contact {
   }
 
   // Signaling
-  static forwardingTimeoutMS = 3/2 * this.maxPingMS - 0.2 * this.maxPingMS;
+  get forwardingTimeout() { // How long to wait for a recursive signals message to get halfway.
+    const roundTrip = this.rpcTimeout('signals', 0, 1, 2, []);
+    return roundTrip - this.maxPingMS;
+  }
   async messageSignals(signals) { // send signals through the network, promising the response signals.
     // If contact cannot be reached, remove it and promise [].
     if (this.host.isStopped()) return [];
@@ -226,29 +228,33 @@ export class Contact {
 	if (!sponsor.connection) continue;
 	const response = await sponsor.sendRPC('signals', this.key, payload);
 	//this.host.xlog('sponsor:', sponsor.sname, 'response:', response);
-	if (response) return response.result || [];
+	if (response) return response;
 	//this._sponsors.delete(sponsor.key); // FIXME: but it might be ok next time.
       }
       return null;
     };
     const try1 = await trySponsors();
-    if (try1) return try1;
+    if (try1) return try1.result || [];
+    await Node.delay(100); // TODO: Why is this necessary, and how long is enough?
+    const try2 = await trySponsors();
+    if (try2) { this.host.xlog('Sponsored result from', this.sname, 'on second try.'); return try2.result || []; } // TODO: why does this ever fire?
 
     if (this.host.isStopped()) return [];
-    if (this.node.isRunning)
-      this.host.log('Using recursive signal routing to', this.sname, 'after trying', sponsors.length, 'sponsors.');
 
+    const reportEmpty = this.isRunning; // Of course, this is only ever false in simulations.
+    if (reportEmpty) this.host.log('Using recursive signal routing to', this.sname, 'after trying', sponsors.length, 'sponsors.'); // No result yet to see if it is empty, but useful in debugging.
     const start = Date.now();
-    const response = await this.host.recursiveSignals(this.key, payload, [], Date.now + this.constructor.forwardingTimeoutMS, this.name);
+    const response = await this.host.recursiveSignals(this.key, payload, [], Date.now() + this.forwardingTimeout, this.sname);
+
+    if (!response && reportEmpty) {
+      this.host.xlog('No recursive response from', this.sname, 'after', (Date.now() - start).toLocaleString(), 'ms and', sponsors.length, 'sponsors', sponsors.filter(c => c.connection).length, 'connected.');
+      return this.checkSignals(null);
+    }
+    
     const {forwardingExclusions, result} = response || {};
-    const elapsed = Date.now() - start;
-    if (!!this.isRunning !== !!result) // Of course, only simulations can really know isRunning to be false.
-      this.host.ilog('Recursive', response ? 'data from' : 'failure from', this.sname,
-		     'in', forwardingExclusions?.length || 'unknown', 'steps over',
-		     elapsed, 'ms, after trying',
-		     sponsors.length, 'sponsors.',
-		    );
-    if (this.host.isStopped()) return [];
+    if (!result && reportEmpty) {
+      this.host.xlog('Empty recursive response from', this.sname, 'after', Date.now() - start, 'ms,', forwardingExclusions?.length, 'sends, and', sponsors.length, 'sponsors', sponsors.filter(c => c.connection).length, 'connected.');
+    }
     return this.checkSignals(result);
   }
   async checkSignals(signals) {

package/transports/simulations.js

@@ -95,7 +95,7 @@ export class SimulatedConnectionContact extends SimulatedContact {
     if (!farContactForUs) return await Node.delay(this.constructor.maxPingMs, null);
     // Use delay from the destination node if set, representing a laggy VM/connection
     const delayMs = this.node.delayMs;
-    const responsePromise = Promise.race([this.getResponsePromise(messageTag), this.rpcTimeout(method)]);
+    const responsePromise = Promise.race([this.getResponsePromise(messageTag), this.rpcTimeout(method, ...rest)]);
     this.constructor.ensureTime(async () => (await farContactForUs).receiveRPC(messageTag, method, farContactForUs, ...rest), delayMs);
     return await responsePromise;
   }

package/transports/webrtc.js

@@ -67,6 +67,14 @@ export class WebContact extends Contact { // Our wrapper for the means of contac
     this.closed = promise;
     const webrtc = this.webrtc = new WebRTC({name: this.webrtcLabel,
 					     debug: host.debug,
+					     configuration: {iceServers: [
+					       {urls: [
+						 'stun:stun1.l.google.com:19302',
+						 'stun:stun2.l.google.com:19302',
+						 'stun:stun3.l.google.com:19302',
+						 'stun:stun4.l.google.com:19302'
+					       ]},
+					     ]},
 					     polite: this.host.key < this.node.key});
     const onclose = () => { // Does NOT mean that the far side has gone away. It could just be over maxTransports.
       this.host.log('connection closed');
@@ -173,11 +181,11 @@ export class WebContact extends Contact { // Our wrapper for the means of contac
     return await Promise.all(result.map(async ([sname, distance]) =>
       new Helper(await this.ensureRemoteContact(sname, this), BigInt(distance))));
   }
-  async transmitRPC(messageTag, method, ...rest) { // Must return a promise.
+  async transmitRPC(messageTag, method, sender, ...rest) { // Must return a promise.
     // this.host.log('transmit to', this.sname, this.connection ? 'with connection' : 'WITHOUT connection');
     const responsePromise = this.getResponsePromise(messageTag);
-    await this.send([messageTag, method, ...rest]);
-    return await Promise.race([responsePromise, this.rpcTimeout(method), this.closed]);
+    await this.send([messageTag, method, sender, ...rest]);
+    return await Promise.race([responsePromise, this.rpcTimeout(method, ...rest), this.closed]);
   }
 
   async receiveWebRTC(dataString) { // Handle receipt of a WebRTC data channel message that was sent to this contact.