wip

Author: dignifiedquire

gulpfile.js

@@ -16,16 +16,16 @@ let nodes = []
 function spawnDaemon (num, callback) {
   num = leftPad(num, 3, 0)
 
-  const node = new IPFS({
-    repo: createTempRepo(),
-    init: {
-      bits: 1024
-    },
-    start: false,
-    EXPERIMENTAL: {
-      pubsub: true
-    },
-    config: {
+  // const node = new IPFS({
+  //   repo: createTempRepo(),
+  //   init: {
+  //     bits: 1024
+  //   },
+  //   start: false,
+  //   EXPERIMENTAL: {
+  //     pubsub: true
+  //   },
+    const config =  {
       Addresses: {
         Swarm: [
           `/ip4/127.0.0.1/tcp/10${num}`,
@@ -40,13 +40,11 @@ function spawnDaemon (num, callback) {
         }
       }
     }
-  })
+  // })
 
-  setTimeout(() => {
-    const daemon = new HTTPAPI(node._repo)
-    nodes.push(daemon)
-    setTimeout(() => daemon.start(callback), 400)
-  }, 800)
+  const daemon = new HTTPAPI(createTempRepo(), config)
+  nodes.push(daemon)
+  daemon.start(true, callback)
 }
 
 gulp.task('libnode:start', (done) => {

package.json

@@ -120,6 +120,7 @@
     "lodash.set": "^4.3.2",
     "lodash.sortby": "^4.7.0",
     "lodash.values": "^4.3.0",
+    "machina": "^2.0.0",
     "mafmt": "^2.1.6",
     "mkdirp": "^0.5.1",
     "multiaddr": "^2.2.2",

src/cli/bin.js

@@ -28,6 +28,13 @@ aliases.forEach((alias) => {
   cli.command(alias.command, alias.describe, alias.builder, alias.handler)
 })
 
+const args = process.argv.slice(2)
+
+// Need to skip to avoid locking the daemon
+if (args[0] === 'daemon') {
+  return cli.help().strict(false).completion().parse(args)
+}
+
 utils.getIPFS((err, ipfs, cleanup) => {
   if (err) {
     throw err
@@ -38,7 +45,7 @@ utils.getIPFS((err, ipfs, cleanup) => {
     .help()
     .strict(false)
     .completion()
-    .parse(process.argv.slice(2), {
+    .parse(args, {
       ipfs: ipfs
     }, (err, argv, output) => {
       cleanup(() => {

src/cli/commands/daemon.js

@@ -1,9 +1,6 @@
 'use strict'
 
 const HttpAPI = require('../../http-api')
-const debug = require('debug')
-const log = debug('cli:daemon')
-log.error = debug('cli:daemon:error')
 
 let httpAPI
 

src/cli/commands/init.js

@@ -35,17 +35,15 @@ module.exports = {
       start: false
     })
 
-    node.once('ready', () => {
-      node.init({
-        bits: argv.bits,
-        emptyRepo: argv.emptyRepo,
-        log: log
-      }, (err) => {
-        if (err) {
-          console.error(err.toString())
-          process.exit(1)
-        }
-      })
+    node.init({
+      bits: argv.bits,
+      emptyRepo: argv.emptyRepo,
+      log: log
+    }, (err) => {
+      if (err) {
+        console.error(err.toString())
+        process.exit(1)
+      }
     })
   }
 }

src/cli/utils.js

@@ -55,9 +55,12 @@ exports.getIPFS = (callback) => {
       cb()
     }
   }
-  node.once('ready', () => {
-    node.preStart(() => callback(null, node, cleanup))
+
+  node.on('error', (err) => {
+    throw err
   })
+
+  callback(null, node, cleanup)
 }
 
 exports.getRepoPath = () => {

src/core/boot.js

@@ -0,0 +1,91 @@
+'use strict'
+
+const waterfall = require('async/waterfall')
+const series = require('async/series')
+const extend = require('deep-extend')
+
+// Boot an IPFS node depending on the options set
+module.exports = (self) => {
+  self.log('booting')
+  const options = self._options
+  const doInit = options.init
+  const doStart = options.start
+  const config = options.config
+  const setConfig = config && typeof config === 'object'
+  const repoOpen = !self._repo.closed
+
+  const customInitOptions = typeof options.init === 'object' ? options.init : {}
+  const initOptions = Object.assign({
+    bits: 2048
+  }, customInitOptions)
+
+  const maybeOpenRepo = (cb) => {
+    waterfall([
+      (cb) => self._repo.exists(cb),
+      (exists, cb) => {
+        if (exists && !repoOpen) {
+          return self._repo.open(cb)
+        }
+        cb()
+      }
+    ], cb)
+  }
+
+  const done = (err) => {
+    if (err) {
+      self.emit('error', err)
+    }
+    self.log('boot:done', err)
+  }
+
+  const tasks = []
+
+  if (doInit) {
+    self.log('boot:doInit')
+    tasks.push((cb) => self.init(initOptions, cb))
+    next(null, true)
+  } else if (!repoOpen) {
+    self._repo.exists(next)
+  }
+
+  function next (err, hasRepo) {
+    self.log('boot:next')
+    if (err) {
+      return done(err)
+    }
+
+    if (hasRepo && !doInit) {
+      self.log('boot:maybeopenreop')
+      tasks.push(maybeOpenRepo)
+    }
+
+    if (setConfig) {
+      self.log('boot:setConfig')
+      // if (!hasRepo) {
+      //   console.log('WARNING, trying to set config on uninitialized repo, maybe forgot to set "init: true"')
+      // } else {
+      tasks.push((cb) => {
+          waterfall([
+            (cb) => self.config.get(cb),
+            (config, cb) => {
+              extend(config, options.config)
+              self.config.replace(config, cb)
+            }
+          ], cb)
+        })
+      // }
+    }
+
+    if (doStart) {
+      self.log('boot:doStart')
+      // if (!hasRepo) {
+      //   console.log('WARNING, trying to start ipfs node on uninitialized repo, maybe forgot to set "init: true"')
+      //   return done(new Error('Uninitalized repo'))
+      // } else {
+        tasks.push((cb) => self.start(cb))
+      // }
+    }
+
+    series(tasks, done)
+  }
+}

src/core/components/init.js

@@ -9,12 +9,14 @@ const addDefaultAssets = require('./init-assets')
 
 module.exports = function init (self) {
   return (opts, callback) => {
-    self.log('init')
     if (typeof opts === 'function') {
       callback = opts
       opts = {}
     }
 
+    self.state.init()
+    self.log('init')
+
     opts.emptyRepo = opts.emptyRepo || false
     opts.bits = Number(opts.bits) || 2048
     opts.log = opts.log || function () {}
@@ -48,7 +50,7 @@ module.exports = function init (self) {
 
         self._repo.init(config, cb)
       },
-      (_, cb) => self._repo.open(cb),
+      (cb) => self._repo.open(cb),
       (cb) => {
         self.log('repo opened')
         if (opts.emptyRepo) {
@@ -77,8 +79,10 @@ module.exports = function init (self) {
         self.log('init failed', err)
         return callback(err)
       }
+      self._state.daemon = 'initialized'
       self.emit('init')
       self.log('init done')
+      self.state.initialized()
       callback(null, res)
     })
   }

src/core/components/pre-start.js

@@ -11,31 +11,45 @@ const mafmt = require('mafmt')
  */
 module.exports = function preStart (self) {
   return (callback) => {
-    waterfall([
-      (cb) => self._repo.config.get(cb),
-      (config, cb) => {
-        const privKey = config.Identity.PrivKey
-
-        peerId.createFromPrivKey(privKey, (err, id) => {
-          cb(err, config, id)
-        })
-      },
-      (config, id, cb) => {
-        self._peerInfo = new PeerInfo(id)
-
-        config.Addresses.Swarm.forEach((addr) => {
-          let ma = multiaddr(addr)
-
-          if (!mafmt.IPFS.matches(ma)) {
-            ma = ma.encapsulate('/ipfs/' +
-              self._peerInfo.id.toB58String())
-          }
-
-          self._peerInfo.multiaddr.add(ma)
-        })
-
-        cb()
+    if (self._repo.closed) {
+      if (self._awaitInit) {
+        self._repo.once('init', start)
+      } else {
+        self._repo.once('open', start)
       }
-    ], callback)
+    } else {
+      start()
+    }
+
+    function start () {
+      self.log('pre-start')
+
+      waterfall([
+        (cb) => self._repo.config.get(cb),
+        (config, cb) => {
+          const privKey = config.Identity.PrivKey
+
+          peerId.createFromPrivKey(privKey, (err, id) => {
+            cb(err, config, id)
+          })
+        },
+        (config, id, cb) => {
+          self._peerInfo = new PeerInfo(id)
+
+          config.Addresses.Swarm.forEach((addr) => {
+            let ma = multiaddr(addr)
+
+            if (!mafmt.IPFS.matches(ma)) {
+              ma = ma.encapsulate('/ipfs/' +
+                                  self._peerInfo.id.toB58String())
+            }
+
+            self._peerInfo.multiaddr.add(ma)
+          })
+
+          cb()
+        }
+      ], callback)
+    }
   }
 }