refactor: pubsub (#467)

* feat: peer-store v0

* chore: apply suggestions from code review

Co-Authored-By: Jacob Heun <jacobheun@gmail.com>

* chore: address review

* refactor: pubsub subsystem

* chore: address review

* chore: use topology interface

* chore: address review

* chore: address review

* chore: simplify tests

test/pubsub/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('Pubsub 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.pubsub).to.not.exist()
+  })
+
+  it('should exist if the module is provided', async () => {
+    libp2p = await create(subsystemOptions)
+    expect(libp2p.pubsub).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.pubsub._pubsub.started).to.equal(false)
+
+    await libp2p.start()
+    expect(libp2p.pubsub._pubsub.started).to.equal(true)
+
+    await libp2p.stop()
+    expect(libp2p.pubsub._pubsub.started).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: {
+        pubsub: {
+          enabled: false
+        }
+      }
+    })
+
+    libp2p = await create(customOptions)
+    expect(libp2p.pubsub._pubsub.started).to.equal(false)
+
+    await libp2p.start()
+    expect(libp2p.pubsub._pubsub.started).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: {
+        pubsub: {
+          enabled: false
+        }
+      }
+    })
+
+    libp2p = await create(customOptions)
+    await libp2p.start()
+    expect(libp2p.pubsub._pubsub.started).to.equal(false)
+
+    await libp2p.pubsub.start()
+    expect(libp2p.pubsub._pubsub.started).to.equal(true)
+  })
+})

test/pubsub/implementations.node.js

@@ -0,0 +1,95 @@
+'use strict'
+/* eslint-env mocha */
+
+const chai = require('chai')
+chai.use(require('dirty-chai'))
+const { expect } = chai
+
+const pWaitFor = require('p-wait-for')
+const pDefer = require('p-defer')
+const mergeOptions = require('merge-options')
+
+const Floodsub = require('libp2p-floodsub')
+const Gossipsub = require('libp2p-gossipsub')
+const { multicodec: floodsubMulticodec } = require('libp2p-floodsub')
+const { multicodec: gossipsubMulticodec } = require('libp2p-gossipsub')
+
+const multiaddr = require('multiaddr')
+
+const { create } = require('../../src')
+const { baseOptions } = require('./utils')
+const peerUtils = require('../utils/creators/peer')
+
+const listenAddr = multiaddr('/ip4/127.0.0.1/tcp/0')
+const remoteListenAddr = multiaddr('/ip4/127.0.0.1/tcp/0')
+
+describe('Pubsub subsystem is able to use different implementations', () => {
+  let peerInfo, remotePeerInfo
+  let libp2p, remoteLibp2p
+  let remAddr
+
+  beforeEach(async () => {
+    [peerInfo, remotePeerInfo] = await peerUtils.createPeerInfoFromFixture(2)
+
+    peerInfo.multiaddrs.add(listenAddr)
+    remotePeerInfo.multiaddrs.add(remoteListenAddr)
+  })
+
+  afterEach(() => Promise.all([
+    libp2p && libp2p.stop(),
+    remoteLibp2p && remoteLibp2p.stop()
+  ]))
+
+  it('Floodsub nodes', () => {
+    return pubsubTest(floodsubMulticodec, Floodsub)
+  })
+
+  it('Gossipsub nodes', () => {
+    return pubsubTest(gossipsubMulticodec, Gossipsub)
+  })
+
+  const pubsubTest = async (multicodec, pubsub) => {
+    const defer = pDefer()
+    const topic = 'test-topic'
+    const data = 'hey!'
+
+    libp2p = await create(mergeOptions(baseOptions, {
+      peerInfo,
+      modules: {
+        pubsub: pubsub
+      }
+    }))
+
+    remoteLibp2p = await create(mergeOptions(baseOptions, {
+      peerInfo: remotePeerInfo,
+      modules: {
+        pubsub: pubsub
+      }
+    }))
+
+    await Promise.all([
+      libp2p.start(),
+      remoteLibp2p.start()
+    ])
+
+    const libp2pId = libp2p.peerInfo.id.toB58String()
+    remAddr = remoteLibp2p.transportManager.getAddrs()[0]
+
+    const connection = await libp2p.dialProtocol(remAddr, multicodec)
+    expect(connection).to.exist()
+
+    libp2p.pubsub.subscribe(topic, (msg) => {
+      expect(msg.data.toString()).to.equal(data)
+      defer.resolve()
+    })
+
+    // wait for remoteLibp2p to know about libp2p subscription
+    await pWaitFor(() => {
+      const subscribedPeers = remoteLibp2p.pubsub.getPeersSubscribed(topic)
+      return subscribedPeers.includes(libp2pId)
+    })
+
+    remoteLibp2p.pubsub.publish(topic, data)
+    await defer.promise
+  }
+})

test/pubsub/operation.node.js

