refactor: use async peer-id and peer-info

dignifiedquire · dignifiedquire · commit fd22c82483a1 · 2016-09-15T12:14:51.000+02:00
diff --git a/src/core/components/init.js b/src/core/components/init.js
@@ -19,7 +19,7 @@ module.exports = function init (self) {
     }
 
     opts.emptyRepo = opts.emptyRepo || false
-    opts.bits = opts.bits || 2048
+    opts.bits = Number(opts.bits) || 2048
     opts.log = opts.log || function () {}
 
     let config
@@ -50,17 +50,20 @@ module.exports = function init (self) {
     // Generate peer identity keypair + transform to desired format + add to config.
     function generateAndSetKeypair () {
       opts.log(`generating ${opts.bits}-bit RSA keypair...`, false)
-      var keys = peerId.create({
+      peerId.create({
         bits: opts.bits
-      })
-      config.Identity = {
-        PeerID: keys.toB58String(),
-        PrivKey: keys.privKey.bytes.toString('base64')
-      }
-      opts.log('done')
-      opts.log('peer identity: ' + config.Identity.PeerID)
+      }, (err, keys) => {
+        if (err) return callback(err)
 
-      writeVersion()
+        config.Identity = {
+          PeerID: keys.toB58String(),
+          PrivKey: keys.privKey.bytes.toString('base64')
+        }
+        opts.log('done')
+        opts.log('peer identity: ' + config.Identity.PeerID)
+
+        writeVersion()
+      })
     }
 
     function writeVersion () {
diff --git a/src/core/components/load.js b/src/core/components/load.js
@@ -3,27 +3,24 @@
 const peerId = require('peer-id')
 const PeerInfo = require('peer-info')
 const multiaddr = require('multiaddr')
+const waterfall = require('run-waterfall')
 
 const utils = require('../utils')
 
 module.exports = function load (self) {
   return (callback) => {
-    utils.ifRepoExists(self._repo, (err) => {
-      if (err) {
-        return callback(err)
-      }
+    waterfall([
+      (cb) => utils.ifRepoExists(self._repo, cb),
+      (cb) => self._repo.config.get(cb),
+      (config, cb) => {
+        const id = peerId.createFromPrivKey(config.Identity.PrivKey)
 
-      self._repo.config.get((err, config) => {
-        if (err) {
-          return callback(err)
-        }
-        const pid = peerId.createFromPrivKey(config.Identity.PrivKey)
-        self._peerInfo = new PeerInfo(pid)
+        self._peerInfo = new PeerInfo(id)
         config.Addresses.Swarm.forEach((addr) => {
           self._peerInfo.multiaddr.add(multiaddr(addr))
         })
-        callback()
-      })
-    })
+        cb()
+      }
+    ], callback)
   }
 }
diff --git a/test/cli/test-init.js b/test/cli/test-init.js
@@ -35,15 +35,15 @@ describe('init', function () {
   })
 
   it('bits', (done) => {
-    nexpect.spawn('node', [process.cwd() + '/src/cli/bin.js', 'init', '--bits', '64'], {env})
+    nexpect.spawn('node', [process.cwd() + '/src/cli/bin.js', 'init', '--bits', '512'], {env})
       .run((err, stdout, exitcode) => {
         expect(err).to.not.exist
         done()
       })
   })
 
   it('empty', (done) => {
-    nexpect.spawn('node', [process.cwd() + '/src/cli/bin.js', 'init', '--bits', '64', '--empty-repo', 'true'], {env})
+    nexpect.spawn('node', [process.cwd() + '/src/cli/bin.js', 'init', '--bits', '512', '--empty-repo', 'true'], {env})
       .run((err, stdout, exitcode) => {
         expect(err).to.not.exist
         expect(repoExistsSync('blocks')).to.equal(false)
diff --git a/test/core/both/test-init.js b/test/core/both/test-init.js
@@ -13,7 +13,7 @@ describe('init', function () {
     const repo = createTempRepo()
     const ipfs = new IPFS(repo)
 
-    ipfs.init({ emptyRepo: true, bits: 128 }, (err) => {
+    ipfs.init({ emptyRepo: true, bits: 512 }, (err) => {
       expect(err).to.not.exist
 
       repo.exists((err, res) => {
@@ -35,10 +35,10 @@ describe('init', function () {
     const repo2 = createTempRepo()
     const ipfsShort = new IPFS(repo1)
     const ipfsLong = new IPFS(repo2)
-    ipfsShort.init({ bits: 128, emptyRepo: true }, (err) => {
+    ipfsShort.init({ bits: 512, emptyRepo: true }, (err) => {
       expect(err).to.not.exist
 
-      ipfsLong.init({ bits: 256, emptyRepo: true }, (err) => {
+      ipfsLong.init({ bits: 1024, emptyRepo: true }, (err) => {
         expect(err).to.not.exist
 
         repo1.config.get((err, config1) => {
diff --git a/test/core/node-only/test-init.js b/test/core/node-only/test-init.js
@@ -23,7 +23,7 @@ describe('init (Node.js specific)', function () {
   })
 
   it('init docs are written', (done) => {
-    ipfs.init({ bits: 64 }, (err) => {
+    ipfs.init({ bits: 512 }, (err) => {
       expect(err).to.not.exist
       var multihash = new Buffer('12205e7c3ce237f936c76faf625e90f7751a9f5eeb048f59873303c215e9cce87599', 'hex')
       setTimeout(() => {
@@ -37,7 +37,7 @@ describe('init (Node.js specific)', function () {
   })
 
   it('empty repo', (done) => {
-    ipfs.init({ bits: 64, emptyRepo: true }, (err) => {
+    ipfs.init({ bits: 512, emptyRepo: true }, (err) => {
       expect(err).to.not.exist
 
       // Check for default assets
diff --git a/test/utils/factory-core/index.js b/test/utils/factory-core/index.js
@@ -34,66 +34,85 @@ function Factory () {
                                  .substring(2, 8)
     }
 
-    if (!config) {
-      config = JSON.parse(JSON.stringify(defaultConfig))
-      const pId = PeerId.create({ bits: 512 }).toJSON()
-      config.Identity.PeerID = pId.id
-      config.Identity.PrivKey = pId.privKey
-    }
-
-    // set up the repo
-    let store
-    let teardown
-
-    if (isNode) {
-      store = require('fs-pull-blob-store')
-      teardown = (done) => {
-        cleanRepo(repoPath)
-        done()
-      }
-    } else {
-      const idb = window.indexedDB ||
-              window.mozIndexedDB ||
-              window.webkitIndexedDB ||
-              window.msIndexedDB
-      store = require('idb-pull-blob-store')
-      teardown = (done) => {
-        idb.deleteDatabase(repoPath)
-        idb.deleteDatabase(repoPath + '/blocks')
-        done()
+    createConfig(config, (err, conf) => {
+      if (err) {
+        return callback(err)
       }
-    }
 
-    const repo = new IPFSRepo(repoPath, { stores: store })
-    repo.teardown = teardown
+      config = conf
 
-    // create the IPFS node
-    const ipfs = new IPFS(repo)
-    ipfs.init({ emptyRepo: true, bits: 512 }, (err) => {
-      if (err) {
-        return callback(err)
+      // set up the repo
+      let store
+      let teardown
+
+      if (isNode) {
+        store = require('fs-pull-blob-store')
+        teardown = (done) => {
+          cleanRepo(repoPath)
+          done()
+        }
+      } else {
+        const idb = window.indexedDB ||
+                window.mozIndexedDB ||
+                window.webkitIndexedDB ||
+                window.msIndexedDB
+        store = require('idb-pull-blob-store')
+        teardown = (done) => {
+          idb.deleteDatabase(repoPath)
+          idb.deleteDatabase(repoPath + '/blocks')
+          done()
+        }
       }
-      repo.config.set(config, launchNode)
-    })
 
-    function launchNode () {
-      ipfs.load((err) => {
+      const repo = new IPFSRepo(repoPath, { stores: store })
+      repo.teardown = teardown
+
+      // create the IPFS node
+      const ipfs = new IPFS(repo)
+      ipfs.init({ emptyRepo: true, bits: 512 }, (err) => {
         if (err) {
           return callback(err)
         }
+        repo.config.set(config, launchNode)
+      })
 
-        ipfs.goOnline((err) => {
+      function launchNode () {
+        ipfs.load((err) => {
           if (err) {
             return callback(err)
           }
 
-          nodes.push({
-            repo: repo,
-            ipfs: ipfs
-          })
+          ipfs.goOnline((err) => {
+            if (err) {
+              return callback(err)
+            }
+
+            nodes.push({
+              repo: repo,
+              ipfs: ipfs
+            })
 
-          callback(null, ipfs)
+            callback(null, ipfs)
+          })
         })
+      }
+    })
+
+    function createConfig (config, cb) {
+      if (config) {
+        return cb(null, config)
+      }
+      const conf = JSON.parse(JSON.stringify(defaultConfig))
+
+      PeerId.create({ bits: 512 }, (err, id) => {
+        if (err) {
+          return cb(err)
+        }
+
+        const pId = id.toJSON()
+        conf.Identity.PeerID = pId.id
+        conf.Identity.PrivKey = pId.privKey
+        cb(null, conf)
       })
     }
   }
diff --git a/test/utils/factory-http/index.js b/test/utils/factory-http/index.js
@@ -35,46 +35,64 @@ function Factory () {
                                  .substring(2, 8)
     }
 
-    if (!config) {
-      config = JSON.parse(JSON.stringify(defaultConfig))
-      const pId = PeerId.create({ bits: 512 }).toJSON()
-      config.Identity.PeerID = pId.id
-      config.Identity.PrivKey = pId.privKey
-    }
-
-    // set up the repo
-    const repo = new IPFSRepo(repoPath, {
-      stores: require('fs-pull-blob-store')
-    })
-    repo.teardown = (done) => {
-      cleanRepo(repoPath)
-      done()
-    }
-
-   // create the IPFS node
-    const ipfs = new IPFS(repo)
-    ipfs.init({ emptyRepo: true, bits: 512 }, (err) => {
+    createConfig(config, (err, conf) => {
       if (err) {
         return callback(err)
       }
-      repo.config.set(config, launchNode)
-    })
 
-    function launchNode () {
-      // create the IPFS node through the HTTP-API
-      const node = new HTTPAPI(repo)
-      nodes.push({
-        httpApi: node,
-        repo: repo
+      config = conf
+      // set up the repo
+      const repo = new IPFSRepo(repoPath, {
+        stores: require('fs-pull-blob-store')
       })
+      repo.teardown = (done) => {
+        cleanRepo(repoPath)
+        done()
+      }
 
-      node.start((err) => {
+      // create the IPFS node
+      const ipfs = new IPFS(repo)
+      ipfs.init({ emptyRepo: true, bits: 512 }, (err) => {
         if (err) {
           return callback(err)
         }
-        console.log(node.apiMultiaddr)
-        const ctl = IPFSAPI(node.apiMultiaddr)
-        callback(null, ctl)
+        repo.config.set(config, launchNode)
+      })
+
+      function launchNode () {
+        // create the IPFS node through the HTTP-API
+        const node = new HTTPAPI(repo)
+        nodes.push({
+          httpApi: node,
+          repo: repo
+        })
+
+        node.start((err) => {
+          if (err) {
+            return callback(err)
+          }
+          console.log(node.apiMultiaddr)
+          const ctl = IPFSAPI(node.apiMultiaddr)
+          callback(null, ctl)
+        })
+      }
+    })
+
+    function createConfig (config, cb) {
+      if (config) {
+        return cb(null, config)
+      }
+      const conf = JSON.parse(JSON.stringify(defaultConfig))
+
+      PeerId.create({ bits: 512 }, (err, id) => {
+        if (err) {
+          return cb(err)
+        }
+
+        const pId = id.toJSON()
+        conf.Identity.PeerID = pId.id
+        conf.Identity.PrivKey = pId.privKey
+        cb(null, conf)
       })
     }
   }
