wip: reworking factory instantiation

Author: dryajov

README.md

@@ -13,8 +13,6 @@
 > Control an ipfs node daemon using either Node.js or the browser
 
 ```
-                                                                                                              
-                                                                                                              
                                                                     +-----+                                   
                                                                     |  H  |                                   
                                                                     |  T  |                                   
@@ -32,7 +30,6 @@
     | +-----------------------+   |                    +-----------------------|----                      |  |
     |                             |                                            |   +----------------------+  |
     +-----------------------------+                                            +-----------------------------+
-                                                                                                              
 ```
 
 ## Table of Contents
@@ -60,13 +57,10 @@ IPFS daemons are already easy to start and stop, but this module is here to do i
 // Start a disposable node, and get access to the api
 // print the node id, and stop the temporary daemon
 
-// IPFS_PATH will point to /tmp/ipfs_***** and will be
-// cleaned up when the process exits.
+const controllerFactory = require('ipfsd-ctl')
+const daemonFactory = controllerFactory()
 
-const daemonFactory = require('ipfsd-ctl')
-const local = daemonFactory.localController
-
-local.spawn(function (err, ipfsd) {
+daemonFactory.spawn(function (err, ipfsd) {
   const ipfsCtl = ipfsd.ctl
   const ipfsCtrl = ipfsd.ctrl
   ipfsCtl.id(function (err, id) {
@@ -82,21 +76,18 @@ local.spawn(function (err, ipfsd) {
 // Start a remote disposable node, and get access to the api
 // print the node id, and stop the temporary daemon
 
-// IPFS_PATH will point to /tmp/ipfs_***** and will be
-// cleaned up when the process exits.
-
-const daemonFactory = require('ipfsd-ctl')
-const server = daemonFactory.server
+const controllerFactory = require('ipfsd-ctl')
+const daemonFactory = controllerFactory()
 
-server.start((err) => {
+const port = 9999
+daemonFactory.start(port, (err) => {
   if (err) {
     throw err
   }
 
-  const remote = daemonFactory.remoteController(port || 9999)
-  remote.spawn(function (err, controller) {
-    const ipfsCtl = controller.ctl
-    const ipfsCtrl = controller.ctrl
+  daemonFactory.spawn(function (err, ipfsd) {
+    const ipfsCtl = ipfsd.ctl
+    const ipfsCtrl = ipfsd.ctrl
     ipfsCtl.id(function (err, id) {
       console.log(id)
       ipfsCtrl.stopDaemon()
@@ -138,16 +129,25 @@ module.exports = {
 
 #### Create factory
 
-- `daemonFactory.localController` - create a local controller
-- `daemonFactory.remoteController([port])` - create a remote controller, usable from browsers
-  - These methods return a factory that exposes the `spawn` method, which allows spawning and controlling ipfs nodes
-- `daemonFactory.server` - exposes `start` and `stop` methods to start and stop the bundled http server that is required to run the remote controller.
+```js
+const controllerFactory = require('ipfsd-ctl')
+const daemonFactory = controllerFactory()
+```
+
+> Create a factory that will expose the `daemonFactory.spawn` method
+
+- These method return a factory that exposes the `spawn` method, which allows spawning and controlling ipfs nodes
+
+
+> `daemonFactory.server` 
+
+- exposes `start` and `stop` methods to start and stop the bundled http server that is required to run the remote controller.
 
 #### Spawn nodes
 
 > Spawn either a js-ipfs or go-ipfs node through `localController` or `remoteController`
 
-`spawn([options], cb)`
+`spawn([options], callback)`
 
 - `options` - is an optional object with various options and ipfs config parameters
   - `js` bool (default false) - spawn a js or go node (default go)
@@ -158,10 +158,11 @@ module.exports = {
   - `args` - array of cmd line arguments to be passed to ipfs daemon
   - `config` - ipfs configuration options
 
- - `cb(err, {ctl: <ipfs-api instance>, ctrl: <Node (ctrl) instance>})` - a callback that receives an object with two members:
-   - `ctl` - an [ipfs-api](https://github.com/ipfs/js-ipfs-api) instance attached to the newly created ipfs node
-   - `ctrl` - an instance of a daemon controller object
-   
+ - `callback` - is a function with the signature `cb(err, ipfsd)` where:
+   - `err` - is the error set if spawning the node is unsuccessful
+   - `ipfsd` - is an object with two properties: 
+     - `ctl` - an [ipfs-api](https://github.com/ipfs/js-ipfs-api) instance attached to the newly created ipfs node
+     - `ctrl` - an instance of a daemon controller object
 
 ### IPFS Client (ctl)
 
@@ -170,14 +171,15 @@ module.exports = {
 
 ### IPFS Daemon Controller (ctrl)
 
+> The IPFS daemon controller that allows interacting with the spawned IPFS process
 
 #### `apiAddr` (getter) 
 
 > Get the address (multiaddr) of connected IPFS API.
 
 - returns multiaddr
 
-#### `gatewayAddr` (getter) 
+#### `gatewayAddr` (getter)
 
 > Get the address (multiaddr) of connected IPFS HTTP Gateway.
 

examples/id/id.js

@@ -1,10 +1,10 @@
 /* eslint no-console: 0 */
 'use strict'
 
-const factory = require('ipfsd-ctl')
-const localController = factory.localController
+const controllerFactory = require('ipfsd-ctl')
+const daemonFactory = controllerFactory()
 
-localController.spawn(function (err, ipfsd) {
+daemonFactory.spawn(function (err, ipfsd) {
   if (err) {
     throw err
   }
@@ -21,19 +21,19 @@ localController.spawn(function (err, ipfsd) {
   })
 })
 
-localController.spawn(function (err, ipfsd) {
+daemonFactory.spawn(function (err, ipfsd) {
   if (err) {
     throw err
   }
 
-  const ipfs = ipfsd.ctl
-  const node = ipfsd.ctrl
-  ipfs.id(function (err, id) {
+  const ipfsCtl = ipfsd.ctl
+  const ipfsCtrl = ipfsd.ctrl
+  ipfsCtl.id(function (err, id) {
     if (err) {
       throw err
     }
     console.log('bob')
     console.log(id)
-    node.stopDaemon()
+    ipfsCtrl.stopDaemon()
   })
 })

examples/local-disposable/local-disposable.js

@@ -4,46 +4,43 @@
 // Start a disposable node, and get access to the api
 // print the node id
 
-// IPFS_PATH will point to /tmp/ipfs_***** and will be
-// cleaned up when the process exits.
-
-const factory = require('ipfsd-ctl')
-const localController = factory.localController
+const controllerFactory = require('ipfsd-ctl')
+const daemonFactory = controllerFactory()
 
 // start a go daemon
-localController.spawn((err, ipfsd) => {
+daemonFactory.spawn((err, ipfsd) => {
   if (err) {
     throw err
   }
 
-  const ipfs = ipfsd.ctl
-  const node = ipfsd.ctrl
-  ipfs.id(function (err, id) {
+  const ipfsCtl = ipfsd.ctl
+  const ipfsCtrl = ipfsd.ctrl
+  ipfsCtl.id(function (err, id) {
     if (err) {
       throw err
     }
 
     console.log('go-ipfs')
     console.log(id)
-    node.stopDaemon()
+    ipfsCtrl.stopDaemon()
   })
 })
 
 // start a js daemon
-localController.spawn({ isJs: true }, (err, ipfsd) => {
+daemonFactory.spawn({ isJs: true }, (err, ipfsd) => {
   if (err) {
     throw err
   }
 
-  const ipfs = ipfsd.ctl
-  const node = ipfsd.ctrl
-  ipfs.id(function (err, id) {
+  const ipfsCtl = ipfsd.ctl
+  const ipfsCtrl = ipfsd.ctrl
+  ipfsCtl.id(function (err, id) {
     if (err) {
       throw err
     }
 
     console.log('js-ipfs')
     console.log(id)
-    node.stopDaemon()
+    ipfsCtrl.stopDaemon()
   })
 })

examples/local/local.js

@@ -1,11 +1,11 @@
 /* eslint no-console: 0 */
 'use strict'
 
-const factory = require('ipfsd-ctl')
-const localController = factory.localController
+const controllerFactory = require('ipfsd-ctl')
+const daemonFactory = controllerFactory()
 
 // opens an api connection to local running go-ipfs node
-localController.spawn({ disposable: false }, (err, ipfsd) => {
+daemonFactory.spawn({ disposable: false }, (err, ipfsd) => {
   if (err) {
     throw err
   }
@@ -24,7 +24,7 @@ localController.spawn({ disposable: false }, (err, ipfsd) => {
 })
 
 // opens an api connection to local running js-ipfs node
-localController.spawn({ isJs: true, disposable: false }, (err, ipfsd) => {
+daemonFactory.spawn({ isJs: true, disposable: false }, (err, ipfsd) => {
   if (err) {
     throw err
   }

examples/remote-disposable/remote-disposable.js

@@ -4,32 +4,29 @@
 // Start a remote disposable node, and get access to the api
 // print the node id, and stop the temporary daemon
 
-// IPFS_PATH will point to /tmp/ipfs_***** and will be
-// cleaned up when the process exits.
-
-const ipfsd = require('ipfsd-ctl')
-const server = ipfsd.server
+const controllerFactory = require('ipfsd-ctl')
+const daemonFactory = controllerFactory({ remote: true })
+const server = controllerFactory.server
 
 server.start((err) => {
   if (err) {
     throw err
   }
 
-  const remoteController = ipfsd.remoteController()
-  remoteController.spawn(function (err, controller) {
+  daemonFactory.spawn(function (err, ipfsd) {
     if (err) {
       throw err
     }
 
-    const ipfs = controller.ctl
-    const node = controller.ctrl
-    ipfs.id(function (err, id) {
+    const ipfsCtl = ipfsd.ctl
+    const ipfsCtrl = ipfsd.ctrl
+    ipfsCtl.id(function (err, id) {
       if (err) {
         throw err
       }
 
       console.log(id)
-      node.stopDaemon(() => server.stop())
+      ipfsCtrl.stopDaemon(() => server.stop())
     })
   })
 })

package.json

@@ -61,7 +61,6 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "@ljharb/eslint-config": "^12.2.1",
     "async": "^2.6.0",
     "debug": "^3.1.0",
     "detect-node": "^2.0.3",
@@ -91,7 +90,7 @@
     "aegir": "^12.2.0",
     "chai": "^4.1.2",
     "dirty-chai": "^2.0.1",
-    "ipfs": "^0.27.0",
+    "ipfs": "~0.27.0",
     "is-running": "1.0.5",
     "mkdirp": "^0.5.1",
     "multihashes": "~0.4.12",

src/daemon.js

@@ -38,11 +38,10 @@ class Node {
     const isJs = truthy(process.env.IPFS_JS)
 
     this.opts = opts || { isJs: isJs || false }
-    process.env.IPFS_JS = this.opts.isJs
 
     this.path = this.opts.disposable ? tempDir(isJs) : (this.opts.repoPath || tempDir(isJs))
     this.disposable = this.opts.disposable
-    this.exec = process.env.IPFS_EXEC || findIpfsExecutable(this.opts.isJs, rootPath)
+    this.exec = this.opts.executable || process.env.IPFS_EXEC || findIpfsExecutable(this.opts.isJs, rootPath)
     this.subprocess = null
     this.initialized = fs.existsSync(path)
     this.clean = true
@@ -115,7 +114,6 @@ class Node {
 
     if (initOpts.directory && initOpts.directory !== this.path) {
       this.path = initOpts.directory
-      this.env.IPFS_PATH = this.path
     }
 
     this._run(['init', '-b', keySize], { env: this.env }, (err, result) => {

src/index.js

@@ -2,9 +2,19 @@
 
 const localController = require('./local')
 const remote = require('./remote')
+const isNode = require('detect-node')
+const defaults = require('lodash.defaultsdeep')
 
-module.exports = {
-  localController,
-  remoteController: remote.remoteController,
-  server: remote.server
+function controllerFactory (opts) {
+  const options = defaults({}, opts, { remote: !isNode })
+
+  if (options.remote) {
+    return remote.remoteController(options.port)
+  }
+
+  return localController
 }
+
+controllerFactory.server = remote.server
+
+module.exports = controllerFactory

src/local.js

@@ -54,6 +54,7 @@ const IpfsDaemonController = {
    * - `disposable` bool - a new repo is created and initialized for each invocation
    * - `config` - ipfs configuration options
    * - `args` - array of cmd line arguments to be passed to ipfs daemon
+   * - `executable` - path to the desired IPFS executable to spawn
    *
    * @param {Object} [opts={}] - various config options and ipfs config parameters
    * @param {Function} callback(err, [`ipfs-api instance`, `Node (ctrl) instance`]) - a callback that receives an array with an `ipfs-instance` attached to the node and a `Node`

src/remote/server.js

@@ -4,22 +4,16 @@ const Hapi = require('hapi')
 const routes = require('./routes')
 
 let server = null
-exports.start = function start (port, host, cb) {
+exports.start = function start (port, cb) {
   if (typeof port === 'function') {
     cb = port
     port = 9999
   }
 
-  if (typeof host === 'function') {
-    cb = host
-    host = 'localhost'
-  }
-
   port = port || 9999
-  host = host || 'localhost'
 
   server = new Hapi.Server()
-  server.connection({ port, host, routes: { cors: true } })
+  server.connection({ port, host: 'localhost', routes: { cors: true } })
 
   routes(server)
   server.start(cb)