dht-rpc 6.6.3 → 6.8.0

package/README.md

@@ -178,6 +178,9 @@ it will switch from persistent mode to ephemeral again.
 
 Emitted when the network interfaces of the computer change.
 
+#### `node.on('nat-update', (host, port) => {})`
+Emitted when `node.host` or `node.port` were changed.
+
 #### `node.on('close')`
 
 Will be emitted after `node.destroy()` is completed.
@@ -340,6 +343,14 @@ Get the routing table peers out as an array of `{ host, port }`
 
 Manually add a node to the routing table.
 
+#### `await node.suspend()`
+
+Tell the DHT you are going to background (ie suspend and allow it to make preperations for that)
+
+#### `await node.resume()`
+
+Tell the DHT you are resuming from suspension.
+
 ## License
 
 MIT

package/index.js

@@ -27,7 +27,7 @@ class DHT extends EventEmitter {
     super()
 
     this.bootstrapNodes = opts.bootstrap === false ? [] : (opts.bootstrap || []).map(parseNode)
-    this.table = new Table(opts.id || randomBytes(32))
+    this.table = new Table(randomBytes(32))
     this.nodes = new TOS()
     this.udx = opts.udx || new UDX()
     this.io = new IO(this.table, this.udx, {
@@ -39,10 +39,11 @@ class DHT extends EventEmitter {
 
     this.concurrency = opts.concurrency || 10
     this.bootstrapped = false
-    this.ephemeral = opts.id ? !!opts.ephemeral : true
+    this.ephemeral = true
     this.firewalled = this.io.firewalled
     this.adaptive = typeof opts.ephemeral !== 'boolean' && opts.adaptive !== false
     this.destroyed = false
+    this.suspended = false
 
     this._nat = new NatSampler()
     this._quickFirewall = opts.quickFirewall !== false
@@ -63,7 +64,6 @@ class DHT extends EventEmitter {
 
     this.table.on('row', this._onrow)
 
-    if (this.ephemeral === false) this.io.ephemeral = false
     this.io.networkInterfaces.on('change', (interfaces) => this._onnetworkchange(interfaces))
 
     if (opts.nodes) {
@@ -74,8 +74,12 @@ class DHT extends EventEmitter {
   static bootstrapper (port, host, opts) {
     if (!port) throw new Error('Port is required')
     if (!host) throw new Error('Host is required')
-    const id = peer.id(host, port)
-    return new this({ port, id, ephemeral: false, firewalled: false, anyPort: false, bootstrap: [], ...opts })
+    if (host === '0.0.0.0' || host === '::') throw new Error('Invalid host')
+    if (!UDX.isIPv4(host)) throw new Error('Host must be a IPv4 address')
+
+    const dht = new this({ port, ephemeral: false, firewalled: false, anyPort: false, bootstrap: [], ...opts })
+    dht._nat.add(host, port)
+    return dht
   }
 
   get id () {
@@ -102,6 +106,23 @@ class DHT extends EventEmitter {
     return this.io.bind()
   }
 
+  async suspend () {
+    await this.io.bind()
+    if (this.suspended || this.destroyed) return
+    this.suspended = false
+    this.io.suspend()
+    this.emit('suspend')
+  }
+
+  async resume () {
+    if (!this.suspended || this.destroyed) return
+    this.suspended = false
+    this._onwakeup()
+    await this.io.resume()
+    this.refresh()
+    this.emit('resume')
+  }
+
   address () {
     const socket = this.socket
     return socket ? socket.address() : null
@@ -173,12 +194,12 @@ class DHT extends EventEmitter {
 
     if (opts && opts.size && opts.size > 0) value = b4a.alloc(opts.size)
 
-    const req = this.io.createRequest({ id: null, host, port }, null, true, PING, null, value, (opts && opts.session) || null)
+    const req = this.io.createRequest({ id: null, host, port }, null, true, PING, null, value, (opts && opts.session) || null, (opts && opts.ttl))
     return this._requestToPromise(req, opts)
   }
 
   request ({ token = null, command, target = null, value = null }, { host, port }, opts) {
-    const req = this.io.createRequest({ id: null, host, port }, token, false, command, target, value, (opts && opts.session) || null)
+    const req = this.io.createRequest({ id: null, host, port }, token, false, command, target, value, (opts && opts.session) || null, (opts && opts.ttl))
     return this._requestToPromise(req, opts)
   }
 
@@ -267,13 +288,24 @@ class DHT extends EventEmitter {
     return req
   }
 
+  _natAdd (host, port) {
+    const prevHost = this._nat.host
+    const prevPort = this._nat.port
+
+    this._nat.add(host, port)
+
+    if (prevHost === this._nat.host && prevPort === this._nat.port) return
+
+    this.emit('nat-update', this._nat.host, this._nat.port)
+  }
+
   // we don't check that this is a bootstrap node but we limit the sample size to very few nodes, so fine
   _sampleBootstrapMaybe (from, to) {
     if (this._nonePersistentSamples.length >= Math.max(1, this.bootstrapNodes.length)) return
     const id = from.host + ':' + from.port
     if (this._nonePersistentSamples.indexOf(id) > -1) return
     this._nonePersistentSamples.push(id)
-    this._nat.add(to.host, to.port)
+    this._natAdd(to.host, to.port)
   }
 
   _addNodeFromNetwork (sample, from, to) {
@@ -293,7 +325,7 @@ class DHT extends EventEmitter {
       if (sample && (oldNode.sampled === 0 || (this._tick - oldNode.sampled) >= OLD_NODE)) {
         oldNode.to = to
         oldNode.sampled = this._tick
-        this._nat.add(to.host, to.port)
+        this._natAdd(to.host, to.port)
       }
 
       oldNode.pinged = oldNode.seen = this._tick
@@ -326,7 +358,7 @@ class DHT extends EventEmitter {
 
     if (node.to && node.sampled === 0) {
       node.sampled = this._tick
-      this._nat.add(node.to.host, node.to.port)
+      this._natAdd(node.to.host, node.to.port)
     }
 
     this.emit('add-node', node)
@@ -352,10 +384,15 @@ class DHT extends EventEmitter {
     this._refreshTicks = 1 // triggers a refresh next tick (allow network time to wake up also)
     this._lastHost = null // clear network cache check
 
-    if (this.adaptive && !this.ephemeral) {
-      this.ephemeral = true
-      this.io.ephemeral = true
-      this.emit('ephemeral')
+    if (this.adaptive) {
+      this.firewalled = true
+      this.io.firewalled = true
+
+      if (!this.ephemeral) {
+        this.ephemeral = true
+        this.io.ephemeral = true
+        this.emit('ephemeral')
+      }
     }
 
     this.emit('wakeup')
@@ -510,7 +547,7 @@ class DHT extends EventEmitter {
   _ontick () {
     const time = Date.now()
 
-    if (time - this._lastTick > SLEEPING_INTERVAL) {
+    if (time - this._lastTick > SLEEPING_INTERVAL && this.suspended === false) {
       this._onwakeup()
     } else {
       this._tick++
@@ -518,7 +555,7 @@ class DHT extends EventEmitter {
 
     this._lastTick = time
 
-    if (!this.bootstrapped) return
+    if (!this.bootstrapped || this.suspended) return
 
     if (this.adaptive && this.ephemeral && --this._stableTicks <= 0) {
       if (this._lastHost === this._nat.host) { // do not recheck the same network...
@@ -574,8 +611,15 @@ class DHT extends EventEmitter {
     }
 
     if (natSampler !== this._nat) {
+      const prevHost = this._nat.host
+      const prevPort = this._nat.port
+
       this._nonePersistentSamples = []
       this._nat = natSampler
+
+      if (prevHost !== this._nat.host || prevPort !== this._nat.port) {
+        this.emit('nat-update', this._nat.host, this._nat.port)
+      }
     }
 
     // TODO: we should make this a bit more defensive in terms of using more

package/lib/errors.js

@@ -7,6 +7,12 @@ exports.createTimeoutError = () => {
   return timeoutErr
 }
 
+exports.createSuspendError = () => {
+  const suspendErr = new Error('Suspended')
+  suspendErr.code = 'ESUSPENDED'
+  return suspendErr
+}
+
 exports.createDestroyedError = () => {
   const destroyErr = new Error('Request destroyed')
   destroyErr.code = 'EDESTROYED'

package/lib/io.js

@@ -37,6 +37,8 @@ module.exports = class IO {
     this._port = port
     this._host = host
     this._anyPort = anyPort !== false
+    this._boundServerPort = 0
+    this._boundClientPort = 0
   }
 
   onmessage (socket, buffer, { host, port }) {
@@ -108,7 +110,10 @@ module.exports = class IO {
   async _destroy () {
     // simplifies timing to await the bind here also, although it might be unneeded
     await this.bind()
+    await this._clear(false)
+  }
 
+  async _clear (suspended) {
     if (this._drainInterval) {
       clearInterval(this._drainInterval)
       this._drainInterval = null
@@ -122,14 +127,35 @@ module.exports = class IO {
 
       if (req.session) req.session._detach(req)
 
-      req.onerror(errors.createDestroyedError(), req)
+      req.onerror(suspended ? errors.createSuspendError() : errors.createDestroyedError(), req)
     }
 
     await Promise.allSettled([
       this.serverSocket.close(),
-      this.clientSocket.close(),
-      this.networkInterfaces.destroy()
+      this.clientSocket.close()
     ])
+
+    if (!suspended) this.networkInterfaces.destroy()
+  }
+
+  async _rebind (binding) {
+    if (binding) await binding
+    if (this._destroying) return this._destroying
+    await this._clear(true)
+    await this._bindSockets()
+  }
+
+  suspend () {
+    if (this._drainInterval) {
+      clearInterval(this._drainInterval)
+      this._drainInterval = null
+    }
+  }
+
+  resume () {
+    const binding = this._binding
+    this._binding = this._rebind(binding)
+    return this._binding
   }
 
   bind () {
@@ -142,7 +168,7 @@ module.exports = class IO {
     const serverSocket = this.udx.createSocket()
 
     try {
-      serverSocket.bind(this._port, this._host)
+      serverSocket.bind(this._boundServerPort || this._port, this._host)
     } catch (err) {
       if (!this._anyPort) {
         await serverSocket.close()
@@ -160,13 +186,20 @@ module.exports = class IO {
     const clientSocket = this.udx.createSocket()
 
     try {
-      clientSocket.bind(0, this._host)
-    } catch (err) {
-      await serverSocket.close()
-      await clientSocket.close()
-      throw err
+      clientSocket.bind(this._boundClientPort || 0, this._host)
+    } catch {
+      try {
+        clientSocket.bind(0, this._host)
+      } catch (err) {
+        await serverSocket.close()
+        await clientSocket.close()
+        throw err
+      }
     }
 
+    this._boundServerPort = serverSocket.address().port
+    this._boundClientPort = clientSocket.address().port
+
     this.clientSocket = clientSocket
     this.serverSocket = serverSocket
 
@@ -203,7 +236,7 @@ module.exports = class IO {
     }
   }
 
-  createRequest (to, token, internal, command, target, value, session) {
+  createRequest (to, token, internal, command, target, value, session, ttl) {
     if (this._destroying !== null) return null
 
     if (this._tid === 65536) this._tid = 0
@@ -211,7 +244,7 @@ module.exports = class IO {
     const tid = this._tid++
     const socket = this.firewalled ? this.clientSocket : this.serverSocket
 
-    const req = new Request(this, socket, tid, null, to, token, internal, command, target, value, session)
+    const req = new Request(this, socket, tid, null, to, token, internal, command, target, value, session, ttl || 0)
     this.inflight.push(req)
     if (session) session._attach(req)
     return req
@@ -219,7 +252,7 @@ module.exports = class IO {
 }
 
 class Request {
-  constructor (io, socket, tid, from, to, token, internal, command, target, value, session) {
+  constructor (io, socket, tid, from, to, token, internal, command, target, value, session, ttl) {
     this.socket = socket
     this.tid = tid
     this.from = from
@@ -230,6 +263,7 @@ class Request {
     this.value = value
     this.internal = internal
     this.session = session
+    this.ttl = ttl
     this.index = -1
     this.sent = 0
     this.retries = 3
@@ -258,7 +292,7 @@ class Request {
 
       if (id !== null) from.id = validateId(id, from)
 
-      return new Request(io, socket, tid, from, to, token, internal, command, target, value, null)
+      return new Request(io, socket, tid, from, to, token, internal, command, target, value, null, 0)
     } catch {
       return null
     }
@@ -279,7 +313,7 @@ class Request {
   relay (value, to, opts) {
     const socket = (opts && opts.socket) || this.socket
     const buffer = this._encodeRequest(null, value, to, socket)
-    socket.trySend(buffer, to.port, to.host)
+    socket.trySend(buffer, to.port, to.host, this.ttl)
   }
 
   send (force = false) {
@@ -304,7 +338,7 @@ class Request {
     if (this.destroyed) return
     this.sent++
     this._io.congestion.send()
-    this.socket.trySend(this._buffer, this.to.port, this.to.host)
+    this.socket.trySend(this._buffer, this.to.port, this.to.host, this.ttl)
     if (this._timeout) clearTimeout(this._timeout)
     this._timeout = setTimeout(oncycle, 1000, this)
   }
@@ -355,7 +389,7 @@ class Request {
     if (error > 0) c.uint.encode(state, error)
     if (value) c.buffer.encode(state, value)
 
-    socket.trySend(state.buffer, from.port, from.host)
+    socket.trySend(state.buffer, from.port, from.host, this.ttl)
   }
 
   _encodeRequest (token, value, to, socket) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dht-rpc",
-  "version": "6.6.3",
+  "version": "6.8.0",
   "description": "Make RPC calls over a Kademlia based DHT",
   "main": "index.js",
   "files": [