@yz-social/kdht 0.1.2 → 0.1.4

package/transports/simulations.js

@@ -6,48 +6,99 @@ export class SimulatedContact extends Contact {
   get key() { return this.node.key; }
   get isServerNode() { return this.node.isServerNode; }
 
-  get isRunning() { // Ask our canonical home contact.
+  get isRunning() { // Is the far node running.
     return this.node.isRunning;
   }
   connection = null;
   async connect() { return this; }
-  disconnectTransport() { }
-  async transmitRPC(method, ...rest) { // Transmit the call to the receiving node's contact.
+  // Dispatch directly on the node, returning the response. This is different than the send to and from with messageTag used by
+  // SimulatedConnectionContact and WebContact.
+  async transmitRPC(messageTag, method, sender, ...rest) {
+    // Use delay from the destination node if set, representing a laggy VM/connection
+    const delayMs = this.node.delayMs;
     return await this.constructor.ensureTime(async () => {
       if (!this.isRunning) return null; // Receiver closed.
-      return await this.node.contact.receiveRPC(method, this.node.ensureContact(this.host.contact), ...rest);
-    });
+      return await this.node.receiveRPC(method, this.node.ensureContact(this.host.contact), ...rest);
+    }, delayMs);
   }
 }
 
 export class SimulatedConnectionContact extends SimulatedContact {
   connection = null; // The cached connection (to another node's connected contact back to us) over which messages can be directly sent, if any.
-  disconnectTransport() {
+  disconnect() {
+    // Report if we are the last node to hold a value.
+    if (Node.refreshTimeIntervalMS && Node.contacts?.length) { // i.e., not shutting down and in simulation where we track all Contacts.
+      for (const key of this.host.storage.keys()) {
+	const found = Node.contacts.find(contact => contact?.host.storage.has(key) && (contact?.key !== this.key));
+	if (!found) console.log('\n\n*** removing last storer for ', key, this.host.storage.get(key), 'among', Node.contacts.filter(e => e).length, 'contacts ***\n');
+      }
+    }
+    return super.disconnect();
+  }
+  disconnectTransport(andNotify = true) {
     const farContactForUs = this.connection;
     if (!farContactForUs) return;
     Node.assert(farContactForUs.key === this.host.key, 'Far contact backpointer', farContactForUs.node.name, 'does not point to us', this.host.name);
     Node.assert(farContactForUs.host.key === this.key, 'Far contact host', farContactForUs.host.name, 'is not hosted at contact', this.name);
-    farContactForUs.connection = null;
-    this.connection = null;
+    super.disconnectTransport(andNotify);
+    this.connection = farContactForUs.connection = null;
   }
   async connect(forMethod = 'findNodes') { // Connect from host to node, promising a possibly cloned contact that has been noted.
     // Simulates the setup of a bilateral transport between this host and node, including bookkeeping.
     // TODO: Simulate webrtc signaling.
     const contact = this;
-    let { host, node, isServerNode } = contact;
+    let { host, node, isServerNode, connection } = contact;
+    if (connection) return connection;
 
     // 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 (!isServerNode) {
+    if (isServerNode) {
+      // No point in slowing the tests down to actually wait for this. It doesn't change the outcome.
+      //await Node.delay(250); // Connect through portal.
+    } else {
+      //this.host.xlog('connecting', this.sname);
       let mutualSponsor = null;
-      for (const sponsor of this._sponsors.values()) {
-	if (!sponsor.connection || !sponsor.node.existingContact(this.node.name)?.connection) continue;
-	mutualSponsor = sponsor;
+      const isConnected = (contact) => { // Is contact already connected to us?
+	return contact.connection && contact.node.existingContact(this.node.name)?.connection;
+      };
+      await Node.delay(100);
+      const sponsors = Array.from(this._sponsors.values());
+      const target = this.node, targetKey = target.key;
+      const findSponsor =  () => {
+	for (const sponsor of sponsors) {
+	  //if (isConnected(sponsor)) return sponsor;
+	  if (sponsor.sendRPC('signals', this.key, [])) {
+	    return sponsor;
+	  }
+	}
+	return null;
+      };
+      function findPath(contact, excluded) {
+	if (contact.key === targetKey) return true;
+	if (!isConnected(contact)) return false;
+	const closest = contact.node.findClosestHelpers(targetKey)
+	      .map(helper => helper.contact)
+	      .filter(contact => !excluded.includes(contact.key));
+	for (const sub of closest) {
+	  if (findPath(sub, [sub.node.key, ...excluded])) return true;
+	}
+	return false;
+      }
+      if (! findSponsor()) {
+	await Node.delay(100);
+	if ( findSponsor()) console.log('*** found sponsor after delay ***');
+	else if (findPath(this.host.contact, [this.host.key])) console.log('*** found path ***');
+	else {
+	  // console.log('No connection path from', this.host.contact.report, 'to', this.report, 'sponsors:', sponsors.map(c => c.report)
+	  // 	      //, 'contacts:', this.node.findClosestHelpers(targetKey).map(helper => helper.contact.report)
+	  // 	     );
+	  return null;
+	}
       }
-      if (!mutualSponsor) return null;
     }
-    
-    const farContactForUs = node.ensureContact(host.contact, contact.sponsor);
+
+    // our sponsors are not transferred to the other side.
+    const farContactForUs = node.ensureContact(host.contact);
 
     contact.connection = farContactForUs;
     host.noteContactForTransport(contact);
@@ -57,10 +108,26 @@ export class SimulatedConnectionContact extends SimulatedContact {
     
     return contact;
   }
-  async transmitRPC(method, ...rest) { // A message from this.host to this.node. Forward to this.node through overlay connection for bucket.
+  signals(...rest) {
+    return [this.name]; // Just a simulation
+  }
+  async send(message) {
+    await Node.delay(10);
+    this.connection?.receiveRPC(...message);
+  }
+  async synchronousSend(message) {
+    const other = this.connection;
+    await Node.delay(1);
+    other?.receiveRPC(...message);
+  }
+  async transmitRPC(messageTag, method, sender, ...rest) { // "transmit" the call (with sending contact added).
     if (!this.isRunning) return null; // Receiver closed.
-    const farContactForUs = this.connection || (await this.connect(method))?.connection;
-    if (!farContactForUs) return null; // receiver no longer reachable.
-    return await this.constructor.ensureTime(() => farContactForUs.receiveRPC(method, farContactForUs, ...rest));
+    const farContactForUs = this.connection;
+    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)]);
+    this.constructor.ensureTime(() => farContactForUs.receiveRPC(messageTag, method, farContactForUs, ...rest), delayMs);
+    return await responsePromise;
   }
 }

package/transports/webrtc.js

@@ -5,7 +5,6 @@ import { Helper } from '../dht/helper.js';
 import { Contact } from './contact.js';
 import { WebRTC } from '@yz-social/webrtc';
 
-
 export class WebContact extends Contact { // Our wrapper for the means of contacting a remote node.
   // Can this set all be done more simply?
   get name() { return this.node.name; } // Key of remote node as a string (e.g., as a guid).
@@ -14,12 +13,15 @@ export class WebContact extends Contact { // Our wrapper for the means of contac
   get isRunning() { return this.node.isRunning; } // Have we marked at is no longer running.
 
   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}.`);
   }
+  // connection:close is far more robust against pooling issues common to some implementations (e.g., NodeJS).
+  // https://github.com/nodejs/undici/issues/3492
   async fetchBootstrap(baseURL, label = 'random') { // Promise to ask portal (over http(s)) to convert a portal
     // 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);
+    const response = await fetch(url, {headers: { 'Connection': 'close' } }).catch(e => this.host.xlog(e));
     this.checkResponse(response);
     return await response.json();
   }
@@ -33,21 +35,49 @@ export class WebContact extends Contact { // Our wrapper for the means of contac
   async fetchSignals(url, signalsToSend) { 
     const response = await fetch(url, {
       method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
+      headers: { 'Content-Type': 'application/json', 'Connection': 'close' },
       body: JSON.stringify(signalsToSend)
-    });
+    }).catch(e => this.host.xlog(e));
     this.checkResponse(response);
-    return this.checkSignals(await response.json());
+    return this.checkSignals(await response?.json());
   }
   async messsageSignals(signals) {
-    return this.checkSignals(await this.host.message({targetKey: this.key, targetSname: this.sname,
-						      payload: ['signal', this.host.contact.sname, ...signals]}));
+    // Try sponsors first (two hops if connected).
+    const payload = [this.host.contact.sname, ...signals];
+    //this.host.xlog('contact messageSignals', payload);
+    const sponsors = Array.from(this._sponsors.values());
+    for (const sponsor of sponsors) {
+      const response = await sponsor.sendRPC('signals', this.key, payload);
+      if (response) return response;
+      this._sponsors.delete(sponsor.key);
+    }
+    if (!this.host.sRunning) return [];
+    this.host.xlog('Unable to signal through sponsor. Using recursive message to', this.sname, this.key);
+    const recursive = await this.host.contact.sendRPC('signals', this.key, payload, []);
+    //this.host.xlog('got recursive response', recursive);
+    if (!this.host.isRunning) return [];
+    if (!recursive) this.host.xlog('Unable to deliver signals to', this.sname);
+    return this.checkSignals(recursive);
+    // return this.checkSignals(await this.host.message({targetKey: this.key, targetSname: this.sname,
+    // 						      payload: ['signal', this.host.contact.sname, ...signals]}));
+  }
+  async signals(senderSname, ...signals) { // Accept directed WebRTC signals from a sender sname, creating if necessary the
+    // new contact on host to receive them, and promising a response.
+    //this.host.xlog('contact signals', senderSname, signals);
+    let contact = await this.ensureRemoteContact(senderSname);
+
+    if (contact.webrtc) return await contact.webrtc.respond(signals);
+
+    this.host.noteContactForTransport(contact);
+    contact.ensureWebRTC();
+    return await contact.webrtc.respond(signals);
   }
   get webrtcLabel() {
     return `@${this.host.contact.sname} ==> ${this.sname}`;
   }
 
-  ensureWebRTC(initiate = false, timeoutMS = this.host.timeoutMS || 5e3) { // If not already configured, sets up contact to have properties:
+  ensureWebRTC(initiate = false, timeoutMS = this.host.timeoutMS || 5e3) { // Ensure we are connected, if possible.
+    // If not already configured, 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)
@@ -68,7 +98,7 @@ export class WebContact extends Contact { // Our wrapper for the means of contac
     const onclose = () => { // Does NOT mean that the far side has gone away. It could just be over maxTransports.
       this.host.log('connection closed');
       resolve(null); // closed promise
-      this.webrtc = this.connection = this.overlay = null;
+      this.webrtc = this.connection = this.unsafeData = null;
     };
     if (initiate) {
       if (bootstrapHost/* || isServerNode*/) {
@@ -90,39 +120,32 @@ export class WebContact extends Contact { // Our wrapper for the means of contac
       dataChannel.addEventListener('message', event => this.receiveWebRTC(event.data));
       if  (this.host.debug) await webrtc.reportConnection(true); // TODO: make this asymchronous?
       if (webrtc.statsElapsed > 500) this.host.xlog(`** slow connection to ${this.sname} took ${webrtc.statsElapsed.toLocaleString()} ms. **`);
+      this.unsafeData = dataChannel;
       return dataChannel;
     });
-    const overlayChannelName = 'overlay';
-    const overlayPromise = webrtc.getDataChannelPromise(overlayChannelName);
-    webrtc.createChannel(overlayChannelName, {negotiated: true});
-    overlayPromise.then(async overlay => {
-      overlay.addEventListener('message', event => host.messageHandler(event.data));
-      return overlay;
-    });
     if (!timeoutMS) {
       this.connection = channelPromise;
-      this.overlay = overlayPromise;
       return;
     }
     const timerPromise = new Promise(expired => {
       timeout = setTimeout(async () => {
 	const now = Date.now();
-	this.host.xlog('**** connection timeout', this.sname, now - start,
-		       'status:', webrtc.pc.connectionState, 'signaling:', webrtc.pc.signalingState,
-		       'last signal:', now - webrtc.lastOutboundSignal,
-		       'last send:', now - webrtc.lastOutboundSend,
-		       'last response:', now - webrtc.lastResponse,
-		       '****');
+	this.host.xlog('Unable to connect to', this.sname);
+	// this.host.xlog('**** connection timeout', this.sname, now - start,
+	// 	       'status:', webrtc.pc.connectionState, 'signaling:', webrtc.pc.signalingState,
+	// 	       'last signal:', now - webrtc.lastOutboundSignal,
+	// 	       'last send:', now - webrtc.lastOutboundSend,
+	// 	       'last response:', now - webrtc.lastResponse,
+	// 	       '****');
 	onclose();
 	await this.host.removeContact(this); // fixme?
 	expired(null);
       }, timeoutMS);
     });
     this.connection = Promise.race([channelPromise, timerPromise]);
-    this.overlay = Promise.race([overlayPromise, timerPromise]);
   }
   async connect() { // Connect from host to node, promising a possibly cloned contact that has been noted.
-    // Creates a WebRTC instance and uses it's connectVia to to signal.
+    // Creates a connected WebRTC instance.
     const contact = this.host.noteContactForTransport(this);
     ///if (contact.connection) contact.host.xlog('connect existing', contact.sname, contact.counter);
 
@@ -131,25 +154,24 @@ export class WebContact extends Contact { // Our wrapper for the means of contac
     // Anyone in the DHT can connect to another DHT node through a sponsor.
     if (contact.connection) return contact.connection;
     contact.ensureWebRTC(true);
-    await Promise.all([this.connection, this.overlay]);
+    await this.connection;
     return this.connection;
   }
-  async signals(senderSname, ...signals) { // Accept directed WebRTC signals from a sender sname, creating if necessary the
-    // new contact on host to receive them, and promising a response.
-    let contact = await this.ensureRemoteContact(senderSname);
-
-    if (contact.webrtc) return await contact.webrtc.respond(signals); 
-
-    this.host.noteContactForTransport(contact);
-    contact.ensureWebRTC();
-    return await contact.webrtc.respond(signals);
-  }
 
   async send(message) { // Promise to send through previously opened connection promise.
     let channel = await this.connection;
     if (channel?.readyState === 'open') channel.send(JSON.stringify(message));
     else this.host.xlog('Unable to open channel');
   }
+  synchronousSend(message) { // this.send awaits channel open promise. This is if we know it has been opened.
+    if (this.unsafeData?.readyState !== 'open') return; // But it may have since been closed.
+    this.host.log('sending', message, 'to', this.sname);
+    try {
+      this.unsafeData.send(JSON.stringify(message));
+    } catch (e) { // Some webrtc can change readyState in background.
+      this.host.log(e); 
+    }
+  }
   getName(sname) { // Answer name from sname.
     if (sname.startsWith(this.constructor.serverSignifier)) return sname.slice(1);
     return sname;
@@ -172,79 +194,59 @@ export class WebContact extends Contact { // Our wrapper for the means of contac
     else if (typeof(sponsor) === 'string') contact.bootstrapHost = sponsor;
     return contact;
   }
-  receiveRPC(method, sender, key, ...rest) { // Receive an RPC from sender, dispatch, and return that value, which will be awaited and sent back to sender.
-    if (method === 'forwardSignals') { // Can't be handled by Node, because 'forwardSignals' is specific to WebContact.
-      const [sendingSname, ...signals] = rest;
-      if (key === this.host.key) { // for us!
-	return this.signals(...rest);
-      } else { // Forward to the target.
-	const target = this.host.findContactByKey(key);
-	if (!target) {
-	  console.log(this.host.contact.sname, 'does not have contact to', sendingSname);
-	  return null;
-	}
-	return target.sendRPC('forwardSignals', key, ...rest);
-      }
-    }
-    return super.receiveRPC(method, sender, key, ...rest);
-  }
-  inFlight = new Map();
-  async transmitRPC(method, key, ...rest) { // Must return a promise.
-    const MAX_PING_MS = 250; // No including connect time. These are single-hop WebRTC data channels.
+  serializeRequest(messageTag, method, sender, targetKey, ...rest) { // Stringify sender and targetKey.
+    Node.assert(sender instanceof Contact, 'no sender', sender);
+    return [messageTag, method, sender.sname, targetKey.toString(), ...rest];
+  }
+  async deserializeRequest(method, sender, targetKey, ...rest) { // Inverse of serializeRequest. Response object will be spread for Node receiveRPC.
+    // TODO: Currently, parameters do NOT include messageTag! (Because of how receiveRPC is called without it.)
+    return [method, await this.ensureRemoteContact(sender), BigInt(targetKey), ...rest];
+  }
+  isSignalResponse(response) {
+    const first = response[0];
+    if (!first) return false;
+    if (('description' in first) || ('candidate' in first)) return true;
+    return false;
+  }
+  serializeResponse(response) {
+    if (!this.host.constructor.isContactsResult(response)) return response;
+    if (this.isSignalResponse(response)) return response;
+    return response.map(helper => [helper.contact.sname, helper.distance.toString()]);
+  }
+  async deserializeResponse(result) {
+    let response;
+    if (!Node.isContactsResult(result)) return result;
+    if (!result.length) return result;
+    if (this.isSignalResponse(result)) return result;
+    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.
     // this.host.log('transmit to', this.sname, this.connection ? 'with connection' : 'WITHOUT connection');
-    if (!await this.connect()) return null;
-    const sender = this.host.contact.sname;
-    // uuid so that the two sides don't send a request with the same id to each other.
-    // Alternatively, we could concatenate a counter to our host.name.
-    const messageTag = uuidv4();
-    const responsePromise = new Promise(resolve => this.inFlight.set(messageTag, resolve));
-    const message = [messageTag, method, sender, key.toString(), ...rest];
-    this.send(message);
-    const timeout = Node.delay(MAX_PING_MS, null); // Faster than waiting for webrtc to observe a close
-    return await Promise.race([responsePromise, timeout, this.closed]);
+    const responsePromise = this.getResponsePromise(messageTag);
+    await this.send([messageTag, method, ...rest]);
+    return await Promise.race([responsePromise, this.rpcTimeout(method), this.closed]);
   }
+
   async receiveWebRTC(dataString) { // Handle receipt of a WebRTC data channel message that was sent to this contact.
     // The message could the start of an RPC sent from the peer, or it could be a response to an RPC that we made.
     // As we do the latter, we generate and note (in transmitRPC) a message tag included in the message.
-    // If we find that in our inFlight tags, then the message is a response.
+    // If we find that in our messageResolvers tags, then the message is a response.
     if (dataString === '"bye"') { // Special messsage that the other side is disconnecting, so we can clean up early.
       this.webrtc.close();
-      this.host.xlog('removing disconnected contact');
+      this.host.xlog('removing disconnected contact', this.sname);
       await this.host.removeContact(this);  // TODO: Make sure we're not invoking this in maxTransports cases.
       return;
     }
     const [messageTag, ...data] = JSON.parse(dataString);
-    const responder = this.inFlight.get(messageTag);
-    if (responder) { // A response to something we sent and are waiting for.
-      let [result] = data;
-      this.inFlight.delete(messageTag);
-      if (Array.isArray(result)) {
-	if (!result.length) responder(result);
-	const first = result[0];
-	const isSignal = Array.isArray(first) && ['offer', 'answer', 'icecandidate'].includes(first[0]);
-	if (isSignal) {
-	  responder(result); // This could be the sponsor or the original sender. Either way, it will know what to do.
-	} else {
-	  responder(await Promise.all(result.map(async ([sname, distance]) =>
-	    new Helper(await this.ensureRemoteContact(sname, this), BigInt(distance)))));
-	}
-      } else {
-	responder(result);
-      }
-    } else { // An incoming request.
-      const [method, senderLabel, key, ...rest] = data;
-      const sender = await this.ensureRemoteContact(senderLabel);
-      let response = await this.receiveRPC(method, sender, BigInt(key), ...rest);
-      if ((method !== 'forwardSignals') && this.host.constructor.isContactsResult(response)) {
-	response = response.map(helper => [helper.contact.sname, helper.distance.toString()]);
-      }
-      this.send([messageTag, response]);
-    }
+    await this.receiveRPC(messageTag, ...data);
   }
   async disconnectTransport() {
-    await this.send('bye'); await Node.delay(50); // FIXME: Hack: We'll need to be able to pass tests without this, too.
-
-    this.webrtc?.close();
-    this.connection = this.webrtc = this.initiating = null;
+    if (!this.connection) return;
+    super.disconnectTransport();
+    Node.delay(100).then(() => { // Allow time for super to send close/bye message.
+      this.webrtc?.close();
+      this.connection = this.webrtc = this.initiating = null;
+    });
   }
 }

package/spec/dhtWriteRead.js

@@ -1,56 +0,0 @@
-#!/usr/bin/env npx jasmine
-const { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach } = globalThis; // For linters.
-import process from 'node:process';
-import { exec } from 'node:child_process';
-import { v4 as uuidv4 } from 'uuid';
-import { WebContact, Node } from '../index.js';
-
-// I cannot get yargs to work properly within jasmine. Get args by hand.
-// Note: jasmine will treat --options as arguments to itself. To pass them to the script, you need to separate with '--'.
-const nWritesIndex = process.argv.indexOf('--nWrites');
-const baseURLIndex = process.argv.indexOf('--baseURL');
-const waitBeforeReadIndex = process.argv.indexOf('--waitBeforeRead');
-const verboseIndex = process.argv.indexOf('--verbose');
-const shutdownIndex = process.argv.indexOf('--shutdown');
-
-const nWrites = nWritesIndex >= 0 ? JSON.parse(process.argv[nWritesIndex + 1]) : 10;
-const baseURL = baseURLIndex >= 0 ? process.argv[baseURLIndex + 1] : 'http://localhost:3000/kdht';
-const waitBeforeRead = waitBeforeReadIndex >= 0 ? JSON.parse(process.argv[waitBeforeReadIndex + 1]) : 10;
-const verbose = verboseIndex >= 0 ? JSON.parse( process.argv[verboseIndex + 1] || 'true' ) : false;
-const shutdown = shutdownIndex >= 0 ? JSON.parse( process.argv[shutdownIndex + 1] || 'true' ) : true;
-
-describe("DHT write/read", function () {
-  let contact;
-  beforeAll(async function () {
-    contact = await WebContact.create({name: uuidv4(), debug: verbose});
-    const bootstrapName = await contact.fetchBootstrap(baseURL);
-    const bootstrapContact = await contact.ensureRemoteContact(bootstrapName, baseURL);
-    console.log(new Date(), contact.sname, 'joining', bootstrapContact.sname);
-    await contact.join(bootstrapContact);
-    console.log(new Date(), contact.sname, 'joined');    
-    for (let index = 0; index < nWrites; index++) {
-      const wrote = await contact.storeValue(index, index);
-      console.log('Wrote', index);
-    }
-    if (waitBeforeRead) {
-      console.log(new Date(), `Written. Waiting ${waitBeforeRead.toLocaleString()} ms before reading.`);
-      await Node.delay(waitBeforeRead);
-    }
-    console.log(new Date(), 'Reading');
-  }, 5e3 * nWrites + 2 * Node.refreshTimeIntervalMS);
-  afterAll(async function () {
-    if (shutdown) {
-      contact.disconnect();
-      exec('pkill kdht-portal-server');
-    } else {
-      contact.disconnect();
-    }
-  });
-  for (let index = 0; index < nWrites; index++) {
-    it(`reads ${index}.`, async function () {
-      const read = await contact.node.locateValue(index);
-      console.log('read', read);
-      expect(read).toBe(index);
-    }, 10e3); // Can take longer to re-establish multiple connections.
-  }
-});