@yz-social/kdht 0.1.2 → 0.1.4

package/dht/nodeProbe.js

@@ -10,29 +10,49 @@ export class NodeProbe extends NodeMessages {
   static isContactsResult(rpcResult) {
     return Array.isArray(rpcResult);
   }
-  async step(targetKey, finder, helper, keysSeen) {
+  async step(targetKey, finder, helper, keysSeen, trace) {
     // Get up to k previously unseen Helpers from helper, adding results to keysSeen.
     const contact = helper.contact;
     // this.log('step with', contact.sname);
     let results = await contact.sendRPC(finder, targetKey);
     if (!results) { // disconnected
+      if (trace) this.log(helper.name, '=> disconnected');
       this.log('removing unconnected contact', contact.sname);
       await this.removeContact(contact);
-      return [];
+      return null; // signal that there is *no* response from this contact - to distinguish from a response that confirms that the contact is alive, even if there are (after filtering) no new contacts to try.
     }
     await this.addToRoutingTable(contact); // Live node, so update bucket.
     // this.log('step added contact', contact.sname);
     if (this.constructor.isContactsResult(results)) { // Keep only those that we have not seen, and note the new ones we have.
-      results = results.filter(helper => !keysSeen.has(helper.key) && keysSeen.add(helper.key));
-      // Results are (helpers around) contacts. Set them up for this host, with contact as sponsor.
+      const rawResults = results;
+      results = results.filter(helper => !keysSeen.has(helper.key) && keysSeen.add(helper.key)); // add() returns the Set, which is truthy
+      // Results are (helpers around) contacts, with distance from the target. Set them up for this host, with contact as sponsor.
       results = results.map(h => new Helper(this.ensureContact(h.contact, contact), h.distance));
-    }
+      if (trace) {
+        const filterMsg = results.length === rawResults.length ? "" : ` after removing ${rawResults.map(h => h.name).filter(name => !results.some(r => r.name === name)).join(', ')}`;
+        this.log(`${helper.name} => ${results.length ? results.map(h => h.name) : '<empty>'}${filterMsg}`);
+      }
+    } else if (trace && false) this.log(`${helper.name} => ${results}`);
+
     return results;
   }
-  static alpha = 3; // How many lookup requests are initially tried in parallel. If no progress, we repeat with up to k more.
-  async iterate(targetKey, finder, k = this.constructor.k, trace = false) {
+
+  static alpha = 3; // How many lookup requests are kept in flight concurrently.
+  static queryTimeoutMs = 10000; // Give up on a query after this many ms.
+  async iterate(targetKey, finder, k = this.constructor.k, trace = false, timing = false, includeSelf = false) {
     // Promise a best-first list of k Helpers from the network, by repeatedly trying to improve our closest known by applying finder.
-    // But if any finder operation answer isValueResult, answer that instead.
+    // But if any finder operation answers isValueResult, answer that instead.
+    // Note: When a value is found, returns { value, responder } where responder is the Helper that provided the value.
+    // This allows callers to identify which node responded. Use isValueResult() to check, and result.value to get the value.
+    //
+    // Per Kademlia paper: keeps alpha requests in flight while making progress.
+    // If alpha consecutive responses fail to find new nodes, escalates to k parallel queries.
+    // Terminates when among the k closest nodes we've seen, none have outstanding queries
+    // (they've all either responded or timed out).
+    //
+    // includeSelf: If true, the local node is eligible to be included in the results (currently used only for storeValue).
+
+    if (trace) this.log(`iterate: key=${targetKey}, finder=${finder}, k=${k}`);
 
     if (targetKey !== this.key) {
       const bucketIndex = this.getBucketIndex(targetKey);
@@ -40,48 +60,221 @@ export class NodeProbe extends NodeMessages {
       // Subtle: if we don't have one now, but will after, refreshes will be rescheduled by KBucket constructor.
       bucket?.resetRefresh();
     }
-    
-    // Each iteration uses a bigger pool than asked for, because some will have disconnected.
-    let pool = this.findClosestHelpers(targetKey, 2*k); // The k best-first Helpers known so far, that we have NOT queried yet.
+
+    const alpha = this.constructor.alpha;
+    const queryTimeoutMs = this.constructor.queryTimeoutMs;
     const isValueResult = this.constructor.isValueResult;
-    const alpha = Math.min(pool.length, this.constructor.alpha);
-    const keysSeen = new Set(pool.map(h => h.key));    // Every key we've seen at all (candidates and all responses).
-    keysSeen.add(this.key); // We might or might not be in our list of closest helpers, and we could be in someone else's.
-    let toQuery = pool.slice(0, alpha);
-    pool = pool.slice(alpha); // Yes, this could be done with splice instead of slice, above, but it makes things hard to trace.
-    let best = []; // The accumulated closest-first result.    
-    while (toQuery.length && this.isRunning) { // Stop if WE disconnect.
-      let requests = toQuery.map(helper => this.step(targetKey, finder, helper, keysSeen));
-      let results = await Promise.all(requests);
-      if (trace) this.log(toQuery.map(h => h.name), '=>', results.map(r => r.map?.(h => h.name) || r));
-      
-      let found = results.find(isValueResult); // Did we get back a 'findValue' result.
-      if (found) {
-	// Store at closest result that didn't have it (if any). This can cause more than k copies in the network.
-	for (let i = 0; i < toQuery.length; i++) {
-	  if (!isValueResult(results[i])) {
-	    toQuery[i].contact.store(targetKey, found.value);
-	    break;
-	  }
-	}
-	return found;
-     }
-
-      let closer = [].concat(...results); // Flatten results.
-      // closer might not be in order, and one or more toQuery might belong among them.
-      best = [...closer, ...toQuery, ...best].sort(Helper.compare).slice(0, k);
-      if (!closer.length) {
-	if (toQuery.length === alpha && pool.length) {
-	  toQuery = pool.slice(0, 2*k);  // Try again with k more. (Interestingly, not k - alpha.)
-	  pool = pool.slice(2*k);
-	} else break; // We've tried everything and there's nothing better.
+    const iterateStartTime = timing ? Date.now() : 0;
+    let requestCount = 0;
+
+    // This is an iterative procedure, starting from the nodes among our own contacts that are
+    // closest to the specified target.  The result of findClosestHelpers might turn out to include
+    // this node itself, but of course there is no point in sending ourselves a query to request
+    // what findClosestHelpers has already delivered, so the node is filtered out before starting
+    // the iteration.  In the case of a caller that would be happy for this node to appear in the
+    // results (if it is indeed one of the closest), the caller should specify includeSelf=true;
+    // this is checked at the end of the method before handing the results back.
+    let allNodesSeen = this.findClosestHelpers(targetKey, 2*k).filter(h => h.key !== this.key);
+    const keysSeen = new Set(allNodesSeen.map(h => h.key));    // Every key we've seen at all (for filtering in step()).
+    keysSeen.add(this.key); // Prevent self from being added via other nodes' responses.
+
+    const pendingTimeouts = new Map(); // helper.key -> timeoutId (queries in flight)
+    const queryState = new Map(); // helper.key -> 'responded' | 'timedOut' | 'disconnected' (queries once they respond or are abandoned)
+    const queryResponders = []; // helpers that have responded (for building result)
+    let responsesWithoutNewNodes = 0; // count of successive empty responses
+    let maxInFlight = alpha; // Normal: alpha parallel queries. Escalates to k when a "round" of alpha queries all fail to find new nodes.
+    let iterationFinished = false;
+
+    let resolveIteration;
+    const iterationPromise = new Promise((resolve) => resolveIteration = (...args) => { iterationFinished = true; resolve(...args) }); // to be resolved with a value result, or undefined
+
+    // Check if termination condition is met:
+    // We're complete when we've found k 'responded' nodes with no unresolved nodes
+    // (pending or not-yet-queried) closer than them.
+    const isComplete = () => {
+      let respondedCount = 0;
+      for (const h of allNodesSeen) {
+        const state = queryState.get(h.key);
+        if (state === 'responded') {
+          respondedCount++;
+          if (respondedCount >= k) return true; // Found k responded with no unresolved gaps
+        } else if (!state) {
+          // No record means it's either a pending query, or that a query hasn't even been sent yet.  We need to wait for it to resolve one way or another.
+          return false;
+        }
+        // 'timedOut' or 'disconnected': resolved but doesn't count, continue
+      }
+      // Exhausted list: fewer than k responsive nodes exist, but all are resolved
+      return true;
+    };
+
+    // Get the next closest node that needs to be queried
+    const getNextToQuery = () => {
+      for (const h of allNodesSeen) {
+        if (!pendingTimeouts.has(h.key) && !queryState.has(h.key)) {
+          return h;
+        }
+      }
+      return null;
+    };
+
+    // Handler for when a request completes.  result is only expected if status='responded'.
+    const handleCompletion = (helper, status, result) => {
+      if (iterationFinished) return; // too late
+
+      if (!this.isRunning) {
+        resolveIteration();
+        return;
+      }
+
+      // Clear the timeout (if still active)
+      const timeoutId = pendingTimeouts.get(helper.key);
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        pendingTimeouts.delete(helper.key);
+      }
+
+      if (timing) {
+        const elapsed = Date.now() - iterateStartTime;
+        const label = status === 'responded' ? 'Response' : status === 'timedOut' ? 'Timeout' : 'Disconnected';
+        console.log(`  ${label}: ${elapsed}ms - ${helper.name} (${pendingTimeouts.size} pending)`);
+      }
+
+      // Handle disconnected or timed-out node
+      if (status !== 'responded') {
+        queryState.set(helper.key, status);
       } else {
-	pool = [...closer, ...pool].slice(0, 2*k); // k best-first nodes that we have not queried.
-	toQuery = pool.slice(0, alpha);
-	pool = pool.slice(alpha);
+        // Response arrived - mark as responded (even if previously marked as timed out)
+        queryState.set(helper.key, 'responded');
+        queryResponders.push(helper);
+
+        // Check for value result (immediate termination, after attempting to add one more storage node)
+        if (isValueResult(result)) {
+          // Store at closest node that didn't have it (if any). This can cause more than k copies in the network.
+          const sortedResponders = [...queryResponders].sort(Helper.compare);
+          for (const h of sortedResponders) {
+            if (h.key !== helper.key) { // Skip the one that returned the value
+              h.contact.store(targetKey, result.value);
+              break;
+            }
+          }
+
+          // Include responder info in the result for diagnostics
+          resolveIteration({ value: result.value, responder: helper });
+          return;
+        }
+
+        // Result is array of Helpers (may be empty if node had no new contacts)
+        // Merge new helpers into allNodesSeen and track progress
+        if (result.length > 0) {
+          allNodesSeen.push(...result);
+          allNodesSeen.sort(Helper.compare); // Keep sorted by distance (best-first).
+          responsesWithoutNewNodes = 0; // reset counter
+          maxInFlight = alpha; // Back to normal parallelism when making progress
+        } else {
+          responsesWithoutNewNodes++;
+          if (responsesWithoutNewNodes >= alpha && maxInFlight < k) {
+            // A "round" of alpha queries all failed to find new nodes.
+            // Per Kademlia paper: escalate to k parallel queries to cast a wider net.
+            maxInFlight = k;
+            if (trace) this.log('escalating to', k, 'parallel queries after', alpha, 'empty responses');
+          }
+        }
+      }
+
+      // Check termination
+      if (isComplete()) {
+        if (trace) this.log('terminated: k closest nodes all resolved');
+        resolveIteration();
+        return;
       }
+
+      // Or terminate when network is exhausted (fewer than k nodes available)
+      if (pendingTimeouts.size === 0 && !getNextToQuery()) {
+        if (trace) this.log('terminated: network exhausted');
+        resolveIteration();
+        return;
+      }
+
+      // Launch requests to maintain maxInFlight in flight
+      while (pendingTimeouts.size < maxInFlight && launchNext()) {
+        // launchNext returns false when no more candidates
+      }
+    };
+
+    // Launch a request to the next candidate
+    const launchNext = () => {
+      const helper = getNextToQuery();
+      if (!helper) return false;
+
+      // Set up active timeout that fires if no response arrives in time
+      const timeoutId = setTimeout(() => {
+        if (iterationFinished) return;
+        if (!pendingTimeouts.has(helper.key)) return; // Already resolved
+
+        if (trace) this.log('query timed out:', helper.name);
+
+        handleCompletion(helper, 'timedOut');
+      }, queryTimeoutMs);
+
+      pendingTimeouts.set(helper.key, timeoutId);
+
+      if (timing) {
+        requestCount++;
+        const elapsed = Date.now() - iterateStartTime;
+        console.log(`  Launch ${requestCount}: ${elapsed}ms - ${helper.name} (${pendingTimeouts.size} pending)`);
+      }
+
+      this.step(targetKey, finder, helper, keysSeen, trace)
+        .then(result => handleCompletion(helper, 'responded', result))
+        .catch(err => {
+          // Handle errors - treat as disconnected
+          handleCompletion(helper, 'disconnected');
+        });
+
+      return true;
+    };
+
+    // Handle edge case: no nodes to query (isolated node)
+    if (allNodesSeen.length === 0) {
+      const contactCount = this.contacts.length;
+      this.log(`iterate(${finder}): no nodes to query - isolated node with ${contactCount} contacts in routing table`);
+      return [];
+    }
+
+    // Launch initial alpha requests
+    for (let i = 0; i < alpha; i++) {
+      if (!launchNext()) break;
     }
-    if (trace) this.log('probe result', best.map(helper => helper.name));
-    return best;
+
+    // Wait for iteration to complete (converged or exhausted, or found a value)
+    const valueResult = await iterationPromise; // undefined if no value result was received
+
+    if (timing) {
+      const totalElapsed = Date.now() - iterateStartTime;
+      console.log(`  Total iterate time: ${totalElapsed}ms (${queryState.size} queried, ${queryResponders.length} responded)`);
+    }
+
+    if (valueResult) {
+      if (trace) this.log(`value result: ${valueResult} after responses from ${queryResponders.length} nodes`);
+      return valueResult;
+    }
+
+    // If includeSelf is true, add self to the results so that on re-sort it might end up among the k closest.
+    // This is used for storeValue, where the local node is itself a valid storage location.
+    if (includeSelf) {
+      const selfDistance = this.constructor.distance(this.key, targetKey);
+      const selfHelper = new Helper(this.contact, selfDistance);
+      queryResponders.push(selfHelper);
+    }
+
+    // Build result: k closest nodes that have actually responded
+    const closestResponsive = queryResponders
+      .sort(Helper.compare)
+      .slice(0, k);
+
+    if (trace) this.log('probe result', closestResponsive.map(helper => `${helper.name}@${String(helper.distance).slice(0,2)}[${String(helper.distance).length}]`).join(', '));
+
+    return closestResponsive;
   }
 }

package/dht/nodeRefresh.js

@@ -7,7 +7,7 @@ export class NodeRefresh extends NodeKeys {
     super({refreshTimeIntervalMS, ...properties});
   }
   static stopRefresh() { // Stop all repeat timers in all instances the next time they come around.
-    this.constructor.refreshTimeIntervalMS = 0;
+    this.refreshTimeIntervalMS = 0;
   }
   stopRefresh() { // Stop repeat timeers in this instance.
     this.refreshTimeIntervalMS = 0;
@@ -15,7 +15,10 @@ export class NodeRefresh extends NodeKeys {
   isStopped(interval) {
     return !this.isRunning || 0 === this.refreshTimeIntervalMS || 0 === this.constructor.refreshTimeIntervalMS || 0 === interval;
   }
-  fuzzyInterval(target = this.refreshTimeIntervalMS/2, margin = target/2) { // Like static fuzzyInterval with target defaulting to refreshTimeIntervalMS/2.
+  // The refreshTimeIntervalMS is the number of nominal number milliseconds we expect to be able to handle for short session timems.
+  // The actual period between bucket and data refreshes may be more or less than this, depending on how well we deal with churn.
+  // That actual average time between refereshes is the default target value here. E.g., this.refreshTimeIntervalMS / 2, or 1.5 * this.refreshTimeIntervalMS, etc.
+  fuzzyInterval(target = 2 * this.refreshTimeIntervalMS, margin = target/2) { // Like static fuzzyInterval with target defaulting to refreshTimeIntervalMS/2.
     return this.constructor.fuzzyInterval(target, margin);
   }
   static fuzzyInterval(target, margin = target/2) {
@@ -32,7 +35,7 @@ export class NodeRefresh extends NodeKeys {
     return this.workQueue = this.workQueue.then(thunk);
   }
   timers = new Map();
-  schedule(timerKey, statisticsKey, thunk) {    
+  schedule(timerKey, statisticsKey, thunk, timeout = this.fuzzyInterval()) {
     // Schedule thunk() to occur at a fuzzyInterval from now, cancelling any
     // existing timer at the same key. This is used in such a way that:
     // 1. A side effect of calling thunk() is that it will be scheduled again, if appropriate.
@@ -41,7 +44,6 @@ export class NodeRefresh extends NodeKeys {
     //    E.g., bucket index 1 === 1 and stored value key BigInt(1) === BigInt(1), but 1 !== BigInt(1)
     if (this.isStopped()) return;
     const start = Date.now();
-    const timeout = this.fuzzyInterval();
     clearInterval(this.timers.get(timerKey));
     this.timers.set(timerKey, setTimeout(async () => {
       const lag = Date.now() - start - timeout;

package/dht/nodeStorage.js

@@ -5,7 +5,11 @@ export class NodeStorage extends NodeRefresh {
   storage = new Map(); // keys must be preserved as bigint, not converted to string.
   // TODO: store across sessions
   storeLocally(key, value) { // Store in memory by a BigInt key (must be already hashed). Not persistent.
+    const hadValue = this.storage.has(key);
     this.storage.set(key, value);
+    if (this.constructor.diagnosticTrace) {
+      this.log(`storeLocally(${key}, ${value}) - ${hadValue ? 'updated' : 'NEW'}`);
+    }
     // TODO: The paper says this can be optimized.
     // Claude.ai suggests just writing to the next in line, but that doesn't work.
     this.schedule(key, 'storage', () => this.storeValue(key, value));

package/dht/nodeTransports.js

@@ -16,7 +16,7 @@ export class NodeTransports extends NodeStorage {
     }
     return false;
   }
-  static maxTransports = 32;
+  static maxTransports = 62; // FIXME: try 124
   noteContactForTransport(contact) { // We're about to use this contact for a message, so keep track of it.
     // Requires: if we later addToRoutingTable successfully, it should be removed from looseTransports.
     // Requires: if we later remove contact because of a failed send, it should be removed from looseTransports.
@@ -36,7 +36,7 @@ export class NodeTransports extends NodeStorage {
       }
       let dropped = removeLast(this.looseTransports);
       if (dropped) {
-	console.log('dropping loose transport', dropped.name, 'in', this.name);
+	//console.log(this.name, 'dropping loose transport', dropped.name);
       } else { // Find the bucket with the most connections.
 	let bestBucket = null, bestCount = 0;
 	this.forEachBucket(bucket => {
@@ -48,7 +48,7 @@ export class NodeTransports extends NodeStorage {
 	});
 	dropped = removeLast(bestBucket.contacts);
 	if (!dropped) console.log('Unable to find something to drop in', this.report(null));
-	else console.log('dropping transport', dropped.name, 'in', this.name, bestBucket.index, 'among', bestCount);
+	//else console.log(this.name, 'dropping transport', dropped.name, 'in bucket', bestBucket.index, 'among', bestCount);
       }
       dropped.disconnectTransport();
     }

package/dht/nodeUtilities.js

@@ -5,7 +5,7 @@ export class NodeUtilities {
   }
   isRunning = true;
   static delay(ms, value) { // Promise to resolve (to nothing) after a given number of milliseconds
-    return new Promise(resolve => setTimeout(resolve, ms, value));
+    return new Promise(resolve => setTimeout(resolve, Math.max(0, ms), value));
   }
   static randomInteger(max) { // Return a random number between 0 (inclusive) and max (exclusive).
     return Math.floor(Math.random() * max);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yz-social/kdht",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Pure Kademlia base, for testing variations.",
   "exports": {
     ".": "./index.js",
@@ -9,25 +9,15 @@
   },
   "type": "module",
   "scripts": {
-    "serverTest": "node spec/portal.js --nPortals 20 --nWrites 40",
-    "serverTestLight": "node spec/portal.js --nPortals 10 --nWrites 40",
-    "smoke": "node spec/portal.js --nPortals 5 --nBots 5 --thrash --nWrites 10",
-    "smoke20": "node spec/portal.js --nPortals 10 --nBots 10 --thrash --nWrites 10",
-    "load30": "node spec/portal.js --nPortals 10 --nBots 20 --nWrites 100",
-    "load50": "node spec/portal.js --nPortals 10 --nBots 65 --nWrites 100",
-    "load75": "node spec/portal.js --nPortals 10 --nBots 40 --nWrites 100",
-    "load100": "node spec/portal.js --nPortals 10 --nBots 90 --nWrites 100",
-    "load150": "node spec/portal.js --nPortals 15 --nBots 135 --nWrites 100",
-    "load200": "node spec/portal.js --nPortals 20 --nBots 180 --nWrites 100",
-    "thrash30": "node spec/portal.js --nPortals 10 --nBots 20 --thrash true --nWrites 100",
-    "thrash50": "node spec/portal.js --nPortals 10 --nBots 40 --thrash true --nWrites 100",
-    "thrash100": "node spec/portal.js --nPortals 10 --nBots 90 --thrash true --nWrites 100",
-    "thrash150": "node spec/portal.js --nPortals 15 --nBots 135 --thrash true --nWrites 100",
-    "thrash200": "node spec/portal.js --nPortals 20 --nBots 180 --thrash true --nWrites 100",
-    "test": "npx jasmine"
+    "start": "node spec/portal.js",
+    "stop": "pkill kdht",
+    "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 && echo '-- SUCCESS --' || echo '**** FAIL ****'"
   },
   "dependencies": {
-    "@yz-social/webrtc": "^0.1.0",
+    "@yz-social/webrtc": "^0.1.1",
     "uuid": "^13.0.0"
   },
   "devDependencies": {

package/portals/node.js

@@ -28,4 +28,11 @@ export async function setup({baseURL, externalBaseURL = '', verbose, fixedSpacin
   const bootstrap = joinURL && await contact.ensureRemoteContact(bootstrapName, joinURL);
   process.send(contact.sname); // Report in to server as available for others to bootstrap through.
   if (bootstrap) await contact.join(bootstrap);
+  contact.host.xlog('joined');
+  process.on('SIGINT', async () => {
+    console.log(process.title, 'Shutdown for Ctrl+C');
+    await contact.disconnect();
+    process.exit(0);
+  });
+  return contact;
 }

package/spec/bots.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import {cpus, availableParallelism } from 'node:os';
 import cluster from 'node:cluster';
 import process from 'node:process';
 import { launchWriteRead } from './writes.js';
@@ -7,14 +8,16 @@ import { WebContact, Node } from '../index.js';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
 
+const logicalCores = availableParallelism();
+
 // Todo: Allow a remote portal to be specified (passing a host to WebContact.create/ensureRemoteContact).
 const argv = yargs(hideBin(process.argv))
-      .usage("Launch nBots that connect to the network through the local portal. A bot is just an ordinary node that can only be contacted through another node. They provide either continuity or churn-testing, depend on whether or not they are told to 'thrash'.")
+      .usage(`Launch nBots that connect to the network through the local portal. A bot is just an ordinary node that can only be contacted through another node. They provide either continuity or churn-testing, depend on whether or not they are told to 'thrash'. Model description "${cpus()[0].model}", ${logicalCores} logical cores.`)
       .option('nBots', {
 	alias: 'n',
 	alias: 'nbots',
 	type: 'number',
-	default: 20,
+	default: Math.min(logicalCores / 2, 2),
 	description: "The number of bots, which can only be reached through the network."
       })
       .option('baseURL', {
@@ -61,13 +64,20 @@ let contact = await WebContact.create({name: host, debug: argv.verbose});
 let bootstrapName = await contact.fetchBootstrap(argv.baseURL);
 let bootstrapContact = await contact.ensureRemoteContact(bootstrapName, argv.baseURL);
 await contact.join(bootstrapContact);
+contact.host.xlog('joined');
+
+// process.on('SIGINT', async () => {
+//   console.log(process.title, 'Shutdown for Ctrl+C');
+//   await contact.disconnect();
+//   process.exit(0);
+// });
 
 while (argv.thrash) {
   await Node.delay(contact.host.fuzzyInterval(Node.refreshTimeIntervalMS));
   const old = contact;
   const next = uuidv4();
   contact.host.xlog('disconnecting');
-  contact.disconnect();
+  await contact.disconnect();
   await Node.delay(1e3); // TODO: remove?
 
   contact = await WebContact.create({name: next, debug: argv.verbose});

package/spec/dhtAcceptanceSpec.js

@@ -10,7 +10,7 @@ const { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach} = glob
 import { setupServerNodes, shutdownServerNodes,
 	 start1, setupClientsByTime, shutdownClientNodes,
 	 getContacts, getRandomLiveContact,
-	 startThrashing, write1, read1, Node } from './dhtImplementation.js';
+	 startThrashing, write1, read1, Node, Contact } from './dhtImplementation.js';
 
 // Some definitions:
 //
@@ -118,7 +118,13 @@ async function parallelReadAll(start = 0) {
   const contacts = await getContacts();
   const readPromises = await Promise.all(contacts.map(async (_, index) => {
     if (index < start) return;
-    const value = await read1(await getRandomLiveContact(), index);
+    let value;
+    for (let liveTry = 0; liveTry < 4; liveTry++) {
+      const contact = await getRandomLiveContact();
+      value = await read1(contact, index);
+      if (contact.isRunning) break;
+      console.log('\n\n*** read from dead contact. retrying', liveTry, '***\n');
+    }
     expect(value).toBe(index);
   }));
   return readPromises.length - start;
@@ -136,8 +142,8 @@ describe("DHT", function () {
   function test(parameters = {}) {
     // Define a suite of tests with the given parameters.
     const {nServerNodes = 10,
-	   pingTimeMS = 40, // Round-trip network time. Implementation should pad network calls to achieve what is specified here.
-	   maxTransports = 152, // How many direct connections are allowed per node?
+	   pingTimeMS = Contact.pingTimeMS, // Round-trip network time. Implementation should pad network calls to achieve what is specified here.
+	   maxTransports = Node.maxTransports, // How many direct connections are allowed per node?
 	   maxClientNodes = Infinity, // If zero, will try to make as many as it can in refreshTimeIntervalMS.
 	   refreshTimeIntervalMS = 15e3, // How long on average does a client stay up?
 	   setupTimeMS = Math.max(2e3, refreshTimeIntervalMS), // How long to create the test nodes.
@@ -148,7 +154,7 @@ describe("DHT", function () {
 	  } = parameters;
     const suiteLabel = `Server nodes: ${nServerNodes}, setup time: ${setupTimeMS}, max client nodes: ${maxClientNodes ?? Infinity}, ping: ${pingTimeMS}ms, max connections: ${maxTransports}, refresh: ${refreshTimeIntervalMS.toFixed(3)}ms, pause before write: ${runtimeBeforeWriteMS.toFixed(3)}ms, pause before read: ${runtimeBeforeReadMS.toFixed(3)}ms, thrash before: ${startThrashingBefore}`;
     
-    describe(suiteLabel, function () {
+    describe(notes || suiteLabel, function () {
       beforeAll(async function () {
 	console.log('\n' + suiteLabel);
 	if (notes) console.log(notes);
@@ -206,17 +212,25 @@ describe("DHT", function () {
 
   // 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({maxClientNodes: 30, pingTimeMS: 0, refreshTimeIntervalMS: 5e3, notes: "Small networks allow faster smoke-testing."});
-  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."});
+  test({pingTimeMS: 0, refreshTimeIntervalMS: 5e3, notes: "Small networks allow faster thrash smoke-testing."});
+  test({notes: "Normal ops"});
+  
+  // 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."});
+
+
+  //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."});
 
   //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, refreshTimeIntervalMS: 3e3, runtimeBeforeWriteMS: 6e3, runtimeBeforeReadMS: 6e3});
+  //test({maxClientNodes: 3, nServerNodes: 3, startThrashingBefore: 'never', refreshTimeIntervalMS: 3e3, runtimeBeforeWriteMS: 6e3, runtimeBeforeReadMS: 6e3});
 
   
   // TODO:

package/spec/dhtImplementation.js

@@ -11,10 +11,8 @@
 
 // In the present case, these manipulate a Contact that directly contains a
 // DHT node with simulated networking.
-//import { InProcessWebContact as Contact, Node } from '../index.js';
-//import { SimulatedContact as Contact, Node } from '../index.js';
 import { SimulatedConnectionContact as Contact, Node } from '../index.js';
-export { Node };
+export { Node, Contact };
 
 
 export async function start1(name, bootstrapContact, refreshTimeIntervalMS, isServerNode = false) {
@@ -24,6 +22,7 @@ export async function start1(name, bootstrapContact, refreshTimeIntervalMS, isSe
 }
 
 export async function startServerNode(name, bootstrapContact, refreshTimeIntervalMS) {
+  Node.refreshTimeIntervalMS = refreshTimeIntervalMS;
   return await start1(name, bootstrapContact, refreshTimeIntervalMS, true);
 }
 
@@ -187,5 +186,6 @@ async function serialSetupClientsByTime(refreshTimeIntervalMS, nServerNodes, max
 export async function shutdownClientNodes(nServerNodes, nClientNodes) {
   await stopThrashing();
   await new Promise(resolve => setTimeout(resolve, 5e3));
+  Node.refreshTimeIntervalMS = 0;
   await shutdown(nServerNodes, nClientNodes + nServerNodes);
 }