@yz-social/kdht 0.1.0 → 0.1.2

package/dht/node.js

@@ -98,7 +98,7 @@ export class Node extends NodeProbe {
       if (!contact.connection) { this.log('skipping unconnected', contact.sname, 'for message', requestTag); continue; }
       if (!(await contact.sendRPC('ping', contact.key))) {
 	this.xlog('failed to get ping', contact.sname, 'for message', requestTag);
-	this.removeContact(contact);
+	await this.removeContact(contact);
 	continue;
       }
       let overlay = await contact.overlay;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yz-social/kdht",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Pure Kademlia base, for testing variations.",
   "exports": {
     ".": "./index.js",

package/spec/node.html

@@ -19,29 +19,34 @@
       import { v4 as uuidv4 } from 'uuid';
       import { WebContact } from '@yz-social/kdht';
       Object.assign(globalThis, {uuidv4, WebContact });
+      const bootstrapBase = new URL('/kdht', origin).href; // Must be a string
+      let contact;
 
-      let name = localStorage.getItem('name');
-      if (!name) {
-	name = uuidv4();
-	localStorage.setItem('name', name);
+      async function connect() { // Connect or reconnect to the network.
+	const name = uuidv4();
+	contact = globalThis.contact = await WebContact.create({name});
+	const bootstrapName = await contact.fetchBootstrap(bootstrapBase);
+	console.log('connecting to', bootstrapName);
+	const bootstrapContact = globalThis.bootstrapContact = await contact.ensureRemoteContact(bootstrapName, bootstrapBase);
+	await contact.join(bootstrapContact);
+	update.onclick();
       }
-      const contact = globalThis.contact = await WebContact.create({name});
-      const bootstrapBase = new URL('/kdht', origin).href; // Must be a string
-      const bootstrapName = await contact.fetchBootstrap(bootstrapBase);
-      console.log('connecting to', bootstrapName);
-      const bootstrapContact = globalThis.bootstrapContact = await contact.ensureRemoteContact(bootstrapName, bootstrapBase);
-      await contact.join(bootstrapContact);
-      console.log('connected');
 
       update.onclick = () => {
         const report = contact.node.report(null);
-        console.log({report, display});
         display.textContent = report;
       };
-      update.onclick();
+      await connect();
 
       write.onclick = () => contact.storeValue(key.value, writeValue.value);
       read.onclick = () => contact.node.locateValue(key.value).then(value => readValue.value = value);
+      document.addEventListener("visibilitychange", () => {
+	if (document.hidden) {
+	  contact.disconnect();
+	} else {
+	  connect();
+	}
+      });
     </script>
   </body>    
 </html>  

package/transports/webrtc.js

@@ -39,9 +39,9 @@ export class WebContact extends Contact { // Our wrapper for the means of contac
     this.checkResponse(response);
     return this.checkSignals(await response.json());
   }
-  messsageSignals(signals) {
-    return this.checkSignals(this.host.message({targetKey: this.key, targetSname: this.sname,
-						payload: ['signal', this.host.contact.sname, ...signals]}));
+  async messsageSignals(signals) {
+    return this.checkSignals(await this.host.message({targetKey: this.key, targetSname: this.sname,
+						      payload: ['signal', this.host.contact.sname, ...signals]}));
   }
   get webrtcLabel() {
     return `@${this.host.contact.sname} ==> ${this.sname}`;
@@ -209,6 +209,7 @@ export class WebContact extends Contact { // Our wrapper for the means of contac
     // If we find that in our inFlight 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');
       await this.host.removeContact(this);  // TODO: Make sure we're not invoking this in maxTransports cases.
       return;
     }

package/junx.js

@@ -1,17 +0,0 @@
-async function bar() {
-  throw new Error("synchronously thrown from bar (asynchronous from foo)");
-}
-async function foo() {
-  try {
-    bar();
-  } catch (e) {
-    console.log('foo caught', e);
-  }
-  throw new Error('synchronously thrown from foo');
-}
-
-try {
-  await foo();
-} catch (e) {
-  console.log('outer caught', e);
-}

package/routes/index.js

@@ -1,39 +0,0 @@
-import express from 'express';
-import { TrickleWebRTC } from '@yz-social/webrtc';
-import { WebContact as Contact } from '../index.js';
-export const router = express.Router();
-
-
-
-router.post('/join/:key', async (req, res, next) => {
-
-  const {params, body} = req;
-  const tag = params.tag;
-  const incomingSignals = body;
-  let connection = testConnections[tag];
-  console.log('post connection:', !!connection, 'incoming:', incomingSignals.map(s => s[0]));
-  if (!connection) {
-    connection = testConnections[tag] = TrickleWebRTC.ensure({serviceLabel: tag});
-    const timer = setTimeout(() => connection.close(), 15e3);
-    console.log('created connection and applying', incomingSignals.map(s => s[0]));
-    connection.next = connection.signals;
-    const dataPromise = connection.dataChannelPromise = connection.ensureDataChannel('echo', {}, incomingSignals);
-    dataPromise.then(dataChannel => {
-      connection.reportConnection(true);
-      dataChannel.onclose = () => {
-	clearTimeout(timer);
-	connection.close();
-	delete testConnections[tag];
-      };
-      dataChannel.onmessage = event => dataChannel.send(event.data); // Just echo what we are given.
-    });
-  } else {
-    console.log('applying incoming signals');
-    connection.signals = incomingSignals;
-  }
-  console.log('awaiting response');
-  const responseSignals = await Promise.race([connection.next, connection.dataChannelPromise]);
-  connection.next = connection.signals;
-  console.log('responding', responseSignals.map(s => s[0]));
-  res.send(responseSignals); // Send back our signalling answer+ice.
-});

package/save/dhtWriteRead.js

@@ -1,48 +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 verboseIndex = process.argv.indexOf('--verbose');
-const shutdownIndex = process.argv.indexOf('--shutdown');
-const nWrites = nWritesIndex >= 0 ? JSON.parse(process.argv[nWritesIndex + 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();
-    const bootstrapContact = await contact.ensureRemoteContact(bootstrapName, 'http://localhost:3000/kdht');
-    console.log(new Date(), contact.sname, 'joining', bootstrapContact.sname);
-    await contact.join(bootstrapContact);
-    console.log('joined');
-    for (let index = 0; index < nWrites; index++) {
-      const wrote = await contact.store(index, index);
-      console.log('Wrote', index);
-    }
-    console.log(new Date(), 'Written. Waiting two refresh periods before reading.', 2 * Node.refreshTimeIntervalMS / 1e3, 'seconds');
-    await Node.delay(2 * Node.refreshTimeIntervalMS);
-    console.log(new Date(), 'Reading');
-  }, 5e3 * nWrites + 2 * Node.refreshTimeIntervalMS);
-  afterAll(function () {
-    if (shutdown) {
-      exec('pkill kdht-bot');
-      Node.delay(2e3);
-      exec('pkill kdht-portal-server');
-    }
-  });
-  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);
-    });
-  }
-});

