Root drive mounting works

Author: andrewosh

bin/setup.js

@@ -1,5 +1,5 @@
 const p = require('path')
-const { spawn } = require('child_process')
+const { spawn, exec } = require('child_process')
 
 const hyperfuse = require('hyperdrive-fuse')
 const ora = require('ora')
@@ -9,11 +9,32 @@ exports.command = 'setup'
 exports.desc = 'Run a one-time configuration step for FUSE.'
 exports.handler = async function (argv) {
   console.log(chalk.blue('Configuring FUSE...'))
-  const child = spawn('sudo', ['node', p.join(__dirname, '../scripts/configure.js')], {
-    stdio: 'inherit'
-  })
-  child.on('exit', code => {
-    if (code !== 0) return console.error(chalk.red(`Could not configure FUSE.`))
-    console.log(chalk.green('Successfully configured FUSE!'))
+  hyperfuse.isConfigured((err, configured) => {
+    if (err) return onerror(err)
+    if (configured) return onsuccess('FUSE is already configured!')
+    return configure()
   })
+
+  function configure () {
+    exec('which node', (err, nodePath) => {
+      if (err) return onerror(err)
+      nodePath = nodePath.trim()
+      const child = spawn('sudo', [nodePath, p.join(__dirname, '../scripts/configure.js')], {
+        stdio: 'inherit'
+      })
+      child.on('exit', code => {
+        if (code !== 0) return onerror() 
+        return onsuccess('Successfully configured FUSE!')
+      })
+    })
+  }
+
+  function onsuccess (msg) {
+    console.log(chalk.green(msg))
+  }
+
+  function onerror (err) {
+    console.error(chalk.red(`Could not configure FUSE.`))
+    if (err) console.error(chalk.red(err))
+  }
 }

bin/start.js

@@ -21,16 +21,13 @@ exports.builder = {
 }
 exports.handler = async function (argv) {
   const client = new HyperdriveClient(`localhost:${argv.port}`)
-  console.log(0)
   client.ready(err => {
-    console.log('err:', err)
     if (err) return onerror(err)
     console.log(chalk.green('The Hyperdrive daemon is already running.'))
   })
 
   function onerror (err) {
     if (!err.disconnected) return showError(err)
-    console.log('starting here')
     start(argv).catch(showError)
   }
 
@@ -41,7 +38,6 @@ exports.handler = async function (argv) {
 }
 
 async function start (argv) {
-  console.log('in start')
   let endpoint = `localhost:${argv.port}`
   await createMetadata(endpoint)
   forever.startDaemon(p.join(__dirname, '..', 'index.js'), {

index.js

@@ -30,14 +30,21 @@ class HyperdriveDaemon extends EventEmitter {
     this.db = level(`${storage}/db`, { valueEncoding: 'json' })
     this.opts = opts
 
+    const dbs = {
+      megastore: sub(this.db, 'megastore'),
+      fuse: sub(this.db, 'fuse', { valueEncoding: 'json' }),
+      drives: sub(this.db, 'drives', { valueEncoding: 'json' })
+    }
+
     const megastoreOpts = {
       storage: path => raf(`${storage}/cores/${path}`),
-      db: sub(this.db, 'megastore'),
+      db: dbs.megastore,
       networker: new SwarmNetworker(opts.network)
     }
+
     this.megastore = new Megastore(megastoreOpts.storage, megastoreOpts.db , megastoreOpts.networker)
-    this.drives = new DriveManager(this.megastore, sub(this.db, 'drives'), this.opts)
-    this.fuse = hyperfuse ? new FuseManager(this.megastore, this.drives, sub(this.db, 'fuse'), this.opts) : null
+    this.drives = new DriveManager(this.megastore, dbs.drives, this.opts)
+    this.fuse = hyperfuse ? new FuseManager(this.megastore, this.drives, dbs.fuse, this.opts) : null
 
     this.drives.on('error', err => this.emit('error', err))
     this.fuse.on('error', err => this.emit('error', err))
@@ -90,34 +97,33 @@ async function start () {
   const storageRoot = argv.storage
   await ensureStorage()
 
-  const hypermount = new HyperdriveDaemon(storageRoot)
-  await hypermount.ready()
+  const daemon = new HyperdriveDaemon(storageRoot)
+  await daemon.ready()
 
   const server = new grpc.Server();
   if (hyperfuse) {
     server.addService(rpc.fuse.services.FuseService, {
-      ...authenticate(metadata, catchErrors(createFuseHandlers(this.fuseManager)))
+      ...wrap(metadata, createFuseHandlers(daemon.fuse), { authenticate: true })
     })
   }
   server.addService(rpc.drive.services.DriveService, {
-    ...authenticate(metadata, catchErrors(createDriveHandlers(this.driveManager)))
+    ...wrap(metadata, createDriveHandlers(daemon.drives), { authenticate: true })
   })
   server.addService(rpc.main.services.HyperdriveService, {
-    ...authenticate(metadata, catchErrors(createMainHandlers(this)))
+    ...wrap(metadata, createMainHandlers(daemon), { authenticate: true })
   })
 
-  console.log('binding server...')
   server.bind(`0.0.0.0:${argv.port}`, grpc.ServerCredentials.createInsecure())
   server.start()
-  console.log('server started.')
+  log.info({ port: argv.port }, 'server listening')
 
   process.once('SIGINT', cleanup)
   process.once('SIGTERM', cleanup)
   process.once('unhandledRejection', cleanup)
   process.once('uncaughtException', cleanup)
 
   async function cleanup () {
-    await hypermount.close()
+    await daemon.close()
     server.tryDestroy()
   }
 
@@ -131,26 +137,47 @@ async function start () {
   }
 }
 
-function authenticate (metadata, methods) {
-  const authenticated = {}
+function wrap (metadata, methods) {
+  const promisified = promisify(methods)
+  let authenticated = authenticate(metadata, methods)
+}
+
+function wrap (metadata, methods, opts) {
+  const wrapped = {}
+  const authenticate = opts && opts.authenticate
   for (const methodName of Object.keys(methods)) {
     const method = methods[methodName]
-    authenticated[methodName] = function (call, ...args) {
-      const cb = args[args.length - 1]
-      const token = call.metadata && call.metadata.token
-      if (!token || !token.equals(metadata.token)) {
-        const err = {
-          code: grpc.status.UNAUTHENTICATED,
-          message: 'Invalid auth token.'
+    wrapped[methodName] = function (call, ...args) {
+      const tag = { method: methodName, received: Date.now() }
+      const cb = args.length ? args[args.length - 1] : null
+      if (authenticate) {
+        let token = call.metadata && call.metadata.get('token')
+        if (token) token = token[0]
+        log.trace({ ...tag, token }, 'received token')
+        if (!token || token !== metadata.token) {
+          log.error(tag, 'request authentication failed')
+          const err = {
+            code: grpc.status.UNAUTHENTICATED,
+            message: 'Invalid auth token.'
+          }
+          if (cb) return cb(err)
+          return call.destroy(err)
         }
-        if (cb) return cb(err)
-        return call.destroy(err)
+        log.debug(tag, 'request authentication succeeded')
       }
-
-      return method(call, ...args)
+      method(call)
+        .then(rsp => {
+          log.debug(tag, 'request was successful')
+          if (cb) return cb(null, rsp)
+        })
+        .catch(err => {
+          log.error({ ...tag, error: err.toString(), stack: err.stack }, 'request failed')
+          if (cb) return cb(serverError(err))
+          return call.destroy(err)
+        })
     }
   }
-  return authenticated
+  return wrapped
 }
 
 function createMainHandlers (daemon) {

lib/drives/index.js

@@ -30,13 +30,28 @@ class DriveManager extends EventEmitter {
     this.ready = () => Promise.resolve()
   }
 
-  _configureDrive (drive) {
+  _configureDrive (drive, opts) {
     // TODO: Extract this into a separate, easily-modifiable script.
     return new Promise((resolve, reject) => {
-      drive.writeFile('.key', drive.key.toString('hex'), err => {
-        if (err) return reject(err)
-        return resolve()
+      drive.readFile('.key', err => {
+        if (err && !err.errno === 2) return reject(err)
+        if (err) return configure()
+        return resolve(0)
       })
+
+      function configure () {
+        drive.writeFile('.key', drive.key.toString('hex'), err => {
+          if (err) return reject(err)
+          if (opts && opts.rootDrive) {
+            drive.mkdir('/home', err => {
+              if (err) return reject(err)
+              return resolve(err)
+            })
+          } else {
+            return resolve()
+          }
+        })
+      }
     })
   }
 
@@ -95,7 +110,7 @@ class DriveManager extends EventEmitter {
       newDrive = true
     }
 
-    log.debug({ name, key, opts }, 'creating a hyperdrive')
+    // log.debug({ name, key, opts }, 'creating a hyperdrive')
     const corestore = this.megastore.get(name)
     const driveOpts = {
       ...opts,
@@ -110,8 +125,11 @@ class DriveManager extends EventEmitter {
         return resolve()
       })
     })
+    key = datEncoding.encode(drive.key)
 
-    await this._configureDrive(drive)
+    if (drive.writable) {
+      await this._configureDrive(drive, opts && opts.configure)
+    }
     if (newDrive && this.opts.stats) {
       this._collectStats(drive)
     }

lib/errors.js

@@ -3,42 +3,19 @@ const grpc = require('grpc')
 function serverError (err) {
   return {
     code: grpc.status.UNKNOWN,
-    msg: err.toString()
+    message: err.toString()
   }
 }
 
-function requestError (msg) {
+function requestError (message) {
   return {
     // TODO: better error code for malformed requests?
     code: grpc.status.UNIMPLEMENTED,
-    msg
+    message
   }
 }
 
-function catchErrors (methods) {
-  const checked = {}
-  for (const methodName of Object.keys(methods)) {
-    const method = methods[methodName]
-    checked[methodName] = function (call, ...args) {
-      // TODO: Support better middleware so that this can be extracted.
-      const cb = args[args.length - 1]
-      method(call)
-        .then(rsp => {
-          if (cb) return cb(null, rsp)
-          return call.end(rsp)
-        })
-        .catch(err => {
-          const error = serverError(err)
-          if (cb) return cb(error)
-          return call.destroy(error)
-        })
-    }
-  }
-  return checked
-}
-
 module.exports = {
   serverError,
-  requestError,
-  catchErrors
+  requestError
 }