@yz-social/kdht 0.1.9 → 0.1.10

package/dht/kbucket.js

@@ -36,7 +36,6 @@ export class KBucket {
   }
   async refresh() { // Refresh specified bucket using LocateNodes for a random key in the specified bucket's range.
     if (this.node.isStopped() || !this.contacts.length) return false; // fixme skip isStopped?
-    this.node.ilog('refresh bucket', this.index);
     const targetKey = this.randomTarget;
     await this.node.locateNodes(targetKey); // Side-effect is to update this bucket.
     return true;

package/dht/nodeStorage.js

@@ -23,7 +23,7 @@ export class NodeStorage extends NodeRefresh {
   }
   async replicateCloserStorage(contact) { // Replicate to new contact any of our data for which contact is closer than us.
     for (const key in this.storage.keys()) {
-      if (contact.distance(key) <= this.distance(key)) {
+      if (contact.connection && (contact.distance(key) <= this.distance(key))) {
 	await contact.store(key, this.retrieveLocally(key));
       }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yz-social/kdht",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "description": "Pure Kademlia base, for testing variations.",
   "exports": {
     ".": "./index.js",
@@ -14,10 +14,11 @@
     "background": "npm stop; (npm start 1>server.log 2>&1 &); sleep 1",
     "bots": "node spec/bots.js",
     "thrashbots": "node spec/bots.js --thrash",
-    "test": "npx jasmine && npx jasmine spec/webrtcTests.js && echo '-- SUCCESS --' || echo '**** FAIL ****'"
+    "testWebrtc": "npx jasmine spec/testWebrtc.js",
+    "test": "npx jasmine && npm run testWebrtc && echo '-- SUCCESS --' || echo '**** FAIL ****'"
   },
   "dependencies": {
-    "@yz-social/webrtc": "^0.1.2",
+    "@yz-social/webrtc": "^0.1.3",
     "uuid": "^13.0.0"
   },
   "devDependencies": {

package/portals/node.js

@@ -3,14 +3,14 @@ import cluster from 'node:cluster';
 import { v4 as uuidv4 } from 'uuid';
 import { WebContact, Node } from '../index.js';
 
-export async function setup({baseURL, externalBaseURL = '', verbose, fixedSpacing, variableSpacing}) {
+export async function setup({baseURL, externalBaseURL = '', debug, fixedSpacing, info, variableSpacing}) {
   const hostName = uuidv4();
   process.title = 'kdht-portal-' + hostName;
   // For debugging:
   // process.on('uncaughtException', error => console.error(hostName, 'Global uncaught exception:', error));
   // process.on('unhandledRejection', error => console.error(hostName, 'Global unhandled promise rejection:', error));
 
-  const contact = await WebContact.create({name: hostName, isServerNode: true, info: false, debug: verbose});
+  const contact = await WebContact.create({name: hostName, isServerNode: true, info, debug});
   // Handle signaling that comes as a message from the server.
   process.on('message', async ([senderSname, ...incomingSignals]) => { // Signals from a sender through the server.
     const response = await contact.signals(senderSname, ...incomingSignals);

package/portals/router.js

@@ -5,8 +5,7 @@ import { Node } from '../index.js';
 export const router = express.Router();
 
 const portals = {}; // Maps worker sname => worker, for the full lifetime of the program. NOTE: MAY get filed in out of order from workers.
-const workers = Object.values(cluster.workers);
-for (const worker of workers) {
+function initWorker(worker) {
   worker.on('message', message => { // Message from a worker, in response to a POST.
     if (!worker.tag) {  // The very first message from a worker (during setup) will identify its tag.
       portals[message] = worker;
@@ -23,8 +22,11 @@ for (const worker of workers) {
     }
   });
 }
-cluster.on('exit', (worker, code, signal) => { // Tell us about dead workers.
+Object.values(cluster.workers).forEach(initWorker);
+cluster.on('exit', (worker, code, signal) => { // Tell us about dead workers and restart them.
   console.error(`\n\n*** Crashed worker ${worker.id}:${worker.tag} received code: ${code} signal: ${signal}. ***\n`);
+  delete worker.tag;
+  initWorker(cluster.fork());
 });
 
 router.get('/name/:label', (req, res, next) => { // Answer the actual sname corresponding to label.

package/spec/bots.js

@@ -17,7 +17,7 @@ const argv = yargs(hideBin(process.argv))
 	alias: 'n',
 	alias: 'nbots',
 	type: 'number',
-	default: Math.max(logicalCores / 2, 2),
+	default: logicalCores,
 	description: "The number of bots, which can only be reached through the network."
       })
       .option('baseURL', {
@@ -37,9 +37,16 @@ const argv = yargs(hideBin(process.argv))
 	default: 0,
 	description: "The number of test writes to check."
       })
+      .option('info', {
+	alias: 'i',
+	type: 'boolean',
+	default: true,
+	description: "Run with info logging."
+      })
       .option('verbose', {
 	alias: 'v',
 	type: 'boolean',
+	default: false,
 	description: "Run with verbose logging."
       })
       .parse();
@@ -48,21 +55,24 @@ const host = uuidv4();
 process.title = 'kdht-bot-' + host;
 
 if (cluster.isPrimary) {
-  console.log(`${cpus()[0].model}, ${logicalCores} logical cores. Starting ${argv.nBots} over ${Node.refreshTimeIntervalMS/1000} seconds.`);
+  console.log(`${cpus()[0].model}, ${logicalCores} logical cores. Starting ${argv.nBots} ${argv.thrash ? 'thrashbots' : 'bots'} over ${Node.refreshTimeIntervalMS/1000} seconds.`);
   for (let i = 1; i < argv.nBots; i++) { // The cluster primary becomes bot 0.
     cluster.fork();
   }
+  cluster.on('exit', (worker, code, signal) => { // Tell us about dead workers and restart them.
+    console.error(`\n\n*** Crashed worker ${worker.id}:${worker.tag} received code: ${code} signal: ${signal}. ***\n`);
+    cluster.fork();
+  });
   if (argv.nWrites) {
     console.log(new Date(), 'Waiting a refresh interval while bots get randomly created before write/read test');
     await Node.delay(2 * Node.refreshTimeIntervalMS);
     launchWriteRead(argv.nWrites, argv.baseURL, Node.refreshTimeIntervalMS, argv.verbose);
-  }
+  }  
 }
 
-const info = false;
 await Node.delay(Node.randomInteger(Node.refreshTimeIntervalMS));
 console.log(cluster.worker?.id || 0, host);
-let contact = await WebContact.create({name: host, info, debug: argv.verbose});
+let contact = await WebContact.create({name: host, info: argv.info, debug: argv.verbose});
 let bootstrapName = await contact.fetchBootstrap(argv.baseURL);
 let bootstrapContact = await contact.ensureRemoteContact(bootstrapName, argv.baseURL);
 await contact.join(bootstrapContact);
@@ -80,7 +90,7 @@ while (argv.thrash) {
   await contact.disconnect();
   await Node.delay(1e3); // TODO: remove?
 
-  contact = await WebContact.create({name: next, info, debug: argv.verbose});
+  contact = await WebContact.create({name: next, info: argv.info, debug: argv.verbose});
   bootstrapName = await contact.fetchBootstrap(argv.baseURL);
   bootstrapContact = await contact.ensureRemoteContact(bootstrapName, argv.baseURL);
   await contact.join(bootstrapContact);

package/spec/portal.js

@@ -21,7 +21,7 @@ const argv = yargs(hideBin(process.argv))
 	alias: 'nportals',	
 	alias: 'p',
 	type: 'number',
-	default: Math.max(logicalCores / 2, 2),
+	default: Math.max(2, logicalCores - 1),
 	description: "The number of steady nodes that handle initial connections."
       })
       .option('nBots', {
@@ -52,9 +52,16 @@ const argv = yargs(hideBin(process.argv))
 	default: '',
 	description: "The base URL of the some other portal server to which we should connect ours, if any."
       })
+      .option('info', {
+	alias: 'i',
+	type: 'boolean',
+	default: true,
+	description: "Run with info logging."
+      })
       .option('verbose', {
 	alias: 'v',
 	type: 'boolean',
+	default: false,
 	description: "Run with verbose logging."
       })
       .option('fixedSpacing', {
@@ -118,6 +125,6 @@ if (cluster.isPrimary) { // Parent process with portal webserver through which c
 
 } else { // A portal node through which client's can connect.
   const portalNode = await import('../portals/node.js');
-  const {baseURL, externalBaseURL, fixedSpacing, variableSpacing, verbose} = argv;
-  await portalNode.setup({baseURL, externalBaseURL, fixedSpacing, variableSpacing, verbose});
+  const {baseURL, externalBaseURL, fixedSpacing, variableSpacing, info, verbose} = argv;
+  await portalNode.setup({baseURL, externalBaseURL, fixedSpacing, variableSpacing, info, debug: verbose});
 }

package/spec/{webrtcTests.js → testWebrtc.js}

@@ -10,18 +10,19 @@ import path from 'path';
 
 describe("DHT write/read", function () {
   let contact, portalProcess, botProcess;
+  const botInfo = false;
   const verbose = false;
+  const testNodeVerbose = verbose;
   const baseURL = 'http://localhost:3000/kdht';
   const logicalCores = availableParallelism();
   console.log(`Model description "${cpus()[0].model}", ${logicalCores} logical cores.`);
-  const maxPerCluster = logicalCores / 2; // Why half? Because we have at least two processes, and clusters of logicalCores size tend to go... off.
-  const nPortals = maxPerCluster;
-  const nBots = maxPerCluster;
+  const nPortals = Math.max(2, logicalCores - 1);
+  const thrash = false;
+  const nBots = Math.max(2, (thrash ? 0.5 : 1) * logicalCores);
   const fixedSpacing  = 2; // Between portals.
   const variableSpacing = 5; // Additional random between portals.
   const nWrites = 40;
   const waitBeforeRead = 15e3;
-  const thrash = true;
   const showPortals = true;
   const showBots = true;
 
@@ -35,7 +36,7 @@ describe("DHT write/read", function () {
     function echo(data) { data = data.slice(0, -1); console.log(data.toString()); }
 
     console.log(new Date(), 'starting', nPortals, 'portals over', portalSeconds, 'seconds');
-    portalProcess = spawn('node', [path.resolve(__dirname, 'portal.js'), '--nPortals', nPortals, '--verbose', verbose.toString()]);
+    portalProcess = spawn('node', [path.resolve(__dirname, 'portal.js'), '--nPortals', nPortals, '--info', botInfo, '--verbose', verbose.toString()]);
     if (showPortals) {
       portalProcess.stdout.on('data', echo);
       portalProcess.stderr.on('data', echo);
@@ -43,18 +44,16 @@ describe("DHT write/read", function () {
     await Node.delay(portalSeconds * 1e3);
 
     if (nBots) {
-      for (let launched = 0, round = Math.min(nBots, maxPerCluster); launched < nBots; round = Math.min(nBots - launched, maxPerCluster), launched += round) {
-	console.log(new Date(), 'starting', round, 'bots over', botsMilliseconds/1e3, 'seconds');
-	botProcess = spawn('node', [path.resolve(__dirname, 'bots.js'), '--nBots', round, '--thrash', thrash.toString(), '--verbose', verbose.toString()]);
-	if (showBots) {
-	  botProcess.stdout.on('data', echo);
-	  botProcess.stderr.on('data', echo);
-	}
-	await Node.delay(botsMilliseconds);
+      console.log(new Date(), 'starting', nBots, thrash ? 'thrashbots' : 'bots', 'over', botsMilliseconds/1e3, 'seconds');
+      botProcess = spawn('node', [path.resolve(__dirname, 'bots.js'), '--nBots', nBots, '--thrash', thrash.toString(), '--info', botInfo, '--verbose', verbose.toString()]);
+      if (showBots) {
+	botProcess.stdout.on('data', echo);
+	botProcess.stderr.on('data', echo);
       }
+      await Node.delay(botsMilliseconds);
     }
 
-    contact = await WebContact.create({name: uuidv4(), debug: verbose});
+    contact = await WebContact.create({name: uuidv4(), debug: testNodeVerbose});
     const bootstrapName = await contact.fetchBootstrap(baseURL);
     const bootstrapContact = await contact.ensureRemoteContact(bootstrapName, baseURL);
     console.log(new Date(), 'client node', contact.sname, 'joining', bootstrapContact.sname);
@@ -69,7 +68,7 @@ describe("DHT write/read", function () {
       await Node.delay(waitBeforeRead);
     }
     console.log(new Date(), 'Reading');
-  }, 5e3 * nWrites + (1 + Math.ceil(nBots / maxPerCluster)) * Node.refreshTimeIntervalMS);
+  }, 5e3 * nWrites + (1 + nBots) * Node.refreshTimeIntervalMS);
   afterAll(async function () {
     contact.disconnect();
     console.log(new Date(), 'killing portals and bots');

package/transports/contact.js

@@ -123,7 +123,7 @@ export class Contact {
   distance(key) { return this.host.constructor.distance(this.key, key); }
 
   // RPC
-  static maxPingMs = 330; // Not including connect time. These are single-hop WebRTC data channels.
+  static maxPingMS = 330; // Not including connect time. These are single-hop WebRTC data channels.
   serializeRequest(...rest) { // Return the composite datum suitable for transport over the wire.
     return rest; // Non-simulation subclases must override.
   }
@@ -140,7 +140,7 @@ export class Contact {
     let hops = 15; // recursive calls
     if (method === 'signals') hops = 2;
     else if (['ping', 'findNodes', 'findValue', 'store'].includes(method)) hops = 1;
-    return Node.delay(hops * this.constructor.maxPingMs, null);
+    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.
     const sender = this.host.contact;
@@ -208,6 +208,7 @@ export class Contact {
   }
 
   // Signaling
+  static forwardingTimeoutMS = 3/2 * this.maxPingMS - 0.2 * 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 [];
@@ -235,14 +236,15 @@ export class Contact {
 
     if (this.host.isStopped()) return [];
     if (this.node.isRunning)
-      this.host.ilog('Using recursive signal routing to', this.sname, 'after trying', sponsors.length, 'sponsors.');
+      this.host.log('Using recursive signal routing to', this.sname, 'after trying', sponsors.length, 'sponsors.');
 
     const start = Date.now();
-    const {forwardingExclusions, result} = (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.constructor.forwardingTimeoutMS, this.name);
+    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', !!result, 'to', this.isRunning ? 'running' : 'disconnected', this.sname,
-		     'in', forwardingExclusions?.length, 'steps over',
+      this.host.ilog('Recursive', response ? 'data from' : 'failure from', this.sname,
+		     'in', forwardingExclusions?.length || 'unknown', 'steps over',
 		     elapsed, 'ms, after trying',
 		     sponsors.length, 'sponsors.',
 		    );
@@ -263,8 +265,7 @@ export class Contact {
     //return `${this.connection ? '_' : ''}${this.sname}v${this.counter}${this.isRunning ? '' : '*'}`;
     return `${this.connection ? '_' : ''}${this.sname}${this.isRunning ? '' : '*'}`; // simpler version
   }
-  static forwardingTimeoutMS = 3 * this.maxPingMS / 2 - 0.2 * this.maxPingMS;
-  static pingTimeMS = 40; // ms
+  static pingTimeMS = 40; // ms to consume each RPC in simulations
   static async ensureTime(thunk, ms = this.pingTimeMS) { // Promise that thunk takes at least ms to execute.
     const start = Date.now();
     const result = await thunk();

package/transports/webrtc.js

@@ -12,8 +12,9 @@ export class WebContact extends Contact { // Our wrapper for the means of contac
   get isServerNode() { return this.node.isServerNode; } // It it reachable through a server.
 
   checkResponse(response) { // Return a fetch response, or throw error if response is not a 200 series.
-    if (!response) return;
-    if (!response.ok) throw new Error(`fetch ${response.url} failed ${response.status}: ${response.statusText}.`);
+    if (response?.ok) return true;
+    this.host.xlog(`*** Unable to reach portal ${response?.url || this.sname}, ${response?.status || 'failed fetch'}: ${response?.statusText || 'Unknown reason'}. ***`);
+    return false;
   }
   // connection:close is far more robust against pooling issues common to some implementations (e.g., NodeJS).
   // https://github.com/nodejs/undici/issues/3492
@@ -21,7 +22,7 @@ export class WebContact extends Contact { // Our wrapper for the means of contac
     // worker index or the string 'random' to an available sname to which we can connect().
     const url = `${baseURL}/name/${label}`;
     const response = await fetch(url, {headers: { 'Connection': 'close' } }).catch(e => this.host.xlog(e));
-    this.checkResponse(response);
+    if (!this.checkResponse(response)) return this.fetchBootstrap(baseURL, label);
     return await response.json();
   }
   async fetchSignals(url, signalsToSend) { 
@@ -30,7 +31,7 @@ export class WebContact extends Contact { // Our wrapper for the means of contac
       headers: { 'Content-Type': 'application/json', 'Connection': 'close' },
       body: JSON.stringify(signalsToSend)
     }).catch(e => this.host.xlog(e));
-    this.checkResponse(response);
+    if (!this.checkResponse(response)) return this.fetchSignals(url, signalsToSend);
     return this.checkSignals(await response?.json());
   }
   async signals(senderSname, ...signals) { // Accept directed WebRTC signals from a sender sname, creating if necessary the
@@ -38,18 +39,18 @@ export class WebContact extends Contact { // Our wrapper for the means of contac
     //this.host.xlog('contact signals', senderSname, signals);
     let contact = await this.ensureRemoteContact(senderSname);
 
-    if (contact.webrtc) return await contact.webrtc.respond(signals);
+    if (contact.webrtc?.pc) return await contact.webrtc.respond(signals);
 
     this.host.noteContactForTransport(contact);
-    contact.ensureWebRTC();
+    contact.createWebRTC(false);
     return await contact.webrtc.respond(signals);
   }
   get webrtcLabel() {
     return `@${this.host.contact.sname} ==> ${this.sname}`;
   }
 
-  ensureWebRTC(initiate = false, timeoutMS = this.host.timeoutMS || 30e3) { // Ensure we are connected, if possible.
-    // If not already configured, sets up contact to have properties:
+  createWebRTC(initiate = false, timeoutMS = this.host.timeoutMS || 30e3) { // Ensure we are connected, if possible.
+    // Sets up contact to have properties:
     // - connection - a promise for an open webrtc data channel:
     //   this.send(string) puts data on the channel
     //   incomming messages are dispatched to receiveWebRTC(string)
@@ -73,7 +74,7 @@ export class WebContact extends Contact { // Our wrapper for the means of contac
       this.webrtc = this.connection = this.unsafeData = null;
     };
     if (initiate) {
-      if (bootstrapHost/* || isServerNode*/) {
+      if (bootstrapHost && !host.connections.length) {
 	const url = `${bootstrapHost || 'http://localhost:3000/kdht'}/join/${host.contact.sname}/${this.sname}`;
 	this.webrtc.transferSignals = signals => this.fetchSignals(url, signals);
       } else {
@@ -101,6 +102,7 @@ export class WebContact extends Contact { // Our wrapper for the means of contac
     }
     const timerPromise = new Promise(expired => {
       timeout = setTimeout(async () => {
+	if (this.host.isStopped()) return;
 	const now = Date.now();
 	this.host.ilog('Unable to connect to', this.sname);
 	// this.host.xlog('**** connection timeout', this.sname, now - start,
@@ -125,9 +127,8 @@ export class WebContact extends Contact { // Our wrapper for the means of contac
     // Anyone can connect to a server node using the server's connect endpoint.
     // Anyone in the DHT can connect to another DHT node through a sponsor.
     if (contact.connection) return contact.connection;
-    contact.ensureWebRTC(true);
-    await this.connection;
-    return this.connection;
+    contact.createWebRTC(true);
+    return await this.connection;
   }
 
   async send(message) { // Promise to send through previously opened connection promise.