feat: adds custom multicodec protocol option (#206)

Author: HexaField

README.md

@@ -48,6 +48,28 @@ See https://libp2p.github.io/js-libp2p-kad-dht for the auto generated docs.
 
 The libp2p-kad-dht module offers 3 APIs: Peer Routing, Content Routing and Peer Discovery.
 
+### Custom secondary DHT in libp2p
+
+```js
+/**
+ * @param {Libp2p} libp2p
+ */
+function addDHT(libp2p) {
+    const customDHT = new KadDHT({
+        libp2p,
+        dialer: libp2p.dialer,
+        peerId: libp2p.peerId,
+        peerStore: libp2p.peerStore,
+        registrar: libp2p.registrar,
+        protocolPrefix: '/custom'
+    })
+    customDHT.start()
+    customDHT.on('peer', libp2p._onDiscoveryPeer)
+    return customDHT
+}
+```
+
+Note that you may want to supply your own peer discovery function and datastore
 ### Peer Routing
 
 [![](https://raw.githubusercontent.com/libp2p/js-libp2p-interfaces/master/src/peer-routing/img/badge.png)](https://github.com/libp2p/js-libp2p-interfaces/tree/master/src/peer-routing)

src/constants.js

@@ -13,7 +13,7 @@ const hour = exports.hour = 60 * minute
 
 exports.MAX_RECORD_AGE = 36 * hour
 
-exports.PROTOCOL_DHT = '/ipfs/kad/1.0.0'
+exports.PROTOCOL_DHT = '/kad/1.0.0'
 
 exports.PROVIDERS_KEY_PREFIX = '/providers/'
 

src/index.js

@@ -47,6 +47,8 @@ class KadDHT extends EventEmitter {
    * @param {function} props.registrar.handle
    * @param {function} props.registrar.register
    * @param {function} props.registrar.unregister
+   * @param {string} [props.protocolPrefix = '/ipfs'] libp2p registrar handle protocol
+   * @param {boolean} [props.forceProtocolLegacy = false] WARNING: this is not recommended and should only be used for legacy purposes
    * @param {number} props.kBucketSize k-bucket size (default 20)
    * @param {boolean} props.clientMode If true, the DHT will not respond to queries. This should be true if your node will not be dialable. (default: false)
    * @param {number} props.concurrency alpha concurrency of queries (default 3)
@@ -63,6 +65,8 @@ class KadDHT extends EventEmitter {
     peerId,
     peerStore,
     registrar,
+    protocolPrefix = '/ipfs',
+    forceProtocolLegacy = false,
     datastore = new MemoryDatastore(),
     kBucketSize = c.K,
     clientMode = false,
@@ -109,6 +113,12 @@ class KadDHT extends EventEmitter {
      */
     this.registrar = registrar
 
+    /**
+     * Registrar protocol
+     * @type {string}
+     */
+    this.protocol = protocolPrefix + (forceProtocolLegacy ? '' : c.PROTOCOL_DHT)
+
     /**
      * k-bucket size
      *
@@ -553,4 +563,4 @@ class KadDHT extends EventEmitter {
 }
 
 module.exports = KadDHT
-module.exports.multicodec = c.PROTOCOL_DHT
+module.exports.multicodec = '/ipfs' + c.PROTOCOL_DHT

src/network.js

@@ -50,12 +50,12 @@ class Network {
     // Only respond to queries when not in client mode
     if (this.dht._clientMode === false) {
       // Incoming streams
-      this.dht.registrar.handle(c.PROTOCOL_DHT, this._rpc)
+      this.dht.registrar.handle(this.dht.protocol, this._rpc)
     }
 
     // register protocol with topology
     const topology = new MulticodecTopology({
-      multicodecs: [c.PROTOCOL_DHT],
+      multicodecs: [this.dht.protocol],
       handlers: {
         onConnect: this._onPeerConnected,
         onDisconnect: () => {}
@@ -129,7 +129,7 @@ class Network {
       conn = await this.dht.dialer.connectToPeer(to)
     }
 
-    const { stream } = await conn.newStream(c.PROTOCOL_DHT)
+    const { stream } = await conn.newStream(this.dht.protocol)
 
     return this._writeReadMessage(stream, msg.serialize())
   }
@@ -153,7 +153,7 @@ class Network {
     if (!conn) {
       conn = await this.dht.dialer.connectToPeer(to)
     }
-    const { stream } = await conn.newStream(c.PROTOCOL_DHT)
+    const { stream } = await conn.newStream(this.dht.protocol)
 
     return this._writeMessage(stream, msg.serialize())
   }

test/kad-dht.spec.js

@@ -957,5 +957,46 @@ describe('KadDHT', () => {
       }
       throw new Error('get should handle correctly an invalid record error and return not found')
     })
+
+    it('should not find peers with different protocols', async function () {
+      this.timeout(40 * 1000)
+
+      const protocol1 = '/test1'
+      const protocol2 = '/test2'
+
+      const tdht = new TestDHT()
+      const dhts = []
+      dhts.push(...await tdht.spawn(2, { protocolPrefix: protocol1 }))
+      dhts.push(...await tdht.spawn(2, { protocolPrefix: protocol2 }))
+
+      // Connect all
+      await Promise.all([
+        tdht.connect(dhts[0], dhts[1]),
+        tdht.connect(dhts[1], dhts[2]),
+        tdht.connect(dhts[2], dhts[3])
+      ])
+
+      try {
+        const ids = dhts.map((d) => d.peerId)
+        await dhts[0].findPeer(ids[3], { timeout: 1000 })
+      } catch (err) {
+        expect(err).to.exist()
+        expect(err.code).to.eql('ERR_NOT_FOUND')
+        return tdht.teardown()
+      }
+      throw new Error('seperate protocols should have their own topologies and communication streams')
+    })
+
+    it('force legacy protocol', async function () {
+      this.timeout(40 * 1000)
+
+      const protocol = '/test/dht/0.0.0'
+
+      const tdht = new TestDHT()
+      const [dht] = await tdht.spawn(1, { protocolPrefix: protocol, forceProtocolLegacy: true })
+
+      expect(dht.protocol).to.eql(protocol)
+      return tdht.teardown()
+    })
   })
 })

test/utils/test-dht.js

@@ -35,6 +35,7 @@ class TestDHT {
       randomWalk: {
         enabled: false
       },
+      protocolPrefix: '/ipfs',
       ...options
     }
 
@@ -46,10 +47,10 @@ class TestDHT {
         (node) => node.peerId.toB58String() === remotePeerB58
       )
 
-      const localOnConnect = regRecord[PROTOCOL_DHT].onConnect
-      const remoteOnConnect = remoteDht.regRecord[PROTOCOL_DHT].onConnect
+      const localOnConnect = regRecord[options.protocolPrefix + PROTOCOL_DHT].onConnect
+      const remoteOnConnect = remoteDht.regRecord[options.protocolPrefix + PROTOCOL_DHT].onConnect
 
-      const remoteHandler = remoteDht.regRecord[PROTOCOL_DHT].handler
+      const remoteHandler = remoteDht.regRecord[options.protocolPrefix + PROTOCOL_DHT].handler
 
       // Notice peers of connection
       const [c0, c1] = ConnectionPair()
@@ -65,7 +66,7 @@ class TestDHT {
           if (!localDHT._clientMode) await remoteOnConnect(peerId, c0)
 
           await remoteHandler({
-            protocol: PROTOCOL_DHT,
+            protocol: options.protocolPrefix + PROTOCOL_DHT,
             stream: c0.stream,
             connection: {
               remotePeer: peerId
@@ -116,8 +117,8 @@ class TestDHT {
   }
 
   async connect (dhtA, dhtB) {
-    const onConnectA = dhtA.regRecord[PROTOCOL_DHT].onConnect
-    const onConnectB = dhtB.regRecord[PROTOCOL_DHT].onConnect
+    const onConnectA = dhtA.regRecord[dhtA.protocol].onConnect
+    const onConnectB = dhtB.regRecord[dhtB.protocol].onConnect
 
     const [c0, c1] = ConnectionPair()