feat: limit scope of queries to k closest peers (#97)

* feat: limit scope of queries to k closest peers

.aegir.js

@@ -1,4 +1,4 @@
 module.exports = {
-    bundlesize: { maxSize: '191kB' }
+    bundlesize: { maxSize: '192kB' }
 }
 

src/constants.js

@@ -28,7 +28,7 @@ exports.READ_MESSAGE_TIMEOUT = minute
 // The number of records that will be retrieved on a call to getMany()
 exports.GET_MANY_RECORD_COUNT = 16
 
-// K is the maximum number of requests to perform before returning failue
+// K is the maximum number of requests to perform before returning failure
 exports.K = 20
 
 // Alpha is the concurrency for asynchronous requests

src/index.js

@@ -72,14 +72,14 @@ class KadDHT extends EventEmitter {
      *
      * @type {number}
      */
-    this.kBucketSize = options.kBucketSize || 20
+    this.kBucketSize = options.kBucketSize || c.K
 
     /**
-     * Number of closest peers to return on kBucket search, default 6
+     * Number of closest peers to return on kBucket search, default 20
      *
      * @type {number}
      */
-    this.ncp = options.ncp || 6
+    this.ncp = options.ncp || c.K
 
     /**
      * The routing table.

src/peer-distance-list.js

@@ -0,0 +1,101 @@
+'use strict'
+
+const distance = require('xor-distance')
+const utils = require('./utils')
+const map = require('async/map')
+
+/**
+ * Maintains a list of peerIds sorted by distance from a DHT key.
+ */
+class PeerDistanceList {
+  /**
+   * Creates a new PeerDistanceList.
+   *
+   * @param {Buffer} originDhtKey - the DHT key from which distance is calculated
+   * @param {number} capacity - the maximum size of the list
+   */
+  constructor (originDhtKey, capacity) {
+    this.originDhtKey = originDhtKey
+    this.capacity = capacity
+    this.peerDistances = []
+  }
+
+  /**
+   * The length of the list
+   */
+  get length () {
+    return this.peerDistances.length
+  }
+
+  /**
+   * The peerIds in the list, in order of distance from the origin key
+   */
+  get peers () {
+    return this.peerDistances.map(pd => pd.peerId)
+  }
+
+  /**
+   * Add a peerId to the list.
+   *
+   * @param {PeerId} peerId
+   * @param {function(Error)} callback
+   * @returns {void}
+   */
+  add (peerId, callback) {
+    if (this.peerDistances.find(pd => pd.peerId.id.equals(peerId.id))) {
+      return callback()
+    }
+
+    utils.convertPeerId(peerId, (err, dhtKey) => {
+      if (err) {
+        return callback(err)
+      }
+
+      const el = {
+        peerId,
+        distance: distance(this.originDhtKey, dhtKey)
+      }
+
+      this.peerDistances.push(el)
+      this.peerDistances.sort((a, b) => distance.compare(a.distance, b.distance))
+      this.peerDistances = this.peerDistances.slice(0, this.capacity)
+
+      callback()
+    })
+  }
+
+  /**
+   * Indicates whether any of the peerIds passed as a parameter are closer
+   * to the origin key than the furthest peerId in the PeerDistanceList.
+   *
+   * @param {Array<PeerId>} peerIds
+   * @param {function(Error, Boolean)} callback
+   * @returns {void}
+   */
+  anyCloser (peerIds, callback) {
+    if (!peerIds.length) {
+      return callback(null, false)
+    }
+
+    if (!this.length) {
+      return callback(null, true)
+    }
+
+    map(peerIds, (peerId, cb) => utils.convertPeerId(peerId, cb), (err, dhtKeys) => {
+      if (err) {
+        return callback(err)
+      }
+
+      const furthestDistance = this.peerDistances[this.peerDistances.length - 1].distance
+      for (const dhtKey of dhtKeys) {
+        const keyDistance = distance(this.originDhtKey, dhtKey)
+        if (distance.compare(keyDistance, furthestDistance) < 0) {
+          return callback(null, true)
+        }
+      }
+      return callback(null, false)
+    })
+  }
+}
+
+module.exports = PeerDistanceList