Many new tests + fuse setup fix

Author: andrewosh

bin/commands/fuse-setup.js

@@ -60,6 +60,8 @@ class SetupCommand extends Command {
       // Emitting errors here would just be confusing, so suppress.
     }
 
+    this.exit(0)
+
     async function configureFuse (cb) {
       const configured = await new Promise((resolve, reject) => {
         hyperfuse.isConfigured((err, fuseConfigured) => {

index.js

@@ -35,7 +35,9 @@ const TREE_CACHE_SIZE = TOTAL_CACHE_SIZE * CACHE_RATIO
 const DATA_CACHE_SIZE = TOTAL_CACHE_SIZE * (1 - CACHE_RATIO)
 
 // This is set dynamically in refreshFuse.
-var hyperfuse = null
+try {
+  var hyperfuse = require('hyperdrive-fuse')
+} catch (err) {}
 
 class HyperdriveDaemon extends EventEmitter {
   constructor (opts = {}) {
@@ -265,16 +267,21 @@ class HyperdriveDaemon extends EventEmitter {
 
           if (hyperfuse) {
             rsp.setFuseavailable(true)
-            const configured = await this._isFuseConfigured()
-            rsp.setFuseconfigured(configured)
+            rsp.setFuseconfigured(this.fuse.fuseConfigured)
           } else {
             rsp.setFuseavailable(false)
+            rsp.setFuseconfigured(false)
           }
         }
         return rsp
       },
       refreshFuse: async call => {
         await this.fuse.ready()
+        if (this.fuse && this.fuse.fuseConfigured) {
+          hyperfuse = require('hyperdrive-fuse')
+          this._versions.fuseNative = require('fuse-native/package.json').version
+          this._versions.hyperdriveFuse = require('hyperdrive-fuse/package.json').version
+        }
         return new rpc.main.messages.FuseRefreshResponse()
       }
     }

lib/drives/index.js

@@ -132,18 +132,20 @@ class DriveManager extends EventEmitter {
   closeSession (id) {
     const drive = this._sessions.get(id)
     if (!drive) return null
+
     const driveKey = drive.key.toString('hex')
     const driveSessions = this._sessionsByKey.get(driveKey)
     this._sessions.delete(id)
-    driveSessions.splice(driveSessions.indexOf(id), 1)
+    const idx = driveSessions.indexOf(id)
+    if (idx !== -1) driveSessions.splice(driveSessions.indexOf(id), 1)
 
     // If there are still active sessions, don't close the drive.
     if (driveSessions.length) return null
 
     log.debug({ id, key: driveKey }, 'closing drive because all associated sessions have closed')
     this._sessionsByKey.delete(driveKey)
 
-    // If a drive is closed in memory-only mode, its storage will be deleted.
+    // If a drive is closed in memory-only mode, its storage will be deleted, so don't actually close.
     if (this.memoryOnly) {
       log.debug({ id, key: driveKey }, 'aborting drive close because we\'re in memory-only mode')
       return null

manager.js

@@ -68,6 +68,7 @@ async function start (opts = {}) {
 
   var interpreter = opts.interpreter || process.execPath
   var interpreterArgs = `--max-old-space-size=${opts.heapSize}`
+  console.log('interpreterArgs:', interpreterArgs)
   if (!IS_WINDOWS) {
     const execArg = [interpreter, interpreterArgs, script].concat(args).map(escapeStringArg).join(' ')
     args = ['-c', execArg]
@@ -90,9 +91,15 @@ async function start (opts = {}) {
   }
 
   try {
-    await removeOldLogs()
+    if (opts.structuredLog === constants.structuredLog) {
+      await fs.rename(constants.structuredLog, constants.structuredLog.replace('.json', '.old.json'))
+    }
+    if (opts.unstructuredLog === constants.unstructuredLog) {
+      await fs.rename(constants.unstructuredLog, constants.unstructuredLog.replace('.log', '.old.log'))
+    }
   } catch (err) {
-    // If the log file couldn't be deleted, it's OK.
+    console.log('err:', err)
+    // If the log file couldn't be rotated, it's OK.
   }
 
   if (opts.foreground) {
@@ -101,13 +108,6 @@ async function start (opts = {}) {
     return startDaemon(description, opts)
   }
 
-  function removeOldLogs () {
-    return Promise.all([
-      fs.unlink(description.output),
-      fs.unlink(description.error)
-    ])
-  }
-
   function startForeground (description, opts) {
     const daemon = new HyperdriveDaemon({ ...opts, metadata: null, main: true })
     process.title = 'hyperdrive'

test/hyperdrive.js

@@ -481,6 +481,45 @@ test('can mount a drive within a remote hyperdrive multiple times', async t => {
   t.end()
 })
 
+test('can mount a versioned drive within a remote hyperdrive', async t => {
+  const { client, cleanup } = await createOne()
+
+  try {
+    const drive1 = await client.drive.get()
+
+    const drive2 = await client.drive.get()
+    await drive2.writeFile('hamster', 'wheel')
+    const version1 = await drive2.version()
+    await drive2.writeFile('blah', 'blahblah')
+
+    await drive1.mount('a', { key: drive2.key })
+    await drive1.mount('aStatic', { key: drive2.key, version: version1 })
+
+    await drive1.writeFile('a/hello', 'world')
+    await drive1.writeFile('adios', 'amigo')
+
+    t.same(await drive1.readFile('adios'), Buffer.from('amigo'))
+    t.same(await drive1.readFile('a/hello'), Buffer.from('world'))
+    t.same(await drive2.readFile('hello'), Buffer.from('world'))
+    t.same(await drive2.readFile('hamster'), Buffer.from('wheel'))
+    t.same(await drive1.readFile('aStatic/hamster'), Buffer.from('wheel'))
+    try {
+      await drive1.readFile('aStatic/blah')
+      t.fail('aStatic should be a versioned mount')
+    } catch (err) {
+      t.true(err)
+    }
+
+    await drive1.close()
+    await drive2.close()
+  } catch (err) {
+    t.fail(err)
+  }
+
+  await cleanup()
+  t.end()
+})
+
 test('can unmount a drive within a remote hyperdrive', async t => {
   const { client, cleanup } = await createOne()
 
@@ -604,8 +643,7 @@ test('can create a symlink to directories', async t => {
   t.end()
 })
 
-// TODO: Stop skipping once we've updated hyperdrive/mountable-hypertrie to nanoresource.
-test.skip('drives are closed when all corresponding sessions are closed', async t => {
+test('drives are closed when all corresponding sessions are closed', async t => {
   const { client, cleanup, daemon } = await createOne()
 
   try {
@@ -630,6 +668,66 @@ test.skip('drives are closed when all corresponding sessions are closed', async
   t.end()
 })
 
+test('reopening a drive after previously closed works', async t => {
+  const { client, cleanup, daemon } = await createOne()
+
+  try {
+    var drive = await client.drive.get()
+    const driveKey = drive.key
+    await drive.writeFile('a', 'a')
+    await drive.writeFile('b', 'b')
+    await drive.writeFile('c', 'c')
+    const otherDrive = await client.drive.get({ key: driveKey })
+    const checkout1 = await client.drive.get({ key: driveKey, version: 1 })
+
+    await drive.close()
+    t.same(daemon.drives._drives.size, 2)
+    await otherDrive.close()
+    t.same(daemon.drives._drives.size, 2)
+    await checkout1.close()
+    t.same(daemon.drives._drives.size, 0)
+
+    drive = await client.drive.get({ key: driveKey })
+    await drive.writeFile('d', 'd')
+    const contents = await drive.readFile('a')
+    t.same(contents, Buffer.from('a'))
+  } catch (err) {
+    t.fail(err)
+  }
+
+  await cleanup()
+  t.end()
+})
+
+test('many quick closes/reopens', async t => {
+  const NUM_CYCLES = 10
+  const { client, cleanup, daemon } = await createOne()
+  var driveKey = null
+  const expected = new Array(NUM_CYCLES).fill(0).map((_, i) => '' + i)
+
+  try {
+    for (let i = 0; i < NUM_CYCLES; i++) {
+      var drive = await client.drive.get({ key: driveKey })
+      if (!driveKey) driveKey = drive.key
+      await drive.writeFile(expected[i], expected[i])
+      await drive.close()
+      if (daemon.drives._drives.size !== 0) t.fail('session close did not trigger drive close')
+    }
+    drive = await client.drive.get({ key: driveKey })
+    const actual = []
+    for (let i = 0; i < NUM_CYCLES; i++) {
+      const contents = await drive.readFile(expected[i])
+      actual[i] = contents.toString('utf8')
+    }
+    t.same(expected, actual)
+  } catch (err) {
+    t.fail(err)
+  }
+
+  await cleanup()
+  t.end()
+})
+
 test('drives are writable after a daemon restart', async t => {
   var { dir, client, cleanup } = await createOne()
 
@@ -656,6 +754,33 @@ test('drives are writable after a daemon restart', async t => {
   t.end()
 })
 
+test('cores are not closed incorrectly during the initial rejoin', async t => {
+  var { dir, client, cleanup } = await createOne()
+
+  try {
+    var drive = await client.drive.get()
+    const driveKey = drive.key
+    await drive.writeFile('a', 'a')
+    await drive.configureNetwork({ announce: true, lookup: true, remember: true })
+
+    await cleanup({ persist: true })
+
+    const newDaemon = await createOne({ dir })
+    client = newDaemon.client
+    cleanup = newDaemon.cleanup
+    drive = await client.drive.get({ key: driveKey })
+
+    t.same(await drive.readFile('a'), Buffer.from('a'))
+    await drive.writeFile('b', 'b')
+    t.same(await drive.readFile('b'), Buffer.from('b'))
+  } catch (err) {
+    t.fail(err)
+  }
+
+  await cleanup()
+  t.end()
+})
+
 test('mounts are writable in memory-only mode', async t => {
   var { client, cleanup } = await createOne({ memoryOnly: true })
 

test/peersockets.js

@@ -277,7 +277,7 @@ test('peersockets, send to all peers swarming a drive, static peers', async t =>
 })
 
 // TODO: There's a nondeterministic failure here on slow machines. Investigate.
-test.skip('peersockets, send to all peers swarming a drive, dynamically-added peers', async t => {
+test('peersockets, send to all peers swarming a drive, dynamically-added peers', async t => {
   const NUM_PEERS = 10
 
   const { clients, daemons, cleanup } = await create(NUM_PEERS)

test/replication.js

@@ -555,7 +555,7 @@ test('can get peer info for one discovery key', async t => {
 })
 
 // This will hang until we add timeouts to the hyperdrive reads.
-test.skip('can continue getting drive info after remote content is cleared (no longer available)', async t => {
+test('can continue getting drive info after remote content is cleared (no longer available)', async t => {
   const { clients, cleanup, daemons } = await create(2)
   const firstClient = clients[0]
   const secondClient = clients[1]
@@ -585,7 +585,6 @@ test.skip('can continue getting drive info after remote content is cleared (no l
 
   async function clearContent (metadataKeys, store) {
     const metadataKeySet = new Set(metadataKeys.map(k => k.toString('hex')))
-    console.log('external cores:', store._externalCores)
     for (const [, core] of store._externalCores) {
       if (metadataKeySet.has(core.key.toString('hex'))) continue
       await new Promise((resolve, reject) => {