@@ -0,0 +1,184 @@
+'use strict'
+/* eslint-env mocha */
+
+const chai = require('chai')
+chai.use(require('dirty-chai'))
+const { expect } = chai
+const sinon = require('sinon')
+
+const pWaitFor = require('p-wait-for')
+const pDefer = require('p-defer')
+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/0')
+const remoteListenAddr = multiaddr('/ip4/127.0.0.1/tcp/0')
+
+describe('Pubsub 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('pubsub 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()
+    ]))
+
+    afterEach(() => {
+      sinon.restore()
+    })
+
+    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.pubsub._pubsub.peers.size === 1),
+        pWaitFor(() => remoteLibp2p.pubsub._pubsub.peers.size === 1)
+      ])
+    })
+
+    it('should receive pubsub messages', async () => {
+      const defer = pDefer()
+      const topic = 'test-topic'
+      const data = 'hey!'
+      const libp2pId = libp2p.peerInfo.id.toB58String()
+
+      await libp2p.dialProtocol(remAddr, subsystemMulticodecs)
+
+      let subscribedTopics = libp2p.pubsub.getTopics()
+      expect(subscribedTopics).to.not.include(topic)
+
+      libp2p.pubsub.subscribe(topic, (msg) => {
+        expect(msg.data.toString()).to.equal(data)
+        defer.resolve()
+      })
+
+      subscribedTopics = libp2p.pubsub.getTopics()
+      expect(subscribedTopics).to.include(topic)
+
+      // wait for remoteLibp2p to know about libp2p subscription
+      await pWaitFor(() => {
+        const subscribedPeers = remoteLibp2p.pubsub.getPeersSubscribed(topic)
+        return subscribedPeers.includes(libp2pId)
+      })
+      remoteLibp2p.pubsub.publish(topic, data)
+
+      await defer.promise
+    })
+  })
+
+  describe('pubsub started after connect', () => {
+    beforeEach(async () => {
+      libp2p = await create(mergeOptions(subsystemOptions, {
+        peerInfo
+      }))
+
+      remoteLibp2p = await create(mergeOptions(subsystemOptions, {
+        peerInfo: remotePeerInfo,
+        config: {
+          pubsub: {
+            enabled: false
+          }
+        }
+      }))
+
+      await libp2p.start()
+      await remoteLibp2p.start()
+
+      remAddr = remoteLibp2p.transportManager.getAddrs()[0]
+    })
+
+    afterEach(() => Promise.all([
+      libp2p && libp2p.stop(),
+      remoteLibp2p && remoteLibp2p.stop()
+    ]))
+
+    afterEach(() => {
+      sinon.restore()
+    })
+
+    it('should get notified of connected peers after starting', async () => {
+      const connection = await libp2p.dial(remAddr)
+
+      expect(connection).to.exist()
+      expect(libp2p.pubsub._pubsub.peers.size).to.be.eql(0)
+      expect(remoteLibp2p.pubsub._pubsub.peers.size).to.be.eql(0)
+
+      remoteLibp2p.pubsub.start()
+
+      return Promise.all([
+        pWaitFor(() => libp2p.pubsub._pubsub.peers.size === 1),
+        pWaitFor(() => remoteLibp2p.pubsub._pubsub.peers.size === 1)
+      ])
+    })
+
+    it('should receive pubsub messages', async function () {
+      this.timeout(10e3)
+      const defer = pDefer()
+      const libp2pId = libp2p.peerInfo.id.toB58String()
+      const topic = 'test-topic'
+      const data = 'hey!'
+
+      await libp2p.dial(remAddr)
+
+      remoteLibp2p.pubsub.start()
+
+      await Promise.all([
+        pWaitFor(() => libp2p.pubsub._pubsub.peers.size === 1),
+        pWaitFor(() => remoteLibp2p.pubsub._pubsub.peers.size === 1)
+      ])
+
+      let subscribedTopics = libp2p.pubsub.getTopics()
+      expect(subscribedTopics).to.not.include(topic)
+
+      libp2p.pubsub.subscribe(topic, (msg) => {
+        expect(msg.data.toString()).to.equal(data)
+        defer.resolve()
+      })
+
+      subscribedTopics = libp2p.pubsub.getTopics()
+      expect(subscribedTopics).to.include(topic)
+
+      // wait for remoteLibp2p to know about libp2p subscription
+      await pWaitFor(() => {
+        const subscribedPeers = remoteLibp2p.pubsub.getPeersSubscribed(topic)
+        return subscribedPeers.includes(libp2pId)
+      })
+
+      remoteLibp2p.pubsub.publish(topic, data)
+
+      await defer.promise
+    })
+  })
+})

test/pubsub/utils.js

@@ -0,0 +1,29 @@
+'use strict'
+
+const Gossipsub = require('libp2p-gossipsub')
+const { multicodec } = require('libp2p-gossipsub')
+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: {
+    pubsub: Gossipsub
+  }
+})
+
+module.exports.subsystemOptions = subsystemOptions
+
+module.exports.subsystemMulticodecs = [multicodec]

test/registrar/registrar.spec.js

