Bubble upstream the latest changes on libp2p

.aegir.js

@@ -6,6 +6,7 @@ module.exports = {
   webpack: {
     resolve: {
       alias: {
+        'libp2p-ipfs': 'libp2p-ipfs-browser',
         'node-forge': path.resolve(
           path.dirname(require.resolve('libp2p-crypto')),
           '../vendor/forge.bundle.js'

package.json

@@ -12,6 +12,7 @@
     "coverage": "gulp coverage",
     "test": "gulp test",
     "test:node": "gulp test:node",
+    "test:core:node": "TEST=core npm run test:node",
     "test:browser": "gulp test:browser",
     "build": "gulp build",
     "release": "gulp release",
@@ -37,14 +38,15 @@
   },
   "homepage": "https://github.com/ipfs/js-ipfs#readme",
   "devDependencies": {
-    "aegir": "^3.1.0",
+    "aegir": "^3.2.0",
     "buffer-loader": "0.0.1",
     "chai": "^3.5.0",
     "expose-loader": "^0.7.1",
     "form-data": "^1.0.0-rc3",
     "gulp": "^3.9.1",
     "idb-plus-blob-store": "^1.1.2",
     "interface-ipfs-core": "^0.1.5",
+    "left-pad": "^1.1.0",
     "lodash": "^4.11.2",
     "mocha": "^2.5.1",
     "ncp": "^2.0.0",
@@ -65,19 +67,20 @@
     "glob": "^7.0.3",
     "hapi": "^13.4.1",
     "ipfs-api": "^4.1.0",
-    "ipfs-bitswap": "^0.3.1",
+    "ipfs-bitswap": "^0.4.0",
     "ipfs-block": "^0.3.0",
     "ipfs-block-service": "^0.4.0",
     "ipfs-merkle-dag": "^0.6.0",
     "ipfs-multipart": "^0.1.0",
     "ipfs-repo": "^0.8.0",
     "ipfs-unixfs-engine": "^0.8.0",
     "joi": "^8.0.5",
-    "libp2p-ipfs": "^0.9.0",
-    "libp2p-ipfs-browser": "^0.8.0",
-    "libp2p-swarm": "^0.19.0",
+    "libp2p-ipfs": "^0.10.0",
+    "libp2p-ipfs-browser": "^0.9.0",
+    "libp2p-swarm": "^0.19.4",
     "lodash.get": "^4.3.0",
     "lodash.set": "^4.2.0",
+    "mafmt": "^2.1.1",
     "multiaddr": "^2.0.2",
     "path-exists": "^3.0.0",
     "peer-book": "^0.3.0",
@@ -109,4 +112,4 @@
     "kumavis <kumavis@users.noreply.github.com>",
     "nginnever <ginneversource@gmail.com>"
   ]
-}
+}

src/core/ipfs/go-online.js

@@ -14,10 +14,10 @@ module.exports = function goOnline (self) {
       }
 
       self._bitswap = new Bitswap(
-        self._peerInfo,
+        self._libp2pNode.peerInfo,
         self._libp2pNode,
         self._repo.datastore,
-        self._peerInfoBook
+        self._libp2pNode.peerBook
       )
       self._bitswap.start()
       self._blockS.goOnline(self._bitswap)

src/core/ipfs/libp2p.js

@@ -1,42 +1,44 @@
 'use strict'
 
 const peerId = require('peer-id')
-const PeerInfo = require('peer-info')
 const multiaddr = require('multiaddr')
 const Libp2pNode = require('libp2p-ipfs').Node
+const mafmt = require('mafmt')
 
 const OFFLINE_ERROR = require('../utils').OFFLINE_ERROR
 
 module.exports = function libp2p (self) {
+  // NOTE: TODO CONSIDER/ CONSIDERING putting all of libp2p (start, stop, peerbook and so on) inside the libp2p object and reduce one layer
+
   return {
     start: (callback) => {
       self._libp2pNode = new Libp2pNode(self._peerInfo)
       self._libp2pNode.start(() => {
         // TODO connect to bootstrap nodes, it will get us more addrs
-        self._peerInfo.multiaddrs.forEach((ma) => {
+        self._libp2pNode.peerInfo.multiaddrs.forEach((ma) => {
           console.log('Swarm listening on', ma.toString())
         })
         callback()
       })
 
       self._libp2pNode.discovery.on('peer', (peerInfo) => {
-        self._peerInfoBook.put(peerInfo)
-        self._libp2pNode.swarm.dial(peerInfo)
+        self._libp2pNode.peerBook.put(peerInfo)
+        self._libp2pNode.dialByPeerInfo(peerInfo, () => {})
       })
       self._libp2pNode.swarm.on('peer-mux-established', (peerInfo) => {
-        self._peerInfoBook.put(peerInfo)
+        self._libp2pNode.peerBook.put(peerInfo)
       })
     },
     stop: (callback) => {
-      self._libp2pNode.swarm.close(callback)
+      self._libp2pNode.stop(callback)
     },
     swarm: {
       peers: (callback) => {
         if (!self.isOnline()) {
           return callback(OFFLINE_ERROR)
         }
 
-        callback(null, self._peerInfoBook.getAll())
+        callback(null, self._libp2pNode.peerBook.getAll())
       },
       // all the addrs we know
       addrs: (callback) => {
@@ -51,34 +53,44 @@ module.exports = function libp2p (self) {
           return callback(OFFLINE_ERROR)
         }
 
-        callback(null, self._peerInfo.multiaddrs)
+        callback(null, self._libp2pNode.peerInfo.multiaddrs)
       },
-      connect: (ma, callback) => {
+      connect: (maddr, callback) => {
         if (!self.isOnline()) {
           return callback(OFFLINE_ERROR)
         }
 
-        const idStr = ma.toString().match(/\/ipfs\/(.*)/)
-        if (!idStr) {
-          return callback(new Error('invalid multiaddr'))
+        if (typeof maddr === 'string') {
+          maddr = multiaddr(maddr)
+        }
+
+        if (!mafmt.IPFS.matches(maddr.toString())) {
+          return callback(new Error('multiaddr not valid'))
         }
-        const id = peerId.createFromB58String(idStr[1])
-        const peer = new PeerInfo(id)
 
-        peer.multiaddr.add(multiaddr(ma))
+        let ipfsIdB58String
+        maddr.stringTuples().forEach((tuple) => {
+          if (tuple[0] === 421) {
+            ipfsIdB58String = tuple[1]
+          }
+        })
 
-        self._peerInfoBook.put(peer)
+        const id = peerId.createFromB58String(ipfsIdB58String)
 
-        self._libp2pNode.swarm.dial(peer, (err) => {
+        self._libp2pNode.dialByMultiaddr(maddr, (err) => {
           callback(err, id)
         })
       },
-      disconnect: (callback) => {
+      disconnect: (maddr, callback) => {
         if (!self.isOnline()) {
           return callback(OFFLINE_ERROR)
         }
 
-        throw new Error('Not implemented')
+        if (typeof maddr === 'string') {
+          maddr = multiaddr(maddr)
+        }
+
+        self._libp2pNode.hangUpByMultiaddr(maddr, callback)
       },
       filters: () => {
         // TODO

test/cli/test-bitswap.js

@@ -19,7 +19,7 @@ describe('bitswap', function () {
   let ipfs
 
   before((done) => {
-    createTempNode(4, (err, _ipfs) => {
+    createTempNode(38, (err, _ipfs) => {
       expect(err).to.not.exist
       ipfs = _ipfs
       ipfs.goOnline(done)

test/core/both/test-bitswap.js

@@ -6,6 +6,7 @@ const _ = require('lodash')
 const series = require('run-series')
 const waterfall = require('run-waterfall')
 const parallel = require('run-parallel')
+const leftPad = require('left-pad')
 const Block = require('ipfs-block')
 const bs58 = require('bs58')
 const bl = require('bl')
@@ -65,7 +66,7 @@ describe('bitswap', () => {
           // cause browser nodes don't have a websockets addrs
           // TODO, what we really need is a way to dial to a peerId only
           // and another to dial to peerInfo
-          target = multiaddr(`/ip4/0.0.0.0/tcp/0/ipfs/${res.ID}`).toString()
+          target = multiaddr(`/ip4/0.0.0.0/tcp/0/ws/ipfs/${res.ID}`).toString()
         }
 
         const swarm = node2.libp2p ? node2.libp2p.swarm : node2.swarm
@@ -85,7 +86,8 @@ describe('bitswap', () => {
     }
 
     function addNode (num, done) {
-      const apiUrl = `/ip4/127.0.0.1/tcp/1100${num}`
+      num = leftPad(num, 3, 0)
+      const apiUrl = `/ip4/127.0.0.1/tcp/31${num}`
       const node = new API(apiUrl)
 
       connectNodes(node, ipfs, (err) => {

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

@@ -2,76 +2,130 @@
 'use strict'
 
 const expect = require('chai').expect
+const parallel = require('run-parallel')
 
 const createTempNode = require('../../utils/temp-node')
 
 describe('swarm', function () {
-  this.timeout(20000)
+  this.timeout(20 * 1000)
 
-  var ipfsA
-  var ipfsB
-  var ipfsAAddr
+  let nodeA
+  let nodeB
 
-  before((done) => {
-    createTempNode(2, (err, ipfs) => {
-      expect(err).to.not.exist
-      ipfsA = ipfs
+  // let nodeAMultiaddr
+  let nodeBMultiaddr
 
-      createTempNode(3, (err, ipfs) => {
-        expect(err).to.not.exist
-        ipfsB = ipfs
-        done()
-      })
-    })
+  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)
   })
 
-  before((done) => {
-    ipfsA.id((err, res) => {
-      expect(err).to.not.exist
-      ipfsAAddr = `${res.Addresses[0]}/ipfs/${res.ID}`
-      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]}/ipfs/${res.ID}`
+          cb()
+        })
+      }
+    ], done)
   })
 
-  it('start', (done) => {
-    ipfsA.goOnline((err) => {
-      expect(err).to.not.exist
-      ipfsB.goOnline((err) => {
-        expect(err).to.not.exist
-        done()
-      })
-    })
+  it('start 2 nodes', (done) => {
+    parallel([
+      nodeA.goOnline,
+      nodeB.goOnline
+    ], done)
   })
 
-  it('connect', (done) => {
-    ipfsB.libp2p.swarm.connect(ipfsAAddr, (err, res) => {
+  it('libp2p.swarm.connect nodeA to nodeB', (done) => {
+    nodeA.libp2p.swarm.connect(nodeBMultiaddr, (err) => {
       expect(err).to.not.exist
-      done()
+      // So that identify has time to execute
+      setTimeout(done, 500)
     })
   })
 
-  it('peers', (done) => {
-    ipfsB.libp2p.swarm.peers((err, res) => {
-      expect(err).to.not.exist
-      expect(Object.keys(res)).to.have.length(1)
-      done()
-    })
+  it('libp2p.swarm.peers on nodeA and nodeB match each other', (done) => {
+    parallel([
+      (cb) => {
+        nodeA.libp2p.swarm.peers((err, res) => {
+          expect(err).to.not.exist
+          expect(Object.keys(res)).to.have.length(1)
+          cb()
+        })
+      },
+      (cb) => {
+        nodeB.libp2p.swarm.peers((err, res) => {
+          expect(err).to.not.exist
+          expect(Object.keys(res)).to.have.length(1)
+          cb()
+        })
+      }
+    ], done)
   })
 
-  it('localAddrs', (done) => {
-    ipfsB.libp2p.swarm.localAddrs((err, res) => {
+  it('libp2p.swarm.localAddrs', (done) => {
+    nodeB.libp2p.swarm.localAddrs((err, res) => {
       expect(err).to.not.exist
       expect(res.length).to.equal(2)
       done()
     })
   })
 
-  it.skip('disconnect', (done) => {})
-
-  it.skip('stop', (done) => {
-    ipfsA.goOffline((err) => {
+  it('libp2p.swarm.disconnect nodeB from nodeA', (done) => {
+    nodeA.libp2p.swarm.disconnect(nodeBMultiaddr, (err) => {
       expect(err).to.not.exist
-      ipfsB.goOffline(done)
+      // So that identify has time to execute
+      setTimeout(check, 500)
+
+      function check () {
+        parallel([
+          (cb) => {
+            nodeA.libp2p.swarm.peers((err, res) => {
+              expect(err).to.not.exist
+              expect(Object.keys(res)).to.have.length(0)
+              cb()
+            })
+          },
+          (cb) => {
+            nodeB.libp2p.swarm.peers((err, res) => {
+              expect(err).to.not.exist
+              expect(Object.keys(res)).to.have.length(0)
+              cb()
+            })
+          }
+        ], done)
+      }
     })
   })
+
+  it('stop', (done) => {
+    parallel([
+      nodeA.goOffline,
+      nodeB.goOffline
+    ], done)
+  })
 })