feat(pubsub): update to new floodsub

Author: daviddias

package.json

@@ -103,7 +103,7 @@
     "ipfs-unixfs-engine": "^0.14.2",
     "ipld-resolver": "^0.4.1",
     "isstream": "^0.1.2",
-    "libp2p-floodsub": "0.6.0",
+    "libp2p-floodsub": "0.7.0",
     "joi": "^10.0.6",
     "libp2p-ipfs-nodejs": "^0.17.1",
     "libp2p-ipfs-browser": "^0.17.3",

src/core/components/go-offline.js

@@ -1,10 +1,14 @@
 'use strict'
 
 module.exports = (self) => {
-  return (cb) => {
+  return (callback) => {
     self._blockService.goOffline()
     self._bitswap.stop()
-    // TODO self._pubsub.stop()
-    self.libp2p.stop(cb)
+    self._pubsub.stop((err) => {
+      if (err) {
+        return callback(err)
+      }
+      self.libp2p.stop(callback)
+    })
   }
 }

src/core/components/go-online.js

@@ -5,13 +5,13 @@ const Bitswap = require('ipfs-bitswap')
 const FloodSub = require('libp2p-floodsub')
 
 module.exports = (self) => {
-  return (cb) => {
+  return (callback) => {
     series([
       self.load,
       self.libp2p.start
     ], (err) => {
       if (err) {
-        return cb(err)
+        return callback(err)
       }
 
       self._bitswap = new Bitswap(
@@ -20,10 +20,11 @@ module.exports = (self) => {
         self._libp2pNode.peerBook
       )
       self._bitswap.start()
+
       self._blockService.goOnline(self._bitswap)
+
       self._pubsub = new FloodSub(self._libp2pNode)
-      // TODO self.pubsub.start()
-      cb()
+      self._pubsub.start(callback)
     })
   }
 }

test/core/node-only/test-swarm-2.js

@@ -1,129 +1,20 @@
 /* eslint-env mocha */
-'use strict'
-
-const expect = require('chai').expect
-const parallel = require('async/parallel')
-
-const createTempNode = require('../../utils/temp-node')
-
-describe('swarm', () => {
-  let nodeA
-  let nodeB
-
-  // let nodeAMultiaddr
-  let nodeBMultiaddr
 
-  it('create 2 temporary nodes', (done) => {
-    parallel([
-      (cb) => {
-        createTempNode(2, (err, tmpNode) => {
-          expect(err).to.not.exist
-          nodeA = tmpNode
-          cb()
-        })
-      },
-      (cb) => {
-        createTempNode(3, (err, tmpNode) => {
-          expect(err).to.not.exist
-          nodeB = tmpNode
-          cb()
-        })
-      }
-    ], done)
-  })
-
-  it('get each peer addr', (done) => {
-    parallel([
-      (cb) => {
-        nodeA.id((err, res) => {
-          expect(err).to.not.exist
-          // nodeAMultiaddr = `${res.addresses[0]}/ipfs/${res.id}`
-          cb()
-        })
-      },
-      (cb) => {
-        nodeB.id((err, res) => {
-          expect(err).to.not.exist
-          nodeBMultiaddr = res.addresses[0]
-          cb()
-        })
-      }
-    ], done)
-  })
-
-  it('start 2 nodes', (done) => {
-    parallel([
-      nodeA.goOnline,
-      nodeB.goOnline
-    ], done)
-  })
-
-  it('libp2p.swarm.connect nodeA to nodeB', (done) => {
-    nodeA.swarm.connect(nodeBMultiaddr, (err) => {
-      expect(err).to.not.exist
-      // So that identify has time to execute
-      setTimeout(done, 500)
-    })
-  })
-
-  it('libp2p.swarm.peers on nodeA and nodeB match each other', (done) => {
-    parallel([
-      (cb) => {
-        nodeA.swarm.peers((err, peers) => {
-          expect(err).to.not.exist
-          expect(peers).to.have.length.above(0)
-          cb()
-        })
-      },
-      (cb) => {
-        nodeB.swarm.peers((err, peers) => {
-          expect(err).to.not.exist
-          expect(peers).to.have.length.above(0)
-          cb()
-        })
-      }
-    ], done)
-  })
+'use strict'
 
-  it('libp2p.swarm.localAddrs', (done) => {
-    nodeB.swarm.localAddrs((err, res) => {
-      expect(err).to.not.exist
-      expect(res.length > 1).to.equal(true)
-      done()
-    })
-  })
+const test = require('interface-ipfs-core')
+const IPFSFactory = require('../../utils/factory-core')
 
-  it('libp2p.swarm.disconnect nodeB from nodeA', (done) => {
-    nodeA.swarm.disconnect(nodeBMultiaddr, (err) => {
-      expect(err).to.not.exist
-      // So that identify has time to execute
-      setTimeout(check, 500)
+let factory
 
-      function check () {
-        parallel([
-          (cb) => {
-            nodeA.swarm.peers((err, peers) => {
-              expect(err).to.not.exist
-              expect(peers).to.have.length(0)
-              cb()
-            })
-          },
-          (cb) => {
-            nodeB.swarm.peers((err, peers) => {
-              expect(err).to.not.exist
-              expect(peers).to.have.length(0)
-              cb()
-            })
-          }
-        ], done)
-      }
-    })
-  })
+const common = {
+  setup: function (cb) {
+    factory = new IPFSFactory()
+    cb(null, factory)
+  },
+  teardown: function (cb) {
+    factory.dismantle(cb)
+  }
+}
 
-  it('stop', (done) => {
-    parallel([
-      nodeA.goOffline,
-      nodeB.goOffline
-    ], done)
-  })
-})
+test.swarm(common)