First pass at daemon

Author: andrewosh

bin/mount.js

@@ -0,0 +1,49 @@
+const p = require('path')
+const request = require('request-promise-native')
+const chalk = require('chalk')
+
+const { loadMetadata, createMetadata } = require('../lib/metadata')
+
+exports.command = 'mount <mnt> [key]'
+exports.desc = 'Mount a hyperdrive at the specified mountpoint.'
+exports.builder = {
+  sparse: {
+    description: 'Create a sparse content feed.',
+    type: 'boolean',
+    default: true
+  },
+  sparseMetadata: {
+    description: 'Create a sparse metadata feed.',
+    type: 'boolean',
+    default: true
+  }
+}
+exports.handler = async function (argv) {
+  try {
+    let metadata = await loadMetadata()
+    let body = {
+      sparse: argv.sparse,
+      sparseMetadata: argv.sparseMetadata,
+      key: argv.key,
+      mnt: p.resolve(argv.mnt)
+    }
+    let rsp = await request(`${metadata.endpoint}/mount`, {
+      method: 'POST',
+      json: true,
+      auth: {
+        bearer: metadata.token
+      },
+      body,
+      resolveWithFullResponse: true,
+    })
+    if (rsp.statusCode === 201) {
+      let { key, mnt } = rsp.body
+      console.log(chalk.green(`Mounted ${key} at ${mnt}`))
+    } else {
+      console.error(chalk.red(`Could not mount hyperdrive: ${rsp.body}`))
+    }
+  } catch (err) {
+    console.error(chalk.red(`Could not mount hyperdrive: ${err}`))
+  }
+}
+

bin/start.js

@@ -0,0 +1,52 @@
+const p = require('path')
+const { URL } = require('url')
+const request = require('request-promise-native')
+const chalk = require('chalk')
+const { Monitor }  = require('forever-monitor')
+const forever = require('forever')
+
+const { loadMetadata, createMetadata } = require('../lib/metadata')
+
+exports.command = 'start'
+exports.desc = 'Start the Hypermount daemon.'
+exports.builder = {
+  port: {
+    description: 'The HTTP port that the daemon will bind to.',
+    type: 'number',
+    default: 3101
+  },
+  replicationPort: {
+    description: 'The port that the hypercore replicator will bind to.',
+    type: 'number',
+    default: 3102
+  }
+}
+exports.handler = async function (argv) {
+  let metadata = await loadMetadata()
+  if (metadata) {
+    try {
+      await request.get(new URL('/status', metadata.endpoint).toString(), {
+        auth: {
+          bearer: metadata.token
+        }
+      })
+    } catch (err) {
+      await start(argv)
+    }
+  } else {
+    await start(argv)
+  }
+}
+
+async function start (argv) {
+  let endpoint = `http://localhost:${argv.port}`
+  await createMetadata(endpoint)
+  forever.startDaemon(p.join(__dirname, '..', 'index.js'), {
+    max: 1,
+    logFile: './hypermount.log',
+    outFile: './hypermount.log',
+    errFile: './hypermount.log',
+    args: ['--replicationPort', argv.replicationPort, '--port', argv.port]
+  })
+  console.log(chalk.green(`Daemon started at ${endpoint}`))
+}

bin/status.js

@@ -0,0 +1,26 @@
+const request = require('request-promise-native')
+const chalk = require('chalk')
+
+const { loadMetadata, createMetadata } = require('../lib/metadata')
+
+exports.command = 'status'
+exports.desc = 'Get information about the hypermount daemon.'
+exports.handler = async function (argv) {
+  try {
+    let metadata = await loadMetadata()
+    let rsp = await request.get(new URL('/status', metadata.endpoint).toString(), {
+      auth: {
+        bearer: metadata.token
+      },
+      resolveWithFullResponse: true
+    })
+    if (rsp.statusCode === 200) {
+      console.log(chalk.green('The daemon is up and running!'))
+    } else {
+      console.log(chalk.orange('Cannot get the deamon\'s status. Did you start it?'))
+    }
+  } catch (err) {
+    console.error(chalk.red(`Could not get server status: ${err}`))
+  }
+}
+

bin/stop.js

@@ -0,0 +1,6 @@
+exports.command = 'stop'
+exports.desc = 'Stop the Hypermount daemon.'
+exports.handler = function (argv) {
+  console.log('stop called for args', argv)
+}
+

bin/unmount.js

@@ -0,0 +1,32 @@
+const p = require('path')
+const request = require('request-promise-native')
+const chalk = require('chalk')
+
+const { loadMetadata, createMetadata } = require('../lib/metadata')
+
+exports.command = 'unmount <mnt>'
+exports.desc = 'Unmount the hyperdrive that was mounted at the specified mountpoint.'
+exports.handler = async function (argv) {
+  try {
+    let metadata = await loadMetadata()
+    let body = {
+      mnt: p.resolve(argv.mnt)
+    }
+    let rsp = await request(`${metadata.endpoint}/unmount`, {
+      method: 'POST',
+      json: true,
+      auth: {
+        bearer: metadata.token
+      },
+      body,
+      resolveWithFullResponse: true,
+    })
+    if (rsp.statusCode === 200) {
+      console.log(chalk.green(`Unmounted hyperdrive at ${argv.mnt}`))
+    } else {
+      console.error(chalk.red(`Could not unmount hyperdrive: ${rsp.body}`))
+    }
+  } catch (err) {
+    console.error(chalk.red(`Could not unmount hyperdrive: ${err}`))
+  }
+}

cli.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+
+const datEncoding = require('dat-encoding')
+const forever = require('forever-monitor')
+const yargs = require('yargs')
+
+yargs.commandDir('bin')
+  .demandCommand()
+  .help()
+  .argv