@@ -7,6 +7,7 @@ const { expect } = chai
 const pDefer = require('p-defer')
 
 const PeerInfo = require('peer-info')
+const Topology = require('libp2p-interfaces/src/topology/multicodec-topology')
 const PeerStore = require('../../src/peer-store')
 const Registrar = require('../../src/registrar')
 const { createMockConnection } = require('./utils')
@@ -32,52 +33,17 @@ describe('registrar', () => {
       throw new Error('should fail to register a protocol if no multicodec is provided')
     })
 
-    it('should fail to register a protocol if no handlers are provided', () => {
-      const topologyProps = {
-        multicodecs: multicodec
+    it('should fail to register a protocol if an invalid topology is provided', () => {
+      const fakeTopology = {
+        random: 1
       }
-
       try {
-        registrar.register(topologyProps)
+        registrar.register()
       } catch (err) {
-        expect(err).to.exist()
+        expect(err).to.exist(fakeTopology)
         return
       }
-      throw new Error('should fail to register a protocol if no handlers are provided')
-    })
-
-    it('should fail to register a protocol if the onConnect handler is not provided', () => {
-      const topologyProps = {
-        multicodecs: multicodec,
-        handlers: {
-          onDisconnect: () => { }
-        }
-      }
-
-      try {
-        registrar.register(topologyProps)
-      } catch (err) {
-        expect(err).to.exist()
-        return
-      }
-      throw new Error('should fail to register a protocol if the onConnect handler is not provided')
-    })
-
-    it('should fail to register a protocol if the onDisconnect handler is not provided', () => {
-      const topologyProps = {
-        multicodecs: multicodec,
-        handlers: {
-          onConnect: () => { }
-        }
-      }
-
-      try {
-        registrar.register(topologyProps)
-      } catch (err) {
-        expect(err).to.exist()
-        return
-      }
-      throw new Error('should fail to register a protocol if the onDisconnect handler is not provided')
+      throw new Error('should fail to register a protocol if an invalid topology is provided')
     })
   })
 
@@ -88,13 +54,13 @@ describe('registrar', () => {
     })
 
     it('should be able to register a protocol', () => {
-      const topologyProps = {
+      const topologyProps = new Topology({
+        multicodecs: multicodec,
         handlers: {
           onConnect: () => { },
           onDisconnect: () => { }
-        },
-        multicodecs: multicodec
-      }
+        }
+      })
 
       const identifier = registrar.register(topologyProps)
 
@@ -102,13 +68,13 @@ describe('registrar', () => {
     })
 
     it('should be able to unregister a protocol', () => {
-      const topologyProps = {
+      const topologyProps = new Topology({
+        multicodecs: multicodec,
         handlers: {
           onConnect: () => { },
           onDisconnect: () => { }
-        },
-        multicodecs: multicodec
-      }
+        }
+      })
 
       const identifier = registrar.register(topologyProps)
       const success = registrar.unregister(identifier)
@@ -138,7 +104,7 @@ describe('registrar', () => {
       registrar.onConnect(remotePeerInfo, conn)
       expect(registrar.connections.size).to.eql(1)
 
-      const topologyProps = {
+      const topologyProps = new Topology({
         multicodecs: multicodec,
         handlers: {
           onConnect: (peerInfo, connection) => {
@@ -153,7 +119,7 @@ describe('registrar', () => {
             onDisconnectDefer.resolve()
           }
         }
-      }
+      })
 
       // Register protocol
       const identifier = registrar.register(topologyProps)
@@ -161,11 +127,9 @@ describe('registrar', () => {
 
       // Topology created
       expect(topology).to.exist()
-      expect(topology.peers.size).to.eql(1)
 
       registrar.onDisconnect(remotePeerInfo)
       expect(registrar.connections.size).to.eql(0)
-      expect(topology.peers.size).to.eql(1) // topology should keep the peer
 
       // Wait for handlers to be called
       return Promise.all([
@@ -178,7 +142,7 @@ describe('registrar', () => {
       const onConnectDefer = pDefer()
       const onDisconnectDefer = pDefer()
 
-      const topologyProps = {
+      const topologyProps = new Topology({
         multicodecs: multicodec,
         handlers: {
           onConnect: () => {
@@ -188,7 +152,7 @@ describe('registrar', () => {
             onDisconnectDefer.resolve()
           }
         }
-      }
+      })
 
       // Register protocol
       const identifier = registrar.register(topologyProps)
@@ -196,7 +160,6 @@ describe('registrar', () => {
 
       // Topology created
       expect(topology).to.exist()
-      expect(topology.peers.size).to.eql(0)
       expect(registrar.connections.size).to.eql(0)
 
       // Setup connections before registrar
@@ -212,7 +175,6 @@ describe('registrar', () => {
       peerStore.put(peerInfo)
 
       await onConnectDefer.promise
-      expect(topology.peers.size).to.eql(1)
 
       // Remove protocol to peer and update it
       peerInfo.protocols.delete(multicodec)