From 4c320e8285dab06beeac4e20ed0af762669a5aff Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Thu, 24 Jan 2019 15:59:33 +0000
Subject: [PATCH 01/49] refactor: gateway for hapi 18

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 package.json                          |   3 +-
 src/cli/commands/daemon.js            |  29 +-
 src/http/gateway/resources/gateway.js | 214 +++++++--------
 src/http/gateway/routes/gateway.js    |  26 +-
 src/http/gateway/routes/index.js      |   4 +-
 src/http/index.js                     | 315 +++++++++++-----------
 test/gateway/index.js                 | 367 +++++++++++---------------
 7 files changed, 433 insertions(+), 525 deletions(-)

diff --git a/package.json b/package.json
index 02134a2e0c..7b26801a04 100644
--- a/package.json
+++ b/package.json
@@ -100,7 +100,8 @@
     "fsm-event": "^2.1.0",
     "get-folder-size": "^2.0.0",
     "glob": "^7.1.3",
-    "hapi": "^16.6.2",
+    "hapi": "^18.0.0",
+    "hapi-pino": "^5.2.0",
     "hapi-set-header": "^1.0.2",
     "hoek": "^6.1.2",
     "human-to-milliseconds": "^1.0.0",
diff --git a/src/cli/commands/daemon.js b/src/cli/commands/daemon.js
index 71024150de..d14dc07bb8 100644
--- a/src/cli/commands/daemon.js
+++ b/src/cli/commands/daemon.js
@@ -1,10 +1,6 @@
 'use strict'
 
-const promisify = require('promisify-es6')
-const utils = require('../utils')
-const print = utils.print
-
-let httpAPI
+const { getRepoPath, print, ipfsPathHelp } = require('../utils')
 
 module.exports = {
   command: 'daemon',
@@ -13,7 +9,7 @@ module.exports = {
 
   builder (yargs) {
     return yargs
-      .epilog(utils.ipfsPathHelp)
+      .epilog(ipfsPathHelp)
       .option('enable-sharding-experiment', {
         type: 'boolean',
         default: false
@@ -40,14 +36,25 @@ module.exports = {
     argv.resolve((async () => {
       print('Initializing IPFS daemon...')
 
-      const repoPath = utils.getRepoPath()
+      const repoPath = getRepoPath()
 
       // Required inline to reduce startup time
-      const HttpAPI = require('../../http')
-      httpAPI = new HttpAPI(process.env.IPFS_PATH, null, argv)
+      const HttpApi = require('../../http')
+      const api = new HttpApi({
+        silent: argv.silent,
+        repo: process.env.IPFS_PATH,
+        offline: argv.offline,
+        pass: argv.pass,
+        EXPERIMENTAL: {
+          pubsub: argv.enablePubsubExperiment,
+          ipnsPubsub: argv.enableNamesysPubsub,
+          dht: argv.enableDhtExperiment,
+          sharding: argv.enableShardingExperiment
+        }
+      })
 
       try {
-        await promisify(httpAPI.start)()
+        await api.start()
       } catch (err) {
         if (err.code === 'ENOENT' && err.message.match(/uninitialized/i)) {
           print('Error: no initialized ipfs repo found in ' + repoPath)
@@ -61,7 +68,7 @@ module.exports = {
 
       const cleanup = async () => {
         print(`Received interrupt signal, shutting down..`)
-        await promisify(httpAPI.stop)()
+        await api.stop()
         process.exit(0)
       }
 
diff --git a/src/http/gateway/resources/gateway.js b/src/http/gateway/resources/gateway.js
index 4f6cc67b8c..805b5bb620 100644
--- a/src/http/gateway/resources/gateway.js
+++ b/src/http/gateway/resources/gateway.js
@@ -4,14 +4,15 @@ const debug = require('debug')
 const log = debug('jsipfs:http-gateway')
 log.error = debug('jsipfs:http-gateway:error')
 const pull = require('pull-stream')
-const toPull = require('stream-to-pull-stream')
+const pushable = require('pull-pushable')
+const toStream = require('pull-stream-to-stream')
 const fileType = require('file-type')
 const mime = require('mime-types')
-const Stream = require('readable-stream')
-const CID = require('cids')
+const { PassThrough } = require('readable-stream')
 
 const { resolver } = require('ipfs-http-response')
 const PathUtils = require('../utils/path')
+const { cidToString } = require('../../../utils/cid')
 
 function detectContentType (ref, chunk) {
   let fileSignature
@@ -29,151 +30,140 @@ function detectContentType (ref, chunk) {
 }
 
 module.exports = {
-  checkCID: (request, reply) => {
+  checkCID (request, h) {
     if (!request.params.cid) {
-      return reply({
+      return h.response({
         Message: 'Path Resolve error: path must contain at least one component',
         Code: 0,
         Type: 'error'
       }).code(400).takeover()
     }
 
-    return reply({
-      ref: `/ipfs/${request.params.cid}`
-    })
+    return { ref: `/ipfs/${request.params.cid}` }
   },
 
-  handler: (request, reply) => {
-    const ref = request.pre.args.ref
-    const ipfs = request.server.app.ipfs
-
-    function handleGatewayResolverError (err) {
-      if (err) {
-        log.error('err: ', err.toString(), ' fileName: ', err.fileName)
-
-        const errorToString = err.toString()
-        // switch case with true feels so wrong.
-        switch (true) {
-          case (errorToString === 'Error: This dag node is a directory'):
-            resolver.directory(ipfs, ref, err.fileName, (err, data) => {
-              if (err) {
-                log.error(err)
-                return reply(err.toString()).code(500)
-              }
-              if (typeof data === 'string') {
-                // no index file found
-                if (!ref.endsWith('/')) {
-                  // for a directory, if URL doesn't end with a /
-                  // append / and redirect permanent to that URL
-                  return reply.redirect(`${ref}/`).permanent(true)
-                } else {
-                  // send directory listing
-                  return reply(data)
-                }
-              } else {
-                // found index file
-                // redirect to URL/<found-index-file>
-                return reply.redirect(PathUtils.joinURLParts(ref, data[0].name))
-              }
-            })
-            break
-          case (errorToString.startsWith('Error: no link named')):
-            return reply(errorToString).code(404)
-          case (errorToString.startsWith('Error: multihash length inconsistent')):
-          case (errorToString.startsWith('Error: Non-base58 character')):
-            return reply({ Message: errorToString, Code: 0, Type: 'error' }).code(400)
-          default:
+  async handler (request, h) {
+    const { ref } = request.pre.args
+    const { ipfs } = request.server.app
+
+    let data
+    try {
+      data = await resolver.cid(ipfs, ref)
+    } catch (err) {
+      const errorToString = err.toString()
+      log.error('err: ', errorToString, ' fileName: ', err.fileName)
+
+      // switch case with true feels so wrong.
+      switch (true) {
+        case (errorToString === 'Error: This dag node is a directory'):
+          try {
+            data = await resolver.directory(ipfs, ref, err.cid)
+          } catch (err) {
             log.error(err)
-            return reply({ Message: errorToString, Code: 0, Type: 'error' }).code(500)
-        }
+            return h.response(err.toString()).code(500)
+          }
+
+          if (typeof data === 'string') {
+            // no index file found
+            if (!ref.endsWith('/')) {
+              // for a directory, if URL doesn't end with a /
+              // append / and redirect permanent to that URL
+              return h.redirect(`${ref}/`).permanent(true)
+            }
+            // send directory listing
+            return h.response(data)
+          }
+
+          // found index file
+          // redirect to URL/<found-index-file>
+          return h.redirect(PathUtils.joinURLParts(ref, data[0].name))
+        case (errorToString.startsWith('Error: no link named')):
+          return h.response(errorToString).code(404)
+        case (errorToString.startsWith('Error: multihash length inconsistent')):
+        case (errorToString.startsWith('Error: Non-base58 character')):
+          return h.response({ Message: errorToString, Code: 0, Type: 'error' }).code(400)
+        default:
+          log.error(err)
+          return h.response({ Message: errorToString, Code: 0, Type: 'error' }).code(500)
       }
     }
 
-    return resolver.multihash(ipfs, ref, (err, data) => {
-      if (err) {
-        return handleGatewayResolverError(err)
-      }
+    if (ref.endsWith('/')) {
+      // remove trailing slash for files
+      return h.redirect(PathUtils.removeTrailingSlash(ref)).permanent(true)
+    }
 
-      const stream = ipfs.catReadableStream(data.multihash)
-      stream.once('error', (err) => {
-        if (err) {
-          log.error(err)
-          return reply(err.toString()).code(500)
-        }
-      })
-
-      if (ref.endsWith('/')) {
-        // remove trailing slash for files
-        return reply
-          .redirect(PathUtils.removeTrailingSlash(ref))
-          .permanent(true)
-      } else {
-        if (!stream._read) {
-          stream._read = () => {}
-          stream._readableState = {}
-        }
-
-        //  response.continue()
-        let contentTypeDetected = false
-        let stream2 = new Stream.PassThrough({ highWaterMark: 1 })
-        stream2.on('error', (err) => {
-          log.error('stream2 err: ', err)
-        })
-
-        let response = reply(stream2).hold()
-
-        // Etag maps directly to an identifier for a specific version of a resource
-        // TODO: change to .cid.toBaseEncodedString() after switch to new js-ipfs-http-response
-        response.header('Etag', `"${data.multihash}"`)
-
-        // Set headers specific to the immutable namespace
-        if (ref.startsWith('/ipfs/')) {
-          response.header('Cache-Control', 'public, max-age=29030400, immutable')
-        }
-
-        pull(
-          toPull.source(stream),
-          pull.through((chunk) => {
-            // Guess content-type (only once)
-            if (chunk.length > 0 && !contentTypeDetected) {
-              let contentType = detectContentType(ref, chunk)
-              contentTypeDetected = true
+    return new Promise((resolve, reject) => {
+      let pusher
+      let started = false
+
+      pull(
+        ipfs.catPullStream(data.cid),
+        pull.drain(
+          chunk => {
+            if (!started) {
+              started = true
+              pusher = pushable()
+              const res = h.response(toStream.source(pusher).pipe(new PassThrough()))
+
+              // Etag maps directly to an identifier for a specific version of a resource
+              res.header('Etag', `"${data.cid}"`)
+
+              // Set headers specific to the immutable namespace
+              if (ref.startsWith('/ipfs/')) {
+                res.header('Cache-Control', 'public, max-age=29030400, immutable')
+              }
+
+              const contentType = detectContentType(ref, chunk)
 
               log('ref ', ref)
               log('mime-type ', contentType)
 
               if (contentType) {
                 log('writing content-type header')
-                response.header('Content-Type', contentType)
+                res.header('Content-Type', contentType)
               }
 
-              response.send()
+              resolve(res)
             }
+            pusher.push(chunk)
+          },
+          err => {
+            if (err) {
+              log.error(err)
+
+              // We already started flowing, abort the stream
+              if (started) {
+                return pusher.end(err)
+              }
 
-            stream2.write(chunk)
-          }),
-          pull.onEnd(() => {
-            log('stream ended.')
-            stream2.end()
-          })
+              return resolve(h.response({
+                Message: err.message,
+                Code: 0,
+                Type: 'error'
+              }).code(500).takeover())
+            }
+
+            pusher.end()
+          }
         )
-      }
+      )
     })
   },
 
-  afterHandler: (request, reply) => {
-    const response = request.response
+  afterHandler (request, h) {
+    const { response } = request
     if (response.statusCode === 200) {
-      const ref = request.pre.args.ref
+      const { ref } = request.pre.args
       response.header('X-Ipfs-Path', ref)
       if (ref.startsWith('/ipfs/')) {
         const rootCid = ref.split('/')[2]
-        const ipfsOrigin = new CID(rootCid).toV1().toBaseEncodedString('base32')
+        const ipfsOrigin = cidToString(rootCid, { base: 'base32' })
         response.header('Suborigin', 'ipfs000' + ipfsOrigin)
       }
       // TODO: we don't have case-insensitive solution for /ipns/ yet (https://github.com/ipfs/go-ipfs/issues/5287)
     }
-    reply.continue()
+    return response
   }
 
 }
diff --git a/src/http/gateway/routes/gateway.js b/src/http/gateway/routes/gateway.js
index 810a520437..eb8543d465 100644
--- a/src/http/gateway/routes/gateway.js
+++ b/src/http/gateway/routes/gateway.js
@@ -2,20 +2,16 @@
 
 const resources = require('../resources')
 
-module.exports = (server) => {
-  const gateway = server.select('Gateway')
-
-  gateway.route({
-    method: '*',
-    path: '/ipfs/{cid*}',
-    config: {
-      pre: [
-        { method: resources.gateway.checkCID, assign: 'args' }
-      ],
-      handler: resources.gateway.handler,
-      ext: {
-        onPostHandler: { method: resources.gateway.afterHandler }
-      }
+module.exports = {
+  method: '*',
+  path: '/ipfs/{cid*}',
+  options: {
+    handler: resources.gateway.handler,
+    pre: [
+      { method: resources.gateway.checkCID, assign: 'args' }
+    ],
+    ext: {
+      onPostHandler: { method: resources.gateway.afterHandler }
     }
-  })
+  }
 }
diff --git a/src/http/gateway/routes/index.js b/src/http/gateway/routes/index.js
index 0e0656c258..2cbf163b04 100644
--- a/src/http/gateway/routes/index.js
+++ b/src/http/gateway/routes/index.js
@@ -1,5 +1,3 @@
 'use strict'
 
-module.exports = (server) => {
-  require('./gateway')(server)
-}
+module.exports = [require('./gateway')]
diff --git a/src/http/index.js b/src/http/index.js
index f35b05d075..aa28870323 100644
--- a/src/http/index.js
+++ b/src/http/index.js
@@ -1,11 +1,11 @@
 'use strict'
 
-const series = require('async/series')
 const Hapi = require('hapi')
+const Pino = require('hapi-pino')
 const debug = require('debug')
 const multiaddr = require('multiaddr')
-const setHeader = require('hapi-set-header')
-const once = require('once')
+// const setHeader = require('hapi-set-header')
+const promisify = require('promisify-es6')
 
 const IPFS = require('../core')
 const WStar = require('libp2p-webrtc-star')
@@ -13,184 +13,167 @@ const TCP = require('libp2p-tcp')
 const MulticastDNS = require('libp2p-mdns')
 const WS = require('libp2p-websockets')
 const Bootstrap = require('libp2p-bootstrap')
-const errorHandler = require('./error-handler')
+// const errorHandler = require('./error-handler')
 
 function uriToMultiaddr (uri) {
   const ipPort = uri.split('/')[2].split(':')
   return `/ip4/${ipPort[0]}/tcp/${ipPort[1]}`
 }
 
-function HttpApi (repo, config, cliArgs) {
-  cliArgs = cliArgs || {}
-  this.node = undefined
-  this.server = undefined
-
-  this.log = debug('jsipfs:http-api')
-  this.log.error = debug('jsipfs:http-api:error')
-
-  if (process.env.IPFS_MONITORING) {
-    // Setup debug metrics collection
-    const prometheusClient = require('prom-client')
-    const prometheusGcStats = require('prometheus-gc-stats')
-    const collectDefaultMetrics = prometheusClient.collectDefaultMetrics
-    collectDefaultMetrics({ timeout: 5000 })
-    prometheusGcStats(prometheusClient.register)()
+class HttpApi {
+  constructor (options) {
+    this._options = options || {}
+    this._log = debug('jsipfs:http-api')
+    this._log.error = debug('jsipfs:http-api:error')
+
+    if (process.env.IPFS_MONITORING) {
+      // Setup debug metrics collection
+      const prometheusClient = require('prom-client')
+      const prometheusGcStats = require('prometheus-gc-stats')
+      const collectDefaultMetrics = prometheusClient.collectDefaultMetrics
+      collectDefaultMetrics({ timeout: 5000 })
+      prometheusGcStats(prometheusClient.register)()
+    }
   }
 
-  this.start = (init, callback) => {
-    if (typeof init === 'function') {
-      callback = init
-      init = false
+  async start () {
+    this._log('starting')
+
+    const libp2p = { modules: {} }
+
+    // Attempt to use any of the WebRTC versions available globally
+    let electronWebRTC
+    let wrtc
+    try {
+      electronWebRTC = require('electron-webrtc')()
+    } catch (err) {
+      this._log('failed to load optional electron-webrtc dependency')
+    }
+    try {
+      wrtc = require('wrtc')
+    } catch (err) {
+      this._log('failed to load optional webrtc dependency')
     }
-    this.log('starting')
-
-    series([
-      (cb) => {
-        cb = once(cb)
-
-        const libp2p = { modules: {} }
-
-        // Attempt to use any of the WebRTC versions available globally
-        let electronWebRTC
-        let wrtc
-        try {
-          electronWebRTC = require('electron-webrtc')()
-        } catch (err) {
-          this.log('failed to load optional electron-webrtc dependency')
-        }
-        try {
-          wrtc = require('wrtc')
-        } catch (err) {
-          this.log('failed to load optional webrtc dependency')
-        }
-
-        if (wrtc || electronWebRTC) {
-          const using = wrtc ? 'wrtc' : 'electron-webrtc'
-          this.log(`Using ${using} for webrtc support`)
-          const wstar = new WStar({ wrtc: (wrtc || electronWebRTC) })
-          libp2p.modules.transport = [TCP, WS, wstar]
-          libp2p.modules.peerDiscovery = [MulticastDNS, Bootstrap, wstar.discovery]
-        }
-
-        // try-catch so that programmer errors are not swallowed during testing
-        try {
-          // start the daemon
-          this.node = new IPFS({
-            silent: cliArgs.silent,
-            repo: repo,
-            init: init,
-            start: true,
-            config: config,
-            offline: cliArgs.offline,
-            pass: cliArgs.pass,
-            EXPERIMENTAL: {
-              pubsub: cliArgs.enablePubsubExperiment,
-              ipnsPubsub: cliArgs.enableNamesysPubsub,
-              dht: cliArgs.enableDhtExperiment,
-              sharding: cliArgs.enableShardingExperiment
-            },
-            libp2p: libp2p
-          })
-        } catch (err) {
-          return cb(err)
-        }
-
-        this.node.once('error', (err) => {
-          this.log('error starting core', err)
-          err.code = 'ENOENT'
-          cb(err)
-        })
-        this.node.once('start', cb)
-      },
-      (cb) => {
-        this.log('fetching config')
-        this.node._repo.config.get((err, config) => {
-          if (err) {
-            return callback(err)
-          }
-
-          // CORS is enabled by default
-          // TODO: shouldn't, fix this
-          this.server = new Hapi.Server({
-            connections: {
-              routes: {
-                cors: true
-              }
-            },
-            debug: process.env.DEBUG ? {
-              request: ['*'],
-              log: ['*']
-            } : undefined
-          })
-
-          this.server.app.ipfs = this.node
-          const api = config.Addresses.API.split('/')
-          const gateway = config.Addresses.Gateway.split('/')
-
-          // select which connection with server.select(<label>) to add routes
-          this.server.connection({
-            host: api[2],
-            port: api[4],
-            labels: 'API'
-          })
-
-          this.server.connection({
-            host: gateway[2],
-            port: gateway[4],
-            labels: 'Gateway'
-          })
-
-          // Nicer errors
-          errorHandler(this, this.server)
-
-          // load routes
-          require('./api/routes')(this.server)
-          // load gateway routes
-          require('./gateway/routes')(this.server)
-
-          // Set default headers
-          setHeader(this.server,
-            'Access-Control-Allow-Headers',
-            'X-Stream-Output, X-Chunked-Output, X-Content-Length')
-          setHeader(this.server,
-            'Access-Control-Expose-Headers',
-            'X-Stream-Output, X-Chunked-Output, X-Content-Length')
-
-          this.server.start(cb)
-        })
-      },
-      (cb) => {
-        const api = this.server.select('API')
-        const gateway = this.server.select('Gateway')
-        this.apiMultiaddr = multiaddr('/ip4/127.0.0.1/tcp/' + api.info.port)
-        api.info.ma = uriToMultiaddr(api.info.uri)
-        gateway.info.ma = uriToMultiaddr(gateway.info.uri)
-
-        this.node._print('API listening on %s', api.info.ma)
-        this.node._print('Gateway (read only) listening on %s', gateway.info.ma)
-        this.node._print('Web UI available at %s', api.info.uri + '/webui')
-
-        // for the CLI to know the where abouts of the API
-        this.node._repo.apiAddr.set(api.info.ma, cb)
+
+    if (wrtc || electronWebRTC) {
+      const using = wrtc ? 'wrtc' : 'electron-webrtc'
+      this._log(`Using ${using} for webrtc support`)
+      const wstar = new WStar({ wrtc: (wrtc || electronWebRTC) })
+      libp2p.modules.transport = [TCP, WS, wstar]
+      libp2p.modules.peerDiscovery = [MulticastDNS, Bootstrap, wstar.discovery]
+    }
+
+    // start the daemon
+    const ipfsOpts = Object.assign({ init: false }, this._options, { start: true, libp2p })
+    const ipfs = new IPFS(ipfsOpts)
+
+    await new Promise((resolve, reject) => {
+      ipfs.once('error', err => {
+        this._log('error starting core', err)
+        err.code = 'ENOENT'
+        reject(err)
+      })
+      ipfs.once('start', resolve)
+    })
+
+    this._ipfs = ipfs
+
+    const config = await ipfs.config.get()
+
+    const apiAddr = config.Addresses.API.split('/')
+    const apiServer = await this._createApiServer(apiAddr[2], apiAddr[4], ipfs)
+    await apiServer.start()
+    apiServer.info.ma = uriToMultiaddr(apiServer.info.uri)
+    this._apiServer = apiServer
+
+    // for the CLI to know the where abouts of the API
+    await promisify(ipfs._repo.apiAddr.set)(apiServer.info.ma)
+
+    const gatewayAddr = config.Addresses.Gateway.split('/')
+    const gatewayServer = await this._createGatewayServer(gatewayAddr[2], gatewayAddr[4], ipfs)
+    await gatewayServer.start()
+    gatewayServer.info.ma = uriToMultiaddr(gatewayServer.info.uri)
+    this._gatewayServer = gatewayServer
+
+    ipfs._print('API listening on %s', apiServer.info.ma)
+    ipfs._print('Gateway (read only) listening on %s', gatewayServer.info.ma)
+    ipfs._print('Web UI available at %s', apiServer.info.uri + '/webui')
+    this._log('started')
+    return this
+  }
+
+  async _createApiServer (host, port, ipfs) {
+    const server = Hapi.server({ host, port })
+    server.app.ipfs = ipfs
+
+    await server.register({
+      plugin: Pino,
+      options: {
+        prettyPrint: Boolean(process.env.DEBUG),
+        logEvents: ['onPostStart', 'onPostStop', 'response', 'request-error'],
+        level: process.env.DEBUG ? 'debug' : 'error'
       }
-    ], (err) => {
-      this.log('done', err)
-      callback(err)
     })
+
+    // CORS is enabled by default
+    // TODO: shouldn't, fix this
+    // -          this.server = new Hapi.Server({
+    // -            connections: {
+    // -              routes: {
+    // -                cors: true
+    // -              }
+    // -            },
+
+    // Set default headers
+    // setHeader(server,
+    //   'Access-Control-Allow-Headers',
+    //   'X-Stream-Output, X-Chunked-Output, X-Content-Length')
+    // setHeader(server,
+    //   'Access-Control-Expose-Headers',
+    //   'X-Stream-Output, X-Chunked-Output, X-Content-Length')
+
+    // TODO: errorHandler(this, server)
+
+    // server.route(require('./gateway/routes'))
+
+    // TODO FIXME
+    return server
   }
 
-  this.stop = (callback) => {
-    this.log('stopping')
-    series([
-      (cb) => this.server.stop(cb),
-      (cb) => this.node.stop(cb)
-    ], (err) => {
-      if (err) {
-        this.log.error(err)
-        console.error('There were errors stopping')
+  async _createGatewayServer (host, port, ipfs) {
+    const server = Hapi.server({ host, port })
+    server.app.ipfs = ipfs
+
+    await server.register({
+      plugin: Pino,
+      options: {
+        prettyPrint: Boolean(process.env.DEBUG),
+        logEvents: ['onPostStart', 'onPostStop', 'response', 'request-error'],
+        level: process.env.DEBUG ? 'debug' : 'error'
       }
-      callback()
     })
+
+    server.route(require('./gateway/routes'))
+
+    // TODO: errorHandler(this, server)
+
+    return server
+  }
+
+  get apiAddr () {
+    if (!this._servers) throw new Error('API address unavailable - server is not started')
+    return multiaddr('/ip4/127.0.0.1/tcp/' + this._server.api.info.port)
+  }
+
+  async stop () {
+    this._log('stopping')
+    await Promise.all([
+      this._apiServer && this._apiServer.stop(),
+      this._gatewayServer && this._gatewayServer.stop(),
+      this._ipfs && this._ipfs.stop()
+    ])
+    this._log('stopped')
+    return this
   }
 }
 
diff --git a/test/gateway/index.js b/test/gateway/index.js
index 682c4497b4..7e65588ff7 100644
--- a/test/gateway/index.js
+++ b/test/gateway/index.js
@@ -5,7 +5,6 @@ const chai = require('chai')
 const dirtyChai = require('dirty-chai')
 const expect = chai.expect
 chai.use(dirtyChai)
-const series = require('async/series')
 const API = require('../../src/http')
 const loadFixture = require('aegir/fixtures')
 const os = require('os')
@@ -30,20 +29,24 @@ describe('HTTP Gateway', function () {
   let http = {}
   let gateway
 
-  before(function (done) {
+  before(async () => {
     this.timeout(60 * 1000)
     const repoPath = path.join(os.tmpdir(), '/ipfs-' + hat())
 
-    http.api = new API(repoPath, {
-      Addresses: {
-        Swarm: ['/ip4/127.0.0.1/tcp/0'],
-        API: '/ip4/127.0.0.1/tcp/0',
-        Gateway: '/ip4/127.0.0.1/tcp/0'
-      },
-      Bootstrap: [],
-      Discovery: {
-        MDNS: {
-          Enabled: false
+    http.api = new API({
+      repo: repoPath,
+      init: true,
+      config: {
+        Addresses: {
+          Swarm: ['/ip4/127.0.0.1/tcp/0'],
+          API: '/ip4/127.0.0.1/tcp/0',
+          Gateway: '/ip4/127.0.0.1/tcp/0'
+        },
+        Bootstrap: [],
+        Discovery: {
+          MDNS: {
+            Enabled: false
+          }
         }
       }
     })
@@ -55,133 +58,75 @@ describe('HTTP Gateway', function () {
 
     const emptyDir = (name) => ({ path: `test-folder/${name}` })
 
-    series([
-      (cb) => http.api.start(true, cb),
-      (cb) => {
-        gateway = http.api.server.select('Gateway')
-        const expectedRootMultihash = 'QmbQD7EMEL1zeebwBsWEfA3ndgSS6F7S6iTuwuqasPgVRi'
-
-        const dirs = [
-          content('index.html'),
-          emptyDir('empty-folder'),
-          content('nested-folder/hello.txt'),
-          content('nested-folder/ipfs.txt'),
-          content('nested-folder/nested.html'),
-          emptyDir('nested-folder/empty')
-        ]
-
-        http.api.node.add(dirs, (err, res) => {
-          expect(err).to.not.exist()
-          const root = res[res.length - 1]
-
-          expect(root.path).to.equal('test-folder')
-          expect(root.hash).to.equal(expectedRootMultihash)
-          cb()
-        })
-      },
-      (cb) => {
-        const expectedMultihash = 'Qme79tX2bViL26vNjPsF3DP1R9rMKMvnPYJiKTTKPrXJjq'
-
-        http.api.node.add(bigFile, (err, res) => {
-          expect(err).to.not.exist()
-          const file = res[0]
-          expect(file.path).to.equal(expectedMultihash)
-          expect(file.hash).to.equal(expectedMultihash)
-          cb()
-        })
-      },
-      (cb) => {
-        const expectedMultihash = 'QmT78zSuBmuS4z925WZfrqQ1qHaJ56DQaTfyMUF7F8ff5o'
-
-        http.api.node.add(Buffer.from('hello world' + '\n'), { cidVersion: 0 }, (err, res) => {
-          expect(err).to.not.exist()
-          const file = res[0]
-          expect(file.path).to.equal(expectedMultihash)
-          expect(file.hash).to.equal(expectedMultihash)
-          cb()
-        })
-      },
-      (cb) => {
-        const expectedMultihash = 'QmW2WQi7j6c7UgJTarActp7tDNikE4B2qXtFCfLPdsgaTQ'
-
-        let dir = [
-          content('cat-folder/cat.jpg')
-        ]
-
-        http.api.node.add(dir, (err, res) => {
-          expect(err).to.not.exist()
-          const file = res[1]
-          expect(file.path).to.equal('test-folder/cat-folder')
-          expect(file.hash).to.equal(expectedMultihash)
-          cb()
-        })
-      },
-      (cb) => {
-        const expectedMultihash = 'QmVZoGxDvKM9KExc8gaL4uTbhdNtWhzQR7ndrY7J1gWs3F'
-
-        let dir = [
-          content('unsniffable-folder/hexagons-xml.svg'),
-          content('unsniffable-folder/hexagons.svg')
-        ]
-
-        http.api.node.add(dir, (err, res) => {
-          expect(err).to.not.exist()
-          const file = res[res.length - 2]
-          expect(file.path).to.equal('test-folder/unsniffable-folder')
-          expect(file.hash).to.equal(expectedMultihash)
-          cb()
-        })
-      }
-    ], done)
+    await http.api.start()
+
+    gateway = http.api._gatewayServer
+
+    // QmbQD7EMEL1zeebwBsWEfA3ndgSS6F7S6iTuwuqasPgVRi
+    await http.api._ipfs.add([
+      content('index.html'),
+      emptyDir('empty-folder'),
+      content('nested-folder/hello.txt'),
+      content('nested-folder/ipfs.txt'),
+      content('nested-folder/nested.html'),
+      emptyDir('nested-folder/empty')
+    ])
+    // Qme79tX2bViL26vNjPsF3DP1R9rMKMvnPYJiKTTKPrXJjq
+    await http.api._ipfs.add(bigFile)
+    // QmT78zSuBmuS4z925WZfrqQ1qHaJ56DQaTfyMUF7F8ff5o
+    await http.api._ipfs.add(Buffer.from('hello world' + '\n'), { cidVersion: 0 })
+    // QmW2WQi7j6c7UgJTarActp7tDNikE4B2qXtFCfLPdsgaTQ
+    await http.api._ipfs.add([content('cat-folder/cat.jpg')])
+    // QmVZoGxDvKM9KExc8gaL4uTbhdNtWhzQR7ndrY7J1gWs3F
+    await http.api._ipfs.add([
+      content('unsniffable-folder/hexagons-xml.svg'),
+      content('unsniffable-folder/hexagons.svg')
+    ])
   })
 
-  after((done) => http.api.stop(done))
+  after(() => http.api.stop())
 
-  it('returns 400 for request without argument', (done) => {
-    gateway.inject({
+  it('returns 400 for request without argument', async () => {
+    const res = await gateway.inject({
       method: 'GET',
       url: '/ipfs'
-    }, (res) => {
-      expect(res.statusCode).to.equal(400)
-      expect(res.result.Message).to.be.a('string')
-      expect(res.headers['cache-control']).to.equal('no-cache')
-      expect(res.headers.etag).to.equal(undefined)
-      expect(res.headers['x-ipfs-path']).to.equal(undefined)
-      expect(res.headers.suborigin).to.equal(undefined)
-      done()
     })
+
+    expect(res.statusCode).to.equal(400)
+    expect(res.result.Message).to.be.a('string')
+    expect(res.headers['cache-control']).to.equal('no-cache')
+    expect(res.headers.etag).to.equal(undefined)
+    expect(res.headers['x-ipfs-path']).to.equal(undefined)
+    expect(res.headers.suborigin).to.equal(undefined)
   })
 
-  it('400 for request with invalid argument', (done) => {
-    gateway.inject({
+  it('400 for request with invalid argument', async () => {
+    const res = await gateway.inject({
       method: 'GET',
       url: '/ipfs/invalid'
-    }, (res) => {
-      expect(res.statusCode).to.equal(400)
-      expect(res.result.Message).to.be.a('string')
-      expect(res.headers['cache-control']).to.equal('no-cache')
-      expect(res.headers.etag).to.equal(undefined)
-      expect(res.headers['x-ipfs-path']).to.equal(undefined)
-      expect(res.headers.suborigin).to.equal(undefined)
-      done()
     })
+
+    expect(res.statusCode).to.equal(400)
+    expect(res.result.Message).to.be.a('string')
+    expect(res.headers['cache-control']).to.equal('no-cache')
+    expect(res.headers.etag).to.equal(undefined)
+    expect(res.headers['x-ipfs-path']).to.equal(undefined)
+    expect(res.headers.suborigin).to.equal(undefined)
   })
 
-  it('valid CIDv0', (done) => {
-    gateway.inject({
+  it('valid CIDv0', async () => {
+    const res = await gateway.inject({
       method: 'GET',
       url: '/ipfs/QmT78zSuBmuS4z925WZfrqQ1qHaJ56DQaTfyMUF7F8ff5o'
-    }, (res) => {
-      expect(res.statusCode).to.equal(200)
-      expect(res.rawPayload).to.eql(Buffer.from('hello world' + '\n'))
-      expect(res.payload).to.equal('hello world' + '\n')
-      expect(res.headers['cache-control']).to.equal('public, max-age=29030400, immutable')
-      expect(res.headers.etag).to.equal('"QmT78zSuBmuS4z925WZfrqQ1qHaJ56DQaTfyMUF7F8ff5o"')
-      expect(res.headers['x-ipfs-path']).to.equal('/ipfs/QmT78zSuBmuS4z925WZfrqQ1qHaJ56DQaTfyMUF7F8ff5o')
-      expect(res.headers.suborigin).to.equal('ipfs000bafybeicg2rebjoofv4kbyovkw7af3rpiitvnl6i7ckcywaq6xjcxnc2mby')
-
-      done()
     })
+
+    expect(res.statusCode).to.equal(200)
+    expect(res.rawPayload).to.eql(Buffer.from('hello world' + '\n'))
+    expect(res.payload).to.equal('hello world' + '\n')
+    expect(res.headers['cache-control']).to.equal('public, max-age=29030400, immutable')
+    expect(res.headers.etag).to.equal('"QmT78zSuBmuS4z925WZfrqQ1qHaJ56DQaTfyMUF7F8ff5o"')
+    expect(res.headers['x-ipfs-path']).to.equal('/ipfs/QmT78zSuBmuS4z925WZfrqQ1qHaJ56DQaTfyMUF7F8ff5o')
+    expect(res.headers.suborigin).to.equal('ipfs000bafybeicg2rebjoofv4kbyovkw7af3rpiitvnl6i7ckcywaq6xjcxnc2mby')
   })
 
   /* TODO when support for CIDv1 lands
@@ -203,152 +148,140 @@ describe('HTTP Gateway', function () {
   })
   */
 
-  it('stream a large file', (done) => {
-    let bigFileHash = 'Qme79tX2bViL26vNjPsF3DP1R9rMKMvnPYJiKTTKPrXJjq'
+  it('stream a large file', async () => {
+    const bigFileHash = 'Qme79tX2bViL26vNjPsF3DP1R9rMKMvnPYJiKTTKPrXJjq'
 
-    gateway.inject({
+    const res = await gateway.inject({
       method: 'GET',
       url: '/ipfs/' + bigFileHash
-    }, (res) => {
-      expect(res.statusCode).to.equal(200)
-      expect(res.rawPayload).to.eql(bigFile)
-      done()
     })
+
+    expect(res.statusCode).to.equal(200)
+    expect(res.rawPayload).to.eql(bigFile)
   })
 
-  it('load a jpg file', (done) => {
-    let kitty = 'QmW2WQi7j6c7UgJTarActp7tDNikE4B2qXtFCfLPdsgaTQ/cat.jpg'
+  it('load a jpg file', async () => {
+    const kitty = 'QmW2WQi7j6c7UgJTarActp7tDNikE4B2qXtFCfLPdsgaTQ/cat.jpg'
 
-    gateway.inject({
+    const res = await gateway.inject({
       method: 'GET',
       url: '/ipfs/' + kitty
-    }, (res) => {
-      expect(res.statusCode).to.equal(200)
-      expect(res.headers['content-type']).to.equal('image/jpeg')
-      expect(res.headers['x-ipfs-path']).to.equal('/ipfs/' + kitty)
-      expect(res.headers['cache-control']).to.equal('public, max-age=29030400, immutable')
-      expect(res.headers.etag).to.equal('"Qmd286K6pohQcTKYqnS1YhWrCiS4gz7Xi34sdwMe9USZ7u"')
-      expect(res.headers.suborigin).to.equal('ipfs000bafybeidsg6t7ici2osxjkukisd5inixiunqdpq2q5jy4a2ruzdf6ewsqk4')
+    })
 
-      let fileSignature = fileType(res.rawPayload)
-      expect(fileSignature.mime).to.equal('image/jpeg')
-      expect(fileSignature.ext).to.equal('jpg')
+    expect(res.statusCode).to.equal(200)
+    expect(res.headers['content-type']).to.equal('image/jpeg')
+    expect(res.headers['x-ipfs-path']).to.equal('/ipfs/' + kitty)
+    expect(res.headers['cache-control']).to.equal('public, max-age=29030400, immutable')
+    expect(res.headers.etag).to.equal('"Qmd286K6pohQcTKYqnS1YhWrCiS4gz7Xi34sdwMe9USZ7u"')
+    expect(res.headers.suborigin).to.equal('ipfs000bafybeidsg6t7ici2osxjkukisd5inixiunqdpq2q5jy4a2ruzdf6ewsqk4')
 
-      done()
-    })
+    let fileSignature = fileType(res.rawPayload)
+    expect(fileSignature.mime).to.equal('image/jpeg')
+    expect(fileSignature.ext).to.equal('jpg')
   })
 
-  it('load a svg file (unsniffable)', (done) => {
-    let hexagons = 'QmVZoGxDvKM9KExc8gaL4uTbhdNtWhzQR7ndrY7J1gWs3F/hexagons.svg'
+  it('load a svg file (unsniffable)', async () => {
+    const hexagons = 'QmVZoGxDvKM9KExc8gaL4uTbhdNtWhzQR7ndrY7J1gWs3F/hexagons.svg'
 
-    gateway.inject({
+    const res = await gateway.inject({
       method: 'GET',
       url: '/ipfs/' + hexagons
-    }, (res) => {
-      expect(res.statusCode).to.equal(200)
-      expect(res.headers['content-type']).to.equal('image/svg+xml')
-
-      done()
     })
+
+    expect(res.statusCode).to.equal(200)
+    expect(res.headers['content-type']).to.equal('image/svg+xml')
   })
 
-  it('load a svg file with xml leading declaration (unsniffable)', (done) => {
-    let hexagons = 'QmVZoGxDvKM9KExc8gaL4uTbhdNtWhzQR7ndrY7J1gWs3F/hexagons-xml.svg'
+  it('load a svg file with xml leading declaration (unsniffable)', async () => {
+    const hexagons = 'QmVZoGxDvKM9KExc8gaL4uTbhdNtWhzQR7ndrY7J1gWs3F/hexagons-xml.svg'
 
-    gateway.inject({
+    const res = await gateway.inject({
       method: 'GET',
       url: '/ipfs/' + hexagons
-    }, (res) => {
-      expect(res.statusCode).to.equal(200)
-      expect(res.headers['content-type']).to.equal('image/svg+xml')
-
-      done()
     })
+
+    expect(res.statusCode).to.equal(200)
+    expect(res.headers['content-type']).to.equal('image/svg+xml')
   })
 
-  it('load a directory', (done) => {
-    let dir = 'QmW2WQi7j6c7UgJTarActp7tDNikE4B2qXtFCfLPdsgaTQ/'
+  it('load a directory', async () => {
+    const dir = 'QmW2WQi7j6c7UgJTarActp7tDNikE4B2qXtFCfLPdsgaTQ/'
 
-    gateway.inject({
+    const res = await gateway.inject({
       method: 'GET',
       url: '/ipfs/' + dir
-    }, (res) => {
-      expect(res.statusCode).to.equal(200)
-      expect(res.headers['content-type']).to.equal('text/html; charset=utf-8')
-      expect(res.headers['x-ipfs-path']).to.equal('/ipfs/' + dir)
-      expect(res.headers['cache-control']).to.equal('no-cache')
-      expect(res.headers.etag).to.equal(undefined)
-      expect(res.headers.suborigin).to.equal('ipfs000bafybeidsg6t7ici2osxjkukisd5inixiunqdpq2q5jy4a2ruzdf6ewsqk4')
-
-      // check if the cat picture is in the payload as a way to check
-      // if this is an index of this directory
-      let listedFile = res.payload.match(/\/ipfs\/QmW2WQi7j6c7UgJTarActp7tDNikE4B2qXtFCfLPdsgaTQ\/cat\.jpg/g)
-      expect(listedFile).to.have.lengthOf(1)
-      done()
     })
+
+    expect(res.statusCode).to.equal(200)
+    expect(res.headers['content-type']).to.equal('text/html; charset=utf-8')
+    expect(res.headers['x-ipfs-path']).to.equal('/ipfs/' + dir)
+    expect(res.headers['cache-control']).to.equal('no-cache')
+    expect(res.headers.etag).to.equal(undefined)
+    expect(res.headers.suborigin).to.equal('ipfs000bafybeidsg6t7ici2osxjkukisd5inixiunqdpq2q5jy4a2ruzdf6ewsqk4')
+
+    // check if the cat picture is in the payload as a way to check
+    // if this is an index of this directory
+    let listedFile = res.payload.match(/\/ipfs\/QmW2WQi7j6c7UgJTarActp7tDNikE4B2qXtFCfLPdsgaTQ\/cat\.jpg/g)
+    expect(listedFile).to.have.lengthOf(1)
   })
 
-  it('load a webpage index.html', (done) => {
-    let dir = 'QmbQD7EMEL1zeebwBsWEfA3ndgSS6F7S6iTuwuqasPgVRi/index.html'
+  it('load a webpage index.html', async () => {
+    const dir = 'QmbQD7EMEL1zeebwBsWEfA3ndgSS6F7S6iTuwuqasPgVRi/index.html'
 
-    gateway.inject({
+    const res = await gateway.inject({
       method: 'GET',
       url: '/ipfs/' + dir
-    }, (res) => {
-      expect(res.statusCode).to.equal(200)
-      expect(res.headers['content-type']).to.equal('text/html; charset=utf-8')
-      expect(res.headers['x-ipfs-path']).to.equal('/ipfs/' + dir)
-      expect(res.headers['cache-control']).to.equal('public, max-age=29030400, immutable')
-      expect(res.headers.etag).to.equal('"Qma6665X5k3zti8nKy7gmXK2BndNDSkgmANpV6k3FUjUeg"')
-      expect(res.headers.suborigin).to.equal('ipfs000bafybeigccfheqv7upr4k64bkg5b5wiwelunyn2l2rbirmm43m34lcpuqqe')
-      expect(res.rawPayload).to.deep.equal(directoryContent['index.html'])
-      done()
     })
+
+    expect(res.statusCode).to.equal(200)
+    expect(res.headers['content-type']).to.equal('text/html; charset=utf-8')
+    expect(res.headers['x-ipfs-path']).to.equal('/ipfs/' + dir)
+    expect(res.headers['cache-control']).to.equal('public, max-age=29030400, immutable')
+    expect(res.headers.etag).to.equal('"Qma6665X5k3zti8nKy7gmXK2BndNDSkgmANpV6k3FUjUeg"')
+    expect(res.headers.suborigin).to.equal('ipfs000bafybeigccfheqv7upr4k64bkg5b5wiwelunyn2l2rbirmm43m34lcpuqqe')
+    expect(res.rawPayload).to.deep.equal(directoryContent['index.html'])
   })
 
-  it('load a webpage {hash}/nested-folder/nested.html', (done) => {
-    let dir = 'QmbQD7EMEL1zeebwBsWEfA3ndgSS6F7S6iTuwuqasPgVRi/nested-folder/nested.html'
+  it('load a webpage {hash}/nested-folder/nested.html', async () => {
+    const dir = 'QmbQD7EMEL1zeebwBsWEfA3ndgSS6F7S6iTuwuqasPgVRi/nested-folder/nested.html'
 
-    gateway.inject({
+    const res = await gateway.inject({
       method: 'GET',
       url: '/ipfs/' + dir
-    }, (res) => {
-      expect(res.statusCode).to.equal(200)
-      expect(res.headers['content-type']).to.equal('text/html; charset=utf-8')
-      expect(res.headers['x-ipfs-path']).to.equal('/ipfs/' + dir)
-      expect(res.headers['cache-control']).to.equal('public, max-age=29030400, immutable')
-      expect(res.headers.etag).to.equal('"QmUBKGqJWiJYMrNed4bKsbo1nGYGmY418WCc2HgcwRvmHc"')
-      expect(res.headers.suborigin).to.equal('ipfs000bafybeigccfheqv7upr4k64bkg5b5wiwelunyn2l2rbirmm43m34lcpuqqe')
-      expect(res.rawPayload).to.deep.equal(directoryContent['nested-folder/nested.html'])
-      done()
     })
+
+    expect(res.statusCode).to.equal(200)
+    expect(res.headers['content-type']).to.equal('text/html; charset=utf-8')
+    expect(res.headers['x-ipfs-path']).to.equal('/ipfs/' + dir)
+    expect(res.headers['cache-control']).to.equal('public, max-age=29030400, immutable')
+    expect(res.headers.etag).to.equal('"QmUBKGqJWiJYMrNed4bKsbo1nGYGmY418WCc2HgcwRvmHc"')
+    expect(res.headers.suborigin).to.equal('ipfs000bafybeigccfheqv7upr4k64bkg5b5wiwelunyn2l2rbirmm43m34lcpuqqe')
+    expect(res.rawPayload).to.deep.equal(directoryContent['nested-folder/nested.html'])
   })
 
-  it('redirect to generated index', (done) => {
-    let dir = 'QmW2WQi7j6c7UgJTarActp7tDNikE4B2qXtFCfLPdsgaTQ'
+  it('redirect to generated index', async () => {
+    const dir = 'QmW2WQi7j6c7UgJTarActp7tDNikE4B2qXtFCfLPdsgaTQ'
 
-    gateway.inject({
+    const res = await gateway.inject({
       method: 'GET',
       url: '/ipfs/' + dir
-    }, (res) => {
-      expect(res.statusCode).to.equal(301)
-      expect(res.headers.location).to.equal('/ipfs/QmW2WQi7j6c7UgJTarActp7tDNikE4B2qXtFCfLPdsgaTQ/')
-      expect(res.headers['x-ipfs-path']).to.equal(undefined)
-      done()
     })
+
+    expect(res.statusCode).to.equal(301)
+    expect(res.headers.location).to.equal('/ipfs/QmW2WQi7j6c7UgJTarActp7tDNikE4B2qXtFCfLPdsgaTQ/')
+    expect(res.headers['x-ipfs-path']).to.equal(undefined)
   })
 
-  it('redirect to webpage index.html', (done) => {
-    let dir = 'QmbQD7EMEL1zeebwBsWEfA3ndgSS6F7S6iTuwuqasPgVRi/'
+  it('redirect to webpage index.html', async () => {
+    const dir = 'QmbQD7EMEL1zeebwBsWEfA3ndgSS6F7S6iTuwuqasPgVRi/'
 
-    gateway.inject({
+    const res = await gateway.inject({
       method: 'GET',
       url: '/ipfs/' + dir
-    }, (res) => {
-      expect(res.statusCode).to.equal(302)
-      expect(res.headers.location).to.equal('/ipfs/QmbQD7EMEL1zeebwBsWEfA3ndgSS6F7S6iTuwuqasPgVRi/index.html')
-      expect(res.headers['x-ipfs-path']).to.equal(undefined)
-      done()
     })
+
+    expect(res.statusCode).to.equal(302)
+    expect(res.headers.location).to.equal('/ipfs/QmbQD7EMEL1zeebwBsWEfA3ndgSS6F7S6iTuwuqasPgVRi/index.html')
+    expect(res.headers['x-ipfs-path']).to.equal(undefined)
   })
 })

From 69ef7bd094164e7fa65e7fd3fad6407f2d75afab Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Thu, 24 Jan 2019 16:38:54 +0000
Subject: [PATCH 02/49] refactor: /api/v0/version for hapi 18

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 package.json                          |  1 -
 src/http/api/resources/version.js     | 25 +++++---------
 src/http/api/routes/index.js          | 48 +++++++++++++-------------
 src/http/api/routes/version.js        | 12 +++----
 src/http/gateway/resources/gateway.js |  2 +-
 src/http/index.js                     | 49 +++++++++++++++------------
 test/http-api/inject/index.js         | 48 ++++++++------------------
 test/http-api/inject/version.js       | 15 ++++----
 8 files changed, 87 insertions(+), 113 deletions(-)

diff --git a/package.json b/package.json
index 7b26801a04..396e4558c5 100644
--- a/package.json
+++ b/package.json
@@ -102,7 +102,6 @@
     "glob": "^7.1.3",
     "hapi": "^18.0.0",
     "hapi-pino": "^5.2.0",
-    "hapi-set-header": "^1.0.2",
     "hoek": "^6.1.2",
     "human-to-milliseconds": "^1.0.0",
     "interface-datastore": "~0.6.0",
diff --git a/src/http/api/resources/version.js b/src/http/api/resources/version.js
index 6d66211cb4..037471e676 100644
--- a/src/http/api/resources/version.js
+++ b/src/http/api/resources/version.js
@@ -1,21 +1,12 @@
 'use strict'
 
-const boom = require('boom')
-
-exports = module.exports
-
-exports.get = (request, reply) => {
-  const ipfs = request.server.app.ipfs
-
-  ipfs.version((err, version) => {
-    if (err) {
-      return reply(boom.badRequest(err))
-    }
-
-    reply({
-      Version: version.version,
-      Commit: version.commit,
-      Repo: version.repo
-    })
+exports.get = async (request, h) => {
+  const { ipfs } = request.server.app
+  const version = await ipfs.version()
+
+  return h.response({
+    Version: version.version,
+    Commit: version.commit,
+    Repo: version.repo
   })
 }
diff --git a/src/http/api/routes/index.js b/src/http/api/routes/index.js
index 450df4e4a5..89528bc922 100644
--- a/src/http/api/routes/index.js
+++ b/src/http/api/routes/index.js
@@ -1,26 +1,26 @@
 'use strict'
 
-module.exports = (server) => {
-  require('./version')(server)
-  require('./shutdown')(server)
-  require('./id')(server)
-  require('./bootstrap')(server)
-  require('./block')(server)
-  require('./object')(server)
-  require('./pin')(server)
-  require('./repo')(server)
-  require('./config')(server)
-  require('./ping')(server)
-  require('./swarm')(server)
-  require('./bitswap')(server)
-  require('./file')(server)
-  require('./files')(server)
-  require('./pubsub')(server)
-  require('./debug')(server)
-  require('./webui')(server)
-  require('./dns')(server)
-  require('./key')(server)
-  require('./stats')(server)
-  require('./resolve')(server)
-  require('./name')(server)
-}
+module.exports = [
+  require('./version')
+  // require('./shutdown')(server)
+  // require('./id')(server)
+  // require('./bootstrap')(server)
+  // require('./block')(server)
+  // require('./object')(server)
+  // require('./pin')(server)
+  // require('./repo')(server)
+  // require('./config')(server)
+  // require('./ping')(server)
+  // require('./swarm')(server)
+  // require('./bitswap')(server)
+  // require('./file')(server)
+  // require('./files')(server)
+  // require('./pubsub')(server)
+  // require('./debug')(server)
+  // require('./webui')(server)
+  // require('./dns')(server)
+  // require('./key')(server)
+  // require('./stats')(server)
+  // require('./resolve')(server)
+  // require('./name')(server)
+]
diff --git a/src/http/api/routes/version.js b/src/http/api/routes/version.js
index 80287a4f3d..1656434b83 100644
--- a/src/http/api/routes/version.js
+++ b/src/http/api/routes/version.js
@@ -2,12 +2,8 @@
 
 const resources = require('./../resources')
 
-module.exports = (server) => {
-  const api = server.select('API')
-
-  api.route({
-    method: '*',
-    path: '/api/v0/version',
-    handler: resources.version.get
-  })
+module.exports = {
+  method: '*',
+  path: '/api/v0/version',
+  handler: resources.version.get
 }
diff --git a/src/http/gateway/resources/gateway.js b/src/http/gateway/resources/gateway.js
index 805b5bb620..caa79e8b26 100644
--- a/src/http/gateway/resources/gateway.js
+++ b/src/http/gateway/resources/gateway.js
@@ -163,7 +163,7 @@ module.exports = {
       }
       // TODO: we don't have case-insensitive solution for /ipns/ yet (https://github.com/ipfs/go-ipfs/issues/5287)
     }
-    return response
+    return h.continue
   }
 
 }
diff --git a/src/http/index.js b/src/http/index.js
index aa28870323..3732dd885d 100644
--- a/src/http/index.js
+++ b/src/http/index.js
@@ -4,7 +4,6 @@ const Hapi = require('hapi')
 const Pino = require('hapi-pino')
 const debug = require('debug')
 const multiaddr = require('multiaddr')
-// const setHeader = require('hapi-set-header')
 const promisify = require('promisify-es6')
 
 const IPFS = require('../core')
@@ -103,7 +102,15 @@ class HttpApi {
   }
 
   async _createApiServer (host, port, ipfs) {
-    const server = Hapi.server({ host, port })
+    const server = Hapi.server({
+      host,
+      port,
+      // CORS is enabled by default
+      // TODO: shouldn't, fix this
+      routes: {
+        cors: true
+      }
+    })
     server.app.ipfs = ipfs
 
     await server.register({
@@ -115,28 +122,28 @@ class HttpApi {
       }
     })
 
-    // CORS is enabled by default
-    // TODO: shouldn't, fix this
-    // -          this.server = new Hapi.Server({
-    // -            connections: {
-    // -              routes: {
-    // -                cors: true
-    // -              }
-    // -            },
+    const setHeader = (key, value) => {
+      server.ext('onPreResponse', (request, h) => {
+        const { response } = request
+        if (response.isBoom) {
+          response.output.headers[key] = value
+        } else {
+          response.header(key, value)
+        }
+        return h.continue
+      })
+    }
 
     // Set default headers
-    // setHeader(server,
-    //   'Access-Control-Allow-Headers',
-    //   'X-Stream-Output, X-Chunked-Output, X-Content-Length')
-    // setHeader(server,
-    //   'Access-Control-Expose-Headers',
-    //   'X-Stream-Output, X-Chunked-Output, X-Content-Length')
+    setHeader('Access-Control-Allow-Headers',
+      'X-Stream-Output, X-Chunked-Output, X-Content-Length')
+    setHeader('Access-Control-Expose-Headers',
+      'X-Stream-Output, X-Chunked-Output, X-Content-Length')
 
-    // TODO: errorHandler(this, server)
+    server.route(require('./api/routes'))
 
-    // server.route(require('./gateway/routes'))
+    // TODO: errorHandler(this, server)
 
-    // TODO FIXME
     return server
   }
 
@@ -161,8 +168,8 @@ class HttpApi {
   }
 
   get apiAddr () {
-    if (!this._servers) throw new Error('API address unavailable - server is not started')
-    return multiaddr('/ip4/127.0.0.1/tcp/' + this._server.api.info.port)
+    if (!this._apiServer) throw new Error('API address unavailable - server is not started')
+    return multiaddr('/ip4/127.0.0.1/tcp/' + this._apiServer.info.port)
   }
 
   async stop () {
diff --git a/test/http-api/inject/index.js b/test/http-api/inject/index.js
index 24d94ebc4e..002f8dc4e0 100644
--- a/test/http-api/inject/index.js
+++ b/test/http-api/inject/index.js
@@ -2,13 +2,10 @@
 'use strict'
 
 const fs = require('fs')
-const chai = require('chai')
-const dirtyChai = require('dirty-chai')
-const expect = chai.expect
-chai.use(dirtyChai)
 const hat = require('hat')
 const API = require('../../../src/http/index')
-const ncp = require('ncp').ncp
+const promisify = require('promisify-es6')
+const ncp = promisify(require('ncp').ncp)
 const path = require('path')
 const clean = require('../../utils/clean')
 
@@ -18,43 +15,28 @@ describe('HTTP API', () => {
 
   let http = {}
 
-  const startHttpAPI = (cb) => {
-    const options = {
+  const startHttpAPI = async () => {
+    http.api = new API({
+      repo: repoTests,
       pass: hat(),
-      enablePubsubExperiment: true
-    }
-    http.api = new API(repoTests, null, options)
-
-    ncp(repoExample, repoTests, (err) => {
-      if (err) {
-        return cb(err)
+      config: { Bootstrap: [] },
+      EXPERIMENTAL: {
+        pubsub: true
       }
-
-      http.api.start(false, (err) => {
-        if (err) {
-          return cb(err)
-        }
-        cb(null, http)
-      })
     })
+    await ncp(repoExample, repoTests)
+    await http.api.start()
   }
 
-  before(function (done) {
+  before(async function () {
     this.timeout(60 * 1000)
-    startHttpAPI((err, _http) => {
-      if (err) {
-        throw err
-      }
-      http = _http
-      done()
-    })
+    await startHttpAPI()
   })
 
-  after((done) => http.api.stop((err) => {
-    expect(err).to.not.exist()
+  after(async () => {
+    await http.api.stop()
     clean(repoTests)
-    done()
-  }))
+  })
 
   describe('## http-api spec tests', () => {
     fs.readdirSync(path.join(__dirname))
diff --git a/test/http-api/inject/version.js b/test/http-api/inject/version.js
index 8d8afaa339..2ab6b18bf9 100644
--- a/test/http-api/inject/version.js
+++ b/test/http-api/inject/version.js
@@ -9,19 +9,18 @@ module.exports = (http) => {
     let api
 
     before(() => {
-      api = http.api.server.select('API')
+      api = http.api._apiServer
     })
 
-    it('get the version', (done) => {
-      api.inject({
+    it('get the version', async () => {
+      const res = await api.inject({
         method: 'GET',
         url: '/api/v0/version'
-      }, (res) => {
-        expect(res.result).to.have.a.property('Version', pkgversion)
-        expect(res.result).to.have.a.property('Commit')
-        expect(res.result).to.have.a.property('Repo')
-        done()
       })
+
+      expect(res.result).to.have.a.property('Version', pkgversion)
+      expect(res.result).to.have.a.property('Commit')
+      expect(res.result).to.have.a.property('Repo')
     })
   })
 }

From 641a7c42fb178f227818d5eb47caccc2cc88c9f3 Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Fri, 25 Jan 2019 08:54:50 +0000
Subject: [PATCH 03/49] refactor: /api/v0/shutdown for hapi 18

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/api/resources/shutdown.js |  4 ++--
 src/http/api/routes/index.js       |  4 ++--
 src/http/api/routes/shutdown.js    | 12 ++++--------
 3 files changed, 8 insertions(+), 12 deletions(-)

diff --git a/src/http/api/resources/shutdown.js b/src/http/api/resources/shutdown.js
index 56f137cc91..101db0c3e0 100644
--- a/src/http/api/resources/shutdown.js
+++ b/src/http/api/resources/shutdown.js
@@ -8,7 +8,7 @@ exports = module.exports
  * Returns an empty response to the caller then
  * on the next 'tick' emits SIGTERM.
  */
-exports.do = (request, reply) => {
+exports.do = (request, h) => {
   setImmediate(() => process.emit('SIGTERM'))
-  return reply()
+  return h.response()
 }
diff --git a/src/http/api/routes/index.js b/src/http/api/routes/index.js
index 89528bc922..7aa9b32164 100644
--- a/src/http/api/routes/index.js
+++ b/src/http/api/routes/index.js
@@ -1,8 +1,8 @@
 'use strict'
 
 module.exports = [
-  require('./version')
-  // require('./shutdown')(server)
+  require('./version'),
+  require('./shutdown')
   // require('./id')(server)
   // require('./bootstrap')(server)
   // require('./block')(server)
diff --git a/src/http/api/routes/shutdown.js b/src/http/api/routes/shutdown.js
index b3d8c9f8ef..0dd098634f 100644
--- a/src/http/api/routes/shutdown.js
+++ b/src/http/api/routes/shutdown.js
@@ -2,12 +2,8 @@
 
 const resources = require('./../resources')
 
-module.exports = (server) => {
-  const api = server.select('API')
-
-  api.route({
-    method: '*',
-    path: '/api/v0/shutdown',
-    handler: resources.shutdown.do
-  })
+module.exports = {
+  method: '*',
+  path: '/api/v0/shutdown',
+  handler: resources.shutdown.do
 }

From fc0f044b8a29aeef262bc0816c33a67f7913698d Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Fri, 25 Jan 2019 09:12:21 +0000
Subject: [PATCH 04/49] refactor: /ip/v0/id for hapi 18

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/api/resources/id.js      | 25 ++++++++-----------------
 src/http/api/routes/id.js         | 12 ++++--------
 src/http/api/routes/index.js      |  4 ++--
 test/fixtures/go-ipfs-repo/config | 10 +++++-----
 test/http-api/inject/id.js        | 23 +++++++++++------------
 5 files changed, 30 insertions(+), 44 deletions(-)

diff --git a/src/http/api/resources/id.js b/src/http/api/resources/id.js
index d05433b329..2ba8218966 100644
--- a/src/http/api/resources/id.js
+++ b/src/http/api/resources/id.js
@@ -1,21 +1,12 @@
 'use strict'
 
-const boom = require('boom')
-
-exports = module.exports
-
-exports.get = (request, reply) => {
-  request.server.app.ipfs.id((err, id) => {
-    if (err) {
-      return reply(boom.badRequest(err))
-    }
-
-    return reply({
-      ID: id.id,
-      PublicKey: id.publicKey,
-      Addresses: id.addresses,
-      AgentVersion: id.agentVersion,
-      ProtocolVersion: id.protocolVersion
-    })
+exports.get = async (request, h) => {
+  const id = await request.server.app.ipfs.id()
+  return h.response({
+    ID: id.id,
+    PublicKey: id.publicKey,
+    Addresses: id.addresses,
+    AgentVersion: id.agentVersion,
+    ProtocolVersion: id.protocolVersion
   })
 }
diff --git a/src/http/api/routes/id.js b/src/http/api/routes/id.js
index 9a13f72efc..25c2bbc949 100644
--- a/src/http/api/routes/id.js
+++ b/src/http/api/routes/id.js
@@ -2,12 +2,8 @@
 
 const resources = require('./../resources')
 
-module.exports = (server) => {
-  const api = server.select('API')
-
-  api.route({
-    method: '*',
-    path: '/api/v0/id',
-    handler: resources.id.get
-  })
+module.exports = {
+  method: '*',
+  path: '/api/v0/id',
+  handler: resources.id.get
 }
diff --git a/src/http/api/routes/index.js b/src/http/api/routes/index.js
index 7aa9b32164..f556f30723 100644
--- a/src/http/api/routes/index.js
+++ b/src/http/api/routes/index.js
@@ -2,8 +2,8 @@
 
 module.exports = [
   require('./version'),
-  require('./shutdown')
-  // require('./id')(server)
+  require('./shutdown'),
+  require('./id')
   // require('./bootstrap')(server)
   // require('./block')(server)
   // require('./object')(server)
diff --git a/test/fixtures/go-ipfs-repo/config b/test/fixtures/go-ipfs-repo/config
index e42d061b2f..2cedcaa632 100644
--- a/test/fixtures/go-ipfs-repo/config
+++ b/test/fixtures/go-ipfs-repo/config
@@ -1,11 +1,11 @@
 {
   "Addresses": {
     "Swarm": [
-      "/ip4/0.0.0.0/tcp/4002",
-      "/ip4/127.0.0.1/tcp/4003/ws"
+      "/ip4/0.0.0.0/tcp/0",
+      "/ip4/127.0.0.1/tcp/0/ws"
     ],
-    "API": "/ip4/127.0.0.1/tcp/5002",
-    "Gateway": "/ip4/127.0.0.1/tcp/9090"
+    "API": "/ip4/127.0.0.1/tcp/0",
+    "Gateway": "/ip4/127.0.0.1/tcp/0"
   },
   "Discovery": {
     "MDNS": {
@@ -80,4 +80,4 @@
       "hash": "sha2-512"
     }
   }
-}
\ No newline at end of file
+}
diff --git a/test/http-api/inject/id.js b/test/http-api/inject/id.js
index 51716b2594..d29f00d088 100644
--- a/test/http-api/inject/id.js
+++ b/test/http-api/inject/id.js
@@ -4,26 +4,25 @@
 const expect = require('chai').expect
 
 module.exports = (http) => {
-  describe('/id', () => {
+  describe.only('/id', () => {
     let api
 
     before(() => {
-      api = http.api.server.select('API')
+      api = http.api._apiServer
     })
 
-    it('get the id', (done) => {
-      api.inject({
+    it('get the id', async () => {
+      const res = await api.inject({
         method: 'GET',
         url: '/api/v0/id'
-      }, (res) => {
-        expect(res.result.ID).to.equal(idResult.ID)
-        expect(res.result.PublicKey).to.equal(idResult.PublicKey)
-        const agentComponents = res.result.AgentVersion.split('/')
-        expect(agentComponents).lengthOf.above(1)
-        expect(agentComponents[0]).to.equal(idResult.AgentVersion)
-        expect(res.result.ProtocolVersion).to.equal(idResult.ProtocolVersion)
-        done()
       })
+
+      expect(res.result.ID).to.equal(idResult.ID)
+      expect(res.result.PublicKey).to.equal(idResult.PublicKey)
+      const agentComponents = res.result.AgentVersion.split('/')
+      expect(agentComponents).lengthOf.above(1)
+      expect(agentComponents[0]).to.equal(idResult.AgentVersion)
+      expect(res.result.ProtocolVersion).to.equal(idResult.ProtocolVersion)
     })
   })
 }

From 665297f101182e39636731bca3f220b5c0b51ea7 Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Fri, 25 Jan 2019 11:09:14 +0000
Subject: [PATCH 05/49] refactor: /api/v0/bootstrap* for hapi 18

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/api/resources/bootstrap.js | 93 ++++++++++++-----------------
 src/http/api/resources/shutdown.js  |  2 +-
 src/http/api/resources/version.js   |  2 +-
 src/http/api/routes/bootstrap.js    | 59 +++++++++---------
 src/http/api/routes/index.js        |  4 +-
 src/http/api/routes/shutdown.js     |  2 +-
 src/http/api/routes/version.js      |  2 +-
 test/http-api/inject/bootstrap.js   | 80 +++++++++++++------------
 test/http-api/inject/id.js          |  2 +-
 9 files changed, 116 insertions(+), 130 deletions(-)

diff --git a/src/http/api/resources/bootstrap.js b/src/http/api/resources/bootstrap.js
index affc3a2126..5780d7c80c 100644
--- a/src/http/api/resources/bootstrap.js
+++ b/src/http/api/resources/bootstrap.js
@@ -2,89 +2,74 @@
 
 const multiaddr = require('multiaddr')
 
-exports = module.exports
-
-function applyError (reply, err) {
-  reply({
-    Message: err.message,
-    Code: 0
-  }).code(500).takeover()
-}
-
-exports.list = (request, reply) => {
-  const ipfs = request.server.app.ipfs
-
-  ipfs.bootstrap.list((err, list) => {
-    if (err) {
-      return applyError(reply, err)
-    }
-
-    return reply(list)
-  })
+exports.list = async (request, h) => {
+  const { ipfs } = request.server.app
+  const list = await ipfs.bootstrap.list()
+  return h.response(list)
 }
 
 exports.add = {
-  parseArgs (request, reply) {
+  parseArgs (request, h) {
     const q = request.query
     const def = q.default === 'true'
 
     if (q.arg != null) {
       try {
-        return reply({
+        return {
           addr: multiaddr(q.arg),
           default: def
-        })
+        }
       } catch (err) {
-        return applyError(reply, new Error('Not a valid multiaddr'))
+        throw new Error('Not a valid multiaddr')
       }
-    } else {
-      reply({ default: def })
     }
-  },
-  handler (request, reply) {
-    const ipfs = request.server.app.ipfs
-    const addr = request.pre.args.addr
-    const def = request.pre.args.default
 
-    ipfs.bootstrap.add(addr && addr.toString(), { default: def }, (err, list) => {
-      if (err) {
-        return applyError(reply, err)
-      }
+    console.log('parseArgs', { default: def })
 
-      return reply(list)
-    })
+    return { default: def }
+  },
+  async handler (request, h) {
+    const { ipfs } = request.server.app
+    const { addr, default: def } = request.pre.args
+    const list = await ipfs.bootstrap.add(addr && addr.toString(), { default: def })
+    return h.response(list)
   }
 }
 
+exports.addDefault = async (request, h) => {
+  const { ipfs } = request.server.app
+  const list = await ipfs.bootstrap.add(null, { default: true })
+  return h.response(list)
+}
+
 exports.rm = {
-  parseArgs (request, reply) {
+  parseArgs (request, h) {
     const q = request.query
     const all = q.all === 'true'
 
     if (q.arg != null) {
       try {
-        return reply({
+        return {
           addr: multiaddr(q.arg),
           all: all
-        })
+        }
       } catch (err) {
-        return applyError(reply, new Error('Not a valid multiaddr'))
+        throw new Error('Not a valid multiaddr')
       }
-    } else {
-      reply({ all: all })
     }
-  },
-  handler (request, reply) {
-    const ipfs = request.server.app.ipfs
-    const addr = request.pre.args.addr
-    const all = request.pre.args.all
-
-    ipfs.bootstrap.rm(addr && addr.toString(), { all: all }, (err, list) => {
-      if (err) {
-        return applyError(reply, err)
-      }
 
-      return reply(list)
-    })
+    return { all }
+  },
+  async handler (request, h) {
+    const { ipfs } = request.server.app
+    const { addr, all } = request.pre.args
+    const list = await ipfs.bootstrap.rm(addr && addr.toString(), { all })
+    return h.response(list)
   }
 }
+
+exports.rmAll = async (request, h) => {
+  const { ipfs } = request.server.app
+  const list = await ipfs.bootstrap.rm(null, { all: true })
+  return h.response(list)
+}
diff --git a/src/http/api/resources/shutdown.js b/src/http/api/resources/shutdown.js
index 101db0c3e0..9224e55a34 100644
--- a/src/http/api/resources/shutdown.js
+++ b/src/http/api/resources/shutdown.js
@@ -8,7 +8,7 @@ exports = module.exports
  * Returns an empty response to the caller then
  * on the next 'tick' emits SIGTERM.
  */
-exports.do = (request, h) => {
+module.exports = (request, h) => {
   setImmediate(() => process.emit('SIGTERM'))
   return h.response()
 }
diff --git a/src/http/api/resources/version.js b/src/http/api/resources/version.js
index 037471e676..833f0caecb 100644
--- a/src/http/api/resources/version.js
+++ b/src/http/api/resources/version.js
@@ -1,6 +1,6 @@
 'use strict'
 
-exports.get = async (request, h) => {
+module.exports = async (request, h) => {
   const { ipfs } = request.server.app
   const version = await ipfs.version()
 
diff --git a/src/http/api/routes/bootstrap.js b/src/http/api/routes/bootstrap.js
index dcc512a952..10b448e69c 100644
--- a/src/http/api/routes/bootstrap.js
+++ b/src/http/api/routes/bootstrap.js
@@ -2,46 +2,45 @@
 
 const resources = require('./../resources')
 
-module.exports = (server) => {
-  const api = server.select('API')
-
-  // https://github.com/ipfs/http-api-spec/blob/master/apiary.apib#L818
-  api.route({
+module.exports = [
+  {
     method: '*',
     path: '/api/v0/bootstrap',
-    config: {
-      handler: resources.bootstrap.list
-    }
-  })
-
-  // https://github.com/ipfs/http-api-spec/blob/master/apiary.apib#L866
-  api.route({
+    handler: resources.bootstrap.list
+  },
+  {
     method: '*',
     path: '/api/v0/bootstrap/add',
-    config: {
+    options: {
       pre: [
         { method: resources.bootstrap.add.parseArgs, assign: 'args' }
-      ],
-      handler: resources.bootstrap.add.handler
-    }
-  })
-
-  // https://github.com/ipfs/http-api-spec/blob/master/apiary.apib#L1081
-  api.route({
+      ]
+    },
+    handler: resources.bootstrap.add.handler
+  },
+  {
+    method: '*',
+    path: '/api/v0/bootstrap/add/default',
+    handler: resources.bootstrap.addDefault
+  },
+  {
     method: '*',
     path: '/api/v0/bootstrap/list',
     handler: resources.bootstrap.list
-  })
-
-  // https://github.com/ipfs/http-api-spec/blob/master/apiary.apib#L1131
-  api.route({
+  },
+  {
     method: '*',
     path: '/api/v0/bootstrap/rm',
-    config: {
+    options: {
       pre: [
         { method: resources.bootstrap.rm.parseArgs, assign: 'args' }
-      ],
-      handler: resources.bootstrap.rm.handler
-    }
-  })
-}
+      ]
+    },
+    handler: resources.bootstrap.rm.handler
+  },
+  {
+    method: '*',
+    path: '/api/v0/bootstrap/rm/all',
+    handler: resources.bootstrap.rmAll
+  }
+]
diff --git a/src/http/api/routes/index.js b/src/http/api/routes/index.js
index f556f30723..058960d25d 100644
--- a/src/http/api/routes/index.js
+++ b/src/http/api/routes/index.js
@@ -3,8 +3,8 @@
 module.exports = [
   require('./version'),
   require('./shutdown'),
-  require('./id')
-  // require('./bootstrap')(server)
+  require('./id'),
+  ...require('./bootstrap')
   // require('./block')(server)
   // require('./object')(server)
   // require('./pin')(server)
diff --git a/src/http/api/routes/shutdown.js b/src/http/api/routes/shutdown.js
index 0dd098634f..822c636915 100644
--- a/src/http/api/routes/shutdown.js
+++ b/src/http/api/routes/shutdown.js
@@ -5,5 +5,5 @@ const resources = require('./../resources')
 module.exports = {
   method: '*',
   path: '/api/v0/shutdown',
-  handler: resources.shutdown.do
+  handler: resources.shutdown
 }
diff --git a/src/http/api/routes/version.js b/src/http/api/routes/version.js
index 1656434b83..0b717a3927 100644
--- a/src/http/api/routes/version.js
+++ b/src/http/api/routes/version.js
@@ -5,5 +5,5 @@ const resources = require('./../resources')
 module.exports = {
   method: '*',
   path: '/api/v0/version',
-  handler: resources.version.get
+  handler: resources.version
 }
diff --git a/test/http-api/inject/bootstrap.js b/test/http-api/inject/bootstrap.js
index 33c9f6459d..7708390cfe 100644
--- a/test/http-api/inject/bootstrap.js
+++ b/test/http-api/inject/bootstrap.js
@@ -10,78 +10,80 @@ module.exports = (http) => {
     const validIp4 = '/ip4/101.236.176.52/tcp/4001/ipfs/QmSoLnSGccFuZQJzRadHn95W2CrSFmZuTdDWP8HXaHca9z'
     let api
 
-    before((done) => {
-      api = http.api.server.select('API')
-      api.inject({
+    before(() => {
+      api = http.api._apiServer
+      return api.inject({
         method: 'GET',
-        url: '/api/v0/bootstrap/add',
-        payload: {
-          default: 'true'
-        }
-      }, () => done())
+        url: '/api/v0/bootstrap/add/default'
+      })
     })
 
-    it('/list', (done) => {
-      api.inject({
+    it('/list', async () => {
+      const res = await api.inject({
         method: 'GET',
         url: '/api/v0/bootstrap/list'
-      }, (res) => {
-        expect(res.statusCode).to.be.eql(200)
-        expect(res.result.Peers).to.deep.equal(defaultList)
-        done()
       })
+
+      expect(res.statusCode).to.be.eql(200)
+      expect(res.result.Peers).to.deep.equal(defaultList)
     })
 
-    it('/list alias', (done) => {
-      api.inject({
+    it('/list alias', async () => {
+      const res = await api.inject({
         method: 'GET',
         url: '/api/v0/bootstrap'
-      }, (res) => {
-        expect(res.statusCode).to.be.eql(200)
-        expect(res.result.Peers).to.deep.equal(defaultList)
-        done()
       })
+
+      expect(res.statusCode).to.be.eql(200)
+      expect(res.result.Peers).to.deep.equal(defaultList)
     })
 
-    it('/add', (done) => {
+    it('/add', async () => {
       const query = {
         arg: validIp4
       }
 
-      api.inject({
+      const res = await api.inject({
         method: 'GET',
         url: `/api/v0/bootstrap/add?${qs.stringify(query)}`
-      }, (res) => {
-        expect(res.statusCode).to.be.eql(200)
-        expect(res.result.Peers).to.be.eql([validIp4])
-        done()
       })
+
+      expect(res.statusCode).to.be.eql(200)
+      expect(res.result.Peers).to.be.eql([validIp4])
+    })
+
+    it('/add/default', async () => {
+      const res = await api.inject({
+        method: 'GET',
+        url: `/api/v0/bootstrap/add/default`
+      })
+
+      expect(res.statusCode).to.be.eql(200)
+      expect(res.result.Peers).to.be.eql(defaultList)
     })
 
-    it('/rm', (done) => {
+    it('/rm', async () => {
       const query = {
         arg: validIp4
       }
 
-      api.inject({
+      const res = await api.inject({
         method: 'GET',
         url: `/api/v0/bootstrap/rm?${qs.stringify(query)}`
-      }, (res) => {
-        expect(res.statusCode).to.be.eql(200)
-        expect(res.result.Peers).to.be.eql([validIp4])
-        done()
       })
+
+      expect(res.statusCode).to.be.eql(200)
+      expect(res.result.Peers).to.be.eql([validIp4])
     })
 
-    it('/list confirm it changed', (done) => {
-      api.inject({
+    it('/rm/all', async () => {
+      const res = await api.inject({
         method: 'GET',
-        url: '/api/v0/bootstrap/list'
-      }, (res) => {
-        expect(res.statusCode).to.be.eql(200)
-        expect(res.result.Peers).to.be.eql(defaultList)
-        done()
+        url: `/api/v0/bootstrap/rm/all`
       })
+
+      expect(res.statusCode).to.be.eql(200)
+      expect(res.result.Peers).to.be.eql([])
     })
   })
 }
diff --git a/test/http-api/inject/id.js b/test/http-api/inject/id.js
index d29f00d088..eb646be893 100644
--- a/test/http-api/inject/id.js
+++ b/test/http-api/inject/id.js
@@ -4,7 +4,7 @@
 const expect = require('chai').expect
 
 module.exports = (http) => {
-  describe.only('/id', () => {
+  describe('/id', () => {
     let api
 
     before(() => {

From 3e6f9de7b9a58e2c26c097cb0ebbd614d26c4c5b Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Fri, 25 Jan 2019 14:58:57 +0000
Subject: [PATCH 06/49] refactor: error handler for hapi 18

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/error-handler.js | 58 +++++++++++----------------------------
 src/http/index.js         |  6 ++--
 2 files changed, 18 insertions(+), 46 deletions(-)

diff --git a/src/http/error-handler.js b/src/http/error-handler.js
index 0c490d4639..eca581d311 100644
--- a/src/http/error-handler.js
+++ b/src/http/error-handler.js
@@ -1,61 +1,35 @@
 'use strict'
 
-const Hoek = require('hoek')
-
-module.exports = (api, server) => {
-  server.ext('onRequest', (request, reply) => {
-    request.handleError = handleError
-    reply.continue()
-  })
-
-  server.ext('onPreResponse', (request, reply) => {
+module.exports = (server, log) => {
+  server.ext('onPreResponse', (request, h) => {
     const res = request.response
-    const req = request.raw.req
 
-    let statusCode = 200
-    let msg = 'Sorry, something went wrong, please retrace your steps.'
-    let code = 1
-
-    if (res.isBoom) {
-      statusCode = res.output.payload.statusCode
-      msg = res.output.payload.message
-
-      if (res.data && res.data.code !== undefined) {
-        code = res.data.code
-      }
+    if (!res.isBoom) {
+      return h.continue
+    }
 
-      if (res.message && res.isDeveloperError) {
-        msg = res.message.replace('Uncaught error: ', '')
-      }
+    const { statusCode, message } = res.output.payload
+    const code = res.data && res.data.code != null ? res.data.code : 1
 
+    if (statusCode >= 500) {
+      const { req } = request.raw
       const debug = {
         method: req.method,
         url: request.url.path,
-        headers: request.raw.req.headers,
+        headers: req.headers,
         info: request.info,
         payload: request.payload,
         response: res.output.payload
       }
 
-      api.log.error(res.stack)
+      log(res)
       server.log('error', debug)
-
-      reply({
-        Message: msg,
-        Code: code,
-        Type: 'error'
-      }).code(statusCode)
-      return
     }
 
-    reply.continue()
+    return h.response({
+      Message: message,
+      Code: code,
+      Type: 'error'
+    }).code(statusCode)
   })
 }
-
-function handleError (error, errorMessage) {
-  if (errorMessage) {
-    return Hoek.assert(!error, errorMessage)
-  }
-
-  return Hoek.assert(!error, error)
-}
diff --git a/src/http/index.js b/src/http/index.js
index 3732dd885d..8b892618de 100644
--- a/src/http/index.js
+++ b/src/http/index.js
@@ -12,7 +12,7 @@ const TCP = require('libp2p-tcp')
 const MulticastDNS = require('libp2p-mdns')
 const WS = require('libp2p-websockets')
 const Bootstrap = require('libp2p-bootstrap')
-// const errorHandler = require('./error-handler')
+const errorHandler = require('./error-handler')
 
 function uriToMultiaddr (uri) {
   const ipPort = uri.split('/')[2].split(':')
@@ -142,7 +142,7 @@ class HttpApi {
 
     server.route(require('./api/routes'))
 
-    // TODO: errorHandler(this, server)
+    errorHandler(server, this._log.error)
 
     return server
   }
@@ -162,8 +162,6 @@ class HttpApi {
 
     server.route(require('./gateway/routes'))
 
-    // TODO: errorHandler(this, server)
-
     return server
   }
 

From f57ab0836bc07fdec00a25d3caba4b48666beb1a Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Fri, 25 Jan 2019 15:00:00 +0000
Subject: [PATCH 07/49] refactor: simplify gateway and use error handler

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/gateway/resources/gateway.js | 26 +++++++-------------------
 1 file changed, 7 insertions(+), 19 deletions(-)

diff --git a/src/http/gateway/resources/gateway.js b/src/http/gateway/resources/gateway.js
index caa79e8b26..77cb25fcb8 100644
--- a/src/http/gateway/resources/gateway.js
+++ b/src/http/gateway/resources/gateway.js
@@ -9,6 +9,7 @@ const toStream = require('pull-stream-to-stream')
 const fileType = require('file-type')
 const mime = require('mime-types')
 const { PassThrough } = require('readable-stream')
+const Boom = require('boom')
 
 const { resolver } = require('ipfs-http-response')
 const PathUtils = require('../utils/path')
@@ -32,11 +33,7 @@ function detectContentType (ref, chunk) {
 module.exports = {
   checkCID (request, h) {
     if (!request.params.cid) {
-      return h.response({
-        Message: 'Path Resolve error: path must contain at least one component',
-        Code: 0,
-        Type: 'error'
-      }).code(400).takeover()
+      throw Boom.badRequest('Path Resolve error: path must contain at least one component')
     }
 
     return { ref: `/ipfs/${request.params.cid}` }
@@ -56,12 +53,7 @@ module.exports = {
       // switch case with true feels so wrong.
       switch (true) {
         case (errorToString === 'Error: This dag node is a directory'):
-          try {
-            data = await resolver.directory(ipfs, ref, err.cid)
-          } catch (err) {
-            log.error(err)
-            return h.response(err.toString()).code(500)
-          }
+          data = await resolver.directory(ipfs, ref, err.cid)
 
           if (typeof data === 'string') {
             // no index file found
@@ -78,13 +70,13 @@ module.exports = {
           // redirect to URL/<found-index-file>
           return h.redirect(PathUtils.joinURLParts(ref, data[0].name))
         case (errorToString.startsWith('Error: no link named')):
-          return h.response(errorToString).code(404)
+          throw Boom.boomify(err, { statusCode: 404 })
         case (errorToString.startsWith('Error: multihash length inconsistent')):
         case (errorToString.startsWith('Error: Non-base58 character')):
-          return h.response({ Message: errorToString, Code: 0, Type: 'error' }).code(400)
+          throw Boom.boomify(err, { statusCode: 400 })
         default:
           log.error(err)
-          return h.response({ Message: errorToString, Code: 0, Type: 'error' }).code(500)
+          throw err
       }
     }
 
@@ -137,11 +129,7 @@ module.exports = {
                 return pusher.end(err)
               }
 
-              return resolve(h.response({
-                Message: err.message,
-                Code: 0,
-                Type: 'error'
-              }).code(500).takeover())
+              return reject(err)
             }
 
             pusher.end()

From ce4f1da2a52f9f6fcfde1eee0a4939e0155e852e Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Fri, 25 Jan 2019 15:01:00 +0000
Subject: [PATCH 08/49] refactor: simplify /api/v0/bootstrap to use error
 handler

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/api/resources/bootstrap.js | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/http/api/resources/bootstrap.js b/src/http/api/resources/bootstrap.js
index 5780d7c80c..f7f3a44736 100644
--- a/src/http/api/resources/bootstrap.js
+++ b/src/http/api/resources/bootstrap.js
@@ -1,6 +1,7 @@
 'use strict'
 
 const multiaddr = require('multiaddr')
+const Boom = require('boom')
 
 exports.list = async (request, h) => {
   const { ipfs } = request.server.app
@@ -20,7 +21,7 @@ exports.add = {
           default: def
         }
       } catch (err) {
-        throw new Error('Not a valid multiaddr')
+        throw Boom.badRequest('Not a valid multiaddr')
       }
     }
 
@@ -54,7 +55,7 @@ exports.rm = {
           all: all
         }
       } catch (err) {
-        throw new Error('Not a valid multiaddr')
+        throw Boom.badRequest('Not a valid multiaddr')
       }
     }
 

From 723f20bbd801824adc58309013ed9a8c00b19e94 Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Fri, 25 Jan 2019 15:01:48 +0000
Subject: [PATCH 09/49] fix: gateway tests

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 test/gateway/index.js | 2 --
 1 file changed, 2 deletions(-)

diff --git a/test/gateway/index.js b/test/gateway/index.js
index 7e65588ff7..54e47e0ba1 100644
--- a/test/gateway/index.js
+++ b/test/gateway/index.js
@@ -93,7 +93,6 @@ describe('HTTP Gateway', function () {
     })
 
     expect(res.statusCode).to.equal(400)
-    expect(res.result.Message).to.be.a('string')
     expect(res.headers['cache-control']).to.equal('no-cache')
     expect(res.headers.etag).to.equal(undefined)
     expect(res.headers['x-ipfs-path']).to.equal(undefined)
@@ -107,7 +106,6 @@ describe('HTTP Gateway', function () {
     })
 
     expect(res.statusCode).to.equal(400)
-    expect(res.result.Message).to.be.a('string')
     expect(res.headers['cache-control']).to.equal('no-cache')
     expect(res.headers.etag).to.equal(undefined)
     expect(res.headers['x-ipfs-path']).to.equal(undefined)

From 2071f5036fc5ddf549a05ef7b2cc9e3dafced789 Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Fri, 25 Jan 2019 15:02:12 +0000
Subject: [PATCH 10/49] refactor: /api/v0/block* for hapi 18

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/api/resources/block.js | 174 ++++++++++-------------
 src/http/api/routes/block.js    |  49 +++----
 src/http/api/routes/index.js    |   4 +-
 test/http-api/inject/block.js   | 239 +++++++++++++++-----------------
 4 files changed, 207 insertions(+), 259 deletions(-)

diff --git a/src/http/api/resources/block.js b/src/http/api/resources/block.js
index 929e1a40ab..396abf5587 100644
--- a/src/http/api/resources/block.js
+++ b/src/http/api/resources/block.js
@@ -4,29 +4,23 @@ const CID = require('cids')
 const multipart = require('ipfs-multipart')
 const Joi = require('joi')
 const multibase = require('multibase')
+const Boom = require('boom')
 const { cidToString } = require('../../../utils/cid')
 const debug = require('debug')
 const log = debug('jsipfs:http-api:block')
 log.error = debug('jsipfs:http-api:block:error')
 
-exports = module.exports
-
 // common pre request handler that parses the args and returns `key` which is assigned to `request.pre.args`
-exports.parseKey = (request, reply) => {
+exports.parseKey = (request, h) => {
   if (!request.query.arg) {
-    return reply("Argument 'key' is required").code(400).takeover()
+    return h.response("Argument 'key' is required").code(400).takeover()
   }
 
   try {
-    return reply({
-      key: new CID(request.query.arg)
-    })
+    return { key: new CID(request.query.arg) }
   } catch (err) {
     log.error(err)
-    return reply({
-      Message: 'Not a valid hash',
-      Code: 0
-    }).code(500).takeover()
+    throw Boom.badRequest('Not a valid hash', { code: 0 })
   }
 }
 
@@ -35,27 +29,22 @@ exports.get = {
   parseArgs: exports.parseKey,
 
   // main route handler which is called after the above `parseArgs`, but only if the args were valid
-  handler: (request, reply) => {
+  async handler (request, h) {
     const key = request.pre.args.key
 
-    request.server.app.ipfs.block.get(key, (err, block) => {
-      if (err) {
-        log.error(err)
-        return reply({
-          Message: 'Failed to get block: ' + err,
-          Code: 0
-        }).code(500)
-      }
-
-      if (block) {
-        return reply(block.data).header('X-Stream-Output', '1')
-      }
-
-      return reply({
-        Message: 'Block was unwanted before it could be remotely retrieved',
-        Code: 0
-      }).code(404)
-    })
+    let block
+    try {
+      block = await request.server.app.ipfs.block.get(key)
+    } catch (err) {
+      log.error(err)
+      throw new Error('Failed to get block: ' + err)
+    }
+
+    if (!block) {
+      throw Boom.notFound('Block was unwanted before it could be remotely retrieved')
+    }
+
+    return h.response(block.data).header('X-Stream-Output', '1')
   }
 }
 
@@ -67,61 +56,53 @@ exports.put = {
   },
 
   // pre request handler that parses the args and returns `data` which is assigned to `request.pre.args`
-  parseArgs: (request, reply) => {
+  parseArgs: (request, h) => {
     if (!request.payload) {
-      return reply({
-        Message: "File argument 'data' is required",
-        Code: 0
-      }).code(400).takeover()
+      throw Boom.badRequest("File argument 'data' is required")
     }
 
-    const parser = multipart.reqParser(request.payload)
-    var file
+    return new Promise((resolve, reject) => {
+      const parser = multipart.reqParser(request.payload)
+      let file
 
-    parser.on('file', (fileName, fileStream) => {
-      file = Buffer.alloc(0)
+      parser.on('file', (fileName, fileStream) => {
+        file = Buffer.alloc(0)
 
-      fileStream.on('data', (data) => {
-        file = Buffer.concat([file, data])
+        fileStream.on('data', (data) => {
+          file = Buffer.concat([file, data])
+        })
       })
-    })
 
-    parser.on('end', () => {
-      if (!file) {
-        return reply({
-          Message: "File argument 'data' is required",
-          Code: 0
-        }).code(400).takeover()
-      }
+      parser.on('end', () => {
+        if (!file) {
+          return reject(Boom.badRequest("File argument 'data' is required"))
+        }
 
-      return reply({
-        data: file
+        resolve({ data: file })
       })
     })
   },
 
   // main route handler which is called after the above `parseArgs`, but only if the args were valid
-  handler: (request, reply) => {
-    const data = request.pre.args.data
-    const ipfs = request.server.app.ipfs
-
-    ipfs.block.put(data, {
-      mhtype: request.query.mhtype,
-      format: request.query.format,
-      version: request.query.version && parseInt(request.query.version)
-    }, (err, block) => {
-      if (err) {
-        log.error(err)
-        return reply({
-          Message: 'Failed to put block: ' + err,
-          Code: 0
-        }).code(500)
-      }
-
-      return reply({
-        Key: cidToString(block.cid, { base: request.query['cid-base'] }),
-        Size: block.data.length
+  async handler (request, h) {
+    const { data } = request.pre.args
+    const { ipfs } = request.server.app
+
+    let block
+    try {
+      block = await ipfs.block.put(data, {
+        mhtype: request.query.mhtype,
+        format: request.query.format,
+        version: request.query.version && parseInt(request.query.version)
       })
+    } catch (err) {
+      log.error(err)
+      throw new Error('Failed to put block: ' + err)
+    }
+
+    return h.response({
+      Key: cidToString(block.cid, { base: request.query['cid-base'] }),
+      Size: block.data.length
     })
   }
 }
@@ -131,20 +112,17 @@ exports.rm = {
   parseArgs: exports.parseKey,
 
   // main route handler which is called after the above `parseArgs`, but only if the args were valid
-  handler: (request, reply) => {
-    const key = request.pre.args.key
-
-    request.server.app.ipfs.block.rm(key, (err, block) => {
-      if (err) {
-        log.error(err)
-        return reply({
-          Message: 'Failed to delete block: ' + err,
-          Code: 0
-        }).code(500)
-      }
+  async handler (request, h) {
+    const { key } = request.pre.args
+
+    try {
+      await request.server.app.ipfs.block.rm(key)
+    } catch (err) {
+      log.error(err)
+      throw new Error('Failed to delete block: ' + err)
+    }
 
-      return reply()
-    })
+    return h.response()
   }
 }
 
@@ -159,22 +137,20 @@ exports.stat = {
   parseArgs: exports.parseKey,
 
   // main route handler which is called after the above `parseArgs`, but only if the args were valid
-  handler: (request, reply) => {
-    const key = request.pre.args.key
+  async handler (request, h) {
+    const { key } = request.pre.args
+
+    let stats
+    try {
+      stats = await request.server.app.ipfs.block.stat(key)
+    } catch (err) {
+      log.error(err)
+      throw new Error('Failed to get block stats: ' + err)
+    }
 
-    request.server.app.ipfs.block.stat(key, (err, stats) => {
-      if (err) {
-        log.error(err)
-        return reply({
-          Message: 'Failed to get block stats: ' + err,
-          Code: 0
-        }).code(500)
-      }
-
-      return reply({
-        Key: cidToString(stats.key, { base: request.query['cid-base'] }),
-        Size: stats.size
-      })
+    return h.response({
+      Key: cidToString(stats.key, { base: request.query['cid-base'] }),
+      Size: stats.size
     })
   }
 }
diff --git a/src/http/api/routes/block.js b/src/http/api/routes/block.js
index 03d8159876..2d006b9f4c 100644
--- a/src/http/api/routes/block.js
+++ b/src/http/api/routes/block.js
@@ -2,24 +2,21 @@
 
 const resources = require('./../resources')
 
-module.exports = (server) => {
-  const api = server.select('API')
-
-  api.route({
+module.exports = [
+  {
     method: '*',
     path: '/api/v0/block/get',
-    config: {
+    options: {
       pre: [
         { method: resources.block.get.parseArgs, assign: 'args' }
-      ],
-      handler: resources.block.get.handler
-    }
-  })
-
-  api.route({
+      ]
+    },
+    handler: resources.block.get.handler
+  },
+  {
     method: '*',
     path: '/api/v0/block/put',
-    config: {
+    options: {
       payload: {
         parse: false,
         output: 'stream'
@@ -27,31 +24,29 @@ module.exports = (server) => {
       pre: [
         { method: resources.block.put.parseArgs, assign: 'args' }
       ],
-      handler: resources.block.put.handler,
       validate: resources.block.put.validate
-    }
-  })
-
-  api.route({
+    },
+    handler: resources.block.put.handler
+  },
+  {
     method: '*',
     path: '/api/v0/block/rm',
     config: {
       pre: [
         { method: resources.block.rm.parseArgs, assign: 'args' }
-      ],
-      handler: resources.block.rm.handler
-    }
-  })
-
-  api.route({
+      ]
+    },
+    handler: resources.block.rm.handler
+  },
+  {
     method: '*',
     path: '/api/v0/block/stat',
     config: {
       pre: [
         { method: resources.block.stat.parseArgs, assign: 'args' }
       ],
-      handler: resources.block.stat.handler,
       validate: resources.block.stat.validate
-    }
-  })
-}
+    },
+    handler: resources.block.stat.handler
+  }
+]
diff --git a/src/http/api/routes/index.js b/src/http/api/routes/index.js
index 058960d25d..27df09498a 100644
--- a/src/http/api/routes/index.js
+++ b/src/http/api/routes/index.js
@@ -4,8 +4,8 @@ module.exports = [
   require('./version'),
   require('./shutdown'),
   require('./id'),
-  ...require('./bootstrap')
-  // require('./block')(server)
+  ...require('./bootstrap'),
+  ...require('./block')
   // require('./object')(server)
   // require('./pin')(server)
   // require('./repo')(server)
diff --git a/test/http-api/inject/block.js b/test/http-api/inject/block.js
index efa44a9212..eac8112b79 100644
--- a/test/http-api/inject/block.js
+++ b/test/http-api/inject/block.js
@@ -13,28 +13,26 @@ module.exports = (http) => {
     let api
 
     before(() => {
-      api = http.api.server.select('API')
+      api = http.api._apiServer
     })
 
     describe('/block/put', () => {
-      it('returns 400 if no node is provided', (done) => {
+      it('returns 400 if no node is provided', async () => {
         const form = new FormData()
         const headers = form.getHeaders()
+        const payload = await streamToPromise(form)
 
-        streamToPromise(form).then((payload) => {
-          api.inject({
-            method: 'POST',
-            url: '/api/v0/block/put',
-            headers: headers,
-            payload: payload
-          }, (res) => {
-            expect(res.statusCode).to.equal(400)
-            done()
-          })
+        const res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/block/put',
+          headers,
+          payload
         })
+
+        expect(res.statusCode).to.equal(400)
       })
 
-      it('updates value', (done) => {
+      it('updates value', async () => {
         const form = new FormData()
         const filePath = 'test/fixtures/test-data/hello'
         form.append('data', fs.createReadStream(filePath))
@@ -44,204 +42,183 @@ module.exports = (http) => {
           Size: 12
         }
 
-        streamToPromise(form).then((payload) => {
-          api.inject({
-            method: 'POST',
-            url: '/api/v0/block/put',
-            headers: headers,
-            payload: payload
-          }, (res) => {
-            expect(res.statusCode).to.equal(200)
-            expect(res.result).to.deep.equal(expectedResult)
-            done()
-          })
+        const payload = await streamToPromise(form)
+        const res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/block/put',
+          headers,
+          payload
         })
+
+        expect(res.statusCode).to.equal(200)
+        expect(res.result).to.deep.equal(expectedResult)
       })
 
-      it('should put a value and return a base64 encoded CID', (done) => {
+      it('should put a value and return a base64 encoded CID', async () => {
         const form = new FormData()
         form.append('data', Buffer.from('TEST' + Date.now()))
         const headers = form.getHeaders()
 
-        streamToPromise(form).then((payload) => {
-          api.inject({
-            method: 'POST',
-            url: '/api/v0/block/put?cid-base=base64',
-            headers: headers,
-            payload: payload
-          }, (res) => {
-            expect(res.statusCode).to.equal(200)
-            expect(multibase.isEncoded(res.result.Key)).to.deep.equal('base64')
-            done()
-          })
+        const payload = await streamToPromise(form)
+        const res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/block/put?cid-base=base64',
+          headers,
+          payload
         })
+
+        expect(res.statusCode).to.equal(200)
+        expect(multibase.isEncoded(res.result.Key)).to.deep.equal('base64')
       })
 
-      it('should not put a value for invalid cid-base option', (done) => {
+      it('should not put a value for invalid cid-base option', async () => {
         const form = new FormData()
         form.append('data', Buffer.from('TEST' + Date.now()))
         const headers = form.getHeaders()
 
-        streamToPromise(form).then((payload) => {
-          api.inject({
-            method: 'POST',
-            url: '/api/v0/block/put?cid-base=invalid',
-            headers: headers,
-            payload: payload
-          }, (res) => {
-            expect(res.statusCode).to.equal(400)
-            expect(res.result.Message).to.include('child "cid-base" fails')
-            done()
-          })
+        const payload = await streamToPromise(form)
+        const res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/block/put?cid-base=invalid',
+          headers,
+          payload
         })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Message).to.include('Invalid request query input')
       })
     })
 
     describe('/block/get', () => {
-      it('returns 400 for request without argument', (done) => {
-        api.inject({
+      it('returns 400 for request without argument', async () => {
+        const res = await api.inject({
           method: 'GET',
           url: '/api/v0/block/get'
-        }, (res) => {
-          expect(res.statusCode).to.equal(400)
-          expect(res.result).to.be.a('string')
-          done()
         })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result).to.be.a('string')
       })
 
-      it('returns 500 for request with invalid argument', (done) => {
-        api.inject({
+      it('returns 400 for request with invalid argument', async () => {
+        const res = await api.inject({
           method: 'GET',
           url: '/api/v0/block/get?arg=invalid'
-        }, (res) => {
-          expect(res.statusCode).to.equal(500)
-          expect(res.result.Code).to.equal(0)
-          expect(res.result.Message).to.be.a('string')
-          done()
         })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Code).to.equal(0)
+        expect(res.result.Message).to.be.a('string')
       })
 
-      it('returns value', (done) => {
-        api.inject({
+      it('returns value', async () => {
+        const res = await api.inject({
           method: 'GET',
           url: '/api/v0/block/get?arg=QmZjTnYw2TFhn9Nn7tjmPSoTBoY7YRkwPzwSrSbabY24Kp'
-        }, (res) => {
-          expect(res.statusCode).to.equal(200)
-          expect(res.result)
-            .to.equal('hello world\n')
-          done()
         })
+
+        expect(res.statusCode).to.equal(200)
+        expect(res.result).to.equal('hello world\n')
       })
     })
 
     describe('/block/stat', () => {
-      it('returns 400 for request without argument', (done) => {
-        api.inject({
+      it('returns 400 for request without argument', async () => {
+        const res = await api.inject({
           method: 'GET',
           url: '/api/v0/block/stat'
-        }, (res) => {
-          expect(res.statusCode).to.equal(400)
-          expect(res.result).to.be.a('string')
-          done()
         })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result).to.be.a('string')
       })
 
-      it('returns 500 for request with invalid argument', (done) => {
-        api.inject({
+      it('returns 400 for request with invalid argument', async () => {
+        const res = await api.inject({
           method: 'GET',
           url: '/api/v0/block/stat?arg=invalid'
-        }, (res) => {
-          expect(res.statusCode).to.equal(500)
-          expect(res.result.Code).to.equal(0)
-          expect(res.result.Message).to.be.a('string')
-          done()
         })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Code).to.equal(0)
+        expect(res.result.Message).to.be.a('string')
       })
 
-      it('returns value', (done) => {
-        api.inject({
+      it('returns value', async () => {
+        const res = await api.inject({
           method: 'GET',
           url: '/api/v0/block/stat?arg=QmZjTnYw2TFhn9Nn7tjmPSoTBoY7YRkwPzwSrSbabY24Kp'
-        }, (res) => {
-          expect(res.statusCode).to.equal(200)
-          expect(res.result.Key)
-            .to.equal('QmZjTnYw2TFhn9Nn7tjmPSoTBoY7YRkwPzwSrSbabY24Kp')
-          expect(res.result.Size).to.equal(12)
-          done()
         })
+
+        expect(res.statusCode).to.equal(200)
+        expect(res.result.Key)
+          .to.equal('QmZjTnYw2TFhn9Nn7tjmPSoTBoY7YRkwPzwSrSbabY24Kp')
+        expect(res.result.Size).to.equal(12)
       })
 
-      it('should stat a block and return a base64 encoded CID', (done) => {
+      it('should stat a block and return a base64 encoded CID', async () => {
         const form = new FormData()
         form.append('data', Buffer.from('TEST' + Date.now()))
         const headers = form.getHeaders()
 
-        streamToPromise(form).then((payload) => {
-          api.inject({
-            method: 'POST',
-            url: '/api/v0/block/put?cid-base=base64',
-            headers: headers,
-            payload: payload
-          }, (res) => {
-            expect(res.statusCode).to.equal(200)
-            expect(multibase.isEncoded(res.result.Key)).to.deep.equal('base64')
-            done()
-          })
+        const payload = await streamToPromise(form)
+        const res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/block/put?cid-base=base64',
+          headers,
+          payload
         })
+
+        expect(res.statusCode).to.equal(200)
+        expect(multibase.isEncoded(res.result.Key)).to.deep.equal('base64')
       })
 
-      it('should not stat a block for invalid cid-base option', (done) => {
+      it('should not stat a block for invalid cid-base option', async () => {
         const form = new FormData()
         form.append('data', Buffer.from('TEST' + Date.now()))
         const headers = form.getHeaders()
 
-        streamToPromise(form).then((payload) => {
-          api.inject({
-            method: 'POST',
-            url: '/api/v0/block/put?cid-base=invalid',
-            headers: headers,
-            payload: payload
-          }, (res) => {
-            expect(res.statusCode).to.equal(400)
-            expect(res.result.Message).to.include('child "cid-base" fails')
-            done()
-          })
+        const payload = await streamToPromise(form)
+        const res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/block/put?cid-base=invalid',
+          headers,
+          payload
         })
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Message).to.include('Invalid request query input')
       })
     })
 
     describe('/block/rm', () => {
-      it('returns 400 for request without argument', (done) => {
-        api.inject({
+      it('returns 400 for request without argument', async () => {
+        const res = await api.inject({
           method: 'GET',
           url: '/api/v0/block/rm'
-        }, (res) => {
-          expect(res.statusCode).to.equal(400)
-          expect(res.result).to.be.a('string')
-          done()
         })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result).to.be.a('string')
       })
 
-      it('returns 500 for request with invalid argument', (done) => {
-        api.inject({
+      it('returns 400 for request with invalid argument', async () => {
+        const res = await api.inject({
           method: 'GET',
           url: '/api/v0/block/rm?arg=invalid'
-        }, (res) => {
-          expect(res.statusCode).to.equal(500)
-          expect(res.result.Code).to.equal(0)
-          expect(res.result.Message).to.be.a('string')
-          done()
         })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Code).to.equal(0)
+        expect(res.result.Message).to.be.a('string')
       })
 
-      it('returns 200', (done) => {
-        api.inject({
+      it('returns 200', async () => {
+        const res = await api.inject({
           method: 'GET',
           url: '/api/v0/block/rm?arg=QmZjTnYw2TFhn9Nn7tjmPSoTBoY7YRkwPzwSrSbabY24Kp'
-        }, (res) => {
-          expect(res.statusCode).to.equal(200)
-          done()
         })
+
+        expect(res.statusCode).to.equal(200)
       })
     })
   })

From 99de1586b0d24b12ee279b3494442764dbf8a99f Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Sat, 26 Jan 2019 21:03:32 +0000
Subject: [PATCH 11/49] refactor: switch default error code to 0

Infer error code from status code if not set.

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/error-handler.js | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/src/http/error-handler.js b/src/http/error-handler.js
index eca581d311..3c8bca9d6b 100644
--- a/src/http/error-handler.js
+++ b/src/http/error-handler.js
@@ -9,7 +9,19 @@ module.exports = (server, log) => {
     }
 
     const { statusCode, message } = res.output.payload
-    const code = res.data && res.data.code != null ? res.data.code : 1
+    let code
+
+    if (res.data && res.data.code != null) {
+      code = res.data.code
+    } else {
+      // Map status code to error code as defined by go-ipfs
+      // https://github.com/ipfs/go-ipfs-cmdkit/blob/0262a120012063c359727423ec703b9649eec447/error.go#L12-L20
+      if (statusCode >= 400 && statusCode < 500) {
+        code = statusCode === 404 ? 3 : 1
+      } else {
+        code = 0
+      }
+    }
 
     if (statusCode >= 500) {
       const { req } = request.raw

From 08728a65944592519ed20aefcdee473a83c7a0a7 Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Sat, 26 Jan 2019 21:04:31 +0000
Subject: [PATCH 12/49] fix: return value for bad request to block endpoints

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/api/resources/block.js |  4 ++--
 test/http-api/inject/block.js   | 12 ++++++------
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/http/api/resources/block.js b/src/http/api/resources/block.js
index 396abf5587..2debf2b45b 100644
--- a/src/http/api/resources/block.js
+++ b/src/http/api/resources/block.js
@@ -13,14 +13,14 @@ log.error = debug('jsipfs:http-api:block:error')
 // common pre request handler that parses the args and returns `key` which is assigned to `request.pre.args`
 exports.parseKey = (request, h) => {
   if (!request.query.arg) {
-    return h.response("Argument 'key' is required").code(400).takeover()
+    throw Boom.badRequest("Argument 'key' is required")
   }
 
   try {
     return { key: new CID(request.query.arg) }
   } catch (err) {
     log.error(err)
-    throw Boom.badRequest('Not a valid hash', { code: 0 })
+    throw Boom.badRequest('Not a valid hash')
   }
 }
 
diff --git a/test/http-api/inject/block.js b/test/http-api/inject/block.js
index eac8112b79..1cf8eb52e4 100644
--- a/test/http-api/inject/block.js
+++ b/test/http-api/inject/block.js
@@ -97,7 +97,7 @@ module.exports = (http) => {
         })
 
         expect(res.statusCode).to.equal(400)
-        expect(res.result).to.be.a('string')
+        expect(res.result.Message).to.be.a('string')
       })
 
       it('returns 400 for request with invalid argument', async () => {
@@ -107,7 +107,7 @@ module.exports = (http) => {
         })
 
         expect(res.statusCode).to.equal(400)
-        expect(res.result.Code).to.equal(0)
+        expect(res.result.Code).to.equal(1)
         expect(res.result.Message).to.be.a('string')
       })
 
@@ -130,7 +130,7 @@ module.exports = (http) => {
         })
 
         expect(res.statusCode).to.equal(400)
-        expect(res.result).to.be.a('string')
+        expect(res.result.Message).to.be.a('string')
       })
 
       it('returns 400 for request with invalid argument', async () => {
@@ -140,7 +140,7 @@ module.exports = (http) => {
         })
 
         expect(res.statusCode).to.equal(400)
-        expect(res.result.Code).to.equal(0)
+        expect(res.result.Code).to.equal(1)
         expect(res.result.Message).to.be.a('string')
       })
 
@@ -198,7 +198,7 @@ module.exports = (http) => {
         })
 
         expect(res.statusCode).to.equal(400)
-        expect(res.result).to.be.a('string')
+        expect(res.result.Message).to.be.a('string')
       })
 
       it('returns 400 for request with invalid argument', async () => {
@@ -208,7 +208,7 @@ module.exports = (http) => {
         })
 
         expect(res.statusCode).to.equal(400)
-        expect(res.result.Code).to.equal(0)
+        expect(res.result.Code).to.equal(1)
         expect(res.result.Message).to.be.a('string')
       })
 

From 9584146c18e41ce2c0e7cfb90d24e8ce8f7a6ca0 Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Sat, 26 Jan 2019 21:05:11 +0000
Subject: [PATCH 13/49] refactor: /api/v0/object* for hapi 18

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/api/resources/object.js |  700 ++++++++----------
 src/http/api/routes/index.js     |    4 +-
 src/http/api/routes/object.js    |  117 ++-
 test/http-api/inject/object.js   | 1176 ++++++++++++++----------------
 4 files changed, 892 insertions(+), 1105 deletions(-)

diff --git a/src/http/api/resources/object.js b/src/http/api/resources/object.js
index e3ed14d72f..3d597cbea4 100644
--- a/src/http/api/resources/object.js
+++ b/src/http/api/resources/object.js
@@ -1,13 +1,16 @@
 'use strict'
 
+const promisify = require('promisify-es6')
 const CID = require('cids')
 const multipart = require('ipfs-multipart')
 const dagPB = require('ipld-dag-pb')
-const DAGLink = dagPB.DAGLink
-const DAGNode = dagPB.DAGNode
-const waterfall = require('async/waterfall')
+const { DAGNode, DAGLink } = dagPB
+const calculateCid = promisify(dagPB.util.cid)
+const deserialize = promisify(dagPB.util.deserialize)
+const createDagNode = promisify(DAGNode.create)
 const Joi = require('joi')
 const multibase = require('multibase')
+const Boom = require('boom')
 const { cidToString } = require('../../../utils/cid')
 const debug = require('debug')
 const log = debug('jsipfs:http-api:object')
@@ -16,21 +19,16 @@ log.error = debug('jsipfs:http-api:object:error')
 exports = module.exports
 
 // common pre request handler that parses the args and returns `key` which is assigned to `request.pre.args`
-exports.parseKey = (request, reply) => {
+exports.parseKey = (request, h) => {
   if (!request.query.arg) {
-    return reply("Argument 'key' is required").code(400).takeover()
+    throw Boom.badRequest("Argument 'key' is required")
   }
 
   try {
-    return reply({
-      key: new CID(request.query.arg)
-    })
+    return { key: new CID(request.query.arg) }
   } catch (err) {
     log.error(err)
-    return reply({
-      Message: 'invalid ipfs ref path',
-      Code: 0
-    }).code(500).takeover()
+    throw Boom.badRequest('invalid ipfs ref path')
   }
 }
 
@@ -41,39 +39,35 @@ exports.new = {
     }).unknown()
   },
 
-  handler (request, reply) {
-    const ipfs = request.server.app.ipfs
+  async handler (request, h) {
+    const { ipfs } = request.server.app
     const template = request.query.arg
 
-    waterfall([
-      (cb) => ipfs.object.new(template, cb),
-      (cid, cb) => ipfs.object.get(cid, (err, node) => cb(err, { node, cid }))
-    ], (err, results) => {
-      if (err) {
-        log.error(err)
-        return reply({
-          Message: `Failed to create object: ${err.message}`,
-          Code: 0
-        }).code(500)
-      }
+    let cid, node
+    try {
+      cid = await ipfs.object.new(template)
+      node = await ipfs.object.get(cid)
+    } catch (err) {
+      log.error(err)
+      throw new Error(`Failed to create object: ${err.message}`)
+    }
 
-      const nodeJSON = results.node.toJSON()
-
-      const answer = {
-        Data: nodeJSON.data,
-        Hash: cidToString(results.cid, { base: request.query['cid-base'], upgrade: false }),
-        Size: nodeJSON.size,
-        Links: nodeJSON.links.map((l) => {
-          return {
-            Name: l.name,
-            Size: l.size,
-            Hash: cidToString(l.cid, { base: request.query['cid-base'], upgrade: false })
-          }
-        })
-      }
+    const nodeJSON = node.toJSON()
+
+    const answer = {
+      Data: nodeJSON.data,
+      Hash: cidToString(cid, { base: request.query['cid-base'], upgrade: false }),
+      Size: nodeJSON.size,
+      Links: nodeJSON.links.map((l) => {
+        return {
+          Name: l.name,
+          Size: l.size,
+          Hash: cidToString(l.cid, { base: request.query['cid-base'], upgrade: false })
+        }
+      })
+    }
 
-      return reply(answer)
-    })
+    return h.response(answer)
   }
 }
 
@@ -88,44 +82,40 @@ exports.get = {
   parseArgs: exports.parseKey,
 
   // main route handler which is called after the above `parseArgs`, but only if the args were valid
-  handler: (request, reply) => {
-    const key = request.pre.args.key
+  async handler (request, h) {
+    const { key } = request.pre.args
     const enc = request.query.enc || 'base58'
-    const ipfs = request.server.app.ipfs
-
-    waterfall([
-      (cb) => ipfs.object.get(key, { enc: enc }, cb),
-      (node, cb) => dagPB.util.cid(node, (err, cid) => cb(err, { node, cid }))
-    ], (err, results) => {
-      if (err) {
-        log.error(err)
-        return reply({
-          Message: 'Failed to get object: ' + err,
-          Code: 0
-        }).code(500)
-      }
+    const { ipfs } = request.server.app
 
-      const nodeJSON = results.node.toJSON()
+    let node, cid
+    try {
+      node = await ipfs.object.get(key, { enc: enc })
+      cid = await calculateCid(node)
+    } catch (err) {
+      log.error(err)
+      throw new Error(`Failed to get object: ${err.message}`)
+    }
 
-      if (Buffer.isBuffer(results.node.data)) {
-        nodeJSON.data = results.node.data.toString(request.query['data-encoding'] || undefined)
-      }
+    const nodeJSON = node.toJSON()
 
-      const answer = {
-        Data: nodeJSON.data,
-        Hash: cidToString(results.cid, { base: request.query['cid-base'], upgrade: false }),
-        Size: nodeJSON.size,
-        Links: nodeJSON.links.map((l) => {
-          return {
-            Name: l.name,
-            Size: l.size,
-            Hash: cidToString(l.cid, { base: request.query['cid-base'], upgrade: false })
-          }
-        })
-      }
+    if (Buffer.isBuffer(node.data)) {
+      nodeJSON.data = node.data.toString(request.query['data-encoding'] || undefined)
+    }
 
-      return reply(answer)
-    })
+    const answer = {
+      Data: nodeJSON.data,
+      Hash: cidToString(cid, { base: request.query['cid-base'], upgrade: false }),
+      Size: nodeJSON.size,
+      Links: nodeJSON.links.map((l) => {
+        return {
+          Name: l.name,
+          Size: l.size,
+          Hash: cidToString(l.cid, { base: request.query['cid-base'], upgrade: false })
+        }
+      })
+    }
+
+    return h.response(answer)
   }
 }
 
@@ -138,119 +128,75 @@ exports.put = {
 
   // pre request handler that parses the args and returns `node`
   // which is assigned to `request.pre.args`
-  parseArgs: (request, reply) => {
+  async parseArgs (request, h) {
     if (!request.payload) {
-      return reply("File argument 'data' is required").code(400).takeover()
+      throw Boom.badRequest("File argument 'data' is required")
     }
 
     const enc = request.query.inputenc
-    const parser = multipart.reqParser(request.payload)
-
-    let file
-    let finished = true
-
-    // TODO: this whole function this to be revisited
-    // so messy
-    parser.on('file', (name, stream) => {
-      finished = false
-      // TODO fix: stream is not emitting the 'end' event
-      stream.on('data', (data) => {
-        if (enc === 'protobuf') {
-          waterfall([
-            (cb) => dagPB.util.deserialize(data, cb),
-            (node, cb) => dagPB.util.cid(node, (err, cid) => cb(err, { node, cid }))
-          ], (err, results) => {
-            if (err) {
-              return reply({
-                Message: 'Failed to put object: ' + err,
-                Code: 0
-              }).code(500).takeover()
-            }
-
-            const nodeJSON = results.node.toJSON()
-
-            const answer = {
-              Data: nodeJSON.data,
-              Hash: results.cid.toBaseEncodedString(),
-              Size: nodeJSON.size,
-              Links: nodeJSON.links.map((l) => {
-                return {
-                  Name: l.name,
-                  Size: l.size,
-                  Hash: l.cid
-                }
-              })
-            }
-
-            file = Buffer.from(JSON.stringify(answer))
-            finished = true
-          })
-        } else {
-          file = data
-
-          finished = true
-        }
-      })
-    })
 
-    parser.on('end', finish)
+    const fileStream = await new Promise((resolve, reject) => {
+      multipart.reqParser(request.payload)
+        .on('file', (name, stream) => resolve(stream))
+        .on('end', () => reject(Boom.badRequest("File argument 'data' is required")))
+    })
 
-    function finish () {
-      if (!finished) {
-        return setTimeout(finish, 10)
-      }
-      if (!file) {
-        return reply("File argument 'data' is required").code(400).takeover()
-      }
+    const data = await new Promise((resolve, reject) => {
+      fileStream
+        .on('data', data => resolve(data))
+        .on('end', () => reject(Boom.badRequest("File argument 'data' is required")))
+    })
 
+    if (enc === 'protobuf') {
       try {
-        return reply({
-          node: JSON.parse(file.toString())
-        })
+        return { node: await deserialize(data) }
       } catch (err) {
-        return reply({
-          Message: 'Failed to parse the JSON: ' + err,
-          Code: 0
-        }).code(500).takeover()
+        throw Boom.badRequest('Failed to deserialize: ' + err)
       }
     }
+
+    let nodeJson
+    try {
+      nodeJson = JSON.parse(data.toString())
+    } catch (err) {
+      throw Boom.badRequest('Failed to parse the JSON: ' + err)
+    }
+
+    try {
+      return { node: await createDagNode(nodeJson.Data, nodeJson.Links) }
+    } catch (err) {
+      throw Boom.badRequest('Failed to create DAG node: ' + err)
+    }
   },
 
   // main route handler which is called after the above `parseArgs`, but only if the args were valid
-  handler: (request, reply) => {
-    const ipfs = request.server.app.ipfs
-    let node = request.pre.args.node
-
-    waterfall([
-      (cb) => DAGNode.create(Buffer.from(node.Data), node.Links, cb),
-      (node, cb) => ipfs.object.put(node, (err, cid) => cb(err, { cid, node }))
-    ], (err, results) => {
-      if (err) {
-        log.error(err)
-
-        return reply({
-          Message: 'Failed to put object: ' + err,
-          Code: 0
-        }).code(500)
-      }
+  async handler (request, h) {
+    const { ipfs } = request.server.app
+    const { node } = request.pre.args
 
-      const nodeJSON = results.node.toJSON()
-
-      const answer = {
-        Data: nodeJSON.data,
-        Hash: cidToString(results.cid, { base: request.query['cid-base'], upgrade: false }),
-        Size: nodeJSON.size,
-        Links: nodeJSON.links.map((l) => {
-          return {
-            Name: l.name,
-            Size: l.size,
-            Hash: cidToString(l.cid, { base: request.query['cid-base'], upgrade: false })
-          }
-        })
-      }
+    let cid
+    try {
+      cid = await ipfs.object.put(node)
+    } catch (err) {
+      throw new Error('Failed to put node: ' + err)
+    }
 
-      return reply(answer)
-    })
+    const nodeJSON = node.toJSON()
+
+    const answer = {
+      Data: nodeJSON.data,
+      Hash: cidToString(cid, { base: request.query['cid-base'], upgrade: false }),
+      Size: nodeJSON.size,
+      Links: nodeJSON.links.map((l) => {
+        return {
+          Name: l.name,
+          Size: l.size,
+          Hash: cidToString(l.cid, { base: request.query['cid-base'], upgrade: false })
+        }
+      })
+    }
+
+    return h.response(answer)
   }
 }
 
@@ -265,23 +211,21 @@ exports.stat = {
   parseArgs: exports.parseKey,
 
   // main route handler which is called after the above `parseArgs`, but only if the args were valid
-  handler: (request, reply) => {
-    const ipfs = request.server.app.ipfs
-    const key = request.pre.args.key
-
-    ipfs.object.stat(key, (err, stats) => {
-      if (err) {
-        log.error(err)
-        return reply({
-          Message: 'Failed to stat object: ' + err,
-          Code: 0
-        }).code(500)
-      }
+  async handler (request, h) {
+    const { ipfs } = request.server.app
+    const { key } = request.pre.args
+
+    let stats
+    try {
+      stats = await ipfs.object.stat(key)
+    } catch (err) {
+      log.error(err)
+      throw new Error('Failed to stat object: ' + err)
+    }
 
-      stats.Hash = cidToString(stats.Hash, { base: request.query['cid-base'], upgrade: false })
+    stats.Hash = cidToString(stats.Hash, { base: request.query['cid-base'], upgrade: false })
 
-      return reply(stats)
-    })
+    return h.response(stats)
   }
 }
 
@@ -290,21 +234,19 @@ exports.data = {
   parseArgs: exports.parseKey,
 
   // main route handler which is called after the above `parseArgs`, but only if the args were valid
-  handler: (request, reply) => {
-    const ipfs = request.server.app.ipfs
-    const key = request.pre.args.key
-
-    ipfs.object.data(key, (err, data) => {
-      if (err) {
-        log.error(err)
-        return reply({
-          Message: 'Failed to get object data: ' + err,
-          Code: 0
-        }).code(500)
-      }
+  async handler (request, h) {
+    const { ipfs } = request.server.app
+    const { key } = request.pre.args
 
-      return reply(data)
-    })
+    let data
+    try {
+      data = await ipfs.object.data(key)
+    } catch (err) {
+      log.error(err)
+      throw new Error('Failed to get object data: ' + err)
+    }
+
+    return h.response(data)
   }
 }
 
@@ -319,72 +261,64 @@ exports.links = {
   parseArgs: exports.parseKey,
 
   // main route handler which is called after the above `parseArgs`, but only if the args were valid
-  handler: (request, reply) => {
-    const key = request.pre.args.key
-    const ipfs = request.server.app.ipfs
-
-    ipfs.object.get(key, (err, node) => {
-      if (err) {
-        log.error(err)
-        return reply({
-          Message: 'Failed to get object links: ' + err,
-          Code: 0
-        }).code(500)
-      }
+  async handler (request, h) {
+    const { ipfs } = request.server.app
+    const { key } = request.pre.args
 
-      const nodeJSON = node.toJSON()
-
-      return reply({
-        Hash: cidToString(key, { base: request.query['cid-base'], upgrade: false }),
-        Links: nodeJSON.links.map((l) => {
-          return {
-            Name: l.name,
-            Size: l.size,
-            Hash: cidToString(l.cid, { base: request.query['cid-base'], upgrade: false })
-          }
-        })
+    let node
+    try {
+      node = await ipfs.object.get(key)
+    } catch (err) {
+      log.error(err)
+      throw new Error('Failed to get object links: ' + err)
+    }
+
+    const nodeJSON = node.toJSON()
+
+    return h.response({
+      Hash: cidToString(key, { base: request.query['cid-base'], upgrade: false }),
+      Links: nodeJSON.links.map((l) => {
+        return {
+          Name: l.name,
+          Size: l.size,
+          Hash: cidToString(l.cid, { base: request.query['cid-base'], upgrade: false })
+        }
       })
     })
   }
 }
 
 // common pre request handler that parses the args and returns `data` & `key` which are assigned to `request.pre.args`
-exports.parseKeyAndData = (request, reply) => {
+exports.parseKeyAndData = async (request, h) => {
   if (!request.query.arg) {
-    return reply("Argument 'root' is required").code(400).takeover()
+    throw Boom.badRequest("Argument 'root' is required")
   }
 
   if (!request.payload) {
-    return reply("File argument 'data' is required").code(400).takeover()
+    throw Boom.badRequest("File argument 'data' is required")
   }
 
-  const parser = multipart.reqParser(request.payload)
-  let file
+  // TODO: support ipfs paths: https://github.com/ipfs/http-api-spec/pull/68/files#diff-2625016b50d68d922257f74801cac29cR3880
+  let cid
+  try {
+    cid = new CID(request.query.arg)
+  } catch (err) {
+    throw Boom.badRequest('invalid ipfs ref path')
+  }
 
-  parser.on('file', (fileName, fileStream) => {
-    fileStream.on('data', (data) => {
-      file = data
-    })
+  const fileStream = await new Promise((resolve, reject) => {
+    multipart.reqParser(request.payload)
+      .on('file', (fileName, fileStream) => resolve(fileStream))
+      .on('end', () => reject(Boom.badRequest("File argument 'data' is required")))
   })
 
-  parser.on('end', () => {
-    if (!file) {
-      return reply("File argument 'data' is required").code(400).takeover()
-    }
-
-    try {
-      return reply({
-        data: file,
-        // TODO: support ipfs paths: https://github.com/ipfs/http-api-spec/pull/68/files#diff-2625016b50d68d922257f74801cac29cR3880
-        key: new CID(request.query.arg)
-      })
-    } catch (err) {
-      return reply({
-        Message: 'invalid ipfs ref path',
-        Code: 0
-      }).code(500).takeover()
-    }
+  const fileData = await new Promise((resolve, reject) => {
+    fileStream
+      .on('data', data => resolve(data))
+      .on('end', () => reject(Boom.badRequest("File argument 'data' is required")))
   })
+
+  return { data: fileData, key: cid }
 }
 
 exports.patchAppendData = {
@@ -398,41 +332,35 @@ exports.patchAppendData = {
   parseArgs: exports.parseKeyAndData,
 
   // main route handler which is called after the above `parseArgs`, but only if the args were valid
-  handler: (request, reply) => {
-    const key = request.pre.args.key
-    const data = request.pre.args.data
-    const ipfs = request.server.app.ipfs
-
-    waterfall([
-      (cb) => ipfs.object.patch.appendData(key, data, cb),
-      (cid, cb) => ipfs.object.get(cid, (err, node) => cb(err, { node, cid }))
-    ], (err, results) => {
-      if (err) {
-        log.error(err)
-
-        return reply({
-          Message: 'Failed to append data to object: ' + err,
-          Code: 0
-        }).code(500)
-      }
+  async handler (request, h) {
+    const { ipfs } = request.server.app
+    const { key, data } = request.pre.args
 
-      const nodeJSON = results.node.toJSON()
-
-      const answer = {
-        Data: nodeJSON.data,
-        Hash: cidToString(results.cid, { base: request.query['cid-base'], upgrade: false }),
-        Size: nodeJSON.size,
-        Links: nodeJSON.links.map((l) => {
-          return {
-            Name: l.name,
-            Size: l.size,
-            Hash: cidToString(l.cid, { base: request.query['cid-base'], upgrade: false })
-          }
-        })
-      }
+    let cid, node
+    try {
+      cid = await ipfs.object.patch.appendData(key, data)
+      node = await ipfs.object.get(cid)
+    } catch (err) {
+      log.error(err)
+      throw new Error('Failed to append data to object: ' + err)
+    }
 
-      return reply(answer)
-    })
+    const nodeJSON = node.toJSON()
+
+    const answer = {
+      Data: nodeJSON.data,
+      Hash: cidToString(cid, { base: request.query['cid-base'], upgrade: false }),
+      Size: nodeJSON.size,
+      Links: nodeJSON.links.map((l) => {
+        return {
+          Name: l.name,
+          Size: l.size,
+          Hash: cidToString(l.cid, { base: request.query['cid-base'], upgrade: false })
+        }
+      })
+    }
+
+    return h.response(answer)
   }
 }
 
@@ -447,35 +375,29 @@ exports.patchSetData = {
   parseArgs: exports.parseKeyAndData,
 
   // main route handler which is called after the above `parseArgs`, but only if the args were valid
-  handler: (request, reply) => {
-    const key = request.pre.args.key
-    const data = request.pre.args.data
-    const ipfs = request.server.app.ipfs
-
-    waterfall([
-      (cb) => ipfs.object.patch.setData(key, data, cb),
-      (cid, cb) => ipfs.object.get(cid, (err, node) => cb(err, { node, cid }))
-    ], (err, results) => {
-      if (err) {
-        log.error(err)
-
-        return reply({
-          Message: 'Failed to set data on object: ' + err,
-          Code: 0
-        }).code(500)
-      }
+  async handler (request, h) {
+    const { ipfs } = request.server.app
+    const { key, data } = request.pre.args
 
-      const nodeJSON = results.node.toJSON()
-
-      return reply({
-        Hash: cidToString(results.cid, { base: request.query['cid-base'], upgrade: false }),
-        Links: nodeJSON.links.map((l) => {
-          return {
-            Name: l.name,
-            Size: l.size,
-            Hash: cidToString(l.cid, { base: request.query['cid-base'], upgrade: false })
-          }
-        })
+    let cid, node
+    try {
+      cid = await ipfs.object.patch.setData(key, data)
+      node = await ipfs.object.get(cid)
+    } catch (err) {
+      log.error(err)
+      throw new Error('Failed to set data on object: ' + err)
+    }
+
+    const nodeJSON = node.toJSON()
+
+    return h.response({
+      Hash: cidToString(cid, { base: request.query['cid-base'], upgrade: false }),
+      Links: nodeJSON.links.map((l) => {
+        return {
+          Name: l.name,
+          Size: l.size,
+          Hash: cidToString(l.cid, { base: request.query['cid-base'], upgrade: false })
+        }
       })
     })
   }
@@ -492,75 +414,64 @@ exports.patchAddLink = {
   parseArgs: (request, reply) => {
     if (!(request.query.arg instanceof Array) ||
         request.query.arg.length !== 3) {
-      return reply("Arguments 'root', 'name' & 'ref' are required").code(400).takeover()
+      throw Boom.badRequest("Arguments 'root', 'name' & 'ref' are required")
     }
 
-    const error = (msg) => reply({
-      Message: msg,
-      Code: 0
-    }).code(500).takeover()
-
     if (!request.query.arg[0]) {
-      return error('cannot create link with no root')
+      throw Boom.badRequest('cannot create link with no root')
     }
 
     if (!request.query.arg[1]) {
-      return error('cannot create link with no name!')
+      throw Boom.badRequest('cannot create link with no name!')
     }
 
     if (!request.query.arg[2]) {
-      return error('cannot create link with no ref')
+      throw Boom.badRequest('cannot create link with no ref')
     }
 
     try {
-      return reply({
+      return {
         root: new CID(request.query.arg[0]),
         name: request.query.arg[1],
         ref: new CID(request.query.arg[2])
-      })
+      }
     } catch (err) {
       log.error(err)
-      return error('invalid ipfs ref path')
+      throw Boom.badRequest('invalid ipfs ref path')
     }
   },
 
   // main route handler which is called after the above `parseArgs`, but only if the args were valid
-  handler: (request, reply) => {
-    const root = request.pre.args.root
-    const name = request.pre.args.name
-    const ref = request.pre.args.ref
-    const ipfs = request.server.app.ipfs
-
-    waterfall([
-      (cb) => ipfs.object.get(ref, cb),
-      (node, cb) => ipfs.object.patch.addLink(root, new DAGLink(name, node.size, ref), cb),
-      (cid, cb) => ipfs.object.get(cid, (err, node) => cb(err, { node, cid }))
-    ], (err, results) => {
-      if (err) {
-        log.error(err)
-        return reply({
-          Message: 'Failed to add link to object: ' + err,
-          Code: 0
-        }).code(500)
-      }
+  async handler (request, h) {
+    const { ipfs } = request.server.app
+    const { root, name, ref } = request.pre.args
 
-      const nodeJSON = results.node.toJSON()
-
-      const answer = {
-        Data: nodeJSON.data,
-        Hash: cidToString(results.cid, { base: request.query['cid-base'], upgrade: false }),
-        Size: nodeJSON.size,
-        Links: nodeJSON.links.map((l) => {
-          return {
-            Name: l.name,
-            Size: l.size,
-            Hash: cidToString(l.cid, { base: request.query['cid-base'], upgrade: false })
-          }
-        })
-      }
+    let node, cid
+    try {
+      node = await ipfs.object.get(ref)
+      cid = await ipfs.object.patch.addLink(root, new DAGLink(name, node.size, ref))
+      node = await ipfs.object.get(cid)
+    } catch (err) {
+      log.error(err)
+      throw new Error('Failed to add link to object: ' + err)
+    }
 
-      return reply(answer)
-    })
+    const nodeJSON = node.toJSON()
+
+    const answer = {
+      Data: nodeJSON.data,
+      Hash: cidToString(cid, { base: request.query['cid-base'], upgrade: false }),
+      Size: nodeJSON.size,
+      Links: nodeJSON.links.map((l) => {
+        return {
+          Name: l.name,
+          Size: l.size,
+          Hash: cidToString(l.cid, { base: request.query['cid-base'], upgrade: false })
+        }
+      })
+    }
+
+    return h.response(answer)
   }
 }
 
@@ -572,67 +483,56 @@ exports.patchRmLink = {
   },
 
   // pre request handler that parses the args and returns `root` & `link` which is assigned to `request.pre.args`
-  parseArgs: (request, reply) => {
+  parseArgs (request, h) {
     if (!(request.query.arg instanceof Array) ||
         request.query.arg.length !== 2) {
-      return reply("Arguments 'root' & 'link' are required").code(400).takeover()
+      throw Boom.badRequest("Arguments 'root' & 'link' are required")
     }
 
     if (!request.query.arg[1]) {
-      return reply({
-        Message: 'cannot remove link with no name!',
-        Code: 0
-      }).code(500).takeover()
+      throw Boom.badRequest('cannot remove link with no name!')
     }
 
     try {
-      return reply({
+      return {
         root: new CID(request.query.arg[0]),
         link: request.query.arg[1]
-      })
+      }
     } catch (err) {
       log.error(err)
-      return reply({
-        Message: 'invalid ipfs ref path',
-        Code: 0
-      }).code(500).takeover()
+      throw Boom.badRequest('invalid ipfs ref path')
     }
   },
 
   // main route handler which is called after the above `parseArgs`, but only if the args were valid
-  handler: (request, reply) => {
-    const root = request.pre.args.root
-    const link = request.pre.args.link
-    const ipfs = request.server.app.ipfs
-
-    waterfall([
-      (cb) => ipfs.object.patch.rmLink(root, { name: link }, cb),
-      (cid, cb) => ipfs.object.get(cid, (err, node) => cb(err, { node, cid }))
-    ], (err, results) => {
-      if (err) {
-        log.error(err)
-        return reply({
-          Message: 'Failed to remove link from object: ' + err,
-          Code: 0
-        }).code(500)
-      }
+  async handler (request, h) {
+    const { ipfs } = request.server.app
+    const { root, link } = request.pre.args
 
-      const nodeJSON = results.node.toJSON()
-
-      const answer = {
-        Data: nodeJSON.data,
-        Hash: cidToString(results.cid, { base: request.query['cid-base'], upgrade: false }),
-        Size: nodeJSON.size,
-        Links: nodeJSON.links.map((l) => {
-          return {
-            Name: l.name,
-            Size: l.size,
-            Hash: cidToString(l.cid, { base: request.query['cid-base'], upgrade: false })
-          }
-        })
-      }
+    let cid, node
+    try {
+      cid = await ipfs.object.patch.rmLink(root, { name: link })
+      node = await ipfs.object.get(cid)
+    } catch (err) {
+      log.error(err)
+      throw new Error('Failed to remove link from object: ' + err)
+    }
 
-      return reply(answer)
-    })
+    const nodeJSON = node.toJSON()
+
+    const answer = {
+      Data: nodeJSON.data,
+      Hash: cidToString(cid, { base: request.query['cid-base'], upgrade: false }),
+      Size: nodeJSON.size,
+      Links: nodeJSON.links.map((l) => {
+        return {
+          Name: l.name,
+          Size: l.size,
+          Hash: cidToString(l.cid, { base: request.query['cid-base'], upgrade: false })
+        }
+      })
+    }
+
+    return h.response(answer)
   }
 }
diff --git a/src/http/api/routes/index.js b/src/http/api/routes/index.js
index 27df09498a..8e4742cdbf 100644
--- a/src/http/api/routes/index.js
+++ b/src/http/api/routes/index.js
@@ -5,8 +5,8 @@ module.exports = [
   require('./shutdown'),
   require('./id'),
   ...require('./bootstrap'),
-  ...require('./block')
-  // require('./object')(server)
+  ...require('./block'),
+  ...require('./object')
   // require('./pin')(server)
   // require('./repo')(server)
   // require('./config')(server)
diff --git a/src/http/api/routes/object.js b/src/http/api/routes/object.js
index 407b6c58a0..9e4b606e05 100644
--- a/src/http/api/routes/object.js
+++ b/src/http/api/routes/object.js
@@ -2,34 +2,30 @@
 
 const resources = require('./../resources')
 
-module.exports = (server) => {
-  const api = server.select('API')
-
-  api.route({
+module.exports = [
+  {
     method: '*',
     path: '/api/v0/object/new',
-    config: {
-      handler: resources.object.new.handler,
+    options: {
       validate: resources.object.new.validate
-    }
-  })
-
-  api.route({
+    },
+    handler: resources.object.new.handler
+  },
+  {
     method: '*',
     path: '/api/v0/object/get',
-    config: {
+    options: {
       pre: [
         { method: resources.object.get.parseArgs, assign: 'args' }
       ],
-      handler: resources.object.get.handler,
       validate: resources.object.get.validate
-    }
-  })
-
-  api.route({
+    },
+    handler: resources.object.get.handler
+  },
+  {
     method: '*',
     path: '/api/v0/object/put',
-    config: {
+    options: {
       payload: {
         parse: false,
         output: 'stream'
@@ -37,50 +33,46 @@ module.exports = (server) => {
       pre: [
         { method: resources.object.put.parseArgs, assign: 'args' }
       ],
-      handler: resources.object.put.handler,
       validate: resources.object.put.validate
-    }
-  })
-
-  api.route({
+    },
+    handler: resources.object.put.handler
+  },
+  {
     method: '*',
     path: '/api/v0/object/stat',
-    config: {
+    options: {
       pre: [
         { method: resources.object.stat.parseArgs, assign: 'args' }
       ],
-      handler: resources.object.stat.handler,
       validate: resources.object.stat.validate
-    }
-  })
-
-  api.route({
+    },
+    handler: resources.object.stat.handler
+  },
+  {
     method: '*',
     path: '/api/v0/object/data',
-    config: {
+    options: {
       pre: [
         { method: resources.object.data.parseArgs, assign: 'args' }
-      ],
-      handler: resources.object.data.handler
-    }
-  })
-
-  api.route({
+      ]
+    },
+    handler: resources.object.data.handler
+  },
+  {
     method: '*',
     path: '/api/v0/object/links',
-    config: {
+    options: {
       pre: [
         { method: resources.object.links.parseArgs, assign: 'args' }
       ],
-      handler: resources.object.links.handler,
       validate: resources.object.links.validate
-    }
-  })
-
-  api.route({
+    },
+    handler: resources.object.links.handler
+  },
+  {
     method: '*',
     path: '/api/v0/object/patch/append-data',
-    config: {
+    options: {
       payload: {
         parse: false,
         output: 'stream'
@@ -88,15 +80,14 @@ module.exports = (server) => {
       pre: [
         { method: resources.object.patchAppendData.parseArgs, assign: 'args' }
       ],
-      handler: resources.object.patchAppendData.handler,
       validate: resources.object.patchAppendData.validate
-    }
-  })
-
-  api.route({
+    },
+    handler: resources.object.patchAppendData.handler
+  },
+  {
     method: '*',
     path: '/api/v0/object/patch/set-data',
-    config: {
+    options: {
       payload: {
         parse: false,
         output: 'stream'
@@ -104,32 +95,30 @@ module.exports = (server) => {
       pre: [
         { method: resources.object.patchSetData.parseArgs, assign: 'args' }
       ],
-      handler: resources.object.patchSetData.handler,
       validate: resources.object.patchSetData.validate
-    }
-  })
-
-  api.route({
+    },
+    handler: resources.object.patchSetData.handler
+  },
+  {
     method: '*',
     path: '/api/v0/object/patch/add-link',
-    config: {
+    options: {
       pre: [
         { method: resources.object.patchAddLink.parseArgs, assign: 'args' }
       ],
-      handler: resources.object.patchAddLink.handler,
       validate: resources.object.patchAddLink.validate
-    }
-  })
-
-  api.route({
+    },
+    handler: resources.object.patchAddLink.handler
+  },
+  {
     method: '*',
     path: '/api/v0/object/patch/rm-link',
-    config: {
+    options: {
       pre: [
         { method: resources.object.patchRmLink.parseArgs, assign: 'args' }
       ],
-      handler: resources.object.patchRmLink.handler,
       validate: resources.object.patchRmLink.validate
-    }
-  })
-}
+    },
+    handler: resources.object.patchRmLink.handler
+  }
+]
diff --git a/test/http-api/inject/object.js b/test/http-api/inject/object.js
index 8180b4e8bd..e329e98c64 100644
--- a/test/http-api/inject/object.js
+++ b/test/http-api/inject/object.js
@@ -11,166 +11,152 @@ const fs = require('fs')
 const FormData = require('form-data')
 const streamToPromise = require('stream-to-promise')
 const multibase = require('multibase')
-const waterfall = require('async/waterfall')
 
 module.exports = (http) => {
   describe('/object', () => {
     let api
 
     before('api', () => {
-      api = http.api.server.select('API')
+      api = http.api._apiServer
     })
 
     describe('/new', () => {
-      it('returns value', (done) => {
-        api.inject({
+      it('returns value', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: '/api/v0/object/new'
-        }, (res) => {
-          expect(res.statusCode).to.equal(200)
-          expect(res.result.Hash)
-            .to.equal('QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n')
-          expect(res.result.Links).to.be.eql([])
-          done()
         })
+
+        expect(res.statusCode).to.equal(200)
+        expect(res.result.Hash)
+          .to.equal('QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n')
+        expect(res.result.Links).to.be.eql([])
       })
 
       // TODO: unskip after switch to v1 CIDs by default
-      it.skip('should create a new object and return a base64 encoded CID', (done) => {
-        api.inject({
+      it.skip('should create a new object and return a base64 encoded CID', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: '/api/v0/object/new?cid-base=base64'
-        }, (res) => {
-          expect(res.statusCode).to.equal(200)
-          expect(multibase.isEncoded(res.result.Hash)).to.deep.equal('base64')
-          done()
         })
+
+        expect(res.statusCode).to.equal(200)
+        expect(multibase.isEncoded(res.result.Hash)).to.deep.equal('base64')
       })
 
-      it('should not create a new object for invalid cid-base option', (done) => {
-        api.inject({
+      it('should not create a new object for invalid cid-base option', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: '/api/v0/object/new?cid-base=invalid'
-        }, (res) => {
-          expect(res.statusCode).to.equal(400)
-          expect(res.result.Message).to.include('child "cid-base" fails')
-          done()
         })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Message).to.include('Invalid request query input')
       })
     })
 
     describe('/get', () => {
-      it('returns 400 for request without argument', (done) => {
-        api.inject({
+      it('returns 400 for request without argument', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: '/api/v0/object/get'
-        }, (res) => {
-          expect(res.statusCode).to.equal(400)
-          expect(res.result).to.be.a('string')
-          done()
         })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Message).to.be.a('string')
       })
 
-      it('returns 500 for request with invalid argument', (done) => {
-        api.inject({
+      it('returns 400 for request with invalid argument', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: '/api/v0/object/get?arg=invalid'
-        }, (res) => {
-          expect(res.statusCode).to.equal(500)
-          expect(res.result.Code).to.equal(0)
-          expect(res.result.Message).to.be.a('string')
-          done()
         })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Code).to.equal(1)
+        expect(res.result.Message).to.be.a('string')
       })
 
-      it('returns value', (done) => {
-        api.inject({
+      it('returns value', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: '/api/v0/object/get?arg=QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n'
-        }, (res) => {
-          expect(res.statusCode).to.equal(200)
-          expect(res.result.Links).to.eql([])
-          expect(res.result.Data).to.be.empty()
-          done()
         })
+
+        expect(res.statusCode).to.equal(200)
+        expect(res.result.Links).to.eql([])
+        expect(res.result.Data).to.be.empty()
       })
 
       // TODO: unskip after switch to v1 CIDs by default
-      it.skip('should get object and return a base64 encoded CID', (done) => {
-        api.inject({
+      it.skip('should get object and return a base64 encoded CID', async () => {
+        let res = await api.inject({
           method: 'POST',
           url: '/api/v0/object/new'
-        }, (res) => {
-          expect(res.statusCode).to.equal(200)
+        })
+
+        expect(res.statusCode).to.equal(200)
 
-          api.inject({
-            method: 'POST',
-            url: '/api/v0/object/get?cid-base=base64&arg=' + res.result.Hash
-          }, (res) => {
-            expect(res.statusCode).to.equal(200)
-            expect(multibase.isEncoded(res.result.Hash)).to.deep.equal('base64')
-            done()
-          })
+        res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/object/get?cid-base=base64&arg=' + res.result.Hash
         })
+
+        expect(res.statusCode).to.equal(200)
+        expect(multibase.isEncoded(res.result.Hash)).to.deep.equal('base64')
       })
 
-      it('should not get an object for invalid cid-base option', (done) => {
-        api.inject({
+      it('should not get an object for invalid cid-base option', async () => {
+        let res = await api.inject({
           method: 'POST',
           url: '/api/v0/object/new'
-        }, (res) => {
-          expect(res.statusCode).to.equal(200)
+        })
+        expect(res.statusCode).to.equal(200)
 
-          api.inject({
-            method: 'POST',
-            url: '/api/v0/object/get?cid-base=invalid&arg=' + res.result.Hash
-          }, (res) => {
-            expect(res.statusCode).to.equal(400)
-            expect(res.result.Message).to.include('child "cid-base" fails')
-            done()
-          })
+        res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/object/get?cid-base=invalid&arg=' + res.result.Hash
         })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Message).to.include('Invalid request query input')
       })
     })
 
     describe('/put', () => {
-      it('returns 400 if no node is provided', (done) => {
+      it('returns 400 if no node is provided', async () => {
         const form = new FormData()
         const headers = form.getHeaders()
 
-        streamToPromise(form).then((payload) => {
-          api.inject({
-            method: 'POST',
-            url: '/api/v0/object/put',
-            headers: headers,
-            payload: payload
-          }, (res) => {
-            expect(res.statusCode).to.equal(400)
-            done()
-          })
+        const payload = await streamToPromise(form)
+        const res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/object/put',
+          headers,
+          payload
         })
+
+        expect(res.statusCode).to.equal(400)
       })
 
-      it('returns 500 if the node is invalid', (done) => {
+      it('returns 400 if the node is invalid', async () => {
         const form = new FormData()
         const filePath = 'test/fixtures/test-data/badnode.json'
         form.append('file', fs.createReadStream(filePath))
         const headers = form.getHeaders()
 
-        streamToPromise(form).then((payload) => {
-          api.inject({
-            method: 'POST',
-            url: '/api/v0/object/put',
-            headers: headers,
-            payload: payload
-          }, (res) => {
-            expect(res.statusCode).to.equal(500)
-            done()
-          })
+        const payload = await streamToPromise(form)
+        const res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/object/put',
+          headers,
+          payload
         })
+
+        expect(res.statusCode).to.equal(400)
       })
 
-      it('updates value', (done) => {
+      it('updates value', async () => {
         const form = new FormData()
         const filePath = 'test/fixtures/test-data/node.json'
         form.append('data', fs.createReadStream(filePath))
@@ -187,199 +173,183 @@ module.exports = (http) => {
           Size: 68
         }
 
-        streamToPromise(form).then((payload) => {
-          api.inject({
-            method: 'POST',
-            url: '/api/v0/object/put',
-            headers: headers,
-            payload: payload
-          }, (res) => {
-            expect(res.statusCode).to.equal(200)
-            expect(res.result).to.eql(expectedResult)
-            done()
-          })
+        const payload = await streamToPromise(form)
+        const res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/object/put',
+          headers,
+          payload
         })
+
+        expect(res.statusCode).to.equal(200)
+        expect(res.result).to.eql(expectedResult)
       })
 
       // TODO: unskip after switch to v1 CIDs by default
-      it.skip('should put data and return a base64 encoded CID', (done) => {
+      it.skip('should put data and return a base64 encoded CID', async () => {
         const form = new FormData()
         form.append('file', JSON.stringify({ Data: 'TEST' + Date.now(), Links: [] }), { filename: 'node.json' })
         const headers = form.getHeaders()
 
-        streamToPromise(form).then((payload) => {
-          api.inject({
-            method: 'POST',
-            url: '/api/v0/object/put?cid-base=base64',
-            headers: headers,
-            payload: payload
-          }, (res) => {
-            expect(res.statusCode).to.equal(200)
-            expect(multibase.isEncoded(res.result.Hash)).to.deep.equal('base64')
-            done()
-          })
+        const payload = await streamToPromise(form)
+        const res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/object/put?cid-base=base64',
+          headers,
+          payload
         })
+
+        expect(res.statusCode).to.equal(200)
+        expect(multibase.isEncoded(res.result.Hash)).to.deep.equal('base64')
       })
 
-      it('should not put data for invalid cid-base option', (done) => {
+      it('should not put data for invalid cid-base option', async () => {
         const form = new FormData()
         form.append('file', JSON.stringify({ Data: 'TEST' + Date.now(), Links: [] }), { filename: 'node.json' })
         const headers = form.getHeaders()
 
-        streamToPromise(form).then((payload) => {
-          api.inject({
-            method: 'POST',
-            url: '/api/v0/object/put?cid-base=invalid',
-            headers: headers,
-            payload: payload
-          }, (res) => {
-            expect(res.statusCode).to.equal(400)
-            expect(res.result.Message).to.include('child "cid-base" fails')
-            done()
-          })
+        const payload = await streamToPromise(form)
+        const res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/object/put?cid-base=invalid',
+          headers,
+          payload
         })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Message).to.include('Invalid request query input')
       })
     })
 
     describe('/stat', () => {
-      it('returns 400 for request without argument', (done) => {
-        api.inject({
+      it('returns 400 for request without argument', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: '/api/v0/object/stat'
-        }, (res) => {
-          expect(res.statusCode).to.equal(400)
-          expect(res.result).to.be.a('string')
-          done()
         })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Message).to.be.a('string')
       })
 
-      it('returns 500 for request with invalid argument', (done) => {
-        api.inject({
+      it('returns 400 for request with invalid argument', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: '/api/v0/object/stat?arg=invalid'
-        }, (res) => {
-          expect(res.statusCode).to.equal(500)
-          expect(res.result.Code).to.equal(0)
-          expect(res.result.Message).to.be.a('string')
-          done()
         })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Code).to.equal(1)
+        expect(res.result.Message).to.be.a('string')
       })
 
-      it('returns value', (done) => {
-        api.inject({
+      it('returns value', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: '/api/v0/object/stat?arg=QmZZmY4KCu9r3e7M2Pcn46Fc5qbn6NpzaAGaYb22kbfTqm'
-        }, (res) => {
-          expect(res.statusCode).to.equal(200)
-          expect(res.result.Hash).to.equal('QmZZmY4KCu9r3e7M2Pcn46Fc5qbn6NpzaAGaYb22kbfTqm')
-          expect(res.result.NumLinks).to.equal(1)
-          expect(res.result.BlockSize).to.equal(60)
-          expect(res.result.LinksSize).to.equal(60 - 7)
-          expect(res.result.DataSize).to.equal(7)
-          expect(res.result.CumulativeSize).to.equal(60 + 8)
-          done()
         })
+
+        expect(res.statusCode).to.equal(200)
+        expect(res.result.Hash).to.equal('QmZZmY4KCu9r3e7M2Pcn46Fc5qbn6NpzaAGaYb22kbfTqm')
+        expect(res.result.NumLinks).to.equal(1)
+        expect(res.result.BlockSize).to.equal(60)
+        expect(res.result.LinksSize).to.equal(60 - 7)
+        expect(res.result.DataSize).to.equal(7)
+        expect(res.result.CumulativeSize).to.equal(60 + 8)
       })
 
       // TODO: unskip after switch to v1 CIDs by default
-      it.skip('should stat object and return a base64 encoded CID', (done) => {
-        api.inject({
+      it.skip('should stat object and return a base64 encoded CID', async () => {
+        let res = await api.inject({
           method: 'POST',
           url: '/api/v0/object/new'
-        }, (res) => {
-          expect(res.statusCode).to.equal(200)
+        })
+
+        expect(res.statusCode).to.equal(200)
 
-          api.inject({
-            method: 'POST',
-            url: '/api/v0/object/stat?cid-base=base64&arg=' + res.result.Hash
-          }, (res) => {
-            expect(res.statusCode).to.equal(200)
-            expect(multibase.isEncoded(res.result.Hash)).to.deep.equal('base64')
-            done()
-          })
+        res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/object/stat?cid-base=base64&arg=' + res.result.Hash
         })
+
+        expect(res.statusCode).to.equal(200)
+        expect(multibase.isEncoded(res.result.Hash)).to.deep.equal('base64')
       })
 
-      it('should not stat object for invalid cid-base option', (done) => {
-        api.inject({
+      it('should not stat object for invalid cid-base option', async () => {
+        let res = await api.inject({
           method: 'POST',
           url: '/api/v0/object/new'
-        }, (res) => {
-          expect(res.statusCode).to.equal(200)
+        })
 
-          api.inject({
-            method: 'POST',
-            url: '/api/v0/object/stat?cid-base=invalid&arg=' + res.result.Hash
-          }, (res) => {
-            expect(res.statusCode).to.equal(400)
-            expect(res.result.Message).to.include('child "cid-base" fails')
-            done()
-          })
+        expect(res.statusCode).to.equal(200)
+
+        res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/object/stat?cid-base=invalid&arg=' + res.result.Hash
         })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Message).to.include('Invalid request query input')
       })
     })
 
     describe('/data', () => {
-      it('returns 400 for request without argument', (done) => {
-        api.inject({
+      it('returns 400 for request without argument', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: '/api/v0/object/data'
-        }, (res) => {
-          expect(res.statusCode).to.equal(400)
-          expect(res.result).to.be.a('string')
-          done()
         })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Message).to.be.a('string')
       })
 
-      it('returns 500 for request with invalid argument', (done) => {
-        api.inject({
+      it('returns 400 for request with invalid argument', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: '/api/v0/object/data?arg=invalid'
-        }, (res) => {
-          expect(res.statusCode).to.equal(500)
-          expect(res.result.Code).to.equal(0)
-          expect(res.result.Message).to.be.a('string')
-          done()
         })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Code).to.equal(1)
+        expect(res.result.Message).to.be.a('string')
       })
 
-      it('returns value', (done) => {
-        api.inject({
+      it('returns value', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: '/api/v0/object/data?arg=QmZZmY4KCu9r3e7M2Pcn46Fc5qbn6NpzaAGaYb22kbfTqm'
-        }, (res) => {
-          expect(res.statusCode).to.equal(200)
-          expect(res.result).to.equal('another')
-          done()
         })
+
+        expect(res.statusCode).to.equal(200)
+        expect(res.result).to.equal('another')
       })
     })
 
     describe('/links', () => {
-      it('returns 400 for request without argument', (done) => {
-        api.inject({
+      it('returns 400 for request without argument', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: '/api/v0/object/links'
-        }, (res) => {
-          expect(res.statusCode).to.equal(400)
-          expect(res.result).to.be.a('string')
-          done()
         })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Message).to.be.a('string')
       })
 
-      it('returns 500 for request with invalid argument', (done) => {
-        api.inject({
+      it('returns 400 for request with invalid argument', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: '/api/v0/object/links?arg=invalid'
-        }, (res) => {
-          expect(res.statusCode).to.equal(500)
-          expect(res.result.Code).to.equal(0)
-          expect(res.result.Message).to.be.a('string')
-          done()
         })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Code).to.equal(1)
+        expect(res.result.Message).to.be.a('string')
       })
 
-      it('returns value', (done) => {
+      it('returns value', async () => {
         const expectedResult = {
           Hash: 'QmZZmY4KCu9r3e7M2Pcn46Fc5qbn6NpzaAGaYb22kbfTqm',
           Links: [
@@ -387,159 +357,135 @@ module.exports = (http) => {
           ]
         }
 
-        api.inject({
+        const res = await api.inject({
           method: 'POST',
           url: '/api/v0/object/links?arg=QmZZmY4KCu9r3e7M2Pcn46Fc5qbn6NpzaAGaYb22kbfTqm'
-        }, (res) => {
-          expect(res.statusCode).to.equal(200)
-          expect(res.result).to.deep.equal(expectedResult)
-          done()
         })
+
+        expect(res.statusCode).to.equal(200)
+        expect(res.result).to.deep.equal(expectedResult)
       })
 
       // TODO: unskip after switch to v1 CIDs by default
-      it.skip('should list object links and return a base64 encoded CID', (done) => {
-        waterfall([
-          (cb) => {
-            api.inject({
-              method: 'POST',
-              url: '/api/v0/object/new'
-            }, (res) => {
-              expect(res.statusCode).to.equal(200)
-              cb(null, res.result.Hash)
-            })
-          },
-          (linkHash, cb) => {
-            const form = new FormData()
-            form.append('file', JSON.stringify({
-              Data: 'TEST' + Date.now(),
-              Links: [{ Name: 'emptyNode', Hash: linkHash, Size: 8 }]
-            }), { filename: 'node.json' })
-            const headers = form.getHeaders()
-
-            streamToPromise(form).then((payload) => {
-              api.inject({
-                method: 'POST',
-                url: '/api/v0/object/put',
-                headers: headers,
-                payload: payload
-              }, (res) => {
-                expect(res.statusCode).to.equal(200)
-                cb(null, res.result.Hash)
-              })
-            })
-          }
-        ], (err, hash) => {
-          expect(err).to.not.exist()
-
-          api.inject({
-            method: 'POST',
-            url: '/api/v0/object/links?cid-base=base64&arg=' + hash
-          }, (res) => {
-            expect(res.statusCode).to.equal(200)
-            expect(multibase.isEncoded(res.result.Hash)).to.deep.equal('base64')
-            expect(res.result.Links).to.have.length(1)
-            expect(multibase.isEncoded(res.result.Links[0].Hash)).to.deep.equal('base64')
-            done()
-          })
-        })
-      })
-
-      it('should not list object links for invalid cid-base option', (done) => {
-        waterfall([
-          (cb) => {
-            api.inject({
-              method: 'POST',
-              url: '/api/v0/object/new'
-            }, (res) => {
-              expect(res.statusCode).to.equal(200)
-              cb(null, res.result.Hash)
-            })
-          },
-          (linkHash, cb) => {
-            const form = new FormData()
-            form.append('file', JSON.stringify({
-              Data: 'TEST' + Date.now(),
-              Links: [{ Name: 'emptyNode', Hash: linkHash, Size: 8 }]
-            }), { filename: 'node.json' })
-            const headers = form.getHeaders()
-
-            streamToPromise(form).then((payload) => {
-              api.inject({
-                method: 'POST',
-                url: '/api/v0/object/put',
-                headers: headers,
-                payload: payload
-              }, (res) => {
-                expect(res.statusCode).to.equal(200)
-                cb(null, res.result.Hash)
-              })
-            })
-          }
-        ], (err, hash) => {
-          expect(err).to.not.exist()
-
-          api.inject({
-            method: 'POST',
-            url: '/api/v0/object/links?cid-base=invalid&arg=' + hash
-          }, (res) => {
-            expect(res.statusCode).to.equal(400)
-            expect(res.result.Message).to.include('child "cid-base" fails')
-            done()
-          })
+      it.skip('should list object links and return a base64 encoded CID', async () => {
+        let res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/object/new'
+        })
+
+        expect(res.statusCode).to.equal(200)
+        const linkHash = res.result.Hash
+
+        const form = new FormData()
+        form.append('file', JSON.stringify({
+          Data: 'TEST' + Date.now(),
+          Links: [{ Name: 'emptyNode', Hash: linkHash, Size: 8 }]
+        }), { filename: 'node.json' })
+        const headers = form.getHeaders()
+
+        const payload = await streamToPromise(form)
+        res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/object/put',
+          headers,
+          payload
+        })
+
+        expect(res.statusCode).to.equal(200)
+        const hash = res.result.Hash
+
+        res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/object/links?cid-base=base64&arg=' + hash
+        })
+
+        expect(res.statusCode).to.equal(200)
+        expect(multibase.isEncoded(res.result.Hash)).to.deep.equal('base64')
+        expect(res.result.Links).to.have.length(1)
+        expect(multibase.isEncoded(res.result.Links[0].Hash)).to.deep.equal('base64')
+      })
+
+      it('should not list object links for invalid cid-base option', async () => {
+        let res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/object/new'
+        })
+
+        expect(res.statusCode).to.equal(200)
+        const linkHash = res.result.Hash
+
+        const form = new FormData()
+        form.append('file', JSON.stringify({
+          Data: 'TEST' + Date.now(),
+          Links: [{ Name: 'emptyNode', Hash: linkHash, Size: 8 }]
+        }), { filename: 'node.json' })
+        const headers = form.getHeaders()
+
+        const payload = await streamToPromise(form)
+        res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/object/put',
+          headers,
+          payload
         })
+
+        expect(res.statusCode).to.equal(200)
+        const hash = res.result.Hash
+
+        res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/object/links?cid-base=invalid&arg=' + hash
+        })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Message).to.include('Invalid request query input')
       })
     })
 
     describe('/patch/append-data', () => {
-      it('returns 400 for request without key', (done) => {
-        api.inject({
+      it('returns 400 for request without key', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: '/api/v0/object/patch/append-data'
-        }, (res) => {
-          expect(res.statusCode).to.equal(400)
-          expect(res.result).to.be.a('string')
-          done()
         })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Message).to.be.a('string')
       })
 
-      it('returns 400 if no data is provided', (done) => {
+      it('returns 400 if no data is provided', async () => {
         const form = new FormData()
         const headers = form.getHeaders()
 
-        streamToPromise(form).then((payload) => {
-          api.inject({
-            method: 'POST',
-            url: '/api/v0/object/patch/append-data?arg=QmVLUHkjGg3duGb5w3dnwK5w2P9QWuJmtVNuDPLc9ZDjzk',
-            headers: headers,
-            payload: payload
-          }, (res) => {
-            expect(res.statusCode).to.equal(400)
-            done()
-          })
+        const payload = await streamToPromise(form)
+        const res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/object/patch/append-data?arg=QmVLUHkjGg3duGb5w3dnwK5w2P9QWuJmtVNuDPLc9ZDjzk',
+          headers,
+          payload
         })
+
+        expect(res.statusCode).to.equal(400)
       })
 
-      it('returns 500 for request with invalid key', (done) => {
+      it('returns 400 for request with invalid key', async () => {
         const form = new FormData()
         const filePath = 'test/fixtures/test-data/badconfig'
         form.append('file', fs.createReadStream(filePath))
         const headers = form.getHeaders()
 
-        streamToPromise(form).then((payload) => {
-          api.inject({
-            method: 'POST',
-            url: '/api/v0/object/patch/append-data?arg=invalid',
-            headers: headers,
-            payload: payload
-          }, (res) => {
-            expect(res.statusCode).to.equal(500)
-            done()
-          })
+        const payload = await streamToPromise(form)
+        const res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/object/patch/append-data?arg=invalid',
+          headers,
+          payload
         })
+
+        expect(res.statusCode).to.equal(400)
       })
 
-      it('updates value', (done) => {
+      it('updates value', async () => {
         const form = new FormData()
         const filePath = 'test/fixtures/test-data/badconfig'
         form.append('data', fs.createReadStream(filePath))
@@ -551,123 +497,112 @@ module.exports = (http) => {
           Size: 19
         }
 
-        streamToPromise(form).then((payload) => {
-          api.inject({
-            method: 'POST',
-            url: '/api/v0/object/patch/append-data?arg=QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n',
-            headers: headers,
-            payload: payload
-          }, (res) => {
-            expect(res.statusCode).to.equal(200)
-            expect(res.result).to.deep.equal(expectedResult)
-            done()
-          })
+        const payload = await streamToPromise(form)
+        const res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/object/patch/append-data?arg=QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n',
+          headers,
+          payload
         })
+
+        expect(res.statusCode).to.equal(200)
+        expect(res.result).to.deep.equal(expectedResult)
       })
 
       // TODO: unskip after switch to v1 CIDs by default
-      it.skip('should append data to object and return a base64 encoded CID', (done) => {
-        api.inject({
+      it.skip('should append data to object and return a base64 encoded CID', async () => {
+        let res = await api.inject({
           method: 'POST',
           url: '/api/v0/object/new'
-        }, (res) => {
-          expect(res.statusCode).to.equal(200)
+        })
 
-          const form = new FormData()
-          form.append('data', Buffer.from('TEST' + Date.now()))
-          const headers = form.getHeaders()
+        expect(res.statusCode).to.equal(200)
+
+        const form = new FormData()
+        form.append('data', Buffer.from('TEST' + Date.now()))
+        const headers = form.getHeaders()
 
-          streamToPromise(form).then((payload) => {
-            api.inject({
-              method: 'POST',
-              url: '/api/v0/object/patch/append-data?cid-base=base64&arg=' + res.result.Hash,
-              headers: headers,
-              payload: payload
-            }, (res) => {
-              expect(res.statusCode).to.equal(200)
-              expect(multibase.isEncoded(res.result.Hash)).to.deep.equal('base64')
-              done()
-            })
-          })
+        const payload = await streamToPromise(form)
+        res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/object/patch/append-data?cid-base=base64&arg=' + res.result.Hash,
+          headers,
+          payload
         })
+
+        expect(res.statusCode).to.equal(200)
+        expect(multibase.isEncoded(res.result.Hash)).to.deep.equal('base64')
       })
 
-      it('should not append data to object for invalid cid-base option', (done) => {
-        api.inject({
+      it('should not append data to object for invalid cid-base option', async () => {
+        let res = await api.inject({
           method: 'POST',
           url: '/api/v0/object/new'
-        }, (res) => {
-          expect(res.statusCode).to.equal(200)
-
-          const form = new FormData()
-          form.append('data', Buffer.from('TEST' + Date.now()))
-          const headers = form.getHeaders()
-
-          streamToPromise(form).then((payload) => {
-            api.inject({
-              method: 'POST',
-              url: '/api/v0/object/patch/append-data?cid-base=invalid&arg=' + res.result.Hash,
-              headers: headers,
-              payload: payload
-            }, (res) => {
-              expect(res.statusCode).to.equal(400)
-              expect(res.result.Message).to.include('child "cid-base" fails')
-              done()
-            })
-          })
         })
+
+        expect(res.statusCode).to.equal(200)
+
+        const form = new FormData()
+        form.append('data', Buffer.from('TEST' + Date.now()))
+        const headers = form.getHeaders()
+
+        const payload = await streamToPromise(form)
+        res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/object/patch/append-data?cid-base=invalid&arg=' + res.result.Hash,
+          headers,
+          payload
+        })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Message).to.include('Invalid request query input')
       })
     })
 
     describe('/patch/set-data', () => {
-      it('returns 400 for request without key', (done) => {
-        api.inject({
+      it('returns 400 for request without key', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: '/api/v0/object/patch/set-data'
-        }, (res) => {
-          expect(res.statusCode).to.equal(400)
-          expect(res.result).to.be.a('string')
-          done()
         })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Message).to.be.a('string')
       })
 
-      it('returns 400 if no data is provided', (done) => {
+      it('returns 400 if no data is provided', async () => {
         const form = new FormData()
         const headers = form.getHeaders()
 
-        streamToPromise(form).then((payload) => {
-          api.inject({
-            method: 'POST',
-            url: '/api/v0/object/patch/set-data?arg=QmVLUHkjGg3duGb5w3dnwK5w2P9QWuJmtVNuDPLc9ZDjzk',
-            headers: headers,
-            payload: payload
-          }, (res) => {
-            expect(res.statusCode).to.equal(400)
-            done()
-          })
+        const payload = await streamToPromise(form)
+        const res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/object/patch/set-data?arg=QmVLUHkjGg3duGb5w3dnwK5w2P9QWuJmtVNuDPLc9ZDjzk',
+          headers,
+          payload
         })
+
+        expect(res.statusCode).to.equal(400)
       })
 
-      it('returns 500 for request with invalid key', (done) => {
+      it('returns 400 for request with invalid key', async () => {
         const form = new FormData()
         const filePath = 'test/fixtures/test-data/badconfig'
         form.append('file', fs.createReadStream(filePath))
         const headers = form.getHeaders()
 
-        streamToPromise(form).then((payload) => {
-          api.inject({
-            method: 'POST',
-            url: '/api/v0/object/patch/set-data?arg=invalid',
-            headers: headers,
-            payload: payload
-          }, (res) => {
-            expect(res.statusCode).to.equal(500)
-            done()
-          })
+        const payload = await streamToPromise(form)
+        const res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/object/patch/set-data?arg=invalid',
+          headers,
+          payload
         })
+
+        expect(res.statusCode).to.equal(400)
       })
 
-      it('updates value', (done) => {
+      it('updates value', async () => {
         const form = new FormData()
         const filePath = 'test/fixtures/test-data/badconfig'
         form.append('data', fs.createReadStream(filePath))
@@ -677,326 +612,289 @@ module.exports = (http) => {
           Links: []
         }
 
-        streamToPromise(form).then((payload) => {
-          api.inject({
-            method: 'POST',
-            url: '/api/v0/object/patch/set-data?arg=QmfY37rjbPCZRnhvvJuQ46htW3VCAWziVB991P79h6WSv6',
-            headers: headers,
-            payload: payload
-          }, (res) => {
-            expect(res.statusCode).to.equal(200)
-            expect(res.result).to.deep.equal(expectedResult)
-            done()
-          })
+        const payload = await streamToPromise(form)
+        const res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/object/patch/set-data?arg=QmfY37rjbPCZRnhvvJuQ46htW3VCAWziVB991P79h6WSv6',
+          headers,
+          payload
         })
+
+        expect(res.statusCode).to.equal(200)
+        expect(res.result).to.deep.equal(expectedResult)
       })
 
       // TODO: unskip after switch to v1 CIDs by default
-      it.skip('should set data for object and return a base64 encoded CID', (done) => {
-        api.inject({
+      it.skip('should set data for object and return a base64 encoded CID', async () => {
+        let res = await api.inject({
           method: 'POST',
           url: '/api/v0/object/new'
-        }, (res) => {
-          expect(res.statusCode).to.equal(200)
+        })
+        expect(res.statusCode).to.equal(200)
 
-          const form = new FormData()
-          form.append('data', Buffer.from('TEST' + Date.now()))
-          const headers = form.getHeaders()
+        const form = new FormData()
+        form.append('data', Buffer.from('TEST' + Date.now()))
+        const headers = form.getHeaders()
 
-          streamToPromise(form).then((payload) => {
-            api.inject({
-              method: 'POST',
-              url: '/api/v0/object/patch/set-data?cid-base=base64&arg=' + res.result.Hash,
-              headers: headers,
-              payload: payload
-            }, (res) => {
-              expect(res.statusCode).to.equal(200)
-              expect(multibase.isEncoded(res.result.Hash)).to.deep.equal('base64')
-              done()
-            })
-          })
+        const payload = await streamToPromise(form)
+        res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/object/patch/set-data?cid-base=base64&arg=' + res.result.Hash,
+          headers,
+          payload
         })
+
+        expect(res.statusCode).to.equal(200)
+        expect(multibase.isEncoded(res.result.Hash)).to.deep.equal('base64')
       })
 
-      it('should not set data for object for invalid cid-base option', (done) => {
-        api.inject({
+      it('should not set data for object for invalid cid-base option', async () => {
+        let res = await api.inject({
           method: 'POST',
           url: '/api/v0/object/new'
-        }, (res) => {
-          expect(res.statusCode).to.equal(200)
-
-          const form = new FormData()
-          form.append('data', Buffer.from('TEST' + Date.now()))
-          const headers = form.getHeaders()
-
-          streamToPromise(form).then((payload) => {
-            api.inject({
-              method: 'POST',
-              url: '/api/v0/object/patch/set-data?cid-base=invalid&arg=' + res.result.Hash,
-              headers: headers,
-              payload: payload
-            }, (res) => {
-              expect(res.statusCode).to.equal(400)
-              expect(res.result.Message).to.include('child "cid-base" fails')
-              done()
-            })
-          })
         })
+
+        expect(res.statusCode).to.equal(200)
+
+        const form = new FormData()
+        form.append('data', Buffer.from('TEST' + Date.now()))
+        const headers = form.getHeaders()
+
+        const payload = await streamToPromise(form)
+        res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/object/patch/set-data?cid-base=invalid&arg=' + res.result.Hash,
+          headers,
+          payload
+        })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Message).to.include('Invalid request query input')
       })
     })
 
     describe('/patch/add-link', () => {
-      it('returns 400 for request without arguments', (done) => {
-        api.inject({
+      it('returns 400 for request without arguments', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: '/api/v0/object/patch/add-link'
-        }, (res) => {
-          expect(res.statusCode).to.equal(400)
-          expect(res.result).to.be.a('string')
-          done()
         })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Message).to.be.a('string')
       })
 
-      it('returns 400 for request with only one invalid argument', (done) => {
-        api.inject({
+      it('returns 400 for request with only one invalid argument', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: '/api/v0/object/patch/add-link?arg=invalid'
-        }, (res) => {
-          expect(res.statusCode).to.equal(400)
-          expect(res.result).to.be.a('string')
-          done()
         })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Message).to.be.a('string')
       })
 
-      it('returns 500 for request with invalid first argument', (done) => {
-        api.inject({
+      it('returns 400 for request with invalid first argument', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: '/api/v0/object/patch/add-link?arg=&arg=foo&arg=QmTz3oc4gdpRMKP2sdGUPZTAGRngqjsi99BPoztyP53JMM'
-        }, (res) => {
-          expect(res.statusCode).to.equal(500)
-          expect(res.result.Code).to.equal(0)
-          expect(res.result.Message).to.be.a('string')
-          done()
         })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Code).to.equal(1)
+        expect(res.result.Message).to.be.a('string')
       })
 
-      it('returns 500 for request with empty second argument', (done) => {
-        api.inject({
+      it('returns 400 for request with empty second argument', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: '/api/v0/object/patch/add-link?arg=QmUNLLsPACCz1vLxQVkXqqLX5R1X345qqfHbsf67hvA3Nn&arg=&arg=QmTz3oc4gdpRMKP2sdGUPZTAGRngqjsi99BPoztyP53JMM'
-        }, (res) => {
-          expect(res.statusCode).to.equal(500)
-          expect(res.result.Code).to.equal(0)
-          expect(res.result.Message).to.be.a('string')
-          done()
         })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Code).to.equal(1)
+        expect(res.result.Message).to.be.a('string')
       })
 
-      it('returns value', (done) => {
-        api.inject({
+      it('returns value', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: '/api/v0/object/patch/add-link?arg=QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n&arg=foo&arg=QmUNLLsPACCz1vLxQVkXqqLX5R1X345qqfHbsf67hvA3Nn'
-        }, (res) => {
-          expect(res.statusCode).to.equal(200)
-          expect(res.result.Hash).to.equal('QmdVHE8fUD6FLNLugtNxqDFyhaCgdob372hs6BYEe75VAK')
-          expect(res.result.Links[0]).to.deep.equal({
-            Name: 'foo',
-            Hash: 'QmUNLLsPACCz1vLxQVkXqqLX5R1X345qqfHbsf67hvA3Nn',
-            Size: 4
-          })
-          done()
+        })
+
+        expect(res.statusCode).to.equal(200)
+        expect(res.result.Hash).to.equal('QmdVHE8fUD6FLNLugtNxqDFyhaCgdob372hs6BYEe75VAK')
+        expect(res.result.Links[0]).to.deep.equal({
+          Name: 'foo',
+          Hash: 'QmUNLLsPACCz1vLxQVkXqqLX5R1X345qqfHbsf67hvA3Nn',
+          Size: 4
         })
       })
 
       // TODO: unskip after switch to v1 CIDs by default
-      it.skip('should add a link to an object and return a base64 encoded CID', (done) => {
-        api.inject({
+      it.skip('should add a link to an object and return a base64 encoded CID', async () => {
+        let res = await api.inject({
           method: 'POST',
           url: '/api/v0/object/new'
-        }, (res) => {
-          expect(res.statusCode).to.equal(200)
+        })
+
+        expect(res.statusCode).to.equal(200)
 
-          api.inject({
-            method: 'POST',
-            url: `/api/v0/object/patch/add-link?cid-base=base64&arg=${res.result.Hash}&arg=test&arg=${res.result.Hash}`
-          }, (res) => {
-            expect(res.statusCode).to.equal(200)
-            expect(multibase.isEncoded(res.result.Hash)).to.deep.equal('base64')
-            done()
-          })
+        res = await api.inject({
+          method: 'POST',
+          url: `/api/v0/object/patch/add-link?cid-base=base64&arg=${res.result.Hash}&arg=test&arg=${res.result.Hash}`
         })
+
+        expect(res.statusCode).to.equal(200)
+        expect(multibase.isEncoded(res.result.Hash)).to.deep.equal('base64')
       })
 
-      it('should not add a link to an object for invalid cid-base option', (done) => {
-        api.inject({
+      it('should not add a link to an object for invalid cid-base option', async () => {
+        let res = await api.inject({
           method: 'POST',
           url: '/api/v0/object/new'
-        }, (res) => {
-          expect(res.statusCode).to.equal(200)
+        })
+
+        expect(res.statusCode).to.equal(200)
 
-          api.inject({
-            method: 'POST',
-            url: `/api/v0/object/patch/add-link?cid-base=invalid&arg=${res.result.Hash}&arg=test&arg=${res.result.Hash}`
-          }, (res) => {
-            expect(res.statusCode).to.equal(400)
-            expect(res.result.Message).to.include('child "cid-base" fails')
-            done()
-          })
+        res = await api.inject({
+          method: 'POST',
+          url: `/api/v0/object/patch/add-link?cid-base=invalid&arg=${res.result.Hash}&arg=test&arg=${res.result.Hash}`
         })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Message).to.include('Invalid request query input')
       })
     })
 
     describe('/patch/rm-link', () => {
-      it('returns 400 for request without arguments', (done) => {
-        api.inject({
+      it('returns 400 for request without arguments', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: '/api/v0/object/patch/rm-link'
-        }, (res) => {
-          expect(res.statusCode).to.equal(400)
-          expect(res.result).to.be.a('string')
-          done()
         })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Message).to.be.a('string')
       })
 
-      it('returns 400 for request with only one invalid argument', (done) => {
-        api.inject({
+      it('returns 400 for request with only one invalid argument', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: '/api/v0/object/patch/rm-link?arg=invalid'
-        }, (res) => {
-          expect(res.statusCode).to.equal(400)
-          expect(res.result).to.be.a('string')
-          done()
         })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Message).to.be.a('string')
       })
 
-      it('returns 500 for request with invalid first argument', (done) => {
-        api.inject({
+      it('returns 400 for request with invalid first argument', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: '/api/v0/object/patch/rm-link?arg=invalid&arg=foo'
-        }, (res) => {
-          expect(res.statusCode).to.equal(500)
-          expect(res.result.Code).to.equal(0)
-          expect(res.result.Message).to.be.a('string')
-          done()
         })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Code).to.equal(1)
+        expect(res.result.Message).to.be.a('string')
       })
 
-      it('returns 500 for request with invalid second argument', (done) => {
-        api.inject({
+      it('returns 400 for request with invalid second argument', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: '/api/v0/object/patch/rm-link?arg=QmZKetgwm4o3LhNaoLSHv32wBhTwj9FBwAdSchDMKyFQEx&arg='
-        }, (res) => {
-          expect(res.statusCode).to.equal(500)
-          expect(res.result.Code).to.equal(0)
-          expect(res.result.Message).to.be.a('string')
-          done()
         })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Code).to.equal(1)
+        expect(res.result.Message).to.be.a('string')
       })
 
-      it('returns value', (done) => {
-        api.inject({
+      it('returns value', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: '/api/v0/object/patch/rm-link?arg=QmdVHE8fUD6FLNLugtNxqDFyhaCgdob372hs6BYEe75VAK&arg=foo'
-        }, (res) => {
-          expect(res.statusCode).to.equal(200)
-          expect(res.result.Hash).to.equal('QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n')
-          done()
         })
+
+        expect(res.statusCode).to.equal(200)
+        expect(res.result.Hash).to.equal('QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n')
       })
 
       // TODO: unskip after switch to v1 CIDs by default
-      it.skip('should remove a link from an object and return a base64 encoded CID', (done) => {
+      it.skip('should remove a link from an object and return a base64 encoded CID', async () => {
         const linkName = 'TEST' + Date.now()
 
-        waterfall([
-          (cb) => {
-            api.inject({
-              method: 'POST',
-              url: '/api/v0/object/new'
-            }, (res) => {
-              expect(res.statusCode).to.equal(200)
-              cb(null, res.result.Hash)
-            })
-          },
-          (linkHash, cb) => {
-            const form = new FormData()
-            form.append('file', JSON.stringify({
-              Data: 'TEST' + Date.now(),
-              Links: [{ Name: linkName, Hash: linkHash, Size: 8 }]
-            }), { filename: 'node.json' })
-            const headers = form.getHeaders()
-
-            streamToPromise(form).then((payload) => {
-              api.inject({
-                method: 'POST',
-                url: '/api/v0/object/put',
-                headers: headers,
-                payload: payload
-              }, (res) => {
-                expect(res.statusCode).to.equal(200)
-                cb(null, res.result.Hash, linkHash)
-              })
-            })
-          }
-        ], (err, hash) => {
-          expect(err).to.not.exist()
-
-          api.inject({
-            method: 'POST',
-            url: `/api/v0/object/patch/rm-link?cid-base=base64&arg=${hash}&arg=${linkName}`
-          }, (res) => {
-            expect(res.statusCode).to.equal(200)
-            expect(multibase.isEncoded(res.result.Hash)).to.deep.equal('base64')
-            done()
-          })
-        })
-      })
-
-      it('should not remove a link from an object for invalid cid-base option', (done) => {
+        let res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/object/new'
+        })
+
+        expect(res.statusCode).to.equal(200)
+        const linkHash = res.result.Hash
+
+        const form = new FormData()
+        form.append('file', JSON.stringify({
+          Data: 'TEST' + Date.now(),
+          Links: [{ Name: linkName, Hash: linkHash, Size: 8 }]
+        }), { filename: 'node.json' })
+        const headers = form.getHeaders()
+
+        const payload = await streamToPromise(form)
+        res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/object/put',
+          headers,
+          payload
+        })
+
+        expect(res.statusCode).to.equal(200)
+        const hash = res.result.Hash
+
+        res = await api.inject({
+          method: 'POST',
+          url: `/api/v0/object/patch/rm-link?cid-base=base64&arg=${hash}&arg=${linkName}`
+        })
+
+        expect(res.statusCode).to.equal(200)
+        expect(multibase.isEncoded(res.result.Hash)).to.deep.equal('base64')
+      })
+
+      it('should not remove a link from an object for invalid cid-base option', async () => {
         const linkName = 'TEST' + Date.now()
 
-        waterfall([
-          (cb) => {
-            api.inject({
-              method: 'POST',
-              url: '/api/v0/object/new'
-            }, (res) => {
-              expect(res.statusCode).to.equal(200)
-              cb(null, res.result.Hash)
-            })
-          },
-          (linkHash, cb) => {
-            const form = new FormData()
-            form.append('file', JSON.stringify({
-              Data: 'TEST' + Date.now(),
-              Links: [{ Name: linkName, Hash: linkHash, Size: 8 }]
-            }), { filename: 'node.json' })
-            const headers = form.getHeaders()
-
-            streamToPromise(form).then((payload) => {
-              api.inject({
-                method: 'POST',
-                url: '/api/v0/object/put',
-                headers: headers,
-                payload: payload
-              }, (res) => {
-                expect(res.statusCode).to.equal(200)
-                cb(null, res.result.Hash)
-              })
-            })
-          }
-        ], (err, hash) => {
-          expect(err).to.not.exist()
-
-          api.inject({
-            method: 'POST',
-            url: `/api/v0/object/patch/rm-link?cid-base=invalid&arg=${hash}&arg=${linkName}`
-          }, (res) => {
-            expect(res.statusCode).to.equal(400)
-            expect(res.result.Message).to.include('child "cid-base" fails')
-            done()
-          })
+        let res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/object/new'
+        })
+
+        expect(res.statusCode).to.equal(200)
+        const linkHash = res.result.Hash
+
+        const form = new FormData()
+        form.append('file', JSON.stringify({
+          Data: 'TEST' + Date.now(),
+          Links: [{ Name: linkName, Hash: linkHash, Size: 8 }]
+        }), { filename: 'node.json' })
+        const headers = form.getHeaders()
+
+        const payload = await streamToPromise(form)
+        res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/object/put',
+          headers,
+          payload
         })
+
+        expect(res.statusCode).to.equal(200)
+        const hash = res.result.Hash
+
+        res = await api.inject({
+          method: 'POST',
+          url: `/api/v0/object/patch/rm-link?cid-base=invalid&arg=${hash}&arg=${linkName}`
+        })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Message).to.include('Invalid request query input')
       })
     })
   })

From 70f05987f70a3a8d8c7d916ee118fcb9e160cd60 Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Sat, 26 Jan 2019 22:37:36 +0000
Subject: [PATCH 14/49] feat: log all errors if DEBUG env var is set

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/error-handler.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/http/error-handler.js b/src/http/error-handler.js
index 3c8bca9d6b..58a3608fbe 100644
--- a/src/http/error-handler.js
+++ b/src/http/error-handler.js
@@ -23,7 +23,7 @@ module.exports = (server, log) => {
       }
     }
 
-    if (statusCode >= 500) {
+    if (process.env.DEBUG || statusCode >= 500) {
       const { req } = request.raw
       const debug = {
         method: req.method,

From ebc415a3b583ab1990ae3fc9a0e94120fdbf27c8 Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Sat, 26 Jan 2019 22:38:09 +0000
Subject: [PATCH 15/49] refactor: /api/v0/pin* for hapi 18

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/api/resources/pin.js | 126 ++++++------
 src/http/api/routes/index.js  |   4 +-
 src/http/api/routes/pin.js    |  36 ++--
 test/http-api/inject/pin.js   | 367 ++++++++++++++++------------------
 4 files changed, 250 insertions(+), 283 deletions(-)

diff --git a/src/http/api/resources/pin.js b/src/http/api/resources/pin.js
index 4aea71de58..88081cde0b 100644
--- a/src/http/api/resources/pin.js
+++ b/src/http/api/resources/pin.js
@@ -4,6 +4,8 @@ const mapValues = require('lodash/mapValues')
 const keyBy = require('lodash/keyBy')
 const multibase = require('multibase')
 const Joi = require('joi')
+const Boom = require('boom')
+const isIpfs = require('is-ipfs')
 const { cidToString } = require('../../../utils/cid')
 const debug = require('debug')
 const log = debug('jsipfs:http-api:pin')
@@ -11,20 +13,19 @@ log.error = debug('jsipfs:http-api:pin:error')
 
 exports = module.exports
 
-function parseArgs (request, reply) {
-  if (!request.query.arg) {
-    return reply({
-      Message: "Argument 'arg' is required",
-      Code: 0
-    }).code(400).takeover()
+function parseArgs (request, h) {
+  const { arg } = request.query
+
+  if (!arg) {
+    throw Boom.badRequest("Argument 'arg' is required")
   }
 
-  const recursive = request.query.recursive !== 'false'
+  if (!isIpfs.ipfsPath(arg) && !isIpfs.cid(arg)) {
+    throw Boom.badRequest('invalid ipfs ref path')
+  }
 
-  return reply({
-    path: request.query.arg,
-    recursive: recursive
-  })
+  const recursive = request.query.recursive !== 'false'
+  return { path: request.query.arg, recursive }
 }
 
 exports.ls = {
@@ -34,34 +35,33 @@ exports.ls = {
     }).unknown()
   },
 
-  parseArgs: (request, reply) => {
-    const type = request.query.type || 'all'
+  parseArgs (request, h) {
+    const { arg } = request.query
 
-    return reply({
-      path: request.query.arg,
-      type: type
-    })
+    if (arg && !isIpfs.ipfsPath(arg) && !isIpfs.cid(arg)) {
+      throw Boom.badRequest('invalid ipfs ref path')
+    }
+    const type = request.query.type || 'all'
+    return { path: request.query.arg, type }
   },
 
-  handler: (request, reply) => {
+  async handler (request, h) {
+    const { ipfs } = request.server.app
     const { path, type } = request.pre.args
-    const ipfs = request.server.app.ipfs
-
-    ipfs.pin.ls(path, { type }, (err, result) => {
-      if (err) {
-        log.error(err)
-        return reply({
-          Message: `Failed to list pins: ${err.message}`,
-          Code: 0
-        }).code(500)
-      }
-
-      return reply({
-        Keys: mapValues(
-          keyBy(result, obj => cidToString(obj.hash, { base: request.query['cid-base'] })),
-          obj => ({ Type: obj.type })
-        )
-      })
+
+    let result
+    try {
+      result = await ipfs.pin.ls(path, { type })
+    } catch (err) {
+      log.error(err)
+      throw new Error(`Failed to list pins: ${err.message}`)
+    }
+
+    return h.response({
+      Keys: mapValues(
+        keyBy(result, obj => cidToString(obj.hash, { base: request.query['cid-base'] })),
+        obj => ({ Type: obj.type })
+      )
     })
   }
 }
@@ -73,24 +73,22 @@ exports.add = {
     }).unknown()
   },
 
-  parseArgs: parseArgs,
+  parseArgs,
 
-  handler: (request, reply) => {
-    const ipfs = request.server.app.ipfs
+  async handler (request, h) {
+    const { ipfs } = request.server.app
     const { path, recursive } = request.pre.args
 
-    ipfs.pin.add(path, { recursive }, (err, result) => {
-      if (err) {
-        log.error(err)
-        return reply({
-          Message: `Failed to add pin: ${err.message}`,
-          Code: 0
-        }).code(500)
-      }
-
-      return reply({
-        Pins: result.map(obj => cidToString(obj.hash, { base: request.query['cid-base'] }))
-      })
+    let result
+    try {
+      result = await ipfs.pin.add(path, { recursive })
+    } catch (err) {
+      log.error(err)
+      throw new Error(`Failed to add pin: ${err.message}`)
+    }
+
+    return h.response({
+      Pins: result.map(obj => cidToString(obj.hash, { base: request.query['cid-base'] }))
     })
   }
 }
@@ -102,24 +100,22 @@ exports.rm = {
     }).unknown()
   },
 
-  parseArgs: parseArgs,
+  parseArgs,
 
-  handler: (request, reply) => {
-    const ipfs = request.server.app.ipfs
+  async handler (request, h) {
+    const { ipfs } = request.server.app
     const { path, recursive } = request.pre.args
 
-    ipfs.pin.rm(path, { recursive }, (err, result) => {
-      if (err) {
-        log.error(err)
-        return reply({
-          Message: `Failed to remove pin: ${err.message}`,
-          Code: 0
-        }).code(500)
-      }
-
-      return reply({
-        Pins: result.map(obj => cidToString(obj.hash, { base: request.query['cid-base'] }))
-      })
+    let result
+    try {
+      result = await ipfs.pin.rm(path, { recursive })
+    } catch (err) {
+      log.error(err)
+      throw new Error(`Failed to remove pin: ${err.message}`)
+    }
+
+    return h.response({
+      Pins: result.map(obj => cidToString(obj.hash, { base: request.query['cid-base'] }))
     })
   }
 }
diff --git a/src/http/api/routes/index.js b/src/http/api/routes/index.js
index 8e4742cdbf..2057d41291 100644
--- a/src/http/api/routes/index.js
+++ b/src/http/api/routes/index.js
@@ -6,8 +6,8 @@ module.exports = [
   require('./id'),
   ...require('./bootstrap'),
   ...require('./block'),
-  ...require('./object')
-  // require('./pin')(server)
+  ...require('./object'),
+  ...require('./pin')
   // require('./repo')(server)
   // require('./config')(server)
   // require('./ping')(server)
diff --git a/src/http/api/routes/pin.js b/src/http/api/routes/pin.js
index 76b6a57ad1..6f7c06c0f5 100644
--- a/src/http/api/routes/pin.js
+++ b/src/http/api/routes/pin.js
@@ -2,42 +2,38 @@
 
 const resources = require('./../resources')
 
-module.exports = (server) => {
-  const api = server.select('API')
-
-  api.route({
+module.exports = [
+  {
     method: '*',
     path: '/api/v0/pin/add',
-    config: {
+    options: {
       pre: [
         { method: resources.pin.add.parseArgs, assign: 'args' }
       ],
-      handler: resources.pin.add.handler,
       validate: resources.pin.add.validate
-    }
-  })
-
-  api.route({
+    },
+    handler: resources.pin.add.handler
+  },
+  {
     method: '*',
     path: '/api/v0/pin/rm',
-    config: {
+    options: {
       pre: [
         { method: resources.pin.rm.parseArgs, assign: 'args' }
       ],
-      handler: resources.pin.rm.handler,
       validate: resources.pin.rm.validate
-    }
-  })
-
-  api.route({
+    },
+    handler: resources.pin.rm.handler
+  },
+  {
     method: '*',
     path: '/api/v0/pin/ls',
     config: {
       pre: [
         { method: resources.pin.ls.parseArgs, assign: 'args' }
       ],
-      handler: resources.pin.ls.handler,
       validate: resources.pin.ls.validate
-    }
-  })
-}
+    },
+    handler: resources.pin.ls.handler
+  }
+]
diff --git a/test/http-api/inject/pin.js b/test/http-api/inject/pin.js
index 9180533246..2ac0be2055 100644
--- a/test/http-api/inject/pin.js
+++ b/test/http-api/inject/pin.js
@@ -36,299 +36,274 @@ module.exports = (http) => {
     let api
 
     before(() => {
-      api = http.api.server.select('API')
+      api = http.api._apiServer
     })
 
     describe('rm', () => {
-      it('fails on invalid args', done => {
-        api.inject({
+      it('fails on invalid args', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: `/api/v0/pin/rm?arg=invalid`
-        }, res => {
-          expect(res.statusCode).to.equal(500)
-          expect(res.result.Message).to.match(/invalid ipfs ref path/)
-          done()
         })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Message).to.match(/invalid ipfs ref path/)
       })
 
-      it('unpins recursive pins', done => {
-        api.inject({
+      it('unpins recursive pins', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: `/api/v0/pin/rm?arg=${pins.root1}`
-        }, (res) => {
-          expect(res.statusCode).to.equal(200)
-          expect(res.result.Pins).to.deep.eql([pins.root1])
-          done()
         })
+
+        expect(res.statusCode).to.equal(200)
+        expect(res.result.Pins).to.deep.eql([pins.root1])
       })
 
-      it('unpins direct pins', done => {
-        api.inject({
+      it('unpins direct pins', async () => {
+        let res = await api.inject({
           method: 'POST',
           url: `/api/v0/pin/add?arg=${pins.root1}&recursive=false`
-        }, res => {
-          expect(res.statusCode).to.equal(200)
-          api.inject({
-            method: 'POST',
-            url: `/api/v0/pin/rm?arg=${pins.root1}&recursive=false`
-          }, (res) => {
-            expect(res.statusCode).to.equal(200)
-            expect(res.result.Pins).to.deep.eql([pins.root1])
-            done()
-          })
         })
+
+        expect(res.statusCode).to.equal(200)
+
+        res = await api.inject({
+          method: 'POST',
+          url: `/api/v0/pin/rm?arg=${pins.root1}&recursive=false`
+        })
+
+        expect(res.statusCode).to.equal(200)
+        expect(res.result.Pins).to.deep.eql([pins.root1])
       })
 
-      it('should remove pin and return base64 encoded CID', done => {
+      it('should remove pin and return base64 encoded CID', async () => {
         const form = new FormData()
         form.append('data', Buffer.from('TEST' + Date.now()))
         const headers = form.getHeaders()
 
-        streamToPromise(form).then((payload) => {
-          api.inject({
-            method: 'POST',
-            url: '/api/v0/add',
-            headers: headers,
-            payload: payload
-          }, (res) => {
-            expect(res.statusCode).to.equal(200)
-            const hash = JSON.parse(res.result).Hash
-
-            api.inject({
-              method: 'POST',
-              url: `/api/v0/pin/rm?arg=${hash}&cid-base=base64`
-            }, (res) => {
-              expect(res.statusCode).to.equal(200)
-              res.result.Pins.forEach(cid => {
-                expect(multibase.isEncoded(cid)).to.deep.equal('base64')
-              })
-              done()
-            })
-          })
+        const payload = await streamToPromise(form)
+        let res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/add',
+          headers: headers,
+          payload: payload
+        })
+
+        expect(res.statusCode).to.equal(200)
+        const hash = JSON.parse(res.result).Hash
+
+        res = await api.inject({
+          method: 'POST',
+          url: `/api/v0/pin/rm?arg=${hash}&cid-base=base64`
+        })
+
+        expect(res.statusCode).to.equal(200)
+        res.result.Pins.forEach(cid => {
+          expect(multibase.isEncoded(cid)).to.deep.equal('base64')
         })
       })
 
-      it('should not remove pin for invalid cid-base option', done => {
+      it('should not remove pin for invalid cid-base option', async () => {
         const form = new FormData()
         form.append('data', Buffer.from('TEST' + Date.now()))
         const headers = form.getHeaders()
 
-        streamToPromise(form).then((payload) => {
-          api.inject({
-            method: 'POST',
-            url: '/api/v0/add',
-            headers: headers,
-            payload: payload
-          }, (res) => {
-            expect(res.statusCode).to.equal(200)
-            const hash = JSON.parse(res.result).Hash
-
-            api.inject({
-              method: 'POST',
-              url: `/api/v0/pin/rm?arg=${hash}&cid-base=invalid`
-            }, (res) => {
-              expect(res.statusCode).to.equal(400)
-              expect(res.result.Message).to.include('child "cid-base" fails')
-              done()
-            })
-          })
+        const payload = await streamToPromise(form)
+        let res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/add',
+          headers: headers,
+          payload: payload
+        })
+
+        expect(res.statusCode).to.equal(200)
+        const hash = JSON.parse(res.result).Hash
+
+        res = await api.inject({
+          method: 'POST',
+          url: `/api/v0/pin/rm?arg=${hash}&cid-base=invalid`
         })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Message).to.include('child "cid-base" fails')
       })
     })
 
     describe('add', () => {
-      it('fails on invalid args', done => {
-        api.inject({
+      it('fails on invalid args', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: `/api/v0/pin/add?arg=invalid`
-        }, res => {
-          expect(res.statusCode).to.equal(500)
-          expect(res.result.Message).to.match(/invalid ipfs ref path/)
-          done()
         })
+
+        expect(res.statusCode).to.equal(500)
+        expect(res.result.Message).to.match(/invalid ipfs ref path/)
       })
 
-      it('recursively', done => {
-        api.inject({
+      it('recursively', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: `/api/v0/pin/add?arg=${pins.root1}`
-        }, (res) => {
-          expect(res.statusCode).to.equal(200)
-          expect(res.result.Pins).to.deep.eql([pins.root1])
-          done()
         })
+
+        expect(res.statusCode).to.equal(200)
+        expect(res.result.Pins).to.deep.eql([pins.root1])
       })
 
-      it('directly', done => {
-        api.inject({
+      it('directly', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: `/api/v0/pin/add?arg=${pins.root1}&recursive=false`
-        }, (res) => {
-          // by directly pinning a node that is already recursively pinned,
-          // it should error and verifies that the endpoint is parsing
-          // the recursive arg correctly.
-          expect(res.statusCode).to.equal(500)
-          expect(res.result.Message).to.match(/already pinned recursively/)
-          done()
         })
+        // by directly pinning a node that is already recursively pinned,
+        // it should error and verifies that the endpoint is parsing
+        // the recursive arg correctly.
+        expect(res.statusCode).to.equal(500)
+        expect(res.result.Message).to.match(/already pinned recursively/)
       })
 
-      it('should add pin and return base64 encoded CID', done => {
+      it('should add pin and return base64 encoded CID', async () => {
         const form = new FormData()
         form.append('data', Buffer.from('TEST' + Date.now()))
         const headers = form.getHeaders()
 
-        streamToPromise(form).then((payload) => {
-          api.inject({
-            method: 'POST',
-            url: '/api/v0/add?pin=false',
-            headers: headers,
-            payload: payload
-          }, (res) => {
-            expect(res.statusCode).to.equal(200)
-            const hash = JSON.parse(res.result).Hash
-
-            api.inject({
-              method: 'POST',
-              url: `/api/v0/pin/add?arg=${hash}&cid-base=base64`
-            }, (res) => {
-              expect(res.statusCode).to.equal(200)
-              res.result.Pins.forEach(cid => {
-                expect(multibase.isEncoded(cid)).to.deep.equal('base64')
-              })
-              done()
-            })
-          })
+        const payload = await streamToPromise(form)
+        let res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/add?pin=false',
+          headers: headers,
+          payload: payload
+        })
+
+        expect(res.statusCode).to.equal(200)
+        const hash = JSON.parse(res.result).Hash
+
+        res = await api.inject({
+          method: 'POST',
+          url: `/api/v0/pin/add?arg=${hash}&cid-base=base64`
+        })
+
+        expect(res.statusCode).to.equal(200)
+        res.result.Pins.forEach(cid => {
+          expect(multibase.isEncoded(cid)).to.deep.equal('base64')
         })
       })
 
-      it('should not add pin for invalid cid-base option', done => {
+      it('should not add pin for invalid cid-base option', async () => {
         const form = new FormData()
         form.append('data', Buffer.from('TEST' + Date.now()))
         const headers = form.getHeaders()
 
-        streamToPromise(form).then((payload) => {
-          api.inject({
-            method: 'POST',
-            url: '/api/v0/add?pin=false',
-            headers: headers,
-            payload: payload
-          }, (res) => {
-            expect(res.statusCode).to.equal(200)
-            const hash = JSON.parse(res.result).Hash
-
-            api.inject({
-              method: 'POST',
-              url: `/api/v0/pin/add?arg=${hash}&cid-base=invalid`
-            }, (res) => {
-              expect(res.statusCode).to.equal(400)
-              expect(res.result.Message).to.include('child "cid-base" fails')
-              done()
-            })
-          })
+        const payload = await streamToPromise(form)
+        let res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/add?pin=false',
+          headers: headers,
+          payload: payload
+        })
+        expect(res.statusCode).to.equal(200)
+        const hash = JSON.parse(res.result).Hash
+
+        res = await api.inject({
+          method: 'POST',
+          url: `/api/v0/pin/add?arg=${hash}&cid-base=invalid`
         })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Message).to.include('child "cid-base" fails')
       })
     })
 
     describe('ls', () => {
-      it('fails on invalid args', done => {
-        api.inject({
+      it('fails on invalid args', async () => {
+        const res = await api.inject({
           method: 'GET',
           url: `/api/v0/pin/ls?arg=invalid`
-        }, res => {
-          expect(res.statusCode).to.equal(500)
-          expect(res.result.Message).to.match(/invalid ipfs ref path/)
-          done()
         })
+
+        expect(res.statusCode).to.equal(500)
+        expect(res.result.Message).to.match(/invalid ipfs ref path/)
       })
 
-      it('finds all pinned objects', done => {
-        api.inject({
+      it('finds all pinned objects', async () => {
+        const res = await api.inject({
           method: 'GET',
           url: '/api/v0/pin/ls'
-        }, (res) => {
-          expect(res.statusCode).to.equal(200)
-          expect(res.result.Keys).to.include.all.keys(Object.values(pins))
-          done()
         })
+
+        expect(res.statusCode).to.equal(200)
+        expect(res.result.Keys).to.include.all.keys(Object.values(pins))
       })
 
-      it('finds specific pinned objects', done => {
-        api.inject({
+      it('finds specific pinned objects', async () => {
+        const res = await api.inject({
           method: 'GET',
           url: `/api/v0/pin/ls?arg=${pins.c1}`
-        }, (res) => {
-          expect(res.statusCode).to.equal(200)
-          expect(res.result.Keys[pins.c1].Type)
-            .to.equal(`indirect through ${pins.root1}`)
-          done()
         })
+
+        expect(res.statusCode).to.equal(200)
+        expect(res.result.Keys[pins.c1].Type)
+          .to.equal(`indirect through ${pins.root1}`)
       })
 
-      it('finds pins of type', done => {
-        api.inject({
+      it('finds pins of type', async () => {
+        const res = await api.inject({
           method: 'GET',
           url: `/api/v0/pin/ls?type=recursive`
-        }, (res) => {
-          expect(res.statusCode).to.equal(200)
-          expect(res.result.Keys['QmfGBRT6BbWJd7yUc2uYdaUZJBbnEFvTqehPFoSMQ6wgdr'])
-            .to.deep.eql({ Type: 'recursive' })
-          done()
         })
+
+        expect(res.statusCode).to.equal(200)
+        expect(res.result.Keys['QmfGBRT6BbWJd7yUc2uYdaUZJBbnEFvTqehPFoSMQ6wgdr'])
+          .to.deep.eql({ Type: 'recursive' })
       })
 
-      it('should list pins and return base64 encoded CIDs', done => {
+      it('should list pins and return base64 encoded CIDs', async () => {
         const form = new FormData()
         form.append('data', Buffer.from('TEST' + Date.now()))
         const headers = form.getHeaders()
 
-        streamToPromise(form).then((payload) => {
-          api.inject({
-            method: 'POST',
-            url: '/api/v0/add',
-            headers: headers,
-            payload: payload
-          }, (res) => {
-            expect(res.statusCode).to.equal(200)
-
-            api.inject({
-              method: 'POST',
-              url: `/api/v0/pin/ls?cid-base=base64`
-            }, (res) => {
-              expect(res.statusCode).to.equal(200)
-              Object.keys(res.result.Keys).forEach(cid => {
-                expect(multibase.isEncoded(cid)).to.deep.equal('base64')
-              })
-              done()
-            })
-          })
+        const payload = await streamToPromise(form)
+        let res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/add',
+          headers: headers,
+          payload: payload
+        })
+        expect(res.statusCode).to.equal(200)
+
+        res = await api.inject({
+          method: 'POST',
+          url: `/api/v0/pin/ls?cid-base=base64`
+        })
+
+        expect(res.statusCode).to.equal(200)
+        Object.keys(res.result.Keys).forEach(cid => {
+          expect(multibase.isEncoded(cid)).to.deep.equal('base64')
         })
       })
 
-      it('should not list pins for invalid cid-base option', done => {
+      it('should not list pins for invalid cid-base option', async () => {
         const form = new FormData()
         form.append('data', Buffer.from('TEST' + Date.now()))
         const headers = form.getHeaders()
 
-        streamToPromise(form).then((payload) => {
-          api.inject({
-            method: 'POST',
-            url: '/api/v0/add',
-            headers: headers,
-            payload: payload
-          }, (res) => {
-            expect(res.statusCode).to.equal(200)
-
-            api.inject({
-              method: 'POST',
-              url: `/api/v0/pin/ls?cid-base=invalid`
-            }, (res) => {
-              expect(res.statusCode).to.equal(400)
-              expect(res.result.Message).to.include('child "cid-base" fails')
-              done()
-            })
-          })
+        const payload = await streamToPromise(form)
+        let res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/add',
+          headers: headers,
+          payload: payload
+        })
+        expect(res.statusCode).to.equal(200)
+
+        res = await api.inject({
+          method: 'POST',
+          url: `/api/v0/pin/ls?cid-base=invalid`
         })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Message).to.include('child "cid-base" fails')
       })
     })
   })

From 1709fa145a036fcedf7c2d36d418c0dfefce25c1 Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Sun, 27 Jan 2019 13:45:06 +0000
Subject: [PATCH 16/49] fix: pin tests

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 test/http-api/inject/pin.js | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/test/http-api/inject/pin.js b/test/http-api/inject/pin.js
index 2ac0be2055..c14fb03fcb 100644
--- a/test/http-api/inject/pin.js
+++ b/test/http-api/inject/pin.js
@@ -126,7 +126,7 @@ module.exports = (http) => {
         })
 
         expect(res.statusCode).to.equal(400)
-        expect(res.result.Message).to.include('child "cid-base" fails')
+        expect(res.result.Message).to.include('Invalid request query input')
       })
     })
 
@@ -137,7 +137,7 @@ module.exports = (http) => {
           url: `/api/v0/pin/add?arg=invalid`
         })
 
-        expect(res.statusCode).to.equal(500)
+        expect(res.statusCode).to.equal(400)
         expect(res.result.Message).to.match(/invalid ipfs ref path/)
       })
 
@@ -211,7 +211,7 @@ module.exports = (http) => {
         })
 
         expect(res.statusCode).to.equal(400)
-        expect(res.result.Message).to.include('child "cid-base" fails')
+        expect(res.result.Message).to.include('Invalid request query input')
       })
     })
 
@@ -222,7 +222,7 @@ module.exports = (http) => {
           url: `/api/v0/pin/ls?arg=invalid`
         })
 
-        expect(res.statusCode).to.equal(500)
+        expect(res.statusCode).to.equal(400)
         expect(res.result.Message).to.match(/invalid ipfs ref path/)
       })
 
@@ -303,7 +303,7 @@ module.exports = (http) => {
         })
 
         expect(res.statusCode).to.equal(400)
-        expect(res.result.Message).to.include('child "cid-base" fails')
+        expect(res.result.Message).to.include('Invalid request query input')
       })
     })
   })

From beed8596ed2ce283c096d823b84b78de04aca3ec Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Sun, 27 Jan 2019 20:19:05 +0000
Subject: [PATCH 17/49] refactor: /api/v0/add /api/v0/cat & /api/v0/get for
 hapi 18

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/api/resources/files-regular.js | 339 +++++++++++-------------
 src/http/api/routes/files.js            |  60 ++---
 src/http/api/routes/index.js            |   4 +-
 test/http-api/inject/files.js           | 163 ++++++------
 4 files changed, 258 insertions(+), 308 deletions(-)

diff --git a/src/http/api/resources/files-regular.js b/src/http/api/resources/files-regular.js
index d0944e250e..96b711cd06 100644
--- a/src/http/api/resources/files-regular.js
+++ b/src/http/api/resources/files-regular.js
@@ -1,6 +1,5 @@
 'use strict'
 
-const CID = require('cids')
 const multipart = require('ipfs-multipart')
 const debug = require('debug')
 const tar = require('tar-stream')
@@ -9,17 +8,17 @@ log.error = debug('jsipfs:http-api:files:error')
 const pull = require('pull-stream')
 const toPull = require('stream-to-pull-stream')
 const pushable = require('pull-pushable')
-const each = require('async/each')
 const toStream = require('pull-stream-to-stream')
 const abortable = require('pull-abortable')
 const Joi = require('joi')
+const Boom = require('boom')
 const ndjson = require('pull-ndjson')
 const { PassThrough } = require('readable-stream')
 const multibase = require('multibase')
+const isIpfs = require('is-ipfs')
+const promisify = require('promisify-es6')
 const { cidToString } = require('../../../utils/cid')
 
-exports = module.exports
-
 function numberFromQuery (query, key) {
   if (query && query[key] !== undefined) {
     const value = parseInt(query[key], 10)
@@ -33,43 +32,24 @@ function numberFromQuery (query, key) {
 }
 
 // common pre request handler that parses the args and returns `key` which is assigned to `request.pre.args`
-exports.parseKey = (request, reply) => {
-  if (!request.query.arg) {
-    return reply({
-      Message: "Argument 'key' is required",
-      Code: 0,
-      Type: 'error'
-    }).code(400).takeover()
-  }
-
-  let key = request.query.arg
-  if (key.indexOf('/ipfs/') === 0) {
-    key = key.substring(6)
-  }
+exports.parseKey = (request, h) => {
+  const { arg } = request.query
 
-  const slashIndex = key.indexOf('/')
-  if (slashIndex > 0) {
-    key = key.substring(0, slashIndex)
+  if (!arg) {
+    throw Boom.badRequest("Argument 'key' is required")
   }
 
-  try {
-    new CID(key) // eslint-disable-line no-new
-  } catch (err) {
-    log.error(err)
-    return reply({
-      Message: 'invalid ipfs ref path',
-      Code: 0,
-      Type: 'error'
-    }).code(500).takeover()
+  if (!isIpfs.ipfsPath(arg) && !isIpfs.cid(arg)) {
+    throw Boom.badRequest('invalid ipfs ref path')
   }
 
-  reply({
-    key: request.query.arg,
+  return {
+    key: arg,
     options: {
       offset: numberFromQuery(request.query, 'offset'),
       length: numberFromQuery(request.query, 'length')
     }
-  })
+  }
 }
 
 exports.cat = {
@@ -77,46 +57,48 @@ exports.cat = {
   parseArgs: exports.parseKey,
 
   // main route handler which is called after the above `parseArgs`, but only if the args were valid
-  handler: (request, reply) => {
-    const key = request.pre.args.key
-    const options = request.pre.args.options
-    const ipfs = request.server.app.ipfs
-
-    let pusher
-    let started = false
-
-    pull(
-      ipfs.catPullStream(key, options),
-      pull.drain(
-        chunk => {
-          if (!started) {
-            started = true
-            pusher = pushable()
-            reply(toStream.source(pusher).pipe(new PassThrough()))
-              .header('X-Stream-Output', '1')
-          }
-          pusher.push(chunk)
-        },
-        err => {
-          if (err) {
-            log.error(err)
-
-            // We already started flowing, abort the stream
-            if (started) {
-              return pusher.end(err)
+  async handler (request, h) {
+    const { ipfs } = request.server.app
+    const { key, options } = request.pre.args
+
+    const stream = await new Promise((resolve, reject) => {
+      let pusher
+      let started = false
+
+      pull(
+        ipfs.catPullStream(key, options),
+        pull.drain(
+          chunk => {
+            if (!started) {
+              started = true
+              pusher = pushable()
+              resolve(toStream.source(pusher).pipe(new PassThrough()))
+            }
+            pusher.push(chunk)
+          },
+          err => {
+            if (err) {
+              log.error(err)
+
+              // We already started flowing, abort the stream
+              if (started) {
+                return pusher.end(err)
+              }
+
+              err.message = err.message === 'No such file'
+                ? err.message
+                : 'Failed to cat file: ' + err
+
+              return reject(err)
             }
 
-            const msg = err.message === 'No such file'
-              ? err.message
-              : 'Failed to cat file: ' + err
-
-            return reply({ Message: msg, Code: 0, Type: 'error' }).code(500)
+            pusher.end()
           }
-
-          pusher.end()
-        }
+        )
       )
-    )
+    })
+
+    return h.response(stream).header('X-Stream-Output', '1')
   }
 }
 
@@ -125,44 +107,41 @@ exports.get = {
   parseArgs: exports.parseKey,
 
   // main route handler which is called after the above `parseArgs`, but only if the args were valid
-  handler: (request, reply) => {
-    const key = request.pre.args.key
-    const ipfs = request.server.app.ipfs
+  async handler (request, h) {
+    const { ipfs } = request.server.app
+    const { key } = request.pre.args
     const pack = tar.pack()
 
-    ipfs.get(key, (err, filesArray) => {
-      if (err) {
-        log.error(err)
-        pack.emit('error', err)
-        pack.destroy()
-        return
-      }
+    let filesArray
+    try {
+      filesArray = await ipfs.get(key)
+    } catch (err) {
+      log.error(err)
+      throw new Error('Failed to get key: ' + err.message)
+    }
 
-      each(filesArray, (file, cb) => {
+    Promise
+      .all(filesArray.map(file => {
         const header = { name: file.path }
 
         if (file.content) {
           header.size = file.size
-          pack.entry(header, file.content, cb)
+          return promisify(pack.entry)(header, file.content)
         } else {
           header.type = 'directory'
-          pack.entry(header, cb)
-        }
-      }, (err) => {
-        if (err) {
-          log.error(err)
-          pack.emit('error', err)
-          pack.destroy()
-          return
+          return promisify(pack.entry)(header)
         }
-
-        pack.finalize()
+      }))
+      .then(() => pack.finalize())
+      .catch(err => {
+        log.error(err)
+        pack.emit('error', err)
+        pack.destroy()
       })
 
-      // reply must be called right away so that tar-stream offloads its content
-      // otherwise it will block in large files
-      reply(pack).header('X-Stream-Output', '1')
-    })
+    // reply must be called right away so that tar-stream offloads its content
+    // otherwise it will block in large files
+    return h.response(pack).header('X-Stream-Output', '1')
   }
 }
 
@@ -182,56 +161,48 @@ exports.add = {
       .options({ allowUnknown: true })
   },
 
-  handler: (request, reply) => {
+  async handler (request, h) {
     if (!request.payload) {
-      return reply({
-        Message: 'Array, Buffer, or String is required.',
-        Code: 0,
-        Type: 'error'
-      }).code(400).takeover()
+      throw Boom.badRequest('Array, Buffer, or String is required.')
     }
 
-    const ipfs = request.server.app.ipfs
-    // TODO: make pull-multipart
-    const parser = multipart.reqParser(request.payload)
-    let filesParsed = false
-
-    const fileAdder = pushable()
-
-    parser.on('file', (fileName, fileStream) => {
-      fileName = decodeURIComponent(fileName)
-      const filePair = {
-        path: fileName,
-        content: toPull(fileStream)
-      }
-      filesParsed = true
-      fileAdder.push(filePair)
-    })
+    const { ipfs } = request.server.app
+
+    const fileAdder = await new Promise((resolve, reject) => {
+      // TODO: make pull-multipart
+      const parser = multipart.reqParser(request.payload)
+      let filesParsed = false
+      const adder = pushable()
 
-    parser.on('directory', (directory) => {
-      directory = decodeURIComponent(directory)
+      parser.on('file', (fileName, fileStream) => {
+        if (!filesParsed) {
+          resolve(adder)
+          filesParsed = true
+        }
 
-      fileAdder.push({
-        path: directory,
-        content: ''
+        adder.push({
+          path: decodeURIComponent(fileName),
+          content: toPull(fileStream)
+        })
       })
-    })
 
-    parser.on('end', () => {
-      if (!filesParsed) {
-        return reply({
-          Message: "File argument 'data' is required.",
-          Code: 0,
-          Type: 'error'
-        }).code(400).takeover()
-      }
-      fileAdder.end()
+      parser.on('directory', (dirName) => {
+        adder.push({
+          path: decodeURIComponent(dirName),
+          content: ''
+        })
+      })
+
+      parser.on('end', () => {
+        if (!filesParsed) {
+          reject(new Error("File argument 'data' is required."))
+        }
+        adder.end()
+      })
     })
 
     const replyStream = pushable()
-    const progressHandler = (bytes) => {
-      replyStream.push({ Bytes: bytes })
-    }
+    const progressHandler = bytes => replyStream.push({ Bytes: bytes })
 
     const options = {
       cidVersion: request.query['cid-version'],
@@ -261,42 +232,42 @@ exports.add = {
       stream._readableState = {}
       stream.unpipe = () => {}
     }
-    reply(stream)
-      .header('x-chunked-output', '1')
-      .header('content-type', 'application/json')
-      .header('Trailer', 'X-Stream-Error')
 
-    function _writeErr (msg, code) {
-      const err = JSON.stringify({ Message: msg, Code: code })
-      request.raw.res.addTrailers({
-        'X-Stream-Error': err
-      })
-      return aborter.abort()
-    }
+    let filesAdded = false
 
     pull(
       fileAdder,
       ipfs.addPullStream(options),
-      pull.map((file) => {
-        return {
-          Name: file.path, // addPullStream already turned this into a hash if it wanted to
-          Hash: cidToString(file.hash, { base: request.query['cid-base'] }),
-          Size: file.size
-        }
-      }),
-      pull.collect((err, files) => {
-        if (err) {
-          return _writeErr(err, 0)
-        }
+      pull.map(file => ({
+        Name: file.path, // addPullStream already turned this into a hash if it wanted to
+        Hash: cidToString(file.hash, { base: request.query['cid-base'] }),
+        Size: file.size
+      })),
+      pull.drain(
+        file => {
+          replyStream.push(file)
+          filesAdded = true
+        },
+        err => {
+          if (err || !filesAdded) {
+            request.raw.res.addTrailers({
+              'X-Stream-Error': JSON.stringify({
+                Message: err ? err.message : 'Failed to add files.',
+                Code: 0
+              })
+            })
+            return aborter.abort()
+          }
 
-        if (files.length === 0 && filesParsed) {
-          return _writeErr('Failed to add files.', 0)
+          replyStream.end()
         }
-
-        files.forEach((f) => replyStream.push(f))
-        replyStream.end()
-      })
+      )
     )
+
+    return h.response(stream)
+      .header('x-chunked-output', '1')
+      .header('content-type', 'application/json')
+      .header('Trailer', 'X-Stream-Error')
   }
 }
 
@@ -311,33 +282,31 @@ exports.ls = {
   parseArgs: exports.parseKey,
 
   // main route handler which is called after the above `parseArgs`, but only if the args were valid
-  handler: (request, reply) => {
+  async handler (request, h) {
+    const { ipfs } = request.server.app
     const { key } = request.pre.args
-    const ipfs = request.server.app.ipfs
     const recursive = request.query && request.query.recursive === 'true'
     const cidBase = request.query['cid-base']
 
-    ipfs.ls(key, { recursive }, (err, files) => {
-      if (err) {
-        return reply({
-          Message: 'Failed to list dir: ' + err.message,
-          Code: 0,
-          Type: 'error'
-        }).code(500).takeover()
-      }
-
-      reply({
-        Objects: [{
-          Hash: key,
-          Links: files.map((file) => ({
-            Name: file.name,
-            Hash: cidToString(file.hash, { base: cidBase }),
-            Size: file.size,
-            Type: toTypeCode(file.type),
-            Depth: file.depth
-          }))
-        }]
-      })
+    let files
+    try {
+      files = await ipfs.ls(key, { recursive })
+    } catch (err) {
+      log.error(err)
+      throw new Error('Failed to list dir: ' + err.message)
+    }
+
+    return h.response({
+      Objects: [{
+        Hash: key,
+        Links: files.map((file) => ({
+          Name: file.name,
+          Hash: cidToString(file.hash, { base: cidBase }),
+          Size: file.size,
+          Type: toTypeCode(file.type),
+          Depth: file.depth
+        }))
+      }]
     })
   }
 }
diff --git a/src/http/api/routes/files.js b/src/http/api/routes/files.js
index 2e51ca7b0c..e9b6ed0390 100644
--- a/src/http/api/routes/files.js
+++ b/src/http/api/routes/files.js
@@ -1,61 +1,55 @@
 'use strict'
 
 const resources = require('./../resources')
-const mfs = require('ipfs-mfs/http')
+// const mfs = require('ipfs-mfs/http')
 
-module.exports = (server) => {
-  const api = server.select('API')
-
-  api.route({
+module.exports = [
+  {
     // TODO fix method
     method: '*',
     path: '/api/v0/cat',
-    config: {
+    options: {
       pre: [
         { method: resources.filesRegular.cat.parseArgs, assign: 'args' }
-      ],
-      handler: resources.filesRegular.cat.handler
-    }
-  })
-
-  api.route({
+      ]
+    },
+    handler: resources.filesRegular.cat.handler
+  },
+  {
     // TODO fix method
     method: '*',
     path: '/api/v0/get',
-    config: {
+    options: {
       pre: [
         { method: resources.filesRegular.get.parseArgs, assign: 'args' }
-      ],
-      handler: resources.filesRegular.get.handler
-    }
-  })
-
-  api.route({
+      ]
+    },
+    handler: resources.filesRegular.get.handler
+  },
+  {
     // TODO fix method
     method: '*',
     path: '/api/v0/add',
-    config: {
+    options: {
       payload: {
         parse: false,
         output: 'stream',
         maxBytes: Number.MAX_SAFE_INTEGER
       },
-      handler: resources.filesRegular.add.handler,
       validate: resources.filesRegular.add.validate
-    }
-  })
-
-  api.route({
+    },
+    handler: resources.filesRegular.add.handler
+  },
+  {
     // TODO fix method
     method: '*',
     path: '/api/v0/ls',
-    config: {
+    options: {
       pre: [
         { method: resources.filesRegular.ls.parseArgs, assign: 'args' }
-      ],
-      handler: resources.filesRegular.ls.handler
-    }
-  })
-
-  mfs(api)
-}
+      ]
+    },
+    handler: resources.filesRegular.ls.handler
+  }
+  // ...mfs
+]
diff --git a/src/http/api/routes/index.js b/src/http/api/routes/index.js
index 2057d41291..fd5b5f302c 100644
--- a/src/http/api/routes/index.js
+++ b/src/http/api/routes/index.js
@@ -7,14 +7,14 @@ module.exports = [
   ...require('./bootstrap'),
   ...require('./block'),
   ...require('./object'),
-  ...require('./pin')
+  ...require('./pin'),
   // require('./repo')(server)
   // require('./config')(server)
   // require('./ping')(server)
   // require('./swarm')(server)
   // require('./bitswap')(server)
   // require('./file')(server)
-  // require('./files')(server)
+  ...require('./files')
   // require('./pubsub')(server)
   // require('./debug')(server)
   // require('./webui')(server)
diff --git a/test/http-api/inject/files.js b/test/http-api/inject/files.js
index 677c4c43fa..06d2e02597 100644
--- a/test/http-api/inject/files.js
+++ b/test/http-api/inject/files.js
@@ -13,11 +13,11 @@ module.exports = (http) => {
     let api
 
     before(() => {
-      api = http.api.server.select('API')
+      api = http.api._apiServer
     })
 
     describe('/add', () => {
-      it('should add buffer bigger than Hapi default max bytes (1024 * 1024)', (done) => {
+      it('should add buffer bigger than Hapi default max bytes (1024 * 1024)', async () => {
         const payload = Buffer.from([
           '',
           '------------287032381131322',
@@ -28,85 +28,78 @@ module.exports = (http) => {
           '------------287032381131322--'
         ].join('\r\n'))
 
-        api.inject({
+        const res = await api.inject({
           method: 'POST',
           url: '/api/v0/add',
           headers: {
             'Content-Type': 'multipart/form-data; boundary=----------287032381131322'
           },
           payload
-        }, (res) => {
-          expect(res.statusCode).to.not.equal(413) // Payload too large
-          expect(res.statusCode).to.equal(200)
-          done()
         })
+
+        expect(res.statusCode).to.not.equal(413) // Payload too large
+        expect(res.statusCode).to.equal(200)
       })
 
       // TODO: unskip when we can retrieve data from the repo with a different
       // version CID then it was added with.
-      it.skip('should add data and return a base64 encoded CID', (done) => {
+      it.skip('should add data and return a base64 encoded CID', async () => {
         const form = new FormData()
         form.append('data', Buffer.from('TEST' + Date.now()))
         const headers = form.getHeaders()
 
-        streamToPromise(form).then((payload) => {
-          api.inject({
-            method: 'POST',
-            url: '/api/v0/add?cid-base=base64',
-            headers: headers,
-            payload: payload
-          }, (res) => {
-            expect(res.statusCode).to.equal(200)
-            expect(multibase.isEncoded(JSON.parse(res.result).Hash)).to.deep.equal('base64')
-            done()
-          })
+        const payload = await streamToPromise(form)
+        const res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/add?cid-base=base64',
+          headers,
+          payload
         })
+
+        expect(res.statusCode).to.equal(200)
+        expect(multibase.isEncoded(JSON.parse(res.result).Hash)).to.deep.equal('base64')
       })
 
-      it('should add data without pinning and return a base64 encoded CID', (done) => {
+      it('should add data without pinning and return a base64 encoded CID', async () => {
         const form = new FormData()
         form.append('data', Buffer.from('TEST' + Date.now()))
         const headers = form.getHeaders()
 
-        streamToPromise(form).then((payload) => {
-          api.inject({
-            method: 'POST',
-            url: '/api/v0/add?cid-base=base64&pin=false',
-            headers: headers,
-            payload: payload
-          }, (res) => {
-            expect(res.statusCode).to.equal(200)
-            expect(multibase.isEncoded(JSON.parse(res.result).Hash)).to.deep.equal('base64')
-            done()
-          })
+        const payload = await streamToPromise(form)
+        const res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/add?cid-base=base64&pin=false',
+          headers,
+          payload
         })
+
+        expect(res.statusCode).to.equal(200)
+        expect(multibase.isEncoded(JSON.parse(res.result).Hash)).to.deep.equal('base64')
       })
     })
 
     describe('/cat', () => {
-      it('returns 400 for request without argument', (done) => {
-        api.inject({
+      it('returns 400 for request without argument', async () => {
+        const res = await api.inject({
           method: 'GET',
           url: '/api/v0/cat'
-        }, (res) => {
-          expect(res.statusCode).to.equal(400)
-          expect(res.result.Message).to.be.a('string')
-          done()
         })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Message).to.be.a('string')
       })
 
-      it('500 for request with invalid argument', (done) => {
-        api.inject({
+      it('returns 400 for request with invalid argument', async () => {
+        const res = await api.inject({
           method: 'GET',
           url: '/api/v0/cat?arg=invalid'
-        }, (res) => {
-          expect(res.statusCode).to.equal(500)
-          expect(res.result.Message).to.be.a('string')
-          done()
         })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Message).to.be.a('string')
       })
 
-      it('should cat a valid hash', function (done) {
+      it('should cat a valid hash', async function () {
         this.timeout(30 * 1000)
 
         const data = Buffer.from('TEST' + Date.now())
@@ -114,61 +107,55 @@ module.exports = (http) => {
         form.append('data', data)
         const headers = form.getHeaders()
 
-        streamToPromise(form).then((payload) => {
-          api.inject({
-            method: 'POST',
-            url: '/api/v0/add',
-            headers: headers,
-            payload: payload
-          }, (res) => {
-            expect(res.statusCode).to.equal(200)
-            const cid = JSON.parse(res.result).Hash
-
-            api.inject({
-              method: 'GET',
-              url: '/api/v0/cat?arg=' + cid
-            }, (res) => {
-              expect(res.statusCode).to.equal(200)
-              expect(res.rawPayload).to.deep.equal(data)
-              expect(res.payload).to.equal(data.toString())
-              done()
-            })
-          })
+        const payload = await streamToPromise(form)
+        let res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/add',
+          headers,
+          payload
+        })
+
+        expect(res.statusCode).to.equal(200)
+        const cid = JSON.parse(res.result).Hash
+
+        res = await api.inject({
+          method: 'GET',
+          url: '/api/v0/cat?arg=' + cid
         })
+
+        expect(res.statusCode).to.equal(200)
+        expect(res.rawPayload).to.deep.equal(data)
+        expect(res.payload).to.equal(data.toString())
       })
     })
 
     describe('/get', () => {}) // TODO
 
     describe('/ls', () => {
-      it('should list directory contents and return a base64 encoded CIDs', (done) => {
+      it('should list directory contents and return a base64 encoded CIDs', async () => {
         const form = new FormData()
         form.append('file', Buffer.from('TEST' + Date.now()), { filename: 'data.txt' })
         const headers = form.getHeaders()
 
-        streamToPromise(form).then((payload) => {
-          api.inject({
-            method: 'POST',
-            url: '/api/v0/add?wrap-with-directory=true',
-            headers: headers,
-            payload: payload
-          }, (res) => {
-            expect(res.statusCode).to.equal(200)
-
-            const files = res.result.trim().split('\n').map(r => JSON.parse(r))
-            const dir = files[files.length - 1]
-
-            api.inject({
-              method: 'POST',
-              url: '/api/v0/ls?cid-base=base64&arg=' + dir.Hash
-            }, (res) => {
-              expect(res.statusCode).to.equal(200)
-              res.result.Objects[0].Links.forEach(item => {
-                expect(multibase.isEncoded(item.Hash)).to.deep.equal('base64')
-              })
-              done()
-            })
-          })
+        const payload = await streamToPromise(form)
+        let res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/add?wrap-with-directory=true',
+          headers,
+          payload
+        })
+        expect(res.statusCode).to.equal(200)
+
+        const files = res.result.trim().split('\n').map(r => JSON.parse(r))
+        const dir = files[files.length - 1]
+
+        res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/ls?cid-base=base64&arg=' + dir.Hash
+        })
+        expect(res.statusCode).to.equal(200)
+        res.result.Objects[0].Links.forEach(item => {
+          expect(multibase.isEncoded(item.Hash)).to.deep.equal('base64')
         })
       })
     })

From 7d2205eecf972d0df203c8a1e7160bb13a674c18 Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Sun, 27 Jan 2019 20:43:09 +0000
Subject: [PATCH 18/49] fix: pin tests

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/api/resources/pin.js | 3 +++
 test/http-api/inject/pin.js   | 4 ++--
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/http/api/resources/pin.js b/src/http/api/resources/pin.js
index 88081cde0b..144786539f 100644
--- a/src/http/api/resources/pin.js
+++ b/src/http/api/resources/pin.js
@@ -84,6 +84,9 @@ exports.add = {
       result = await ipfs.pin.add(path, { recursive })
     } catch (err) {
       log.error(err)
+      if (err.message.includes('already pinned recursively')) {
+        throw Boom.boomify(err, { statusCode: 400 })
+      }
       throw new Error(`Failed to add pin: ${err.message}`)
     }
 
diff --git a/test/http-api/inject/pin.js b/test/http-api/inject/pin.js
index c14fb03fcb..8911f0597b 100644
--- a/test/http-api/inject/pin.js
+++ b/test/http-api/inject/pin.js
@@ -32,7 +32,7 @@ const pins = {
 }
 
 module.exports = (http) => {
-  describe('pin', () => {
+  describe.only('pin', () => {
     let api
 
     before(() => {
@@ -159,7 +159,7 @@ module.exports = (http) => {
         // by directly pinning a node that is already recursively pinned,
         // it should error and verifies that the endpoint is parsing
         // the recursive arg correctly.
-        expect(res.statusCode).to.equal(500)
+        expect(res.statusCode).to.equal(400)
         expect(res.result.Message).to.match(/already pinned recursively/)
       })
 

From 137fea80cbdd7faa0cdb028cc26e014e780f40e7 Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Sun, 27 Jan 2019 20:45:50 +0000
Subject: [PATCH 19/49] chore: remove .only

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 test/http-api/inject/pin.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/http-api/inject/pin.js b/test/http-api/inject/pin.js
index 8911f0597b..b433e0f27f 100644
--- a/test/http-api/inject/pin.js
+++ b/test/http-api/inject/pin.js
@@ -32,7 +32,7 @@ const pins = {
 }
 
 module.exports = (http) => {
-  describe.only('pin', () => {
+  describe('pin', () => {
     let api
 
     before(() => {

From b4c9d5dd74903174917308afa410a87684863684 Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Sun, 27 Jan 2019 20:54:47 +0000
Subject: [PATCH 20/49] refactor: /api/v0/repo* for hapi 18

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/api/resources/repo.js | 64 ++++++++++------------------------
 src/http/api/routes/index.js   |  2 +-
 src/http/api/routes/repo.js    | 24 +++++--------
 3 files changed, 28 insertions(+), 62 deletions(-)

diff --git a/src/http/api/resources/repo.js b/src/http/api/resources/repo.js
index 13b68e115a..724928a8ca 100644
--- a/src/http/api/resources/repo.js
+++ b/src/http/api/resources/repo.js
@@ -2,56 +2,30 @@
 
 exports = module.exports
 
-exports.gc = (request, reply) => {
-  const ipfs = request.server.app.ipfs
-
-  ipfs.repo.gc((err) => {
-    if (err) {
-      return reply({
-        Message: err.toString(),
-        Code: 0
-      }).code(500)
-    }
-
-    reply()
-  })
+exports.gc = async (request, h) => {
+  const { ipfs } = request.server.app
+  await ipfs.repo.gc()
+  return h.response()
 }
 
-exports.version = (request, reply) => {
-  const ipfs = request.server.app.ipfs
-
-  ipfs.repo.version((err, version) => {
-    if (err) {
-      return reply({
-        Message: err.toString(),
-        Code: 0
-      }).code(500)
-    }
-
-    reply({
-      Version: version
-    })
+exports.version = async (request, h) => {
+  const { ipfs } = request.server.app
+  const version = await ipfs.repo.version()
+  return h.response({
+    Version: version
   })
 }
 
-exports.stat = (request, reply) => {
-  const ipfs = request.server.app.ipfs
+exports.stat = async (request, h) => {
+  const { ipfs } = request.server.app
   const human = request.query.human === 'true'
-
-  ipfs.repo.stat({ human: human }, (err, stat) => {
-    if (err) {
-      return reply({
-        Message: err.toString(),
-        Code: 0
-      }).code(500)
-    }
-
-    reply({
-      NumObjects: stat.numObjects,
-      RepoSize: stat.repoSize,
-      RepoPath: stat.repoPath,
-      Version: stat.version,
-      StorageMax: stat.storageMax
-    })
+  const stat = await ipfs.repo.stat({ human })
+
+  return h.response({
+    NumObjects: stat.numObjects,
+    RepoSize: stat.repoSize,
+    RepoPath: stat.repoPath,
+    Version: stat.version,
+    StorageMax: stat.storageMax
   })
 }
diff --git a/src/http/api/routes/index.js b/src/http/api/routes/index.js
index fd5b5f302c..2b07a21789 100644
--- a/src/http/api/routes/index.js
+++ b/src/http/api/routes/index.js
@@ -8,7 +8,7 @@ module.exports = [
   ...require('./block'),
   ...require('./object'),
   ...require('./pin'),
-  // require('./repo')(server)
+  ...require('./repo'),
   // require('./config')(server)
   // require('./ping')(server)
   // require('./swarm')(server)
diff --git a/src/http/api/routes/repo.js b/src/http/api/routes/repo.js
index 3eb7ab2a88..e5254b0ab5 100644
--- a/src/http/api/routes/repo.js
+++ b/src/http/api/routes/repo.js
@@ -2,24 +2,16 @@
 
 const resources = require('./../resources')
 
-module.exports = (server) => {
-  const api = server.select('API')
-
-  api.route({
+module.exports = [
+  {
     method: '*',
     path: '/api/v0/repo/version',
-    config: {
-      handler: resources.repo.version
-    }
-  })
-
-  api.route({
+    handler: resources.repo.version
+  },
+  {
     method: '*',
     path: '/api/v0/repo/stat',
-    config: {
-      handler: resources.repo.stat
-    }
-  })
-
+    handler: resources.repo.stat
+  }
   // TODO: implement the missing spec https://github.com/ipfs/interface-ipfs-core/blob/master/SPEC/REPO.md
-}
+]

From 49358d3bf7226863ae7f7ea6dae9f3c01bf9ede7 Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Sun, 27 Jan 2019 21:58:31 +0000
Subject: [PATCH 21/49] refactor: /api/v0/config* for hapi 18

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/api/resources/config.js | 215 ++++++++++++-------------------
 src/http/api/routes/config.js    |  36 +++---
 src/http/api/routes/index.js     |   2 +-
 test/http-api/inject/config.js   | 208 +++++++++++++-----------------
 4 files changed, 193 insertions(+), 268 deletions(-)

diff --git a/src/http/api/resources/config.js b/src/http/api/resources/config.js
index 9ad56080ea..ef0af77e68 100644
--- a/src/http/api/resources/config.js
+++ b/src/http/api/resources/config.js
@@ -6,12 +6,13 @@ const set = require('lodash/set')
 const log = debug('jsipfs:http-api:config')
 log.error = debug('jsipfs:http-api:config:error')
 const multipart = require('ipfs-multipart')
+const Boom = require('boom')
 
 exports = module.exports
 
 exports.getOrSet = {
   // pre request handler that parses the args and returns `key` & `value` which are assigned to `request.pre.args`
-  parseArgs: (request, reply) => {
+  parseArgs (request, h) {
     const parseValue = (args) => {
       if (request.query.bool !== undefined) {
         args.value = args.value === 'true'
@@ -20,14 +21,11 @@ exports.getOrSet = {
           args.value = JSON.parse(args.value)
         } catch (err) {
           log.error(err)
-          return reply({
-            Message: 'failed to unmarshal json. ' + err,
-            Code: 0
-          }).code(500).takeover()
+          throw Boom.badRequest('failed to unmarshal json. ' + err)
         }
       }
 
-      return reply(args)
+      return args
     }
 
     if (request.query.arg instanceof Array) {
@@ -45,172 +43,125 @@ exports.getOrSet = {
     }
 
     if (!request.query.arg) {
-      return reply("Argument 'key' is required").code(400).takeover()
+      throw Boom.badRequest("Argument 'key' is required")
     }
 
-    return reply({
-      key: request.query.arg
-    })
+    return { key: request.query.arg }
   },
 
   // main route handler which is called after the above `parseArgs`, but only if the args were valid
-  handler: (request, reply) => {
-    const key = request.pre.args.key
-    const value = request.pre.args.value
-    const ipfs = request.server.app.ipfs
+  async handler (request, h) {
+    const { ipfs } = request.server.app
+    const { key } = request.pre.args
+    let { value } = request.pre.args
 
     // check that value exists - typeof null === 'object'
     if (value && (typeof value === 'object' &&
         value.type === 'Buffer')) {
-      return reply({
-        Message: 'Invalid value type',
-        Code: 0
-      }).code(500)
+      throw Boom.badRequest('Invalid value type')
     }
 
-    if (value === undefined) {
-      // Get the value of a given key
-      return ipfs.config.get((err, config) => {
-        if (err) {
-          log.error(err)
-          return reply({
-            Message: 'Failed to get config value: ' + err,
-            Code: 0
-          }).code(500)
-        }
-
-        const value = get(config, key)
-        if (value === undefined) {
-          return reply({
-            Message: 'Failed to get config value:  key has no attributes',
-            Code: 0
-          }).code(500)
-        }
-
-        return reply({
-          Key: key,
-          Value: value
-        })
-      })
+    let originalConfig
+    try {
+      originalConfig = await ipfs.config.get()
+    } catch (err) {
+      log.error(err)
+      throw new Error('Failed to get config value: ' + err)
     }
 
-    // Set the new value of a given key
-    ipfs.config.get((err, originalConfig) => {
-      if (err) {
-        log.error(err)
-        return reply({
-          Message: 'Failed to get config value: ' + err,
-          Code: 0
-        }).code(500)
+    if (value === undefined) {
+      // Get the value of a given key
+      value = get(originalConfig, key)
+      if (value === undefined) {
+        throw Boom.notFound('Failed to get config value: key has no attributes')
       }
-
+    } else {
+      // Set the new value of a given key
       const updatedConfig = set(originalConfig, key, value)
-      ipfs.config.replace(updatedConfig, (err) => {
-        if (err) {
-          log.error(err)
-          return reply({
-            Message: 'Failed to get config value: ' + err,
-            Code: 0
-          }).code(500)
-        }
+      try {
+        await ipfs.config.replace(updatedConfig)
+      } catch (err) {
+        log.error(err)
+        throw new Error('Failed to get config value: ' + err)
+      }
+    }
 
-        return reply({
-          Key: key,
-          Value: value
-        })
-      })
+    return h.response({
+      Key: key,
+      Value: value
     })
   }
 }
 
-exports.get = (request, reply) => {
-  const ipfs = request.server.app.ipfs
+exports.get = async (request, h) => {
+  const { ipfs } = request.server.app
 
-  ipfs.config.get((err, config) => {
-    if (err) {
-      log.error(err)
-      return reply({
-        Message: 'Failed to get config value: ' + err,
-        Code: 0
-      }).code(500)
-    }
+  let config
+  try {
+    config = await ipfs.config.get()
+  } catch (err) {
+    log.error(err)
+    throw new Error('Failed to get config value: ' + err)
+  }
 
-    return reply({
-      Value: config
-    })
+  return h.response({
+    Value: config
   })
 }
 
-exports.show = (request, reply) => {
-  const ipfs = request.server.app.ipfs
+exports.show = async (request, h) => {
+  const { ipfs } = request.server.app
 
-  ipfs.config.get((err, config) => {
-    if (err) {
-      log.error(err)
-      return reply({
-        Message: 'Failed to get config value: ' + err,
-        Code: 0
-      }).code(500)
-    }
+  let config
+  try {
+    config = await ipfs.config.get()
+  } catch (err) {
+    log.error(err)
+    throw new Error('Failed to get config value: ' + err)
+  }
 
-    return reply(config)
-  })
+  return h.response(config)
 }
 
 exports.replace = {
   // pre request handler that parses the args and returns `config` which is assigned to `request.pre.args`
-  parseArgs: (request, reply) => {
+  async parseArgs (request, h) {
     if (!request.payload) {
-      return reply({
-        Message: "Argument 'file' is required",
-        Code: 1123
-
-      }).code(400).takeover()
+      throw Boom.badRequest("Argument 'file' is required")
     }
 
-    const parser = multipart.reqParser(request.payload)
-    var file
-
-    parser.on('file', (fileName, fileStream) => {
-      fileStream.on('data', (data) => {
-        file = data
-      })
+    const fileStream = await new Promise((resolve, reject) => {
+      multipart.reqParser(request.payload)
+        .on('file', (fileName, fileStream) => resolve(fileStream))
+        .on('end', () => reject(Boom.badRequest("Argument 'file' is required")))
     })
 
-    parser.on('end', () => {
-      if (!file) {
-        return reply({
-          Message: "Argument 'file' is required",
-          Code: 1123
-
-        }).code(400).takeover()
-      }
-
-      try {
-        return reply({
-          config: JSON.parse(file.toString())
-        })
-      } catch (err) {
-        return reply({
-          Message: 'Failed to decode file as config: ' + err,
-          Code: 0
-        }).code(500).takeover()
-      }
+    const file = await new Promise((resolve, reject) => {
+      fileStream
+        .on('data', data => resolve(data))
+        .on('end', () => reject(Boom.badRequest("Argument 'file' is required")))
     })
+
+    try {
+      return { config: JSON.parse(file.toString()) }
+    } catch (err) {
+      log.error(err)
+      throw new Error('Failed to decode file as config: ' + err)
+    }
   },
 
   // main route handler which is called after the above `parseArgs`, but only if the args were valid
-  handler: (request, reply) => {
-    return request.server.app.ipfs.config.replace(request.pre.args.config, (err) => {
-      if (err) {
-        log.error(err)
-        return reply({
-          Message: 'Failed to save config: ' + err,
-          Code: 0
-        }).code(500)
-      }
+  async handler (request, h) {
+    const { ipfs } = request.server.app
+    const { config } = request.pre.args
 
-      return reply()
-    })
+    try {
+      await ipfs.config.replace(config)
+    } catch (err) {
+      log.error(err)
+      throw new Error('Failed to save config: ' + err)
+    }
+
+    return h.response()
   }
 }
diff --git a/src/http/api/routes/config.js b/src/http/api/routes/config.js
index 452d84ed0b..410351b5c0 100644
--- a/src/http/api/routes/config.js
+++ b/src/http/api/routes/config.js
@@ -2,38 +2,34 @@
 
 const resources = require('./../resources')
 
-module.exports = (server) => {
-  const api = server.select('API')
-
-  api.route({
+module.exports = [
+  {
     method: '*',
     path: '/api/v0/config/{key?}',
-    config: {
+    options: {
       pre: [
         { method: resources.config.getOrSet.parseArgs, assign: 'args' }
-      ],
-      handler: resources.config.getOrSet.handler
-    }
-  })
-
-  api.route({
+      ]
+    },
+    handler: resources.config.getOrSet.handler
+  },
+  {
     method: '*',
     path: '/api/v0/config/show',
     handler: resources.config.show
-  })
-
-  api.route({
+  },
+  {
     method: '*',
     path: '/api/v0/config/replace',
-    config: {
+    options: {
       payload: {
         parse: false,
         output: 'stream'
       },
       pre: [
         { method: resources.config.replace.parseArgs, assign: 'args' }
-      ],
-      handler: resources.config.replace.handler
-    }
-  })
-}
+      ]
+    },
+    handler: resources.config.replace.handler
+  }
+]
diff --git a/src/http/api/routes/index.js b/src/http/api/routes/index.js
index 2b07a21789..3d0bd75a01 100644
--- a/src/http/api/routes/index.js
+++ b/src/http/api/routes/index.js
@@ -9,7 +9,7 @@ module.exports = [
   ...require('./object'),
   ...require('./pin'),
   ...require('./repo'),
-  // require('./config')(server)
+  ...require('./config'),
   // require('./ping')(server)
   // require('./swarm')(server)
   // require('./bitswap')(server)
diff --git a/test/http-api/inject/config.js b/test/http-api/inject/config.js
index e016beba41..cdc5baec02 100644
--- a/test/http-api/inject/config.js
+++ b/test/http-api/inject/config.js
@@ -8,7 +8,7 @@ const streamToPromise = require('stream-to-promise')
 const path = require('path')
 
 module.exports = (http) => {
-  describe('/config', () => {
+  describe.only('/config', () => {
     const configPath = path.join(__dirname, '../../repo-tests-run/config')
     const originalConfigPath = path.join(__dirname, '../../fixtures/go-ipfs-repo/config')
 
@@ -17,198 +17,176 @@ module.exports = (http) => {
 
     before(() => {
       updatedConfig = () => JSON.parse(fs.readFileSync(configPath, 'utf8'))
-
-      api = http.api.server.select('API')
+      api = http.api._apiServer
     })
 
     after(() => {
       fs.writeFileSync(configPath, fs.readFileSync(originalConfigPath, 'utf8'), 'utf8')
     })
 
-    describe('400 for request with no args', () => {
-      it('returns 400 for request without arguments', (done) => {
-        api.inject({
+    describe('/config', () => {
+      it('returns 400 for request without arguments', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: '/api/v0/config'
-        }, (res) => {
-          expect(res.statusCode).to.equal(400)
-          done()
         })
+
+        expect(res.statusCode).to.equal(400)
       })
 
-      it('500 for request with invalid args', (done) => {
-        api.inject({
+      it('404 for request with missing args', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: '/api/v0/config?arg=kitten'
-        }, (res) => {
-          expect(res.statusCode).to.equal(500)
-          expect(res.result.Code).to.equal(0)
-          expect(res.result.Message).to.be.a('string')
-          done()
         })
+
+        expect(res.statusCode).to.equal(404)
+        expect(res.result.Code).to.equal(3)
+        expect(res.result.Message).to.be.a('string')
       })
 
-      it('returns value for request with valid arg', (done) => {
-        api.inject({
+      it('returns value for request with valid arg', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: '/api/v0/config?arg=API.HTTPHeaders'
-        }, (res) => {
-          expect(res.statusCode).to.equal(200)
-          expect(res.result.Key).to.equal('API.HTTPHeaders')
-          expect(res.result.Value).to.equal(null)
-          done()
         })
+
+        expect(res.statusCode).to.equal(200)
+        expect(res.result.Key).to.equal('API.HTTPHeaders')
+        expect(res.result.Value).to.equal(null)
       })
 
-      it('returns value for request as subcommand', (done) => {
-        api.inject({
+      it('returns value for request as subcommand', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: '/api/v0/config/API.HTTPHeaders'
-        }, (res) => {
-          expect(res.statusCode).to.equal(200)
-          expect(res.result.Key).to.equal('API.HTTPHeaders')
-          expect(res.result.Value).to.equal(null)
-          done()
         })
+
+        expect(res.statusCode).to.equal(200)
+        expect(res.result.Key).to.equal('API.HTTPHeaders')
+        expect(res.result.Value).to.equal(null)
       })
 
-      it('updates value for request with both args', (done) => {
-        api.inject({
+      it('updates value for request with both args', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: '/api/v0/config?arg=Datastore.Path&arg=kitten'
-        }, (res) => {
-          expect(res.statusCode).to.equal(200)
-          expect(res.result.Key).to.equal('Datastore.Path')
-          expect(res.result.Value).to.equal('kitten')
-          expect(updatedConfig().Datastore.Path).to.equal('kitten')
-
-          done()
         })
+
+        expect(res.statusCode).to.equal(200)
+        expect(res.result.Key).to.equal('Datastore.Path')
+        expect(res.result.Value).to.equal('kitten')
+        expect(updatedConfig().Datastore.Path).to.equal('kitten')
       })
 
-      it('returns 500 value for request with both args and JSON flag with invalid JSON argument', (done) => {
-        api.inject({
+      it('returns 400 value for request with both args and JSON flag with invalid JSON argument', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: '/api/v0/config?arg=Datastore.Path&arg=kitten&json'
-        }, (res) => {
-          expect(res.statusCode).to.equal(500)
-          expect(res.result.Code).to.equal(0)
-          expect(res.result.Message).to.be.a('string')
-
-          done()
         })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Code).to.equal(1)
+        expect(res.result.Message).to.be.a('string')
       })
 
-      it('updates value for request with both args and JSON flag with valid JSON argument', (done) => {
-        api.inject({
+      it('updates value for request with both args and JSON flag with valid JSON argument', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: '/api/v0/config?arg=Datastore.Path&arg={"kitten": true}&json'
-        }, (res) => {
-          expect(res.statusCode).to.equal(200)
-          expect(res.result.Key).to.equal('Datastore.Path')
-          expect(res.result.Value).to.deep.equal({ kitten: true })
-          expect(updatedConfig().Datastore.Path).to.deep.equal({ kitten: true })
-
-          done()
         })
+
+        expect(res.statusCode).to.equal(200)
+        expect(res.result.Key).to.equal('Datastore.Path')
+        expect(res.result.Value).to.deep.equal({ kitten: true })
+        expect(updatedConfig().Datastore.Path).to.deep.equal({ kitten: true })
       })
 
-      it('updates value for request with both args and bool flag and true argument', (done) => {
-        api.inject({
+      it('updates value for request with both args and bool flag and true argument', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: '/api/v0/config?arg=Datastore.Path&arg=true&bool'
-        }, (res) => {
-          expect(res.statusCode).to.equal(200)
-          expect(res.result.Key).to.equal('Datastore.Path')
-          expect(res.result.Value).to.deep.equal(true)
-          expect(updatedConfig().Datastore.Path).to.deep.equal(true)
-
-          done()
         })
+
+        expect(res.statusCode).to.equal(200)
+        expect(res.result.Key).to.equal('Datastore.Path')
+        expect(res.result.Value).to.deep.equal(true)
+        expect(updatedConfig().Datastore.Path).to.deep.equal(true)
       })
 
-      it('updates value for request with both args and bool flag and false argument', (done) => {
-        api.inject({
+      it('updates value for request with both args and bool flag and false argument', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: '/api/v0/config?arg=Datastore.Path&arg=false&bool'
-        }, (res) => {
-          expect(res.statusCode).to.equal(200)
-          expect(res.result.Key).to.equal('Datastore.Path')
-          expect(res.result.Value).to.deep.equal(false)
-          expect(updatedConfig().Datastore.Path).to.deep.equal(false)
-
-          done()
         })
+
+        expect(res.statusCode).to.equal(200)
+        expect(res.result.Key).to.equal('Datastore.Path')
+        expect(res.result.Value).to.deep.equal(false)
+        expect(updatedConfig().Datastore.Path).to.deep.equal(false)
       })
     })
 
-    it('/config/show', (done) => {
-      api.inject({
+    it('/config/show', async () => {
+      const res = await api.inject({
         method: 'POST',
         url: '/api/v0/config/show'
-      }, (res) => {
-        expect(res.statusCode).to.equal(200)
-        expect(res.result).to.deep.equal(updatedConfig())
-        done()
       })
+
+      expect(res.statusCode).to.equal(200)
+      expect(res.result).to.deep.equal(updatedConfig())
     })
 
-    describe.skip('/config/replace', () => {
-      it('returns 400 if no config is provided', (done) => {
+    describe('/config/replace', () => {
+      it('returns 400 if no config is provided', async () => {
         const form = new FormData()
         const headers = form.getHeaders()
 
-        streamToPromise(form).then((payload) => {
-          api.inject({
-            method: 'POST',
-            url: '/api/v0/config/replace',
-            headers: headers,
-            payload: payload
-          }, (res) => {
-            expect(res.statusCode).to.equal(400)
-            done()
-          })
+        const payload = await streamToPromise(form)
+        const res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/config/replace',
+          headers,
+          payload
         })
+
+        expect(res.statusCode).to.equal(400)
       })
 
-      it('returns 500 if the config is invalid', (done) => {
+      it('returns 500 if the config is invalid', async () => {
         const form = new FormData()
         const filePath = 'test/fixtures/test-data/badconfig'
         form.append('file', fs.createReadStream(filePath))
         const headers = form.getHeaders()
 
-        streamToPromise(form).then((payload) => {
-          api.inject({
-            method: 'POST',
-            url: '/api/v0/config/replace',
-            headers: headers,
-            payload: payload
-          }, (res) => {
-            expect(res.statusCode).to.equal(500)
-            done()
-          })
+        const payload = await streamToPromise(form)
+        const res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/config/replace',
+          headers,
+          payload
         })
+
+        expect(res.statusCode).to.equal(500)
       })
 
-      it('updates value', (done) => {
+      it('updates value', async () => {
         const form = new FormData()
         const filePath = 'test/fixtures/test-data/otherconfig'
         form.append('file', fs.createReadStream(filePath))
         const headers = form.getHeaders()
         const expectedConfig = JSON.parse(fs.readFileSync(filePath, 'utf8'))
 
-        streamToPromise(form).then((payload) => {
-          api.inject({
-            method: 'POST',
-            url: '/api/v0/config/replace',
-            headers: headers,
-            payload: payload
-          }, (res) => {
-            expect(res.statusCode).to.equal(200)
-            expect(updatedConfig()).to.deep.equal(expectedConfig)
-            done()
-          })
+        const payload = await streamToPromise(form)
+        const res = await api.inject({
+          method: 'POST',
+          url: '/api/v0/config/replace',
+          headers,
+          payload
         })
+
+        expect(res.statusCode).to.equal(200)
+        expect(updatedConfig()).to.deep.equal(expectedConfig)
       })
     })
   })

From eb212f978e378bad7beeb5ee391b073d0356c5af Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Mon, 28 Jan 2019 08:32:44 +0000
Subject: [PATCH 22/49] refactor: better logging, less boilerplate

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/api/resources/block.js         | 12 ++++------
 src/http/api/resources/config.js        | 18 +++++----------
 src/http/api/resources/files-regular.js |  6 ++---
 src/http/api/resources/object.js        | 29 +++++++++----------------
 src/http/api/resources/pin.js           |  9 +++-----
 5 files changed, 25 insertions(+), 49 deletions(-)

diff --git a/src/http/api/resources/block.js b/src/http/api/resources/block.js
index 2debf2b45b..6dd1d5a524 100644
--- a/src/http/api/resources/block.js
+++ b/src/http/api/resources/block.js
@@ -36,8 +36,7 @@ exports.get = {
     try {
       block = await request.server.app.ipfs.block.get(key)
     } catch (err) {
-      log.error(err)
-      throw new Error('Failed to get block: ' + err)
+      throw Boom.boomify(err, { message: 'Failed to get block' })
     }
 
     if (!block) {
@@ -96,8 +95,7 @@ exports.put = {
         version: request.query.version && parseInt(request.query.version)
       })
     } catch (err) {
-      log.error(err)
-      throw new Error('Failed to put block: ' + err)
+      throw Boom.boomify(err, { message: 'Failed to put block' })
     }
 
     return h.response({
@@ -118,8 +116,7 @@ exports.rm = {
     try {
       await request.server.app.ipfs.block.rm(key)
     } catch (err) {
-      log.error(err)
-      throw new Error('Failed to delete block: ' + err)
+      throw Boom.boomify(err, { message: 'Failed to delete block' })
     }
 
     return h.response()
@@ -144,8 +141,7 @@ exports.stat = {
     try {
       stats = await request.server.app.ipfs.block.stat(key)
     } catch (err) {
-      log.error(err)
-      throw new Error('Failed to get block stats: ' + err)
+      throw Boom.boomify(err, { message: 'Failed to get block stats' })
     }
 
     return h.response({
diff --git a/src/http/api/resources/config.js b/src/http/api/resources/config.js
index ef0af77e68..8e36fde63d 100644
--- a/src/http/api/resources/config.js
+++ b/src/http/api/resources/config.js
@@ -65,8 +65,7 @@ exports.getOrSet = {
     try {
       originalConfig = await ipfs.config.get()
     } catch (err) {
-      log.error(err)
-      throw new Error('Failed to get config value: ' + err)
+      throw Boom.boomify(err, { message: 'Failed to get config value' })
     }
 
     if (value === undefined) {
@@ -81,8 +80,7 @@ exports.getOrSet = {
       try {
         await ipfs.config.replace(updatedConfig)
       } catch (err) {
-        log.error(err)
-        throw new Error('Failed to get config value: ' + err)
+        throw Boom.boomify(err, { message: 'Failed to get config value' })
       }
     }
 
@@ -100,8 +98,7 @@ exports.get = async (request, h) => {
   try {
     config = await ipfs.config.get()
   } catch (err) {
-    log.error(err)
-    throw new Error('Failed to get config value: ' + err)
+    throw Boom.boomify(err, { message: 'Failed to get config value' })
   }
 
   return h.response({
@@ -116,8 +113,7 @@ exports.show = async (request, h) => {
   try {
     config = await ipfs.config.get()
   } catch (err) {
-    log.error(err)
-    throw new Error('Failed to get config value: ' + err)
+    throw Boom.boomify(err, { message: 'Failed to get config value' })
   }
 
   return h.response(config)
@@ -145,8 +141,7 @@ exports.replace = {
     try {
       return { config: JSON.parse(file.toString()) }
     } catch (err) {
-      log.error(err)
-      throw new Error('Failed to decode file as config: ' + err)
+      throw Boom.boomify(err, { message: 'Failed to decode file as config' })
     }
   },
 
@@ -158,8 +153,7 @@ exports.replace = {
     try {
       await ipfs.config.replace(config)
     } catch (err) {
-      log.error(err)
-      throw new Error('Failed to save config: ' + err)
+      throw Boom.boomify(err, { message: 'Failed to save config' })
     }
 
     return h.response()
diff --git a/src/http/api/resources/files-regular.js b/src/http/api/resources/files-regular.js
index 96b711cd06..090f5fe72b 100644
--- a/src/http/api/resources/files-regular.js
+++ b/src/http/api/resources/files-regular.js
@@ -116,8 +116,7 @@ exports.get = {
     try {
       filesArray = await ipfs.get(key)
     } catch (err) {
-      log.error(err)
-      throw new Error('Failed to get key: ' + err.message)
+      throw Boom.boomify(err, { message: 'Failed to get key' })
     }
 
     Promise
@@ -292,8 +291,7 @@ exports.ls = {
     try {
       files = await ipfs.ls(key, { recursive })
     } catch (err) {
-      log.error(err)
-      throw new Error('Failed to list dir: ' + err.message)
+      throw Boom.boomify(err, { message: 'Failed to list dir' })
     }
 
     return h.response({
diff --git a/src/http/api/resources/object.js b/src/http/api/resources/object.js
index 3d597cbea4..ead1c09b34 100644
--- a/src/http/api/resources/object.js
+++ b/src/http/api/resources/object.js
@@ -48,8 +48,7 @@ exports.new = {
       cid = await ipfs.object.new(template)
       node = await ipfs.object.get(cid)
     } catch (err) {
-      log.error(err)
-      throw new Error(`Failed to create object: ${err.message}`)
+      throw Boom.boomify(err, { message: 'Failed to create object' })
     }
 
     const nodeJSON = node.toJSON()
@@ -92,8 +91,7 @@ exports.get = {
       node = await ipfs.object.get(key, { enc: enc })
       cid = await calculateCid(node)
     } catch (err) {
-      log.error(err)
-      throw new Error(`Failed to get object: ${err.message}`)
+      throw Boom.boomify(err, { message: 'Failed to get object' })
     }
 
     const nodeJSON = node.toJSON()
@@ -178,7 +176,7 @@ exports.put = {
     try {
       cid = await ipfs.object.put(node)
     } catch (err) {
-      throw new Error('Failed to put node: ' + err)
+      throw Boom.boomify(err, { message: 'Failed to put node' })
     }
 
     const nodeJSON = node.toJSON()
@@ -219,8 +217,7 @@ exports.stat = {
     try {
       stats = await ipfs.object.stat(key)
     } catch (err) {
-      log.error(err)
-      throw new Error('Failed to stat object: ' + err)
+      throw Boom.boomify(err, { message: 'Failed to stat object' })
     }
 
     stats.Hash = cidToString(stats.Hash, { base: request.query['cid-base'], upgrade: false })
@@ -242,8 +239,7 @@ exports.data = {
     try {
       data = await ipfs.object.data(key)
     } catch (err) {
-      log.error(err)
-      throw new Error('Failed to get object data: ' + err)
+      throw Boom.boomify(err, { message: 'Failed to get object data' })
     }
 
     return h.response(data)
@@ -269,8 +265,7 @@ exports.links = {
     try {
       node = await ipfs.object.get(key)
     } catch (err) {
-      log.error(err)
-      throw new Error('Failed to get object links: ' + err)
+      throw Boom.boomify(err, { message: 'Failed to get object links' })
     }
 
     const nodeJSON = node.toJSON()
@@ -341,8 +336,7 @@ exports.patchAppendData = {
       cid = await ipfs.object.patch.appendData(key, data)
       node = await ipfs.object.get(cid)
     } catch (err) {
-      log.error(err)
-      throw new Error('Failed to append data to object: ' + err)
+      throw Boom.boomify(err, { message: 'Failed to append data to object' })
     }
 
     const nodeJSON = node.toJSON()
@@ -384,8 +378,7 @@ exports.patchSetData = {
       cid = await ipfs.object.patch.setData(key, data)
       node = await ipfs.object.get(cid)
     } catch (err) {
-      log.error(err)
-      throw new Error('Failed to set data on object: ' + err)
+      throw Boom.boomify(err, { message: 'Failed to set data on object' })
     }
 
     const nodeJSON = node.toJSON()
@@ -452,8 +445,7 @@ exports.patchAddLink = {
       cid = await ipfs.object.patch.addLink(root, new DAGLink(name, node.size, ref))
       node = await ipfs.object.get(cid)
     } catch (err) {
-      log.error(err)
-      throw new Error('Failed to add link to object: ' + err)
+      throw Boom.boomify(err, { message: 'Failed to add link to object' })
     }
 
     const nodeJSON = node.toJSON()
@@ -514,8 +506,7 @@ exports.patchRmLink = {
       cid = await ipfs.object.patch.rmLink(root, { name: link })
       node = await ipfs.object.get(cid)
     } catch (err) {
-      log.error(err)
-      throw new Error('Failed to remove link from object: ' + err)
+      throw Boom.boomify(err, { message: 'Failed to remove link from object' })
     }
 
     const nodeJSON = node.toJSON()
diff --git a/src/http/api/resources/pin.js b/src/http/api/resources/pin.js
index 144786539f..a99954a958 100644
--- a/src/http/api/resources/pin.js
+++ b/src/http/api/resources/pin.js
@@ -53,8 +53,7 @@ exports.ls = {
     try {
       result = await ipfs.pin.ls(path, { type })
     } catch (err) {
-      log.error(err)
-      throw new Error(`Failed to list pins: ${err.message}`)
+      throw Boom.boomify(err, { message: 'Failed to list pins' })
     }
 
     return h.response({
@@ -83,11 +82,10 @@ exports.add = {
     try {
       result = await ipfs.pin.add(path, { recursive })
     } catch (err) {
-      log.error(err)
       if (err.message.includes('already pinned recursively')) {
         throw Boom.boomify(err, { statusCode: 400 })
       }
-      throw new Error(`Failed to add pin: ${err.message}`)
+      throw Boom.boomify(err, { message: 'Failed to add pin' })
     }
 
     return h.response({
@@ -113,8 +111,7 @@ exports.rm = {
     try {
       result = await ipfs.pin.rm(path, { recursive })
     } catch (err) {
-      log.error(err)
-      throw new Error(`Failed to remove pin: ${err.message}`)
+      throw Boom.boomify(err, { message: 'Failed to remove pin' })
     }
 
     return h.response({

From 149ec348c449ed9d11198b8c220e76c88d8e7cc8 Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Mon, 28 Jan 2019 14:03:00 +0000
Subject: [PATCH 23/49] refactor: mfs for hapi 18

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/api/routes/{files.js => files-regular.js} | 2 --
 1 file changed, 2 deletions(-)
 rename src/http/api/routes/{files.js => files-regular.js} (95%)

diff --git a/src/http/api/routes/files.js b/src/http/api/routes/files-regular.js
similarity index 95%
rename from src/http/api/routes/files.js
rename to src/http/api/routes/files-regular.js
index e9b6ed0390..581d7b7c9e 100644
--- a/src/http/api/routes/files.js
+++ b/src/http/api/routes/files-regular.js
@@ -1,7 +1,6 @@
 'use strict'
 
 const resources = require('./../resources')
-// const mfs = require('ipfs-mfs/http')
 
 module.exports = [
   {
@@ -51,5 +50,4 @@ module.exports = [
     },
     handler: resources.filesRegular.ls.handler
   }
-  // ...mfs
 ]

From 3f4e58376e9f4e63d4d430f3607485995ae1ea13 Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Mon, 28 Jan 2019 14:04:01 +0000
Subject: [PATCH 24/49] chore: remove .only

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 test/http-api/inject/config.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/http-api/inject/config.js b/test/http-api/inject/config.js
index cdc5baec02..3e647505ff 100644
--- a/test/http-api/inject/config.js
+++ b/test/http-api/inject/config.js
@@ -8,7 +8,7 @@ const streamToPromise = require('stream-to-promise')
 const path = require('path')
 
 module.exports = (http) => {
-  describe.only('/config', () => {
+  describe('/config', () => {
     const configPath = path.join(__dirname, '../../repo-tests-run/config')
     const originalConfigPath = path.join(__dirname, '../../fixtures/go-ipfs-repo/config')
 

From 4606f9d0aa83a82b1f3f778ab142e9c3936cf1d7 Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Mon, 28 Jan 2019 14:04:34 +0000
Subject: [PATCH 25/49] refactor: use hapi logger, do not repeat logs

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/error-handler.js | 6 +++---
 src/http/index.js         | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/http/error-handler.js b/src/http/error-handler.js
index 58a3608fbe..b735264efb 100644
--- a/src/http/error-handler.js
+++ b/src/http/error-handler.js
@@ -1,6 +1,6 @@
 'use strict'
 
-module.exports = (server, log) => {
+module.exports = server => {
   server.ext('onPreResponse', (request, h) => {
     const res = request.response
 
@@ -34,8 +34,8 @@ module.exports = (server, log) => {
         response: res.output.payload
       }
 
-      log(res)
-      server.log('error', debug)
+      server.logger().error(debug)
+      server.logger().error(res)
     }
 
     return h.response({
diff --git a/src/http/index.js b/src/http/index.js
index 8b892618de..bd21c822df 100644
--- a/src/http/index.js
+++ b/src/http/index.js
@@ -142,7 +142,7 @@ class HttpApi {
 
     server.route(require('./api/routes'))
 
-    errorHandler(server, this._log.error)
+    errorHandler(server)
 
     return server
   }

From 1e1777afa1b0fa94a78f6f32e6a5325702e51cc9 Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Mon, 28 Jan 2019 14:05:29 +0000
Subject: [PATCH 26/49] chore: update mfs dependency

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 396e4558c5..5d8a65d014 100644
--- a/package.json
+++ b/package.json
@@ -110,7 +110,7 @@
     "ipfs-block-service": "~0.15.1",
     "ipfs-http-client": "^29.0.0",
     "ipfs-http-response": "~0.2.1",
-    "ipfs-mfs": "~0.8.0",
+    "ipfs-mfs": "github:ipfs/js-ipfs-mfs#refactor/hapi-18",
     "ipfs-multipart": "~0.1.0",
     "ipfs-repo": "~0.26.1",
     "ipfs-unixfs": "~0.1.16",

From a2c8fa012a8737f577167ace2043c17aef91d0ad Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Mon, 28 Jan 2019 14:05:51 +0000
Subject: [PATCH 27/49] refactor: /api/v0/ping for hapi 18

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/api/resources/ping.js | 68 +++++++++++++++-------------------
 src/http/api/routes/index.js   |  5 ++-
 src/http/api/routes/ping.js    | 18 ++++-----
 test/http-api/inject/ping.js   | 29 +++++++--------
 4 files changed, 52 insertions(+), 68 deletions(-)

diff --git a/src/http/api/resources/ping.js b/src/http/api/resources/ping.js
index 56b54b3c05..ef5056cea0 100644
--- a/src/http/api/resources/ping.js
+++ b/src/http/api/resources/ping.js
@@ -2,12 +2,13 @@
 
 const Joi = require('joi')
 const pull = require('pull-stream')
-const toStream = require('pull-stream-to-stream')
 const ndjson = require('pull-ndjson')
-const PassThrough = require('readable-stream').PassThrough
-const pump = require('pump')
+const { PassThrough } = require('readable-stream')
+const debug = require('debug')
+const log = debug('jsipfs:http-api:ping')
+log.error = debug('jsipfs:http-api:ping:error')
 
-exports.get = {
+module.exports = {
   validate: {
     query: Joi.object().keys({
       n: Joi.alternatives()
@@ -20,47 +21,36 @@ exports.get = {
       arg: Joi.string().required()
     }).unknown()
   },
-  handler: (request, reply) => {
-    const ipfs = request.server.app.ipfs
+  async handler (request, h) {
+    const { ipfs } = request.server.app
     const peerId = request.query.arg
 
     // Default count to 10
     const count = request.query.n || request.query.count || 10
 
-    // Streams from pull-stream-to-stream don't seem to be compatible
-    // with the stream2 readable interface
-    // see: https://github.com/hapijs/hapi/blob/c23070a3de1b328876d5e64e679a147fafb04b38/lib/response.js#L533
-    // and: https://github.com/pull-stream/pull-stream-to-stream/blob/e436acee18b71af8e71d1b5d32eee642351517c7/index.js#L28
-
-    const source = pull(
-      ipfs.pingPullStream(peerId, { count: count }),
-      pull.map((chunk) => ({
-        Success: chunk.success,
-        Time: chunk.time,
-        Text: chunk.text
-      })),
-      ndjson.serialize()
-    )
-
-    const responseStream = toStream.source(source)
-    const stream2 = new PassThrough()
-    let replied = false
-    pump(responseStream, stream2)
-
-    // FIXME: This is buffering all ping responses before sending them so that
-    // we can capture the error if it happens. #fixTheHTTPAPI
-    responseStream.on('error', (err) => {
-      if (!replied) {
-        replied = true
-        reply(err)
-      }
+    const responseStream = await new Promise((resolve, reject) => {
+      const stream = new PassThrough()
+
+      pull(
+        ipfs.pingPullStream(peerId, { count }),
+        pull.map((chunk) => ({
+          Success: chunk.success,
+          Time: chunk.time,
+          Text: chunk.text
+        })),
+        ndjson.serialize(),
+        pull.drain(chunk => {
+          stream.write(chunk)
+        }, err => {
+          if (err) return reject(err)
+          resolve(stream)
+          stream.end()
+        })
+      )
     })
 
-    responseStream.on('end', () => {
-      if (!replied) {
-        replied = true
-        reply(stream2).type('application/json').header('X-Chunked-Output', '1')
-      }
-    })
+    return h.response(responseStream)
+      .type('application/json')
+      .header('X-Chunked-Output', '1')
   }
 }
diff --git a/src/http/api/routes/index.js b/src/http/api/routes/index.js
index 3d0bd75a01..de3a837ca3 100644
--- a/src/http/api/routes/index.js
+++ b/src/http/api/routes/index.js
@@ -10,11 +10,12 @@ module.exports = [
   ...require('./pin'),
   ...require('./repo'),
   ...require('./config'),
-  // require('./ping')(server)
+  require('./ping'),
   // require('./swarm')(server)
   // require('./bitswap')(server)
   // require('./file')(server)
-  ...require('./files')
+  ...require('./files-regular'),
+  ...require('ipfs-mfs/http')
   // require('./pubsub')(server)
   // require('./debug')(server)
   // require('./webui')(server)
diff --git a/src/http/api/routes/ping.js b/src/http/api/routes/ping.js
index 92b081862f..3d84ee39fe 100644
--- a/src/http/api/routes/ping.js
+++ b/src/http/api/routes/ping.js
@@ -2,15 +2,11 @@
 
 const resources = require('./../resources')
 
-module.exports = (server) => {
-  const api = server.select('API')
-
-  api.route({
-    method: '*',
-    path: '/api/v0/ping',
-    config: {
-      handler: resources.ping.get.handler,
-      validate: resources.ping.get.validate
-    }
-  })
+module.exports = {
+  method: '*',
+  path: '/api/v0/ping',
+  config: {
+    handler: resources.ping.handler,
+    validate: resources.ping.validate
+  }
 }
diff --git a/test/http-api/inject/ping.js b/test/http-api/inject/ping.js
index 42759c38f3..1d3519e3d0 100644
--- a/test/http-api/inject/ping.js
+++ b/test/http-api/inject/ping.js
@@ -13,37 +13,34 @@ module.exports = (http) => {
     let api
 
     before(() => {
-      api = http.api.server.select('API')
+      api = http.api._apiServer
     })
 
-    it('returns 400 if both n and count are provided', (done) => {
-      api.inject({
+    it('returns 400 if both n and count are provided', async () => {
+      const res = await api.inject({
         method: 'GET',
         url: `/api/v0/ping?arg=peerid&n=1&count=1`
-      }, (res) => {
-        expect(res.statusCode).to.equal(400)
-        done()
       })
+
+      expect(res.statusCode).to.equal(400)
     })
 
-    it('returns 400 if arg is not provided', (done) => {
-      api.inject({
+    it('returns 400 if arg is not provided', async () => {
+      const res = await api.inject({
         method: 'GET',
         url: `/api/v0/ping?count=1`
-      }, (res) => {
-        expect(res.statusCode).to.equal(400)
-        done()
       })
+
+      expect(res.statusCode).to.equal(400)
     })
 
-    it('returns 500 for incorrect Peer Id', (done) => {
-      api.inject({
+    it('returns 500 for incorrect Peer Id', async () => {
+      const res = await api.inject({
         method: 'GET',
         url: `/api/v0/ping?arg=peerid`
-      }, (res) => {
-        expect(res.statusCode).to.equal(500)
-        done()
       })
+
+      expect(res.statusCode).to.equal(500)
     })
   })
 }

From 4ee90b6f75533064ae863e9946d27f9ed09577d8 Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Mon, 28 Jan 2019 14:27:35 +0000
Subject: [PATCH 28/49] refactor: /api/v0/swarm* for hapi 18

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/api/resources/swarm.js | 165 +++++++++++---------------------
 src/http/api/routes/index.js    |   2 +-
 src/http/api/routes/swarm.js    |  67 +++++--------
 3 files changed, 83 insertions(+), 151 deletions(-)

diff --git a/src/http/api/resources/swarm.js b/src/http/api/resources/swarm.js
index 918f7c8ba3..7487c4d503 100644
--- a/src/http/api/resources/swarm.js
+++ b/src/http/api/resources/swarm.js
@@ -1,111 +1,74 @@
 'use strict'
 
-const debug = require('debug')
-const log = debug('jsipfs:http-api:block')
-log.error = debug('jsipfs:http-api:block:error')
 const multiaddr = require('multiaddr')
-
-exports = module.exports
+const Boom = require('boom')
 
 // common pre request handler that parses the args and returns `addr` which is assigned to `request.pre.args`
-exports.parseAddrs = (request, reply) => {
+exports.parseAddrs = (request, h) => {
   if (!request.query.arg) {
-    const err = 'Argument `addr` is required'
-    log.error(err)
-    return reply({
-      Code: 0,
-      Message: err
-    }).code(400).takeover()
+    throw Boom.badRequest('Argument `addr` is required')
   }
 
   try {
     multiaddr(request.query.arg)
   } catch (err) {
-    log.error(err)
-    return reply({
-      Code: 0,
-      Message: err.message
-    }).code(500).takeover()
+    throw Boom.boomify(err, { statusCode: 400 })
   }
 
-  return reply({
+  return {
     addr: request.query.arg
-  })
+  }
 }
 
 exports.peers = {
-  handler: (request, reply) => {
+  async handler (request, h) {
     const rawVerbose = request.query.v || request.query.verbose
     const verbose = rawVerbose === 'true'
-    const ipfs = request.server.app.ipfs
-
-    ipfs.swarm.peers({ verbose: verbose }, (err, peers) => {
-      if (err) {
-        log.error(err)
-        return reply({
-          Message: err.toString(),
-          Code: 0
-        }).code(500)
-      }
-
-      return reply({
-        Peers: peers.map((p) => {
-          const res = {
-            Peer: p.peer.toB58String(),
-            Addr: p.addr.toString()
-          }
-
-          if (verbose) {
-            res.Latency = p.latency
-          }
-
-          return res
-        })
+    const { ipfs } = request.server.app
+
+    const peers = await ipfs.swarm.peers({ verbose })
+
+    return h.response({
+      Peers: peers.map((p) => {
+        const res = {
+          Peer: p.peer.toB58String(),
+          Addr: p.addr.toString()
+        }
+
+        if (verbose) {
+          res.Latency = p.latency
+        }
+
+        return res
       })
     })
   }
 }
 
 exports.addrs = {
-  handler: (request, reply) => {
-    const ipfs = request.server.app.ipfs
-    ipfs.swarm.addrs((err, peers) => {
-      if (err) {
-        log.error(err)
-        return reply({
-          Message: err.toString(),
-          Code: 0
-        }).code(500)
-      }
-
-      const addrs = {}
-      peers.forEach((peer) => {
-        addrs[peer.id.toB58String()] = peer.multiaddrs.toArray()
-          .map((addr) => addr.toString())
-      })
+  async handler (request, h) {
+    const { ipfs } = request.server.app
+    const peers = await ipfs.swarm.addrs()
+
+    const addrs = {}
+    peers.forEach((peer) => {
+      addrs[peer.id.toB58String()] = peer.multiaddrs.toArray()
+        .map((addr) => addr.toString())
+    })
 
-      return reply({
-        Addrs: addrs
-      })
+    return h.response({
+      Addrs: addrs
     })
   }
 }
 
 exports.localAddrs = {
-  handler: (request, reply) => {
-    const ipfs = request.server.app.ipfs
-    ipfs.swarm.localAddrs((err, addrs) => {
-      if (err) {
-        log.error(err)
-        return reply({
-          Message: err.toString(),
-          Code: 0
-        }).code(500)
-      }
-
-      return reply({
-        Strings: addrs.map((addr) => addr.toString())
-      })
+  async handler (request, h) {
+    const { ipfs } = request.server.app
+    const addrs = await ipfs.swarm.localAddrs()
+
+    return h.response({
+      Strings: addrs.map((addr) => addr.toString())
     })
   }
 }
@@ -115,22 +78,14 @@ exports.connect = {
   parseArgs: exports.parseAddrs,
 
   // main route handler which is called after the above `parseArgs`, but only if the args were valid
-  handler: (request, reply) => {
-    const addr = request.pre.args.addr
-    const ipfs = request.server.app.ipfs
-
-    ipfs.swarm.connect(addr, (err) => {
-      if (err) {
-        log.error(err)
-        return reply({
-          Message: err.toString(),
-          Code: 0
-        }).code(500)
-      }
-
-      reply({
-        Strings: [`connect ${addr} success`]
-      })
+  async handler (request, h) {
+    const { addr } = request.pre.args
+    const { ipfs } = request.server.app
+
+    await ipfs.swarm.connect(addr)
+
+    return h.response({
+      Strings: [`connect ${addr} success`]
     })
   }
 }
@@ -140,22 +95,14 @@ exports.disconnect = {
   parseArgs: exports.parseAddrs,
 
   // main route handler which is called after the above `parseArgs`, but only if the args were valid
-  handler: (request, reply) => {
-    const addr = request.pre.args.addr
-    const ipfs = request.server.app.ipfs
-
-    ipfs.swarm.disconnect(addr, (err) => {
-      if (err) {
-        log.error(err)
-        return reply({
-          Message: err.toString(),
-          Code: 0
-        }).code(500)
-      }
-
-      return reply({
-        Strings: [`disconnect ${addr} success`]
-      })
+  async handler (request, h) {
+    const { addr } = request.pre.args
+    const { ipfs } = request.server.app
+
+    await ipfs.swarm.disconnect(addr)
+
+    return h.response({
+      Strings: [`disconnect ${addr} success`]
     })
   }
 }
diff --git a/src/http/api/routes/index.js b/src/http/api/routes/index.js
index de3a837ca3..ba1e11301b 100644
--- a/src/http/api/routes/index.js
+++ b/src/http/api/routes/index.js
@@ -11,7 +11,7 @@ module.exports = [
   ...require('./repo'),
   ...require('./config'),
   require('./ping'),
-  // require('./swarm')(server)
+  ...require('./swarm'),
   // require('./bitswap')(server)
   // require('./file')(server)
   ...require('./files-regular'),
diff --git a/src/http/api/routes/swarm.js b/src/http/api/routes/swarm.js
index 0667acded4..62fd7ee9d7 100644
--- a/src/http/api/routes/swarm.js
+++ b/src/http/api/routes/swarm.js
@@ -2,61 +2,46 @@
 
 const resources = require('./../resources')
 
-module.exports = (server) => {
-  const api = server.select('API')
-
-  api.route({
+module.exports = [
+  {
     method: '*',
     path: '/api/v0/swarm/peers',
-    config: {
-      handler: resources.swarm.peers.handler
-    }
-  })
-
-  api.route({
+    handler: resources.swarm.peers.handler
+  },
+  {
     method: '*',
     path: '/api/v0/swarm/addrs',
-    config: {
-      handler: resources.swarm.addrs.handler
-    }
-  })
-
-  api.route({
+    handler: resources.swarm.addrs.handler
+  },
+  {
     method: '*',
     path: '/api/v0/swarm/addrs/local',
-    config: {
-      handler: resources.swarm.localAddrs.handler
-    }
-  })
-
-  api.route({
+    handler: resources.swarm.localAddrs.handler
+  },
+  {
     method: '*',
     path: '/api/v0/swarm/connect',
-    config: {
+    options: {
       pre: [
         { method: resources.swarm.connect.parseArgs, assign: 'args' }
-      ],
-      handler: resources.swarm.connect.handler
-    }
-  })
-
-  api.route({
+      ]
+    },
+    handler: resources.swarm.connect.handler
+  },
+  {
     method: '*',
     path: '/api/v0/swarm/disconnect',
-    config: {
+    options: {
       pre: [
         { method: resources.swarm.disconnect.parseArgs, assign: 'args' }
-      ],
-      handler: resources.swarm.disconnect.handler
-    }
-  })
-
+      ]
+    },
+    handler: resources.swarm.disconnect.handler
+  }
   // TODO
-  // api.route({
+  // {
   //  method: '*',
   //  path: '/api/v0/swarm/filters',
-  //  config: {
-  //    handler: resources.swarm.disconnect
-  //  }
-  // })
-}
+  //  handler: resources.swarm.disconnect
+  // }
+]

From 63c6c5f936acce3cc99790cb33c26eb9788b6b52 Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Mon, 28 Jan 2019 15:37:17 +0000
Subject: [PATCH 29/49] refactor: /api/v0/bitswap* for hapi 18

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/api/resources/bitswap.js |  74 ++++++++-----------
 src/http/api/routes/bitswap.js    |  38 +++++-----
 src/http/api/routes/index.js      |   2 +-
 src/http/error-handler.js         |   2 +
 test/http-api/inject/bitswap.js   | 114 ++++++++++++++----------------
 test/utils/wait-for.js            |  19 +++++
 6 files changed, 123 insertions(+), 126 deletions(-)

diff --git a/src/http/api/resources/bitswap.js b/src/http/api/resources/bitswap.js
index 9028fce698..8dcc13c51b 100644
--- a/src/http/api/resources/bitswap.js
+++ b/src/http/api/resources/bitswap.js
@@ -1,12 +1,9 @@
 'use strict'
 
-const boom = require('boom')
 const Joi = require('joi')
 const multibase = require('multibase')
 const { cidToString } = require('../../../utils/cid')
-const parseKey = require('./block').parseKey
-
-exports = module.exports
+const { parseKey } = require('./block')
 
 exports.wantlist = {
   validate: {
@@ -15,19 +12,17 @@ exports.wantlist = {
     }).unknown()
   },
 
-  handler: (request, reply) => {
+  async handler (request, h) {
+    const { ipfs } = request.server.app
     const peerId = request.query.peer
     const cidBase = request.query['cid-base']
 
-    request.server.app.ipfs.bitswap.wantlist(peerId, (err, list) => {
-      if (err) {
-        return reply(boom.badRequest(err))
-      }
-      reply({
-        Keys: list.Keys.map(k => ({
-          '/': cidToString(k['/'], { base: cidBase, upgrade: false })
-        }))
-      })
+    const list = await ipfs.bitswap.wantlist(peerId)
+
+    return h.response({
+      Keys: list.Keys.map(k => ({
+        '/': cidToString(k['/'], { base: cidBase, upgrade: false })
+      }))
     })
   }
 }
@@ -39,33 +34,26 @@ exports.stat = {
     }).unknown()
   },
 
-  handler: (request, reply) => {
-    const ipfs = request.server.app.ipfs
+  async handler (request, h) {
+    const { ipfs } = request.server.app
     const cidBase = request.query['cid-base']
 
-    ipfs.bitswap.stat((err, stats) => {
-      if (err) {
-        return reply({
-          Message: err.toString(),
-          Code: 0
-        }).code(500)
-      }
+    const stats = await ipfs.bitswap.stat()
 
-      stats.wantlist = stats.wantlist.map(k => ({
-        '/': cidToString(k['/'], { base: cidBase, upgrade: false })
-      }))
+    stats.wantlist = stats.wantlist.map(k => ({
+      '/': cidToString(k['/'], { base: cidBase, upgrade: false })
+    }))
 
-      reply({
-        ProvideBufLen: stats.provideBufLen,
-        BlocksReceived: stats.blocksReceived,
-        Wantlist: stats.wantlist,
-        Peers: stats.peers,
-        DupBlksReceived: stats.dupBlksReceived,
-        DupDataReceived: stats.dupDataReceived,
-        DataReceived: stats.dataReceived,
-        BlocksSent: stats.blocksSent,
-        DataSent: stats.dataSent
-      })
+    return h.response({
+      ProvideBufLen: stats.provideBufLen,
+      BlocksReceived: stats.blocksReceived,
+      Wantlist: stats.wantlist,
+      Peers: stats.peers,
+      DupBlksReceived: stats.dupBlksReceived,
+      DupDataReceived: stats.dupDataReceived,
+      DataReceived: stats.dataReceived,
+      BlocksSent: stats.blocksSent,
+      DataSent: stats.dataSent
     })
   }
 }
@@ -81,14 +69,10 @@ exports.unwant = {
   parseArgs: parseKey,
 
   // main route handler which is called after the above `parseArgs`, but only if the args were valid
-  handler: (request, reply) => {
+  async handler (request, h) {
     const key = request.pre.args.key
-    const ipfs = request.server.app.ipfs
-    ipfs.bitswap.unwant(key, (err) => {
-      if (err) {
-        return reply(boom.badRequest(err))
-      }
-      reply({ key: cidToString(key, { base: request.query['cid-base'], upgrade: false }) })
-    })
+    const { ipfs } = request.server.app
+    await ipfs.bitswap.unwant(key)
+    return h.response({ key: cidToString(key, { base: request.query['cid-base'], upgrade: false }) })
   }
 }
diff --git a/src/http/api/routes/bitswap.js b/src/http/api/routes/bitswap.js
index 45be830b6d..c4a942aeac 100644
--- a/src/http/api/routes/bitswap.js
+++ b/src/http/api/routes/bitswap.js
@@ -2,36 +2,32 @@
 
 const resources = require('./../resources')
 
-module.exports = (server) => {
-  const api = server.select('API')
-
-  api.route({
+module.exports = [
+  {
     method: '*',
     path: '/api/v0/bitswap/wantlist',
-    config: {
-      handler: resources.bitswap.wantlist.handler,
+    options: {
       validate: resources.bitswap.wantlist.validate
-    }
-  })
-
-  api.route({
+    },
+    handler: resources.bitswap.wantlist.handler
+  },
+  {
     method: '*',
     path: '/api/v0/bitswap/stat',
-    config: {
-      handler: resources.bitswap.stat.handler,
+    options: {
       validate: resources.bitswap.stat.validate
-    }
-  })
-
-  api.route({
+    },
+    handler: resources.bitswap.stat.handler
+  },
+  {
     method: '*',
     path: '/api/v0/bitswap/unwant',
-    config: {
+    options: {
       pre: [
         { method: resources.bitswap.unwant.parseArgs, assign: 'args' }
       ],
-      handler: resources.bitswap.unwant.handler,
       validate: resources.bitswap.unwant.validate
-    }
-  })
-}
+    },
+    handler: resources.bitswap.unwant.handler
+  }
+]
diff --git a/src/http/api/routes/index.js b/src/http/api/routes/index.js
index ba1e11301b..30b5340d7c 100644
--- a/src/http/api/routes/index.js
+++ b/src/http/api/routes/index.js
@@ -12,7 +12,7 @@ module.exports = [
   ...require('./config'),
   require('./ping'),
   ...require('./swarm'),
-  // require('./bitswap')(server)
+  ...require('./bitswap'),
   // require('./file')(server)
   ...require('./files-regular'),
   ...require('ipfs-mfs/http')
diff --git a/src/http/error-handler.js b/src/http/error-handler.js
index b735264efb..ad2afb6326 100644
--- a/src/http/error-handler.js
+++ b/src/http/error-handler.js
@@ -34,6 +34,8 @@ module.exports = server => {
         response: res.output.payload
       }
 
+      console.log(res)
+
       server.logger().error(debug)
       server.logger().error(res)
     }
diff --git a/test/http-api/inject/bitswap.js b/test/http-api/inject/bitswap.js
index e91f80293e..c8a1d0568c 100644
--- a/test/http-api/inject/bitswap.js
+++ b/test/http-api/inject/bitswap.js
@@ -3,7 +3,7 @@
 
 const expect = require('chai').expect
 const CID = require('cids')
-const waitFor = require('../../utils/wait-for')
+const waitFor = require('../../utils/wait-for').promises
 
 module.exports = (http) => {
   describe('/bitswap', () => {
@@ -12,111 +12,107 @@ module.exports = (http) => {
     let api
 
     before(() => {
-      api = http.api.server.select('API')
+      api = http.api._apiServer
     })
 
-    before(function (done) {
+    before(async function () {
       this.timeout(120 * 1000)
 
       // Add a CID to the wantlist
       api.inject({ method: 'GET', url: `/api/v0/block/get?arg=${wantedCid0}` })
       api.inject({ method: 'GET', url: `/api/v0/block/get?arg=${wantedCid1}` })
 
-      const test = (cb) => {
-        api.inject({
+      const test = async () => {
+        const res = await api.inject({
           method: 'GET',
           url: '/api/v0/bitswap/wantlist'
-        }, (res) => {
-          if (res.statusCode !== 200) {
-            return cb(new Error(`unexpected status ${res.statusCode}`))
-          }
-          const isWanted0 = res.result.Keys.some(k => k['/'] === wantedCid0)
-          const isWanted1 = res.result.Keys.some(k => k['/'] === wantedCid1)
-          cb(null, isWanted0 && isWanted1)
         })
+
+        if (res.statusCode !== 200) {
+          throw new Error(`unexpected status ${res.statusCode}`)
+        }
+
+        const isWanted0 = res.result.Keys.some(k => k['/'] === wantedCid0)
+        const isWanted1 = res.result.Keys.some(k => k['/'] === wantedCid1)
+
+        return isWanted0 && isWanted1
       }
 
-      waitFor(test, {
+      return waitFor(test, {
         name: `${wantedCid0} and ${wantedCid1} to be wanted`,
         timeout: 60 * 1000
-      }, done)
+      })
     })
 
-    it('/wantlist', (done) => {
-      api.inject({
+    it('/wantlist', async () => {
+      const res = await api.inject({
         method: 'GET',
         url: '/api/v0/bitswap/wantlist'
-      }, (res) => {
-        expect(res.statusCode).to.equal(200)
-        expect(res.result).to.have.property('Keys')
-        expect(res.result.Keys).to.deep.include({ '/': wantedCid0 })
-        done()
       })
+
+      expect(res.statusCode).to.equal(200)
+      expect(res.result).to.have.property('Keys')
+      expect(res.result.Keys).to.deep.include({ '/': wantedCid0 })
     })
 
-    it('/wantlist?cid-base=base64', (done) => {
+    it('/wantlist?cid-base=base64', async () => {
       const base64Cid = new CID(wantedCid1).toString('base64')
-      api.inject({
+      const res = await api.inject({
         method: 'GET',
         url: '/api/v0/bitswap/wantlist?cid-base=base64'
-      }, (res) => {
-        expect(res.statusCode).to.equal(200)
-        expect(res.result.Keys).to.deep.include({ '/': base64Cid })
-        done()
       })
+
+      expect(res.statusCode).to.equal(200)
+      expect(res.result.Keys).to.deep.include({ '/': base64Cid })
     })
 
-    it('/wantlist?cid-base=invalid', (done) => {
-      api.inject({
+    it('/wantlist?cid-base=invalid', async () => {
+      const res = await api.inject({
         method: 'GET',
         url: '/api/v0/bitswap/wantlist?cid-base=invalid'
-      }, (res) => {
-        expect(res.statusCode).to.equal(400)
-        expect(res.result.Message).to.include('child "cid-base" fails')
-        done()
       })
+
+      expect(res.statusCode).to.equal(400)
+      expect(res.result.Message).to.include('Invalid request query input')
     })
 
-    it('/stat', (done) => {
-      api.inject({
+    it('/stat', async () => {
+      const res = await api.inject({
         method: 'GET',
         url: '/api/v0/bitswap/stat'
-      }, (res) => {
-        expect(res.statusCode).to.equal(200)
-        expect(res.result).to.have.property('ProvideBufLen')
-        expect(res.result).to.have.property('BlocksReceived')
-        expect(res.result).to.have.property('Wantlist')
-        expect(res.result).to.have.property('Peers')
-        expect(res.result).to.have.property('DupBlksReceived')
-        expect(res.result).to.have.property('DupDataReceived')
-        expect(res.result).to.have.property('DataReceived')
-        expect(res.result).to.have.property('BlocksSent')
-        expect(res.result).to.have.property('DataSent')
-        done()
       })
+
+      expect(res.statusCode).to.equal(200)
+      expect(res.result).to.have.property('ProvideBufLen')
+      expect(res.result).to.have.property('BlocksReceived')
+      expect(res.result).to.have.property('Wantlist')
+      expect(res.result).to.have.property('Peers')
+      expect(res.result).to.have.property('DupBlksReceived')
+      expect(res.result).to.have.property('DupDataReceived')
+      expect(res.result).to.have.property('DataReceived')
+      expect(res.result).to.have.property('BlocksSent')
+      expect(res.result).to.have.property('DataSent')
     })
 
-    it('/stat?cid-base=base64', (done) => {
+    it('/stat?cid-base=base64', async () => {
       const base64Cid = new CID(wantedCid1).toString('base64')
-      api.inject({
+      const res = await api.inject({
         method: 'GET',
         url: '/api/v0/bitswap/stat?cid-base=base64'
-      }, (res) => {
-        expect(res.statusCode).to.equal(200)
-        expect(res.result.Wantlist).to.deep.include({ '/': base64Cid })
-        done()
       })
+
+      expect(res.statusCode).to.equal(200)
+      expect(res.result.Wantlist).to.deep.include({ '/': base64Cid })
     })
 
-    it('/stat?cid-base=invalid', (done) => {
-      api.inject({
+    it('/stat?cid-base=invalid', async () => {
+      const res = await api.inject({
         method: 'GET',
         url: '/api/v0/bitswap/stat?cid-base=invalid'
-      }, (res) => {
-        expect(res.statusCode).to.equal(400)
-        expect(res.result.Message).to.include('child "cid-base" fails')
-        done()
       })
+
+      expect(res.statusCode).to.equal(400)
+      expect(res.result.Message).to.include('Invalid request query input')
     })
   })
 }
diff --git a/test/utils/wait-for.js b/test/utils/wait-for.js
index 9e0ee39edd..d610a455e2 100644
--- a/test/utils/wait-for.js
+++ b/test/utils/wait-for.js
@@ -35,3 +35,22 @@ module.exports = function waitFor (test, options, callback) {
 
   check()
 }
+
+module.exports.promises = async (test, options) => {
+  options = Object.assign({ timeout: 5000, interval: 0, name: 'event' }, options)
+  const start = Date.now()
+
+  while (true) {
+    const arrived = await test()
+
+    if (arrived) {
+      return
+    }
+
+    if (Date.now() > start + options.timeout) {
+      throw new Error(`Timed out waiting for ${options.name}`)
+    }
+
+    await new Promise(resolve => setTimeout(resolve, options.interval))
+  }
+}

From 10d6b733b65cf29511c0eb6ea17c2fb03ea3bd1c Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Mon, 28 Jan 2019 15:39:59 +0000
Subject: [PATCH 30/49] refactor: use pretty print unless in production env

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/index.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/http/index.js b/src/http/index.js
index bd21c822df..493725f956 100644
--- a/src/http/index.js
+++ b/src/http/index.js
@@ -116,7 +116,7 @@ class HttpApi {
     await server.register({
       plugin: Pino,
       options: {
-        prettyPrint: Boolean(process.env.DEBUG),
+        prettyPrint: process.env.NODE_ENV === 'production',
         logEvents: ['onPostStart', 'onPostStop', 'response', 'request-error'],
         level: process.env.DEBUG ? 'debug' : 'error'
       }

From 9707d9443f57413bee79b6e8cd0699e34e02e66c Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Mon, 28 Jan 2019 15:40:32 +0000
Subject: [PATCH 31/49] refactor: use pretty print unless in production env

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/index.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/http/index.js b/src/http/index.js
index 493725f956..ab5811835f 100644
--- a/src/http/index.js
+++ b/src/http/index.js
@@ -116,7 +116,7 @@ class HttpApi {
     await server.register({
       plugin: Pino,
       options: {
-        prettyPrint: process.env.NODE_ENV === 'production',
+        prettyPrint: process.env.NODE_ENV !== 'production',
         logEvents: ['onPostStart', 'onPostStop', 'response', 'request-error'],
         level: process.env.DEBUG ? 'debug' : 'error'
       }

From 16ef0d89ba3020fff877b69491728e4ffd7acff1 Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Mon, 28 Jan 2019 15:52:54 +0000
Subject: [PATCH 32/49] refactor: /api/v0/file/ls for hapi 18

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/api/resources/file.js | 87 +++++++++++++++-------------------
 src/http/api/routes/file.js    | 24 ++++------
 src/http/api/routes/index.js   |  2 +-
 3 files changed, 48 insertions(+), 65 deletions(-)

diff --git a/src/http/api/resources/file.js b/src/http/api/resources/file.js
index b786bebc19..5f10e5ac3e 100644
--- a/src/http/api/resources/file.js
+++ b/src/http/api/resources/file.js
@@ -1,13 +1,11 @@
 'use strict'
 
-const mh = require('multihashes')
-const debug = require('debug')
-const log = debug('jsipfs:http-api:file')
-log.error = debug('jsipfs:http-api:file:error')
+const isIpfs = require('is-ipfs')
 const unixfsEngine = require('ipfs-unixfs-engine')
 const exporter = unixfsEngine.exporter
 const pull = require('pull-stream')
 const toB58String = require('multihashes').toB58String
+const Boom = require('boom')
 
 exports = module.exports
 
@@ -29,12 +27,9 @@ function toFileObject (file) {
 }
 
 // common pre request handler that parses the args and returns `key` which is assigned to `request.pre.args`
-exports.parseKey = (request, reply) => {
+exports.parseKey = (request, h) => {
   if (!request.query.arg) {
-    return reply({
-      Message: "Argument 'key' is required",
-      Code: 0
-    }).code(400).takeover()
+    throw Boom.badRequest("Argument 'key' is required")
   }
 
   let key = request.query.arg
@@ -48,24 +43,18 @@ exports.parseKey = (request, reply) => {
     hash = hash.substring(0, slashIndex)
   }
 
-  try {
-    mh.fromB58String(hash)
-  } catch (err) {
-    log.error(err)
-    return reply({
-      Message: 'invalid ipfs ref path',
-      Code: 0
-    }).code(500).takeover()
+  if (!isIpfs.ipfsPath(request.query.arg) && !isIpfs.cid(request.query.arg)) {
+    throw Boom.badRequest('invalid ipfs ref path')
   }
 
   const subpaths = key.split('/')
   subpaths.shift()
-  reply({
+  return {
     path: request.query.arg,
     subpaths: subpaths,
     key: key,
     hash: hash
-  })
+  }
 }
 
 exports.ls = {
@@ -73,39 +62,37 @@ exports.ls = {
   parseArgs: exports.parseKey,
 
   // main route handler which is called after the above `parseArgs`, but only if the args were valid
-  handler: (request, reply) => {
-    const path = request.pre.args.path
-    const ipfs = request.server.app.ipfs
-    const subpaths = request.pre.args.subpaths
+  async handler (request, h) {
+    const { ipfs } = request.server.app
+    const { path, subpaths } = request.pre.args.path
     const rootDepth = subpaths.length
 
-    pull(
-      exporter(path, ipfs._ipld, { maxDepth: rootDepth + 1 }),
-      pull.collect((err, files) => {
-        if (err) {
-          return reply({
-            Message: 'Failed to list dir: ' + err.message,
-            Code: 0
-          }).code(500)
-        }
-
-        let res = {
-          Arguments: {},
-          Objects: {}
-        }
-        const links = []
-        files.forEach((file) => {
-          if (file.depth === rootDepth) {
-            let id = toB58String(file.hash)
-            res.Arguments[path] = id
-            res.Objects[id] = toFileObject(file)
-            res.Objects[id].Links = file.type === 'file' ? null : links
-          } else {
-            links.push(toFileObject(file))
-          }
+    const files = await new Promise((resolve, reject) => {
+      pull(
+        exporter(path, ipfs._ipld, { maxDepth: rootDepth + 1 }),
+        pull.collect((err, files) => {
+          if (err) return reject(err)
+          resolve(files)
         })
-        return reply(res)
-      })
-    )
+      )
+    })
+
+    const res = {
+      Arguments: {},
+      Objects: {}
+    }
+    const links = []
+    files.forEach((file) => {
+      if (file.depth === rootDepth) {
+        const id = toB58String(file.hash)
+        res.Arguments[path] = id
+        res.Objects[id] = toFileObject(file)
+        res.Objects[id].Links = file.type === 'file' ? null : links
+      } else {
+        links.push(toFileObject(file))
+      }
+    })
+
+    return h.response(res)
   }
 }
diff --git a/src/http/api/routes/file.js b/src/http/api/routes/file.js
index 1abf7456b2..f8d86f8e3b 100644
--- a/src/http/api/routes/file.js
+++ b/src/http/api/routes/file.js
@@ -2,18 +2,14 @@
 
 const resources = require('./../resources')
 
-module.exports = (server) => {
-  const api = server.select('API')
-
-  api.route({
-    // TODO fix method
-    method: '*',
-    path: '/api/v0/file/ls',
-    config: {
-      pre: [
-        { method: resources.file.ls.parseArgs, assign: 'args' }
-      ],
-      handler: resources.file.ls.handler
-    }
-  })
+module.exports = {
+  // TODO fix method
+  method: '*',
+  path: '/api/v0/file/ls',
+  config: {
+    pre: [
+      { method: resources.file.ls.parseArgs, assign: 'args' }
+    ]
+  },
+  handler: resources.file.ls.handler
 }
diff --git a/src/http/api/routes/index.js b/src/http/api/routes/index.js
index 30b5340d7c..48858c69ab 100644
--- a/src/http/api/routes/index.js
+++ b/src/http/api/routes/index.js
@@ -13,7 +13,7 @@ module.exports = [
   require('./ping'),
   ...require('./swarm'),
   ...require('./bitswap'),
-  // require('./file')(server)
+  require('./file'),
   ...require('./files-regular'),
   ...require('ipfs-mfs/http')
   // require('./pubsub')(server)

From ade3f09b747f3cb02ed4be7dca3659b528d33df9 Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Mon, 28 Jan 2019 16:23:28 +0000
Subject: [PATCH 33/49] refactor: /api/v0/pubsub* for hapi 18

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/api/resources/pubsub.js | 85 ++++++++++++++++----------------
 src/http/api/routes/index.js     |  4 +-
 src/http/api/routes/pubsub.js    | 41 ++++++---------
 test/http-api/inject/pubsub.js   | 78 ++++++++++++++---------------
 4 files changed, 95 insertions(+), 113 deletions(-)

diff --git a/src/http/api/resources/pubsub.js b/src/http/api/resources/pubsub.js
index 82d8daabe4..b9cf8aed40 100644
--- a/src/http/api/resources/pubsub.js
+++ b/src/http/api/resources/pubsub.js
@@ -3,20 +3,21 @@
 const PassThrough = require('stream').PassThrough
 const bs58 = require('bs58')
 const binaryQueryString = require('binary-querystring')
+const Boom = require('boom')
 
 exports = module.exports
 
 exports.subscribe = {
-  handler: (request, reply) => {
+  async handler (request, h) {
     const query = request.query
     const discover = query.discover === 'true'
     const topic = query.arg
 
     if (!topic) {
-      return reply(new Error('Missing topic'))
+      throw Boom.badRequest('Missing topic')
     }
 
-    const ipfs = request.server.app.ipfs
+    const { ipfs } = request.server.app
 
     const res = new PassThrough({ highWaterMark: 1 })
 
@@ -39,76 +40,74 @@ exports.subscribe = {
     request.once('disconnect', unsubscribe)
     request.once('finish', unsubscribe)
 
-    ipfs.pubsub.subscribe(topic, handler, { discover: discover }, (err) => {
-      if (err) {
-        return reply(err)
-      }
+    await ipfs.pubsub.subscribe(topic, handler, { discover: discover })
 
-      reply(res)
-        .header('X-Chunked-Output', '1')
-        .header('content-encoding', 'identity') // stop gzip from buffering, see https://github.com/hapijs/hapi/issues/2975
-        .header('content-type', 'application/json')
-    })
+    return h.response(res)
+      .header('X-Chunked-Output', '1')
+      .header('content-encoding', 'identity') // stop gzip from buffering, see https://github.com/hapijs/hapi/issues/2975
+      .header('content-type', 'application/json')
   }
 }
 
 exports.publish = {
-  handler: (request, reply) => {
-    const arg = request.query.arg
+  async handler (request, h) {
+    const { arg } = request.query
     const topic = arg[0]
 
     const rawArgs = binaryQueryString(request.url.search)
     const buf = rawArgs.arg && rawArgs.arg[1]
 
-    const ipfs = request.server.app.ipfs
+    const { ipfs } = request.server.app
 
     if (!topic) {
-      return reply(new Error('Missing topic'))
+      throw Boom.badRequest('Missing topic')
     }
 
     if (!buf || buf.length === 0) {
-      return reply(new Error('Missing buf'))
+      throw Boom.badRequest('Missing buf')
     }
 
-    ipfs.pubsub.publish(topic, buf, (err) => {
-      if (err) {
-        return reply(new Error(`Failed to publish to topic ${topic}: ${err}`))
-      }
+    try {
+      await ipfs.pubsub.publish(topic, buf)
+    } catch (err) {
+      throw Boom.boomify(err, { message: `Failed to publish to topic ${topic}` })
+    }
 
-      reply()
-    })
+    return h.response()
   }
 }
 
 exports.ls = {
-  handler: (request, reply) => {
-    const ipfs = request.server.app.ipfs
-
-    ipfs.pubsub.ls((err, subscriptions) => {
-      if (err) {
-        return reply(new Error(`Failed to list subscriptions: ${err}`))
-      }
+  async handler (request, h) {
+    const { ipfs } = request.server.app
+
+    let subscriptions
+    try {
+      subscriptions = await ipfs.pubsub.ls()
+    } catch (err) {
+      throw Boom.boomify(err, { message: 'Failed to list subscriptions' })
+    }
 
-      reply({ Strings: subscriptions })
-    })
+    return h.response({ Strings: subscriptions })
   }
 }
 
 exports.peers = {
-  handler: (request, reply) => {
+  async handler (request, h) {
     const topic = request.query.arg
-    const ipfs = request.server.app.ipfs
+    const { ipfs } = request.server.app
 
-    ipfs.pubsub.peers(topic, (err, peers) => {
-      if (err) {
-        const message = topic
-          ? `Failed to find peers subscribed to ${topic}: ${err}`
-          : `Failed to find peers: ${err}`
+    let peers
+    try {
+      peers = await ipfs.pubsub.peers(topic)
+    } catch (err) {
+      const message = topic
+        ? `Failed to find peers subscribed to ${topic}: ${err}`
+        : `Failed to find peers: ${err}`
 
-        return reply(new Error(message))
-      }
+      throw Boom.boomify(err, { message })
+    }
 
-      reply({ Strings: peers })
-    })
+    return h.response({ Strings: peers })
   }
 }
diff --git a/src/http/api/routes/index.js b/src/http/api/routes/index.js
index 48858c69ab..54dbff8b84 100644
--- a/src/http/api/routes/index.js
+++ b/src/http/api/routes/index.js
@@ -15,8 +15,8 @@ module.exports = [
   ...require('./bitswap'),
   require('./file'),
   ...require('./files-regular'),
-  ...require('ipfs-mfs/http')
-  // require('./pubsub')(server)
+  ...require('ipfs-mfs/http'),
+  ...require('./pubsub')
   // require('./debug')(server)
   // require('./webui')(server)
   // require('./dns')(server)
diff --git a/src/http/api/routes/pubsub.js b/src/http/api/routes/pubsub.js
index 6f55b52b65..a2ec7a2b83 100644
--- a/src/http/api/routes/pubsub.js
+++ b/src/http/api/routes/pubsub.js
@@ -2,38 +2,25 @@
 
 const resources = require('./../resources')
 
-module.exports = (server) => {
-  const api = server.select('API')
-
-  api.route({
+module.exports = [
+  {
     method: '*',
     path: '/api/v0/pubsub/sub',
-    config: {
-      handler: resources.pubsub.subscribe.handler
-    }
-  })
-
-  api.route({
+    handler: resources.pubsub.subscribe.handler
+  },
+  {
     method: '*',
     path: '/api/v0/pubsub/pub',
-    config: {
-      handler: resources.pubsub.publish.handler
-    }
-  })
-
-  api.route({
+    handler: resources.pubsub.publish.handler
+  },
+  {
     method: '*',
     path: '/api/v0/pubsub/ls',
-    config: {
-      handler: resources.pubsub.ls.handler
-    }
-  })
-
-  api.route({
+    handler: resources.pubsub.ls.handler
+  },
+  {
     method: '*',
     path: '/api/v0/pubsub/peers',
-    config: {
-      handler: resources.pubsub.peers.handler
-    }
-  })
-}
+    handler: resources.pubsub.peers.handler
+  }
+]
diff --git a/test/http-api/inject/pubsub.js b/test/http-api/inject/pubsub.js
index b51ab21cf3..e91df8b3a3 100644
--- a/test/http-api/inject/pubsub.js
+++ b/test/http-api/inject/pubsub.js
@@ -16,37 +16,39 @@ module.exports = (http) => {
     const topicNotSubscribed = 'somethingRandom'
 
     before(() => {
-      api = http.api.server.select('API')
+      api = http.api._apiServer
     })
 
     describe('/sub', () => {
-      it('returns 500 if no topic is provided', (done) => {
-        api.inject({
+      it('returns 400 if no topic is provided', async () => {
+        const res = await api.inject({
           method: 'GET',
           url: `/api/v0/pubsub/sub`
-        }, (res) => {
-          expect(res.statusCode).to.equal(500)
-          expect(res.result.Code).to.be.eql(1)
-          done()
         })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Code).to.be.eql(1)
       })
 
-      it('returns 200 with topic', (done) => {
+      it('returns 200 with topic', async () => {
         // TODO: Agree on a better way to test this (currently this hangs)
         // Regarding: https://github.com/ipfs/js-ipfs/pull/644#issuecomment-267687194
         // Current Patch: Subscribe to a topic so the other tests run as expected
         const ipfs = api.app.ipfs
         const handler = (msg) => {}
-        ipfs.pubsub.subscribe(topic, handler, () => {
+
+        await ipfs.pubsub.subscribe(topic, handler)
+
+        await new Promise((resolve, reject) => {
           setTimeout(() => {
             ipfs.pubsub.unsubscribe(topic, handler)
-            done()
+            resolve()
           }, 100)
         })
-        // api.inject({
+        // const res = await api.inject({
         //   method: 'GET',
         //   url: `/api/v0/pubsub/sub/${topic}`
-        // }, (res) => {
+        // })
         //   console.log(res.result)
         //   expect(res.statusCode).to.equal(200)
         //   done()
@@ -55,62 +57,56 @@ module.exports = (http) => {
     })
 
     describe('/pub', () => {
-      it('returns 500 if no buffer is provided', (done) => {
-        api.inject({
+      it('returns 400 if no buffer is provided', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: `/api/v0/pubsub/pub?arg=&arg=`
-        }, (res) => {
-          expect(res.statusCode).to.equal(500)
-          expect(res.result.Code).to.be.eql(1)
-          done()
         })
+
+        expect(res.statusCode).to.equal(400)
+        expect(res.result.Code).to.be.eql(1)
       })
 
-      it('returns 200 with topic and buffer', (done) => {
-        api.inject({
+      it('returns 200 with topic and buffer', async () => {
+        const res = await api.inject({
           method: 'POST',
           url: `/api/v0/pubsub/pub?arg=${topic}&arg=${buf}`
-        }, (res) => {
-          expect(res.statusCode).to.equal(200)
-          done()
         })
+
+        expect(res.statusCode).to.equal(200)
       })
     })
 
     describe.skip('/ls', () => {
-      it('returns 200', (done) => {
-        api.inject({
+      it('returns 200', async () => {
+        const res = await api.inject({
           method: 'GET',
           url: `/api/v0/pubsub/ls`
-        }, (res) => {
-          expect(res.statusCode).to.equal(200)
-          expect(res.result.Strings).to.be.eql([topic])
-          done()
         })
+        expect(res.statusCode).to.equal(200)
+        expect(res.result.Strings).to.be.eql([topic])
       })
     })
 
     describe('/peers', () => {
-      it('returns 200 if not subscribed to a topic', (done) => {
-        api.inject({
+      it('returns 200 if not subscribed to a topic', async () => {
+        const res = await api.inject({
           method: 'GET',
           url: `/api/v0/pubsub/peers?arg=${topicNotSubscribed}`
-        }, (res) => {
-          expect(res.statusCode).to.equal(200)
-          expect(res.result.Strings).to.be.eql([])
-          done()
         })
+
+        expect(res.statusCode).to.equal(200)
+        expect(res.result.Strings).to.be.eql([])
       })
 
-      it('returns 200 with topic', (done) => {
-        api.inject({
+      it('returns 200 with topic', async () => {
+        const res = await api.inject({
           method: 'GET',
           url: `/api/v0/pubsub/peers?arg=${topic}`
-        }, (res) => {
-          expect(res.statusCode).to.equal(200)
-          expect(res.result.Strings).to.be.eql([])
-          done()
         })
+
+        expect(res.statusCode).to.equal(200)
+        expect(res.result.Strings).to.be.eql([])
       })
     })
   })

From 5beae7036cf40208d1ae8214948f578ed0d73d6b Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Mon, 28 Jan 2019 21:31:48 +0000
Subject: [PATCH 34/49] refactor: /api/v0/debug/metrics/prometheus for hapi 18

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/api/routes/debug.js | 44 ++++++++++++++++--------------------
 src/http/api/routes/index.js |  4 ++--
 2 files changed, 22 insertions(+), 26 deletions(-)

diff --git a/src/http/api/routes/debug.js b/src/http/api/routes/debug.js
index d5ae1e434d..d57989b323 100644
--- a/src/http/api/routes/debug.js
+++ b/src/http/api/routes/debug.js
@@ -1,31 +1,27 @@
 'use strict'
 
-const register = require('prom-client').register
 const client = require('prom-client')
+const Boom = require('boom')
 
-// Endpoint for handling debug metrics
-module.exports = (server) => {
-  const api = server.select('API')
-  // Clear the register to make sure we're not registering multiple ones
-  register.clear()
-  const gauge = new client.Gauge({ name: 'number_of_peers', help: 'the_number_of_currently_connected_peers' })
+// Clear the register to make sure we're not registering multiple ones
+client.register.clear()
+const gauge = new client.Gauge({ name: 'number_of_peers', help: 'the_number_of_currently_connected_peers' })
 
-  api.route({
-    method: 'GET',
-    path: '/debug/metrics/prometheus',
-    handler: (request, reply) => {
-      if (!process.env.IPFS_MONITORING) {
-        return reply('Monitoring is disabled. Enable it by setting environment variable IPFS_MONITORING')
-          .code(501) // 501 = Not Implemented
-      }
-      server.app.ipfs.swarm.peers((err, res) => {
-        if (err) {
-          return reply(err).code(500)
-        }
-        const count = res.length
-        gauge.set(count)
-        reply(register.metrics()).header('Content-Type', register.contentType)
-      })
+// Endpoint for handling debug metrics
+module.exports = {
+  method: 'GET',
+  path: '/debug/metrics/prometheus',
+  async handler (request, h) {
+    if (!process.env.IPFS_MONITORING) {
+      throw Boom.notImplemented('Monitoring is disabled. Enable it by setting environment variable IPFS_MONITORING')
     }
-  })
+
+    const { ipfs } = request.server.app
+    const peers = await ipfs.swarm.peers()
+
+    gauge.set(peers.length)
+
+    return h.response(client.register.metrics())
+      .type(client.register.contentType)
+  }
 }
diff --git a/src/http/api/routes/index.js b/src/http/api/routes/index.js
index 54dbff8b84..c610f3f30a 100644
--- a/src/http/api/routes/index.js
+++ b/src/http/api/routes/index.js
@@ -16,8 +16,8 @@ module.exports = [
   require('./file'),
   ...require('./files-regular'),
   ...require('ipfs-mfs/http'),
-  ...require('./pubsub')
-  // require('./debug')(server)
+  ...require('./pubsub'),
+  require('./debug')
   // require('./webui')(server)
   // require('./dns')(server)
   // require('./key')(server)

From 7ec3d9e6de2840522d39416e81892418c6381343 Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Mon, 28 Jan 2019 21:39:58 +0000
Subject: [PATCH 35/49] fix: promisify tar pack entry

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/api/resources/files-regular.js | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/http/api/resources/files-regular.js b/src/http/api/resources/files-regular.js
index 090f5fe72b..ac6213ee82 100644
--- a/src/http/api/resources/files-regular.js
+++ b/src/http/api/resources/files-regular.js
@@ -119,16 +119,18 @@ exports.get = {
       throw Boom.boomify(err, { message: 'Failed to get key' })
     }
 
+    pack.entry = promisify(pack.entry.bind(pack))
+
     Promise
       .all(filesArray.map(file => {
         const header = { name: file.path }
 
         if (file.content) {
           header.size = file.size
-          return promisify(pack.entry)(header, file.content)
+          return pack.entry(header, file.content)
         } else {
           header.type = 'directory'
-          return promisify(pack.entry)(header)
+          return pack.entry(header)
         }
       }))
       .then(() => pack.finalize())

From a38cca583fe370ffb2ef158d8baa962dc162bca4 Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Mon, 28 Jan 2019 21:40:40 +0000
Subject: [PATCH 36/49] refactor: /webui for hapi 18

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/api/routes/index.js |  4 ++--
 src/http/api/routes/webui.js | 38 ++++++++++++++++--------------------
 2 files changed, 19 insertions(+), 23 deletions(-)

diff --git a/src/http/api/routes/index.js b/src/http/api/routes/index.js
index c610f3f30a..82567a2f4c 100644
--- a/src/http/api/routes/index.js
+++ b/src/http/api/routes/index.js
@@ -17,8 +17,8 @@ module.exports = [
   ...require('./files-regular'),
   ...require('ipfs-mfs/http'),
   ...require('./pubsub'),
-  require('./debug')
-  // require('./webui')(server)
+  require('./debug'),
+  ...require('./webui')
   // require('./dns')(server)
   // require('./key')(server)
   // require('./stats')(server)
diff --git a/src/http/api/routes/webui.js b/src/http/api/routes/webui.js
index bec3007c03..3a0f1a1db0 100644
--- a/src/http/api/routes/webui.js
+++ b/src/http/api/routes/webui.js
@@ -2,26 +2,22 @@
 
 const resources = require('../../gateway/resources')
 
-module.exports = (server) => {
-  const gateway = server.select('API')
-
-  gateway.route([
-    {
-      method: '*',
-      path: '/ipfs/{cid*}',
-      config: {
-        pre: [
-          { method: resources.gateway.checkCID, assign: 'args' }
-        ],
-        handler: resources.gateway.handler
-      }
+module.exports = [
+  {
+    method: '*',
+    path: '/ipfs/{cid*}',
+    options: {
+      pre: [
+        { method: resources.gateway.checkCID, assign: 'args' }
+      ]
     },
-    {
-      method: '*',
-      path: '/webui',
-      handler: (request, reply) => {
-        return reply().redirect().location('/ipfs/QmXc9raDM1M5G5fpBnVyQ71vR4gbnskwnB9iMEzBuLgvoZ')
-      }
+    handler: resources.gateway.handler
+  },
+  {
+    method: '*',
+    path: '/webui',
+    handler (request, h) {
+      return h.redirect('/ipfs/QmXc9raDM1M5G5fpBnVyQ71vR4gbnskwnB9iMEzBuLgvoZ')
     }
-  ])
-}
+  }
+]

From 599372741962131eca53bc7e78743fdbe9068316 Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Mon, 28 Jan 2019 21:44:55 +0000
Subject: [PATCH 37/49] refactor: /api/v0/dns for hapi 18

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/api/resources/dns.js | 22 ++++++----------------
 src/http/api/routes/dns.js    | 12 ++++--------
 src/http/api/routes/index.js  |  4 ++--
 test/http-api/inject/dns.js   | 11 +++++------
 4 files changed, 17 insertions(+), 32 deletions(-)

diff --git a/src/http/api/resources/dns.js b/src/http/api/resources/dns.js
index 92549e68b7..db20a9f170 100644
--- a/src/http/api/resources/dns.js
+++ b/src/http/api/resources/dns.js
@@ -1,24 +1,14 @@
 'use strict'
 
-const boom = require('boom')
+const Boom = require('boom')
 
-exports = module.exports
-
-exports.get = (request, reply) => {
+module.exports = async (request, h) => {
   if (!request.query.arg) {
-    return reply({
-      Message: "Argument 'domain' is required",
-      Code: 0
-    }).code(400).takeover()
+    throw Boom.badRequest("Argument 'domain' is required")
   }
 
-  request.server.app.ipfs.dns(request.query.arg, (err, path) => {
-    if (err) {
-      return reply(boom.badRequest(err))
-    }
-
-    return reply({
-      Path: path
-    })
+  const path = await request.server.app.ipfs.dns(request.query.arg)
+  return h.response({
+    Path: path
   })
 }
diff --git a/src/http/api/routes/dns.js b/src/http/api/routes/dns.js
index dd3f074025..e8c57cc1b7 100644
--- a/src/http/api/routes/dns.js
+++ b/src/http/api/routes/dns.js
@@ -2,12 +2,8 @@
 
 const resources = require('./../resources')
 
-module.exports = (server) => {
-  const api = server.select('API')
-
-  api.route({
-    method: '*',
-    path: '/api/v0/dns',
-    handler: resources.dns.get
-  })
+module.exports = {
+  method: '*',
+  path: '/api/v0/dns',
+  handler: resources.dns
 }
diff --git a/src/http/api/routes/index.js b/src/http/api/routes/index.js
index 82567a2f4c..bdb44f3438 100644
--- a/src/http/api/routes/index.js
+++ b/src/http/api/routes/index.js
@@ -18,8 +18,8 @@ module.exports = [
   ...require('ipfs-mfs/http'),
   ...require('./pubsub'),
   require('./debug'),
-  ...require('./webui')
-  // require('./dns')(server)
+  ...require('./webui'),
+  require('./dns')
   // require('./key')(server)
   // require('./stats')(server)
   // require('./resolve')(server)
diff --git a/test/http-api/inject/dns.js b/test/http-api/inject/dns.js
index bf84eb6b07..163f2dfd4f 100644
--- a/test/http-api/inject/dns.js
+++ b/test/http-api/inject/dns.js
@@ -8,17 +8,16 @@ module.exports = (http) => {
     let api
 
     before(() => {
-      api = http.api.server.select('API')
+      api = http.api._apiServer
     })
 
-    it('resolve ipfs.io dns', (done) => {
-      api.inject({
+    it('resolve ipfs.io dns', async () => {
+      const res = await api.inject({
         method: 'GET',
         url: '/api/v0/dns?arg=ipfs.io'
-      }, (res) => {
-        expect(res.result).to.have.property('Path')
-        done()
       })
+
+      expect(res.result).to.have.property('Path')
     })
   })
 }

From 395910e642b3c4e5eab06f2021729ec016a3b661 Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Mon, 28 Jan 2019 22:10:25 +0000
Subject: [PATCH 38/49] refactor: /api/v0/key* for hapi 18

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/api/resources/key.js        | 116 ++++++++-------------------
 src/http/api/routes/bitswap.js       |   2 +-
 src/http/api/routes/block.js         |   2 +-
 src/http/api/routes/bootstrap.js     |   2 +-
 src/http/api/routes/config.js        |   2 +-
 src/http/api/routes/dns.js           |   2 +-
 src/http/api/routes/file.js          |   2 +-
 src/http/api/routes/files-regular.js |   2 +-
 src/http/api/routes/id.js            |   2 +-
 src/http/api/routes/index.js         |   4 +-
 src/http/api/routes/key.js           |  37 ++++-----
 src/http/api/routes/name.js          |   2 +-
 src/http/api/routes/object.js        |   2 +-
 src/http/api/routes/pin.js           |   2 +-
 src/http/api/routes/ping.js          |   2 +-
 src/http/api/routes/pubsub.js        |   2 +-
 src/http/api/routes/repo.js          |   2 +-
 src/http/api/routes/resolve.js       |   2 +-
 src/http/api/routes/shutdown.js      |   2 +-
 src/http/api/routes/stats.js         |   2 +-
 src/http/api/routes/swarm.js         |   2 +-
 src/http/api/routes/version.js       |   2 +-
 22 files changed, 70 insertions(+), 125 deletions(-)

diff --git a/src/http/api/resources/key.js b/src/http/api/resources/key.js
index 0e5e1545fc..825401a390 100644
--- a/src/http/api/resources/key.js
+++ b/src/http/api/resources/key.js
@@ -1,14 +1,5 @@
 'use strict'
 
-exports = module.exports
-
-function applyError (reply, err) {
-  reply({
-    Message: err.message,
-    Code: 0
-  }).code(500).takeover()
-}
-
 function toKeyInfo (key) {
   return {
     Name: key.name,
@@ -16,87 +7,48 @@ function toKeyInfo (key) {
   }
 }
 
-exports.list = (request, reply) => {
-  const ipfs = request.server.app.ipfs
-
-  ipfs._keychain.listKeys((err, keys) => {
-    if (err) {
-      return applyError(reply, err)
-    }
-
-    keys = keys.map(toKeyInfo)
-    return reply({ Keys: keys })
-  })
+exports.list = async (request, h) => {
+  const { ipfs } = request.server.app
+  const keys = await ipfs.key.list()
+  return h.response({ Keys: keys.map(toKeyInfo) })
 }
 
-exports.rm = (request, reply) => {
-  const ipfs = request.server.app.ipfs
+exports.rm = async (request, h) => {
+  const { ipfs } = request.server.app
   const name = request.query.arg
-  ipfs._keychain.removeKey(name, (err, key) => {
-    if (err) {
-      return applyError(reply, err)
-    }
-
-    return reply({ Keys: [ toKeyInfo(key) ] })
-  })
-}
-
-exports.rename = (request, reply) => {
-  const ipfs = request.server.app.ipfs
-  const oldName = request.query.arg[0]
-  const newName = request.query.arg[1]
-  ipfs._keychain.renameKey(oldName, newName, (err, key) => {
-    if (err) {
-      return applyError(reply, err)
-    }
-
-    const result = {
-      Was: oldName,
-      Now: key.name,
-      Id: key.id,
-      Overwrite: false
-    }
-    return reply(result)
+  const key = await ipfs.key.rm(name)
+  return h.response({ Keys: [ toKeyInfo(key) ] })
+}
+
+exports.rename = async (request, h) => {
+  const { ipfs } = request.server.app
+  const [ oldName, newName ] = request.query.arg
+  const key = await ipfs.key.rename(oldName, newName)
+  return h.response({
+    Was: key.was,
+    Now: key.name,
+    Id: key.id,
+    Overwrite: key.overwrite
   })
 }
 
-exports.gen = (request, reply) => {
-  const ipfs = request.server.app.ipfs
-  const name = request.query.arg
-  const type = request.query.type
-  const size = parseInt(request.query.size)
-  ipfs._keychain.createKey(name, type, size, (err, key) => {
-    if (err) {
-      return applyError(reply, err)
-    }
-
-    return reply(toKeyInfo(key))
-  })
+exports.gen = async (request, h) => {
+  const { ipfs } = request.server.app
+  const { name, type, size } = request.query
+  const key = await ipfs.key.gen(name, { type, size: parseInt(size) })
+  return h.response(toKeyInfo(key))
 }
 
-exports.export = (request, reply) => {
-  const ipfs = request.server.app.ipfs
-  const name = request.query.arg
-  const password = request.query.password
-  ipfs._keychain.exportKey(name, password, (err, pem) => {
-    if (err) {
-      return applyError(reply, err)
-    }
-
-    return reply(pem).type('application/x-pem-file')
-  })
+exports.export = async (request, h) => {
+  const { ipfs } = request.server.app
+  const { arg: name, password } = request.query
+  const pem = await ipfs.key.export(name, password)
+  return h.response(pem).type('application/x-pem-file')
 }
 
-exports.import = (request, reply) => {
-  const ipfs = request.server.app.ipfs
-  const name = request.query.arg
-  const pem = request.query.pem
-  const password = request.query.password
-  ipfs._keychain.importKey(name, pem, password, (err, key) => {
-    if (err) {
-      return applyError(reply, err)
-    }
-
-    return reply(toKeyInfo(key))
-  })
+exports.import = async (request, h) => {
+  const { ipfs } = request.server.app
+  const { arg: name, pem, password } = request.query
+  const key = await ipfs.key.import(name, pem, password)
+  return h.response(toKeyInfo(key))
 }
diff --git a/src/http/api/routes/bitswap.js b/src/http/api/routes/bitswap.js
index c4a942aeac..8a59fe6169 100644
--- a/src/http/api/routes/bitswap.js
+++ b/src/http/api/routes/bitswap.js
@@ -1,6 +1,6 @@
 'use strict'
 
-const resources = require('./../resources')
+const resources = require('../resources')
 
 module.exports = [
   {
diff --git a/src/http/api/routes/block.js b/src/http/api/routes/block.js
index 2d006b9f4c..1e25b98543 100644
--- a/src/http/api/routes/block.js
+++ b/src/http/api/routes/block.js
@@ -1,6 +1,6 @@
 'use strict'
 
-const resources = require('./../resources')
+const resources = require('../resources')
 
 module.exports = [
   {
diff --git a/src/http/api/routes/bootstrap.js b/src/http/api/routes/bootstrap.js
index 10b448e69c..ec37966895 100644
--- a/src/http/api/routes/bootstrap.js
+++ b/src/http/api/routes/bootstrap.js
@@ -1,6 +1,6 @@
 'use strict'
 
-const resources = require('./../resources')
+const resources = require('../resources')
 
 module.exports = [
   {
diff --git a/src/http/api/routes/config.js b/src/http/api/routes/config.js
index 410351b5c0..5315a043dc 100644
--- a/src/http/api/routes/config.js
+++ b/src/http/api/routes/config.js
@@ -1,6 +1,6 @@
 'use strict'
 
-const resources = require('./../resources')
+const resources = require('../resources')
 
 module.exports = [
   {
diff --git a/src/http/api/routes/dns.js b/src/http/api/routes/dns.js
index e8c57cc1b7..4a3bbec3c9 100644
--- a/src/http/api/routes/dns.js
+++ b/src/http/api/routes/dns.js
@@ -1,6 +1,6 @@
 'use strict'
 
-const resources = require('./../resources')
+const resources = require('../resources')
 
 module.exports = {
   method: '*',
diff --git a/src/http/api/routes/file.js b/src/http/api/routes/file.js
index f8d86f8e3b..5fd57355bd 100644
--- a/src/http/api/routes/file.js
+++ b/src/http/api/routes/file.js
@@ -1,6 +1,6 @@
 'use strict'
 
-const resources = require('./../resources')
+const resources = require('../resources')
 
 module.exports = {
   // TODO fix method
diff --git a/src/http/api/routes/files-regular.js b/src/http/api/routes/files-regular.js
index 581d7b7c9e..537116e38e 100644
--- a/src/http/api/routes/files-regular.js
+++ b/src/http/api/routes/files-regular.js
@@ -1,6 +1,6 @@
 'use strict'
 
-const resources = require('./../resources')
+const resources = require('../resources')
 
 module.exports = [
   {
diff --git a/src/http/api/routes/id.js b/src/http/api/routes/id.js
index 25c2bbc949..3af3386301 100644
--- a/src/http/api/routes/id.js
+++ b/src/http/api/routes/id.js
@@ -1,6 +1,6 @@
 'use strict'
 
-const resources = require('./../resources')
+const resources = require('../resources')
 
 module.exports = {
   method: '*',
diff --git a/src/http/api/routes/index.js b/src/http/api/routes/index.js
index bdb44f3438..64398f8bed 100644
--- a/src/http/api/routes/index.js
+++ b/src/http/api/routes/index.js
@@ -19,8 +19,8 @@ module.exports = [
   ...require('./pubsub'),
   require('./debug'),
   ...require('./webui'),
-  require('./dns')
-  // require('./key')(server)
+  require('./dns'),
+  ...require('./key')
   // require('./stats')(server)
   // require('./resolve')(server)
   // require('./name')(server)
diff --git a/src/http/api/routes/key.js b/src/http/api/routes/key.js
index 4493bdab39..036efd4637 100644
--- a/src/http/api/routes/key.js
+++ b/src/http/api/routes/key.js
@@ -1,43 +1,36 @@
 'use strict'
 
-const resources = require('./../resources')
+const resources = require('../resources')
 
-module.exports = (server) => {
-  const api = server.select('API')
-
-  api.route({
+module.exports = [
+  {
     method: '*',
     path: '/api/v0/key/list',
     handler: resources.key.list
-  })
-
-  api.route({
+  },
+  {
     method: '*',
     path: '/api/v0/key/gen',
     handler: resources.key.gen
-  })
-
-  api.route({
+  },
+  {
     method: '*',
     path: '/api/v0/key/rm',
     handler: resources.key.rm
-  })
-
-  api.route({
+  },
+  {
     method: '*',
     path: '/api/v0/key/rename',
     handler: resources.key.rename
-  })
-
-  api.route({
+  },
+  {
     method: '*',
     path: '/api/v0/key/export',
     handler: resources.key.export
-  })
-
-  api.route({
+  },
+  {
     method: '*',
     path: '/api/v0/key/import',
     handler: resources.key.import
-  })
-}
+  }
+]
diff --git a/src/http/api/routes/name.js b/src/http/api/routes/name.js
index f49d0bd6ca..a3a7e48121 100644
--- a/src/http/api/routes/name.js
+++ b/src/http/api/routes/name.js
@@ -1,6 +1,6 @@
 'use strict'
 
-const resources = require('./../resources')
+const resources = require('../resources')
 
 module.exports = (server) => {
   const api = server.select('API')
diff --git a/src/http/api/routes/object.js b/src/http/api/routes/object.js
index 9e4b606e05..c7c0daae4b 100644
--- a/src/http/api/routes/object.js
+++ b/src/http/api/routes/object.js
@@ -1,6 +1,6 @@
 'use strict'
 
-const resources = require('./../resources')
+const resources = require('../resources')
 
 module.exports = [
   {
diff --git a/src/http/api/routes/pin.js b/src/http/api/routes/pin.js
index 6f7c06c0f5..6912fe42fc 100644
--- a/src/http/api/routes/pin.js
+++ b/src/http/api/routes/pin.js
@@ -1,6 +1,6 @@
 'use strict'
 
-const resources = require('./../resources')
+const resources = require('../resources')
 
 module.exports = [
   {
diff --git a/src/http/api/routes/ping.js b/src/http/api/routes/ping.js
index 3d84ee39fe..a2eff08989 100644
--- a/src/http/api/routes/ping.js
+++ b/src/http/api/routes/ping.js
@@ -1,6 +1,6 @@
 'use strict'
 
-const resources = require('./../resources')
+const resources = require('../resources')
 
 module.exports = {
   method: '*',
diff --git a/src/http/api/routes/pubsub.js b/src/http/api/routes/pubsub.js
index a2ec7a2b83..1f70ef892e 100644
--- a/src/http/api/routes/pubsub.js
+++ b/src/http/api/routes/pubsub.js
@@ -1,6 +1,6 @@
 'use strict'
 
-const resources = require('./../resources')
+const resources = require('../resources')
 
 module.exports = [
   {
diff --git a/src/http/api/routes/repo.js b/src/http/api/routes/repo.js
index e5254b0ab5..21b306e51e 100644
--- a/src/http/api/routes/repo.js
+++ b/src/http/api/routes/repo.js
@@ -1,6 +1,6 @@
 'use strict'
 
-const resources = require('./../resources')
+const resources = require('../resources')
 
 module.exports = [
   {
diff --git a/src/http/api/routes/resolve.js b/src/http/api/routes/resolve.js
index 259ae3bdd1..d531cc41b2 100644
--- a/src/http/api/routes/resolve.js
+++ b/src/http/api/routes/resolve.js
@@ -1,6 +1,6 @@
 'use strict'
 
-const resources = require('./../resources')
+const resources = require('../resources')
 
 module.exports = (server) => {
   const api = server.select('API')
diff --git a/src/http/api/routes/shutdown.js b/src/http/api/routes/shutdown.js
index 822c636915..f7201a40e6 100644
--- a/src/http/api/routes/shutdown.js
+++ b/src/http/api/routes/shutdown.js
@@ -1,6 +1,6 @@
 'use strict'
 
-const resources = require('./../resources')
+const resources = require('../resources')
 
 module.exports = {
   method: '*',
diff --git a/src/http/api/routes/stats.js b/src/http/api/routes/stats.js
index 1fe0707c1b..d2de7dfc94 100644
--- a/src/http/api/routes/stats.js
+++ b/src/http/api/routes/stats.js
@@ -1,6 +1,6 @@
 'use strict'
 
-const resources = require('./../resources')
+const resources = require('../resources')
 
 module.exports = (server) => {
   const api = server.select('API')
diff --git a/src/http/api/routes/swarm.js b/src/http/api/routes/swarm.js
index 62fd7ee9d7..73f3fad47b 100644
--- a/src/http/api/routes/swarm.js
+++ b/src/http/api/routes/swarm.js
@@ -1,6 +1,6 @@
 'use strict'
 
-const resources = require('./../resources')
+const resources = require('../resources')
 
 module.exports = [
   {
diff --git a/src/http/api/routes/version.js b/src/http/api/routes/version.js
index 0b717a3927..8333d40a80 100644
--- a/src/http/api/routes/version.js
+++ b/src/http/api/routes/version.js
@@ -1,6 +1,6 @@
 'use strict'
 
-const resources = require('./../resources')
+const resources = require('../resources')
 
 module.exports = {
   method: '*',

From b2ee66f8493e947b71d1dae9a41d58b28458fcb5 Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Mon, 28 Jan 2019 22:18:07 +0000
Subject: [PATCH 39/49] refactor: /api/v0/stats* for hapi 18

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/api/resources/stats.js |  9 ++++-----
 src/http/api/routes/index.js    |  4 ++--
 src/http/api/routes/stats.js    | 35 +++++++++++++--------------------
 3 files changed, 20 insertions(+), 28 deletions(-)

diff --git a/src/http/api/resources/stats.js b/src/http/api/resources/stats.js
index 7ec7b0cb42..4f46f92b93 100644
--- a/src/http/api/resources/stats.js
+++ b/src/http/api/resources/stats.js
@@ -11,14 +11,12 @@ const transformBandwidth = (stat) => {
   }
 }
 
-exports = module.exports
-
 exports.bitswap = require('./bitswap').stat
 
 exports.repo = require('./repo').stat
 
-exports.bw = (request, reply) => {
-  const ipfs = request.server.app.ipfs
+exports.bw = async (request, h) => {
+  const { ipfs } = request.server.app
   const options = {
     peer: request.query.peer,
     proto: request.query.proto,
@@ -40,7 +38,8 @@ exports.bw = (request, reply) => {
   })
 
   res.pipe(output)
-  reply(output)
+
+  return h.response(output)
     .header('content-type', 'application/json')
     .header('x-chunked-output', '1')
 }
diff --git a/src/http/api/routes/index.js b/src/http/api/routes/index.js
index 64398f8bed..c1b185fde1 100644
--- a/src/http/api/routes/index.js
+++ b/src/http/api/routes/index.js
@@ -20,8 +20,8 @@ module.exports = [
   require('./debug'),
   ...require('./webui'),
   require('./dns'),
-  ...require('./key')
-  // require('./stats')(server)
+  ...require('./key'),
+  ...require('./stats')
   // require('./resolve')(server)
   // require('./name')(server)
 ]
diff --git a/src/http/api/routes/stats.js b/src/http/api/routes/stats.js
index d2de7dfc94..86b259c2f0 100644
--- a/src/http/api/routes/stats.js
+++ b/src/http/api/routes/stats.js
@@ -2,30 +2,23 @@
 
 const resources = require('../resources')
 
-module.exports = (server) => {
-  const api = server.select('API')
-
-  api.route({
+module.exports = [
+  {
     method: '*',
     path: '/api/v0/stats/bitswap',
-    config: {
-      handler: resources.stats.bitswap.handler
-    }
-  })
-
-  api.route({
+    options: {
+      validate: resources.stats.bitswap.validate
+    },
+    handler: resources.stats.bitswap.handler
+  },
+  {
     method: '*',
     path: '/api/v0/stats/repo',
-    config: {
-      handler: resources.stats.repo
-    }
-  })
-
-  api.route({
+    handler: resources.stats.repo
+  },
+  {
     method: '*',
     path: '/api/v0/stats/bw',
-    config: {
-      handler: resources.stats.bw
-    }
-  })
-}
+    handler: resources.stats.bw
+  }
+]

From 9a5b663bd64ee4cc4a1d3ab9530e354eb025c32c Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Tue, 29 Jan 2019 09:31:36 +0000
Subject: [PATCH 40/49] refactor: /api/v0/resolve for hapi 18

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/api/resources/resolve.js | 13 ++----
 src/http/api/routes/index.js      |  4 +-
 src/http/api/routes/resolve.js    | 18 +++-----
 test/http-api/inject/resolve.js   | 71 ++++++++++++++-----------------
 4 files changed, 45 insertions(+), 61 deletions(-)

diff --git a/src/http/api/resources/resolve.js b/src/http/api/resources/resolve.js
index 478e423595..0984aeb5a6 100644
--- a/src/http/api/resources/resolve.js
+++ b/src/http/api/resources/resolve.js
@@ -21,20 +21,15 @@ module.exports = {
       'cid-base': Joi.string().valid(multibase.names)
     }).unknown()
   },
-  handler (request, reply) {
-    const ipfs = request.server.app.ipfs
+  async handler (request, h) {
+    const { ipfs } = request.server.app
     const name = request.query.arg
     const recursive = request.query.r || request.query.recursive || false
     const cidBase = request.query['cid-base']
 
     log(name, { recursive, cidBase })
+    const res = await ipfs.resolve(name, { recursive, cidBase })
 
-    ipfs.resolve(name, { recursive, cidBase }, (err, res) => {
-      if (err) {
-        log.error(err)
-        return reply({ Message: err.message, Code: 0 }).code(500)
-      }
-      reply({ Path: res })
-    })
+    return h.response({ Path: res })
   }
 }
diff --git a/src/http/api/routes/index.js b/src/http/api/routes/index.js
index c1b185fde1..d6ee05a56a 100644
--- a/src/http/api/routes/index.js
+++ b/src/http/api/routes/index.js
@@ -21,7 +21,7 @@ module.exports = [
   ...require('./webui'),
   require('./dns'),
   ...require('./key'),
-  ...require('./stats')
-  // require('./resolve')(server)
+  ...require('./stats'),
+  require('./resolve')
   // require('./name')(server)
 ]
diff --git a/src/http/api/routes/resolve.js b/src/http/api/routes/resolve.js
index d531cc41b2..a95a2e2d62 100644
--- a/src/http/api/routes/resolve.js
+++ b/src/http/api/routes/resolve.js
@@ -2,15 +2,11 @@
 
 const resources = require('../resources')
 
-module.exports = (server) => {
-  const api = server.select('API')
-
-  api.route({
-    method: '*',
-    path: '/api/v0/resolve',
-    config: {
-      handler: resources.resolve.handler,
-      validate: resources.resolve.validate
-    }
-  })
+module.exports = {
+  method: '*',
+  path: '/api/v0/resolve',
+  options: {
+    validate: resources.resolve.validate
+  },
+  handler: resources.resolve.handler
 }
diff --git a/test/http-api/inject/resolve.js b/test/http-api/inject/resolve.js
index a9aef87266..edb7eb94ab 100644
--- a/test/http-api/inject/resolve.js
+++ b/test/http-api/inject/resolve.js
@@ -12,61 +12,54 @@ module.exports = (http) => {
     let api
 
     before(() => {
-      api = http.api.server.select('API')
+      api = http.api._apiServer
     })
 
-    it('should resolve a path and return a base2 encoded CID', done => {
+    it('should resolve a path and return a base2 encoded CID', async () => {
       const form = new FormData()
       form.append('data', Buffer.from('TEST' + Date.now()))
       const headers = form.getHeaders()
 
-      streamToPromise(form).then((payload) => {
-        api.inject({
-          method: 'POST',
-          url: '/api/v0/add',
-          headers: headers,
-          payload: payload
-        }, (res) => {
-          expect(res.statusCode).to.equal(200)
-          const hash = JSON.parse(res.result).Hash
+      const payload = await streamToPromise(form)
+      let res = await api.inject({
+        method: 'POST',
+        url: '/api/v0/add',
+        headers: headers,
+        payload: payload
+      })
+      expect(res.statusCode).to.equal(200)
+      const hash = JSON.parse(res.result).Hash
 
-          api.inject({
-            method: 'POST',
-            url: `/api/v0/resolve?arg=/ipfs/${hash}&cid-base=base2`
-          }, (res) => {
-            expect(res.statusCode).to.equal(200)
-            expect(multibase.isEncoded(res.result.Path.replace('/ipfs/', ''))).to.deep.equal('base2')
-            done()
-          })
-        })
+      res = await api.inject({
+        method: 'POST',
+        url: `/api/v0/resolve?arg=/ipfs/${hash}&cid-base=base2`
       })
+
+      expect(res.statusCode).to.equal(200)
+      expect(multibase.isEncoded(res.result.Path.replace('/ipfs/', ''))).to.deep.equal('base2')
     })
 
-    it('should not resolve a path for invalid cid-base option', done => {
+    it('should not resolve a path for invalid cid-base option', async () => {
       const form = new FormData()
       form.append('data', Buffer.from('TEST' + Date.now()))
       const headers = form.getHeaders()
 
-      streamToPromise(form).then((payload) => {
-        api.inject({
-          method: 'POST',
-          url: '/api/v0/add',
-          headers: headers,
-          payload: payload
-        }, (res) => {
-          expect(res.statusCode).to.equal(200)
-          const hash = JSON.parse(res.result).Hash
+      const payload = await streamToPromise(form)
+      let res = await api.inject({
+        method: 'POST',
+        url: '/api/v0/add',
+        headers: headers,
+        payload: payload
+      })
+      expect(res.statusCode).to.equal(200)
+      const hash = JSON.parse(res.result).Hash
 
-          api.inject({
-            method: 'POST',
-            url: `/api/v0/resolve?arg=/ipfs/${hash}&cid-base=invalid`
-          }, (res) => {
-            expect(res.statusCode).to.equal(400)
-            expect(res.result.Message).to.include('child "cid-base" fails')
-            done()
-          })
-        })
+      res = await api.inject({
+        method: 'POST',
+        url: `/api/v0/resolve?arg=/ipfs/${hash}&cid-base=invalid`
       })
+      expect(res.statusCode).to.equal(400)
+      expect(res.result.Message).to.include('Invalid request query input')
     })
   })
 }

From f6a7be338533516b31328853aeacaf6115bc7962 Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Tue, 29 Jan 2019 09:57:02 +0000
Subject: [PATCH 41/49] refactor: /api/v0/name* for hapi 18

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/api/resources/config.js   |  2 -
 src/http/api/resources/file.js     |  2 -
 src/http/api/resources/name.js     | 89 +++++++++---------------------
 src/http/api/resources/object.js   |  2 -
 src/http/api/resources/pin.js      |  2 -
 src/http/api/resources/pubsub.js   |  2 -
 src/http/api/resources/repo.js     |  2 -
 src/http/api/resources/shutdown.js |  2 -
 src/http/api/routes/index.js       |  4 +-
 src/http/api/routes/name.js        | 56 ++++++++-----------
 test/http-api/inject/name.js       | 41 +++++++-------
 11 files changed, 70 insertions(+), 134 deletions(-)

diff --git a/src/http/api/resources/config.js b/src/http/api/resources/config.js
index 8e36fde63d..364d19315d 100644
--- a/src/http/api/resources/config.js
+++ b/src/http/api/resources/config.js
@@ -8,8 +8,6 @@ log.error = debug('jsipfs:http-api:config:error')
 const multipart = require('ipfs-multipart')
 const Boom = require('boom')
 
-exports = module.exports
-
 exports.getOrSet = {
   // pre request handler that parses the args and returns `key` & `value` which are assigned to `request.pre.args`
   parseArgs (request, h) {
diff --git a/src/http/api/resources/file.js b/src/http/api/resources/file.js
index 5f10e5ac3e..a56c079256 100644
--- a/src/http/api/resources/file.js
+++ b/src/http/api/resources/file.js
@@ -7,8 +7,6 @@ const pull = require('pull-stream')
 const toB58String = require('multihashes').toB58String
 const Boom = require('boom')
 
-exports = module.exports
-
 const fileTypeMap = {
   file: 'File',
   dir: 'Directory'
diff --git a/src/http/api/resources/name.js b/src/http/api/resources/name.js
index be2c9eaad5..9a4182f42e 100644
--- a/src/http/api/resources/name.js
+++ b/src/http/api/resources/name.js
@@ -2,8 +2,6 @@
 
 const Joi = require('joi')
 
-exports = module.exports
-
 exports.resolve = {
   validate: {
     query: Joi.object().keys({
@@ -12,21 +10,14 @@ exports.resolve = {
       recursive: Joi.boolean().default(false)
     }).unknown()
   },
-  handler: (request, reply) => {
-    const ipfs = request.server.app.ipfs
+  async handler (request, h) {
+    const { ipfs } = request.server.app
     const { arg } = request.query
 
-    ipfs.name.resolve(arg, request.query, (err, res) => {
-      if (err) {
-        return reply({
-          Message: err.toString(),
-          Code: 0
-        }).code(500)
-      }
+    const res = await ipfs.name.resolve(arg, request.query)
 
-      return reply({
-        Path: res.path
-      }).code(200)
+    return h.response({
+      Path: res.path
     })
   }
 }
@@ -40,60 +31,39 @@ exports.publish = {
       key: Joi.string().default('self')
     }).unknown()
   },
-  handler: (request, reply) => {
-    const ipfs = request.server.app.ipfs
+  async handler (request, h) {
+    const { ipfs } = request.server.app
     const { arg } = request.query
 
-    ipfs.name.publish(arg, request.query, (err, res) => {
-      if (err) {
-        return reply({
-          Message: err.toString(),
-          Code: 0
-        }).code(500)
-      }
+    const res = await ipfs.name.publish(arg, request.query)
 
-      return reply({
-        Name: res.name,
-        Value: res.value
-      }).code(200)
+    return h.response({
+      Name: res.name,
+      Value: res.value
     })
   }
 }
 
 exports.pubsub = {
   state: {
-    handler: (request, reply) => {
-      const ipfs = request.server.app.ipfs
+    async handler (request, h) {
+      const { ipfs } = request.server.app
 
-      ipfs.name.pubsub.state((err, res) => {
-        if (err) {
-          return reply({
-            Message: err.toString(),
-            Code: 0
-          }).code(500)
-        }
+      const res = await ipfs.name.pubsub.state()
 
-        return reply({
-          Enabled: res.enabled
-        }).code(200)
+      return h.response({
+        Enabled: res.enabled
       })
     }
   },
   subs: {
-    handler: (request, reply) => {
-      const ipfs = request.server.app.ipfs
+    async handler (request, h) {
+      const { ipfs } = request.server.app
 
-      ipfs.name.pubsub.subs((err, res) => {
-        if (err) {
-          return reply({
-            Message: err.toString(),
-            Code: 0
-          }).code(500)
-        }
+      const res = await ipfs.name.pubsub.subs()
 
-        return reply({
-          Strings: res
-        }).code(200)
+      return h.response({
+        Strings: res
       })
     }
   },
@@ -103,21 +73,14 @@ exports.pubsub = {
         arg: Joi.string().required()
       }).unknown()
     },
-    handler: (request, reply) => {
-      const ipfs = request.server.app.ipfs
+    async handler (request, h) {
+      const { ipfs } = request.server.app
       const { arg } = request.query
 
-      ipfs.name.pubsub.cancel(arg, (err, res) => {
-        if (err) {
-          return reply({
-            Message: err.toString(),
-            Code: 0
-          }).code(500)
-        }
+      const res = await ipfs.name.pubsub.cancel(arg)
 
-        return reply({
-          Canceled: res.canceled
-        }).code(200)
+      return h.response({
+        Canceled: res.canceled
       })
     }
   }
diff --git a/src/http/api/resources/object.js b/src/http/api/resources/object.js
index ead1c09b34..0c192adcd9 100644
--- a/src/http/api/resources/object.js
+++ b/src/http/api/resources/object.js
@@ -16,8 +16,6 @@ const debug = require('debug')
 const log = debug('jsipfs:http-api:object')
 log.error = debug('jsipfs:http-api:object:error')
 
-exports = module.exports
-
 // common pre request handler that parses the args and returns `key` which is assigned to `request.pre.args`
 exports.parseKey = (request, h) => {
   if (!request.query.arg) {
diff --git a/src/http/api/resources/pin.js b/src/http/api/resources/pin.js
index a99954a958..ca7fd63cbf 100644
--- a/src/http/api/resources/pin.js
+++ b/src/http/api/resources/pin.js
@@ -11,8 +11,6 @@ const debug = require('debug')
 const log = debug('jsipfs:http-api:pin')
 log.error = debug('jsipfs:http-api:pin:error')
 
-exports = module.exports
-
 function parseArgs (request, h) {
   const { arg } = request.query
 
diff --git a/src/http/api/resources/pubsub.js b/src/http/api/resources/pubsub.js
index b9cf8aed40..3c8b95539a 100644
--- a/src/http/api/resources/pubsub.js
+++ b/src/http/api/resources/pubsub.js
@@ -5,8 +5,6 @@ const bs58 = require('bs58')
 const binaryQueryString = require('binary-querystring')
 const Boom = require('boom')
 
-exports = module.exports
-
 exports.subscribe = {
   async handler (request, h) {
     const query = request.query
diff --git a/src/http/api/resources/repo.js b/src/http/api/resources/repo.js
index 724928a8ca..998431111a 100644
--- a/src/http/api/resources/repo.js
+++ b/src/http/api/resources/repo.js
@@ -1,7 +1,5 @@
 'use strict'
 
-exports = module.exports
-
 exports.gc = async (request, h) => {
   const { ipfs } = request.server.app
   await ipfs.repo.gc()
diff --git a/src/http/api/resources/shutdown.js b/src/http/api/resources/shutdown.js
index 9224e55a34..90eb66790f 100644
--- a/src/http/api/resources/shutdown.js
+++ b/src/http/api/resources/shutdown.js
@@ -1,7 +1,5 @@
 'use strict'
 
-exports = module.exports
-
 /*
  * Stop the daemon.
  *
diff --git a/src/http/api/routes/index.js b/src/http/api/routes/index.js
index d6ee05a56a..8f310ee73e 100644
--- a/src/http/api/routes/index.js
+++ b/src/http/api/routes/index.js
@@ -22,6 +22,6 @@ module.exports = [
   require('./dns'),
   ...require('./key'),
   ...require('./stats'),
-  require('./resolve')
-  // require('./name')(server)
+  require('./resolve'),
+  ...require('./name')
 ]
diff --git a/src/http/api/routes/name.js b/src/http/api/routes/name.js
index a3a7e48121..a2a7a61e4c 100644
--- a/src/http/api/routes/name.js
+++ b/src/http/api/routes/name.js
@@ -2,49 +2,39 @@
 
 const resources = require('../resources')
 
-module.exports = (server) => {
-  const api = server.select('API')
-
-  api.route({
+module.exports = [
+  {
     method: '*',
     path: '/api/v0/name/resolve',
-    config: {
-      handler: resources.name.resolve.handler,
+    options: {
       validate: resources.name.resolve.validate
-    }
-  })
-
-  api.route({
+    },
+    handler: resources.name.resolve.handler
+  },
+  {
     method: '*',
     path: '/api/v0/name/publish',
-    config: {
-      handler: resources.name.publish.handler,
+    options: {
       validate: resources.name.publish.validate
-    }
-  })
-
-  api.route({
+    },
+    handler: resources.name.publish.handler
+  },
+  {
     method: '*',
     path: '/api/v0/name/pubsub/state',
-    config: {
-      handler: resources.name.pubsub.state.handler
-    }
-  })
-
-  api.route({
+    handler: resources.name.pubsub.state.handler
+  },
+  {
     method: '*',
     path: '/api/v0/name/pubsub/subs',
-    config: {
-      handler: resources.name.pubsub.subs.handler
-    }
-  })
-
-  api.route({
+    handler: resources.name.pubsub.subs.handler
+  },
+  {
     method: '*',
     path: '/api/v0/name/pubsub/cancel',
-    config: {
-      handler: resources.name.pubsub.cancel.handler,
+    options: {
       validate: resources.name.pubsub.cancel.validate
-    }
-  })
-}
+    },
+    handler: resources.name.pubsub.cancel.handler
+  }
+]
diff --git a/test/http-api/inject/name.js b/test/http-api/inject/name.js
index c4efe81b84..1f3864b968 100644
--- a/test/http-api/inject/name.js
+++ b/test/http-api/inject/name.js
@@ -16,38 +16,35 @@ module.exports = (http) => {
     let api
 
     before(() => {
-      api = http.api.server.select('API')
+      api = http.api._apiServer
     })
 
-    it('should publish a record', (done) => {
-      api.inject({
+    it('should publish a record', async () => {
+      const res = await api.inject({
         method: 'GET',
         url: `/api/v0/name/publish?arg=${cid}&resolve=false`
-      }, (res) => {
-        expect(res).to.exist()
-        expect(res.result.Value).to.equal(`/ipfs/${cid}`)
-        done()
       })
+
+      expect(res).to.exist()
+      expect(res.result.Value).to.equal(`/ipfs/${cid}`)
     })
 
-    it('should publish and resolve a record', (done) => {
-      api.inject({
+    it('should publish and resolve a record', async () => {
+      let res = await api.inject({
         method: 'GET',
         url: `/api/v0/name/publish?arg=${cid}&resolve=false`
-      }, (res) => {
-        expect(res).to.exist()
-        expect(res.result.Value).to.equal(`/ipfs/${cid}`)
-
-        api.inject({
-          method: 'GET',
-          url: `/api/v0/name/resolve`
-        }, (res) => {
-          expect(res).to.exist()
-          expect(res.result.Path).to.satisfy(checkAll([`/ipfs/${cid}`]))
-
-          done()
-        })
       })
+
+      expect(res).to.exist()
+      expect(res.result.Value).to.equal(`/ipfs/${cid}`)
+
+      res = await api.inject({
+        method: 'GET',
+        url: `/api/v0/name/resolve`
+      })
+
+      expect(res).to.exist()
+      expect(res.result.Path).to.satisfy(checkAll([`/ipfs/${cid}`]))
     })
   })
 }

From c64bf5ff9810ef26855fe3a694cc502030ef9391 Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Tue, 29 Jan 2019 10:23:20 +0000
Subject: [PATCH 42/49] fix: communicate error message for 500+ errors

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/error-handler.js | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/http/error-handler.js b/src/http/error-handler.js
index ad2afb6326..e1027211f1 100644
--- a/src/http/error-handler.js
+++ b/src/http/error-handler.js
@@ -8,7 +8,8 @@ module.exports = server => {
       return h.continue
     }
 
-    const { statusCode, message } = res.output.payload
+    const message = res.message || res.output.payload.message
+    const { statusCode } = res.output.payload
     let code
 
     if (res.data && res.data.code != null) {
@@ -34,8 +35,6 @@ module.exports = server => {
         response: res.output.payload
       }
 
-      console.log(res)
-
       server.logger().error(debug)
       server.logger().error(res)
     }

From 755baee956538c8276af551fadf81c7d43a73577 Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Tue, 29 Jan 2019 10:28:04 +0000
Subject: [PATCH 43/49] fix: key name query arg for key gen

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/api/resources/key.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/http/api/resources/key.js b/src/http/api/resources/key.js
index 825401a390..cd035a4bad 100644
--- a/src/http/api/resources/key.js
+++ b/src/http/api/resources/key.js
@@ -34,8 +34,8 @@ exports.rename = async (request, h) => {
 
 exports.gen = async (request, h) => {
   const { ipfs } = request.server.app
-  const { name, type, size } = request.query
-  const key = await ipfs.key.gen(name, { type, size: parseInt(size) })
+  const { arg, type, size } = request.query
+  const key = await ipfs.key.gen(arg, { type, size: parseInt(size) })
   return h.response(toKeyInfo(key))
 }
 

From dec15ffbd8b3af81aa335c0275760bc4eb2fb0b3 Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Tue, 29 Jan 2019 10:58:17 +0000
Subject: [PATCH 44/49] fix: pin arg validation

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/api/resources/pin.js | 27 +++++++++++++++++++--------
 1 file changed, 19 insertions(+), 8 deletions(-)

diff --git a/src/http/api/resources/pin.js b/src/http/api/resources/pin.js
index ca7fd63cbf..010e7861f4 100644
--- a/src/http/api/resources/pin.js
+++ b/src/http/api/resources/pin.js
@@ -12,18 +12,22 @@ const log = debug('jsipfs:http-api:pin')
 log.error = debug('jsipfs:http-api:pin:error')
 
 function parseArgs (request, h) {
-  const { arg } = request.query
+  let { arg } = request.query
 
   if (!arg) {
     throw Boom.badRequest("Argument 'arg' is required")
   }
 
-  if (!isIpfs.ipfsPath(arg) && !isIpfs.cid(arg)) {
-    throw Boom.badRequest('invalid ipfs ref path')
-  }
+  arg = Array.isArray(arg) ? arg : [arg]
+
+  arg.forEach(path => {
+    if (!isIpfs.ipfsPath(path) && !isIpfs.cid(path)) {
+      throw Boom.badRequest('invalid ipfs ref path')
+    }
+  })
 
   const recursive = request.query.recursive !== 'false'
-  return { path: request.query.arg, recursive }
+  return { path: arg, recursive }
 }
 
 exports.ls = {
@@ -34,11 +38,18 @@ exports.ls = {
   },
 
   parseArgs (request, h) {
-    const { arg } = request.query
+    let { arg } = request.query
 
-    if (arg && !isIpfs.ipfsPath(arg) && !isIpfs.cid(arg)) {
-      throw Boom.badRequest('invalid ipfs ref path')
+    if (arg) {
+      arg = Array.isArray(arg) ? arg : [arg]
+
+      arg.forEach(path => {
+        if (!isIpfs.ipfsPath(path) && !isIpfs.cid(path)) {
+          throw Boom.badRequest('invalid ipfs ref path')
+        }
+      })
     }
+
     const type = request.query.type || 'all'
     return { path: request.query.arg, type }
   },

From db65043ff3c6ba8ff9f940c4703f6b21f3ffa944 Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Tue, 29 Jan 2019 11:06:37 +0000
Subject: [PATCH 45/49] fix: remove unused loggers

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/api/resources/pin.js  | 3 ---
 src/http/api/resources/ping.js | 3 ---
 2 files changed, 6 deletions(-)

diff --git a/src/http/api/resources/pin.js b/src/http/api/resources/pin.js
index 010e7861f4..b4232c6916 100644
--- a/src/http/api/resources/pin.js
+++ b/src/http/api/resources/pin.js
@@ -7,9 +7,6 @@ const Joi = require('joi')
 const Boom = require('boom')
 const isIpfs = require('is-ipfs')
 const { cidToString } = require('../../../utils/cid')
-const debug = require('debug')
-const log = debug('jsipfs:http-api:pin')
-log.error = debug('jsipfs:http-api:pin:error')
 
 function parseArgs (request, h) {
   let { arg } = request.query
diff --git a/src/http/api/resources/ping.js b/src/http/api/resources/ping.js
index ef5056cea0..01e8bc3bbc 100644
--- a/src/http/api/resources/ping.js
+++ b/src/http/api/resources/ping.js
@@ -4,9 +4,6 @@ const Joi = require('joi')
 const pull = require('pull-stream')
 const ndjson = require('pull-ndjson')
 const { PassThrough } = require('readable-stream')
-const debug = require('debug')
-const log = debug('jsipfs:http-api:ping')
-log.error = debug('jsipfs:http-api:ping:error')
 
 module.exports = {
   validate: {

From cb6c6c3e5909cb73b911b8c97c9f92471e67473d Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Tue, 29 Jan 2019 12:23:44 +0000
Subject: [PATCH 46/49] fix: subscribe disconnect/finish event

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/api/resources/pubsub.js |  4 ++--
 test/cli/pubsub.js               | 27 ++++++++++++---------------
 2 files changed, 14 insertions(+), 17 deletions(-)

diff --git a/src/http/api/resources/pubsub.js b/src/http/api/resources/pubsub.js
index 3c8b95539a..9d217afd6b 100644
--- a/src/http/api/resources/pubsub.js
+++ b/src/http/api/resources/pubsub.js
@@ -35,8 +35,8 @@ exports.subscribe = {
       ipfs.pubsub.unsubscribe(topic, handler, () => res.end())
     }
 
-    request.once('disconnect', unsubscribe)
-    request.once('finish', unsubscribe)
+    request.events.once('disconnect', unsubscribe)
+    request.events.once('finish', unsubscribe)
 
     await ipfs.pubsub.subscribe(topic, handler, { discover: discover })
 
diff --git a/test/cli/pubsub.js b/test/cli/pubsub.js
index 4a87d0429c..b80eed7f09 100644
--- a/test/cli/pubsub.js
+++ b/test/cli/pubsub.js
@@ -100,23 +100,20 @@ describe('pubsub', function () {
 
   it('ls', function () {
     this.timeout(80 * 1000)
+    let sub
 
-    const sub = cli(`pubsub sub ${topicB}`)
-
-    sub.stdout.once('data', (data) => {
-      expect(data.toString().trim()).to.be.eql('world')
-      cli('pubsub ls')
-        .then((out) => {
-          expect(out.trim()).to.be.eql(topicB)
-          sub.kill()
-        })
+    return new Promise((resolve, reject) => {
+      sub = cli(`pubsub sub ${topicB}`)
+      sub.stdout.once('data', d => resolve(d.toString().trim()))
+      delay(200).then(() => cli(`pubsub pub ${topicB} world`))
     })
-
-    return Promise.all([
-      sub.catch(ignoreKill),
-      delay(200)
-        .then(() => cli(`pubsub pub ${topicB} world`))
-    ])
+      .then(data => expect(data).to.be.eql('world'))
+      .then(() => cli('pubsub ls'))
+      .then(out => {
+        expect(out.trim()).to.be.eql(topicB)
+        sub.kill()
+        return sub.catch(ignoreKill)
+      })
   })
 
   it('peers', (done) => {

From ff6fb0b363ff3caf5036b385c08370d5a7a053d5 Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Tue, 29 Jan 2019 13:22:46 +0000
Subject: [PATCH 47/49] fix: allow pass CID path

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/api/resources/files-regular.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/http/api/resources/files-regular.js b/src/http/api/resources/files-regular.js
index ac6213ee82..0ee0c35ca7 100644
--- a/src/http/api/resources/files-regular.js
+++ b/src/http/api/resources/files-regular.js
@@ -39,7 +39,7 @@ exports.parseKey = (request, h) => {
     throw Boom.badRequest("Argument 'key' is required")
   }
 
-  if (!isIpfs.ipfsPath(arg) && !isIpfs.cid(arg)) {
+  if (!isIpfs.ipfsPath(arg) && !isIpfs.cid(arg) && !isIpfs.ipfsPath('/ipfs/' + arg)) {
     throw Boom.badRequest('invalid ipfs ref path')
   }
 

From e630a7e88a77bc989b36b12c41acacc104a563fd Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Tue, 29 Jan 2019 14:05:30 +0000
Subject: [PATCH 48/49] fix: disconnect event for bandwidth stats

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 src/http/api/resources/stats.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/http/api/resources/stats.js b/src/http/api/resources/stats.js
index 4f46f92b93..616b678154 100644
--- a/src/http/api/resources/stats.js
+++ b/src/http/api/resources/stats.js
@@ -33,7 +33,7 @@ exports.bw = async (request, h) => {
     }
   })
 
-  request.on('disconnect', () => {
+  request.events.on('disconnect', () => {
     res.destroy()
   })
 

From f7515d126123b0faaf2c174f51e4d823ad14e898 Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Thu, 31 Jan 2019 21:32:28 +0000
Subject: [PATCH 49/49] chore: update ipfs-mfs dependency

License: MIT
Signed-off-by: Alan Shaw <alan.shaw@protocol.ai>
---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 5d8a65d014..58d8337540 100644
--- a/package.json
+++ b/package.json
@@ -110,7 +110,7 @@
     "ipfs-block-service": "~0.15.1",
     "ipfs-http-client": "^29.0.0",
     "ipfs-http-response": "~0.2.1",
-    "ipfs-mfs": "github:ipfs/js-ipfs-mfs#refactor/hapi-18",
+    "ipfs-mfs": "0.9.0",
     "ipfs-multipart": "~0.1.0",
     "ipfs-repo": "~0.26.1",
     "ipfs-unixfs": "~0.1.16",