index.js

@@ -0,0 +1,99 @@
+const datEncoding = require('dat-encoding')
+const corestore = require('corestore')
+const hyperdrive = require('hyperdrive')
+const hyperfuse = require('hyperdrive-fuse')
+const express = require('express')
+const level = require('level')
+const argv = require('yargs').argv
+
+const { loadMetadata } = require('./lib/metadata')
+
+class Hypermount {
+  constructor (store) {
+    this.store = store
+  }
+
+  mount (key, mnt, opts) {
+    if (typeof opts === 'function') return this.mount(key, mnt, null, opts)
+    opts = opts || {}
+
+    const factory = (key, coreOpts) => {
+      coreOpts.seed = (opts.seed !== undefined) ? opts.seed : true
+      return this.store.get(key, coreOpts)
+    }
+    const drive = hyperdrive(factory, key, {
+      ...opts,
+      factory: true,
+      sparse: (opts.sparse !== undefined) ? opts.sparse : true,
+      sparseMetadata: (opts.sparseMetadata !== undefined) ? opts.sparseMetadata : true
+    })
+
+    return hyperfuse.mount(drive, mnt) 
+  }
+
+  unmount (mnt) {
+    return hyperfuse.unmount(mnt) 
+  }
+
+  close () {
+    return this.store.close()
+  }
+}
+
+async function start () {
+  const metadata = await loadMetadata()
+  const store = corestore(argv.storage || './storage', {
+    network: {
+      port: argv.replicationPort || 3006
+    }
+  })
+  const hypermount = new Hypermount(store)
+  const app = express()
+
+  app.use(express.json())
+  app.use((req, res, next) => {
+    if (!req.headers.authorization) return res.sendStatus(403)
+    if (!req.headers.authorization === `Bearer ${metadata.token}`) return res.sendStatus(403)
+    return next()
+  })
+
+  app.post('/mount', async (req, res) => {
+    try {
+      console.log('req.body:', req.body)
+      let { key, mnt } = await hypermount.mount(req.body.key, req.body.mnt, req.body)
+      return res.status(201).json({ key, mnt })
+    } catch (err) {
+      console.error('Mount error:', err)
+      return res.sendStatus(500)
+    }
+  })
+  app.post('/unmount', async (req, res) => {
+    try {
+      await hypermount.unmount(req.body.mnt)
+      return res.sendStatus(200)
+    } catch (err) {
+      console.error('Unmount error:', err)
+      return res.sendStatus(500)
+    }
+  })
+  app.post('/close', async (req, res) => {
+    try {
+      await store.close()
+      server.close()
+      return res.sendStatus(200)
+    } catch (err) {
+      console.error('Close error:', err)
+      return res.sendStatus(500)
+    }
+  })
+  app.get('/status', async (req, res) => {
+    return res.sendStatus(200)
+  })
+
+  await store.ready()
+  var server = app.listen(argv.port || 3005)
+}
+
+if (require.main === module) {
+  start()
+}

lib/metadata.js

@@ -0,0 +1,36 @@
+const p = require('path')
+const os = require('os')
+const fs = require('fs-extra')
+
+const sodium = require('sodium-universal')
+
+const METADATA_FILE_PATH = p.join(os.homedir(), '.hypermount')
+
+async function loadMetadata () {
+  try {
+    let contents = await fs.readFile(METADATA_FILE_PATH)
+    if (contents) contents = JSON.parse(contents)
+    return contents
+  } catch (err) {
+    return null
+  }
+}
+
+async function createMetadata (endpoint) {
+  const rnd = Buffer.allocUnsafe(64)
+  sodium.randombytes_buf(rnd)
+  return fs.writeFile(METADATA_FILE_PATH, JSON.stringify({
+    token: rnd.toString('hex'),
+    endpoint
+  }))
+}
+
+async function deleteMetadata () {
+  return fs.unlink(METADATA_FILE_PATH)
+}
+
+module.exports = {
+  createMetadata,
+  loadMetadata,
+  deleteMetadata
+}

package.json

@@ -0,0 +1,47 @@
+{
+  "name": "hypermount",
+  "version": "1.0.0",
+  "description": "A FUSE-mountable distributed filesystem, built on Hyperdrive",
+  "main": "index.js",
+  "bin": {
+    "hypermount": "./cli.js"
+  },
+  "scripts": {
+    "test": "tape test/*.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/andrewosh/hypermount.git"
+  },
+  "keywords": [
+    "hyperdrive",
+    "fuse",
+    "daemon"
+  ],
+  "author": "Andrew Osheorff <[email protected]>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/andrewosh/hypermount/issues"
+  },
+  "homepage": "https://github.com/andrewosh/hypermount#readme",
+  "dependencies": {
+    "chalk": "^2.4.2",
+    "corestore": "^1.2.2",
+    "dat-encoding": "^5.0.1",
+    "express": "^4.16.4",
+    "forever": "^0.15.3",
+    "forever-monitor": "^1.7.1",
+    "fs-extra": "^7.0.1",
+    "hyperdrive": "git+https://github.com/andrewosh/hyperdrive.git#fuse-testing",
+    "hyperdrive-fuse": "git+https://github.com/andrewosh/hyperdrive-fuse",
+    "level": "^4.0.0",
+    "request": "^2.88.0",
+    "request-promise-native": "^1.0.7",
+    "sodium-universal": "^2.0.0",
+    "yargs": "^13.2.1"
+  },
+  "devDependencies": {
+    "standard": "^12.0.1",
+    "tape": "^4.10.1"
+  }
+}