refactor: dht async/await (#480)

* refactor: core async (#478)

* refactor: cleanup core

test: auto dial on startup

* fix: make hangup work properly

* chore: fix lint

* chore: apply suggestions from code review

Co-Authored-By: Vasco Santos <vasco.santos@moxy.studio>

* fix: provide libp2p dialer to the dht

* chore: use dht release

test/dht/configuration.node.js

@@ -0,0 +1,92 @@
+'use strict'
+/* eslint-env mocha */
+
+const chai = require('chai')
+chai.use(require('dirty-chai'))
+const { expect } = chai
+
+const mergeOptions = require('merge-options')
+const multiaddr = require('multiaddr')
+
+const { create } = require('../../src')
+const { baseOptions, subsystemOptions } = require('./utils')
+const peerUtils = require('../utils/creators/peer')
+
+const listenAddr = multiaddr('/ip4/127.0.0.1/tcp/0')
+
+describe('DHT subsystem is configurable', () => {
+  let libp2p
+
+  afterEach(async () => {
+    libp2p && await libp2p.stop()
+  })
+
+  it('should not exist if no module is provided', async () => {
+    libp2p = await create(baseOptions)
+    expect(libp2p._dht).to.not.exist()
+  })
+
+  it('should exist if the module is provided', async () => {
+    libp2p = await create(subsystemOptions)
+    expect(libp2p._dht).to.exist()
+  })
+
+  it('should start and stop by default once libp2p starts', async () => {
+    const [peerInfo] = await peerUtils.createPeerInfoFromFixture(1)
+    peerInfo.multiaddrs.add(listenAddr)
+
+    const customOptions = mergeOptions(subsystemOptions, {
+      peerInfo
+    })
+
+    libp2p = await create(customOptions)
+    expect(libp2p._dht._dht.isStarted).to.equal(false)
+
+    await libp2p.start()
+    expect(libp2p._dht._dht.isStarted).to.equal(true)
+
+    await libp2p.stop()
+    expect(libp2p._dht._dht.isStarted).to.equal(false)
+  })
+
+  it('should not start if disabled once libp2p starts', async () => {
+    const [peerInfo] = await peerUtils.createPeerInfoFromFixture(1)
+    peerInfo.multiaddrs.add(listenAddr)
+
+    const customOptions = mergeOptions(subsystemOptions, {
+      peerInfo,
+      config: {
+        dht: {
+          enabled: false
+        }
+      }
+    })
+
+    libp2p = await create(customOptions)
+    expect(libp2p._dht._dht.isStarted).to.equal(false)
+
+    await libp2p.start()
+    expect(libp2p._dht._dht.isStarted).to.equal(false)
+  })
+
+  it('should allow a manual start', async () => {
+    const [peerInfo] = await peerUtils.createPeerInfoFromFixture(1)
+    peerInfo.multiaddrs.add(listenAddr)
+
+    const customOptions = mergeOptions(subsystemOptions, {
+      peerInfo,
+      config: {
+        dht: {
+          enabled: false
+        }
+      }
+    })
+
+    libp2p = await create(customOptions)
+    await libp2p.start()
+    expect(libp2p._dht._dht.isStarted).to.equal(false)
+
+    await libp2p._dht.start()
+    expect(libp2p._dht._dht.isStarted).to.equal(true)
+  })
+})

test/dht/operation.node.js

@@ -0,0 +1,135 @@
+'use strict'
+/* eslint-env mocha */
+
+const chai = require('chai')
+chai.use(require('dirty-chai'))
+const { expect } = chai
+
+const pWaitFor = require('p-wait-for')
+const mergeOptions = require('merge-options')
+const multiaddr = require('multiaddr')
+
+const { create } = require('../../src')
+const { subsystemOptions, subsystemMulticodecs } = require('./utils')
+const peerUtils = require('../utils/creators/peer')
+
+const listenAddr = multiaddr('/ip4/127.0.0.1/tcp/8000')
+const remoteListenAddr = multiaddr('/ip4/127.0.0.1/tcp/8001')
+
+describe('DHT subsystem operates correctly', () => {
+  let peerInfo, remotePeerInfo
+  let libp2p, remoteLibp2p
+  let remAddr
+
+  beforeEach(async () => {
+    [peerInfo, remotePeerInfo] = await peerUtils.createPeerInfoFromFixture(2)
+
+    peerInfo.multiaddrs.add(listenAddr)
+    remotePeerInfo.multiaddrs.add(remoteListenAddr)
+  })
+
+  describe('dht started before connect', () => {
+    beforeEach(async () => {
+      libp2p = await create(mergeOptions(subsystemOptions, {
+        peerInfo
+      }))
+
+      remoteLibp2p = await create(mergeOptions(subsystemOptions, {
+        peerInfo: remotePeerInfo
+      }))
+
+      await Promise.all([
+        libp2p.start(),
+        remoteLibp2p.start()
+      ])
+
+      remAddr = remoteLibp2p.transportManager.getAddrs()[0]
+    })
+
+    afterEach(() => Promise.all([
+      libp2p && libp2p.stop(),
+      remoteLibp2p && remoteLibp2p.stop()
+    ]))
+
+    it('should get notified of connected peers on dial', async () => {
+      const connection = await libp2p.dialProtocol(remAddr, subsystemMulticodecs)
+
+      expect(connection).to.exist()
+
+      return Promise.all([
+        pWaitFor(() => libp2p._dht._dht.routingTable.size === 1),
+        pWaitFor(() => remoteLibp2p._dht._dht.routingTable.size === 1)
+      ])
+    })
+
+    it('should put on a peer and get from the other', async () => {
+      const key = Buffer.from('hello')
+      const value = Buffer.from('world')
+
+      await libp2p.dialProtocol(remAddr, subsystemMulticodecs)
+
+      await Promise.all([
+        pWaitFor(() => libp2p._dht._dht.routingTable.size === 1),
+        pWaitFor(() => remoteLibp2p._dht._dht.routingTable.size === 1)
+      ])
+
+      await libp2p._dht.put(key, value)
+
+      const fetchedValue = await remoteLibp2p._dht.get(key)
+      expect(fetchedValue).to.eql(value)
+    })
+  })
+
+  describe('dht started after connect', () => {
+    beforeEach(async () => {
+      libp2p = await create(mergeOptions(subsystemOptions, {
+        peerInfo
+      }))
+
+      remoteLibp2p = await create(mergeOptions(subsystemOptions, {
+        peerInfo: remotePeerInfo,
+        config: {
+          dht: {
+            enabled: false
+          }
+        }
+      }))
+
+      await libp2p.start()
+      await remoteLibp2p.start()
+
+      remAddr = remoteLibp2p.transportManager.getAddrs()[0]
+    })
+
+    afterEach(() => Promise.all([
+      libp2p && libp2p.stop(),
+      remoteLibp2p && remoteLibp2p.stop()
+    ]))
+
+    it('should get notified of connected peers after starting', async () => {
+      const connection = await libp2p.dial(remAddr)
+
+      expect(connection).to.exist()
+      expect(libp2p._dht._dht.routingTable.size).to.be.eql(0)
+      expect(remoteLibp2p._dht._dht.routingTable.size).to.be.eql(0)
+
+      await remoteLibp2p._dht.start()
+      return pWaitFor(() => libp2p._dht._dht.routingTable.size === 1)
+    })
+
+    it('should put on a peer and get from the other', async () => {
+      await libp2p.dial(remAddr)
+
+      const key = Buffer.from('hello')
+      const value = Buffer.from('world')
+
+      await remoteLibp2p._dht.start()
+      await pWaitFor(() => libp2p._dht._dht.routingTable.size === 1)
+
+      await libp2p._dht.put(key, value)
+
+      const fetchedValue = await remoteLibp2p._dht.get(key)
+      expect(fetchedValue).to.eql(value)
+    })
+  })
+})

test/dht/utils.js

@@ -0,0 +1,37 @@
+'use strict'
+
+const KadDht = require('libp2p-kad-dht')
+const { multicodec } = require('libp2p-kad-dht')
+const Crypto = require('../../src/insecure/plaintext')
+const Muxer = require('libp2p-mplex')
+const Transport = require('libp2p-tcp')
+
+const mergeOptions = require('merge-options')
+
+const baseOptions = {
+  modules: {
+    transport: [Transport],
+    streamMuxer: [Muxer],
+    connEncryption: [Crypto]
+  }
+}
+
+module.exports.baseOptions = baseOptions
+
+const subsystemOptions = mergeOptions(baseOptions, {
+  modules: {
+    dht: KadDht
+  },
+  config: {
+    dht: {
+      kBucketSize: 20,
+      randomWalk: {
+        enabled: true
+      },
+      enabled: true
+    }
+  }
+})
+
+module.exports.subsystemOptions = subsystemOptions
+module.exports.subsystemMulticodecs = [multicodec]

test/dialing/direct.node.js

@@ -17,6 +17,7 @@ const pipe = require('it-pipe')
 
 const Libp2p = require('../../src')
 const Dialer = require('../../src/dialer')
+const PeerStore = require('../../src/peer-store')
 const TransportManager = require('../../src/transport-manager')
 const { codes: ErrorCodes } = require('../../src/errors')
 const Protector = require('../../src/pnet')
@@ -86,7 +87,7 @@ describe('Dialing (direct, TCP)', () => {
     expect.fail('Dial should have failed')
   })
 
-  it('should be able to connect to a given peer', async () => {
+  it('should be able to connect to a given peer info', async () => {
     const dialer = new Dialer({ transportManager: localTM })
     const peerId = await PeerId.createFromJSON(Peers[0])
     const peerInfo = new PeerInfo(peerId)
@@ -97,6 +98,23 @@ describe('Dialing (direct, TCP)', () => {
     await connection.close()
   })
 
+  it('should be able to connect to a given peer id', async () => {
+    const peerStore = new PeerStore()
+    const dialer = new Dialer({
+      transportManager: localTM,
+      peerStore
+    })
+
+    const peerId = await PeerId.createFromJSON(Peers[0])
+    const peerInfo = new PeerInfo(peerId)
+    peerInfo.multiaddrs.add(remoteAddr)
+    peerStore.put(peerInfo)
+
+    const connection = await dialer.connectToPeer(peerId)
+    expect(connection).to.exist()
+    await connection.close()
+  })
+
   it('should fail to connect to a given peer with unsupported addresses', async () => {
     const dialer = new Dialer({ transportManager: localTM })
     const peerId = await PeerId.createFromJSON(Peers[0])