package/save/webrtc.js

@@ -1,212 +0,0 @@
-import { v4 as uuidv4 } from 'uuid';
-import { Node } from '../dht/node.js';
-import { Helper } from '../dht/helper.js';
-import { Contact } from './contact.js';
-import { WebRTC } from '@yz-social/webrtc';
-const { BigInt } = globalThis; // For linters.
-
-
-export class WebContact extends Contact {
-  // Can this set all be done more simply?
-  get name() { return this.node.name; }
-  get key() { return this.node.key; }
-  get isServerNode() { return this.node.isServerNode; }
-  get isRunning() { return this.node.isRunning; }
-
-  checkResponse(response) {
-    if (!response.ok) throw new Error(`${this.sname} fetch ${response.url} failed ${response.status}: ${response.statusText}.`);
-  }
-  async fetchSignals(url, signalsToSend) {
-    const response = await fetch(url, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(signalsToSend)
-    });
-    this.checkResponse(response);
-    return await response.json();
-  }
-  async fetchBootstrap(label = 'random') {
-    const url = `http://localhost:3000/kdht/name/${label}`;
-    const response = await fetch(url);
-    this.checkResponse(response);
-    return await response.json();
-  }
-  get webrtcLabel() {
-    return `@${this.host.contact.sname} ==> ${this.sname}`;
-  }
-  // Within a process, there is only one WebContact.serializer, so each process can only complete one  connection at a time.
-  // (It can maintain Node.maxTransports open connections. The serialization is a limit on the connection/signal process.)
-  static serializer = Promise.resolve();
-  channelName = 'kdht';
-
-  ensureWebRTC(initialSignals) { // If not already configured, sets up contact to have properties:
-    // - connection - a promise for an open webrtc data channel:
-    //   send(string) puts data on the channel
-    //   incomming messages are dispatched to receiveWebRTC(string)
-    // - closed - resolves when webrtc closes.
-    // - webrtc - an instance of WebRTC (which may be used for webrtc.respond()
-    // initialSignals should be a list, or null for the creator of the offer.
-    if (this.webrtc) return this.webrtc;
-
-    const webrtc = this.webrtc = new WebRTC({label: this.webrtcLabel});
-    let {promise, resolve} = Promise.withResolvers();
-    this.closed = promise;
-    const dataChannelPromise = webrtc.ensureDataChannel(this.channelName, {}, initialSignals);
-    dataChannelPromise.then(dataChannel => {
-      webrtc.reportConnection(true);
-      dataChannel.addEventListener('close', () => {
-	console.log(webrtc.label, 'connection closed');
-	this.connection = this.webrtc = null;
-	resolve(null);
-      });
-      dataChannel.addEventListener('message', event => this.receiveWebRTC(event.data));
-    });
-    return dataChannelPromise;
-  }
-  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.
-    const contact = this.host.noteContactForTransport(this);
-    //this.host.log('ensuring connection for', contact.sname, contact.connection ? 'exists' : 'must create');
-    if (contact.connection) return contact.connection;
-    contact.initiating = true;
-    //console.log('setting client contact connection promise');
-    return contact.connection = contact.constructor.serializer = contact.constructor.serializer.then(async () => { // TODO: do we need this serialization?
-      const { host, node, isServerNode, bootstrapHost } = contact;
-      // 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.
-      const dataChannelPromise = contact.ensureWebRTC(null);
-      await this.webrtc.signalsReady;      
-      let sponsor = contact.findSponsor(candidate => candidate.connection) ||
-	  contact.findSponsor(candidate => candidate.isServerNode);
-      try {
-	if (sponsor) {
-	  await contact.webrtc.connectVia(async signals => sponsor.sendRPC('forwardSignals', contact.key, host.contact.sname, ...signals));
-	} else if (bootstrapHost || !contact.isServerNode) {
-	  const url = `${bootstrapHost || 'http://localhost:3000/kdht'}/join/${this.host.contact.sname}/${this.sname}`;
-	  await contact.webrtc.connectVia(signals => this.fetchSignals(url, signals));
-	} else {
-	  console.error(`Cannot reach unsponsored contact ${contact.sname}.`);
-	  await contact.host.removeContact(contact);
-	  return contact.connection = contact.webrtc = null;
-	}
-      } catch (error) {
-	console.error(`${contact.webrtc.label} failed to connect through ${sponsor ? `sponsor ${sponsor.sname}` : `bootstrap ${bootstrapHost || contact.sname}`}`);
-	console.error(error);
-	return null;
-      }
-      return await dataChannelPromise;
-    });
-  }
-  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.initiating) return []; // TODO: is this the right response?
-    if (contact.webrtc) return await contact.webrtc.respond(signals); // TODO: move this and its counterpart on connect to ensureWebRTC?
-    this.host.noteContactForTransport(contact);
-    contact.connection = contact.ensureWebRTC(signals);
-    return await contact.webrtc.respond([]);
-  }
-  async send(message) { // Promise to send through previously opened connection promise.
-    return this.connection   // Connection could be reset to null  
-      ?.then(channel => channel?.send(JSON.stringify(message)))
-      .catch(error => console.error(this.host.contact.sname, error, error.stack)); 
-  }
-  getName(sname) { // Answer name from sname.
-    if (sname.startsWith(this.constructor.serverSignifier)) return sname.slice(1);
-    return sname;
-  }
-  async ensureRemoteContact(sname, sponsor = null) {
-    let contact;
-    if (sname === this.host.contact.sname) {
-      contact = this.host.contact; // ok, not remote, but contacts can send back us in a list of closest nodes.
-    }
-    const name = this.getName(sname);
-    if (!contact) {
-      // Not the final answer. Just an optimization to avoid hashing name.
-      contact = this.host.existingContact(name);
-    }
-    if (!contact) {
-      const isServerNode = name !== sname;
-      contact = await this.constructor.create({name, isServerNode}, this.host); // checks for existence AFTER creating Node.
-    }
-    if (sponsor instanceof Contact) contact.noteSponsor(sponsor);
-    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;
-      //console.log(this.host.contact.sname, this.host.key, 'received forwardingSignals from', sender.sname, 'on contact', this.sname, this.key, 'concerning', key);
-      if (key === this.host.key) { // for us!
-	//console.log(this.host.contact.sname, 'processing signals from', sendingSname, signals.map(s => s[0]));
-	return this.signals(...rest);
-      } else { // Forard to the target.
-	const target = this.host.findContactByKey(key);
-	if (!target) {
-	  //console.log(this.host.contact.same, 'does not have contact to', sendingSname);
-	  return null;
-	}
-	//if (this.debugCounter++ > 3) process.exit(1);
-	//console.log(this.host.contact.sname, 'forwarding signals from', sendingSname, signals.map(s => s[0]), 'to target', target.sname, key);
-	return target.sendRPC('forwardSignals', key, ...rest);
-      }
-    }
-    return super.receiveRPC(method, sender, key, ...rest);
-  }
-  //debugCounter = 0;
-  inFlight = new Map();
-  async transmitRPC(method, key, ...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));
-    // this.host.log('sending to', this.sname);
-    //console.log(this.host.contact.sname, 'sending', method, key, rest.map(s => Array.isArray(s) ? s[0] : s), 'to', this.sname);
-    this.send([messageTag, method, sender, key.toString(), ...rest]);
-    const response = await Promise.race([responsePromise, this.closed]);
-    // this.host.log('got response from', this.sname);
-    return response;
-  }
-  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.
-    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);
-      //this.host.log('received response', result);
-      if (Array.isArray(result)) {
-	if (!result.length) responder(result);
-	const first = result[0];
-	const isSignal = Array.isArray(first) && ['offer', 'answer', 'icecandidate'].includes(first[0]);
-	//console.log(this.host.contact.sname, 'got rpc response on contact', this.sname, isSignal, result.map(s => Array.isArray(s) ? s[0] : s));
-	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);
-      //this.host.log('dispatched', method, 'from', sender.sname);
-      let response = await this.receiveRPC(method, sender, BigInt(key), ...rest);
-      //if (method === 'forwardSignals') console.log(this.host.contact.sname, 'incoming signals through', this.sname, 'originating from', rest[0]);
-      if ((method !== 'forwardSignals') && this.host.constructor.isContactsResult(response)) {
-	response = response.map(helper => [helper.contact.sname, helper.distance.toString()]);
-      }
-      this.send([messageTag, response]);
-    }
-  }
-  disconnectTransport() {
-    this.webrtc?.close();
-  }
-}