autobee 2.0.0-rc.13 → 2.0.0-rc.15

package/index.js

@@ -14,7 +14,7 @@ const asserts = require('./lib/asserts.js')
 const boot = require('./lib/boot.js')
 const { resolveWeight, currentWeight } = require('./lib/witness.js')
 const encoding = require('./lib/encoding.js')
-const Reboot = require('./lib/reboot.js')
+const FastForward = require('./lib/fast-forward.js')
 const System = require('./lib/system.js')
 const ApplyCalls = require('./lib/apply-calls.js')
 const topo = require('./lib/topo.js')
@@ -57,6 +57,7 @@ module.exports = class Autobee extends ReadyResource {
     this.id = null
     this.bootstrap = null
     this.handlers = handlers
+    this.stats = { undos: 0, fastForwards: 0, drains: 0, applies: 0, appends: 0 }
 
     this.system = new System(this.store.namespace('system'), this.name, {
       getEncryptionProvider: this.getSystemEncryption,
@@ -84,9 +85,9 @@ module.exports = class Autobee extends ReadyResource {
     // conservative (default on): only fast-forward onto a head someone can serve whole
     this._conservativeFF = fastForward.conservative !== false
 
-    this.reboot = null
-    this.rebooting = null
-    this.rebootTo = null
+    this.ff = null
+    this.fastForwarding = null
+    this.fastForwardTo = null
 
     this._workingBee = bee
     this._workingView = handlers.open ? handlers.open(this._workingBee, this) : this._workingBee
@@ -249,6 +250,8 @@ module.exports = class Autobee extends ReadyResource {
         session.clearRequests(session.activeRequests, closingError)
       }
     }
+
+    if (this.fastForwarding) this.fastForwarding.clearRequests(closingError)
   }
 
   async changesFrom({ system } = {}) {
@@ -440,8 +443,6 @@ module.exports = class Autobee extends ReadyResource {
   async _bump() {
     if (!(await this._bootReady())) return
 
-    await this._flushWakeup()
-
     this.bumping++
 
     if (!this._draining) {
@@ -498,6 +499,8 @@ module.exports = class Autobee extends ReadyResource {
   async _drain() {
     if (this._updating) await this._updating
 
+    this.stats.drains++
+
     if (this.bootFrom) {
       await this._initFromHead(this.bootFrom)
       this.bootFrom = null
@@ -522,8 +525,11 @@ module.exports = class Autobee extends ReadyResource {
 
       try {
         while (!this._interrupting) {
-          if (this.rebootTo !== null) {
-            await this._applyReboot()
+          await this._flushWakeup()
+          if (this._interrupting) break
+
+          if (this.fastForwardTo !== null) {
+            await this._applyFastForward()
             break // revaluate conditions...
           }
 
@@ -590,15 +596,28 @@ module.exports = class Autobee extends ReadyResource {
 
   async _flushWakeup() {
     const hints = this._wakeup.flush()
+    if (!hints.size) return
 
     this.previousDrain = Date.now()
-    this.rebootFromHeads(hints).catch(noop)
 
     for (const [hex, length] of hints) {
       const key = b4a.from(hex, 'hex')
       if (this.writers.has(hex)) continue
       await this.writers.wakeup(key, length)
     }
+
+    // a scheduled fast-forward is applied by the drain before we look again
+    if (this.fastForwardTo !== null) return
+    if (this._interrupting || this.closing) return
+
+    try {
+      await this.fastForwardFromHeads(hints, { wait: false, timeout: FastForward.DEFAULT_TIMEOUT })
+    } catch (err) {
+      safetyCatch(err)
+      return false
+    }
+
+    return true
   }
 
   async _getOplog(key, length, opts = null) {
@@ -731,7 +750,7 @@ module.exports = class Autobee extends ReadyResource {
     await this.bootstrap.setUserData('autobee/local', this.local.key)
     await oldLocal.close()
 
-    // done, soft reboot
+    // done, soft restart
     this.emit('rotate-local-writer')
   }
 
@@ -919,6 +938,7 @@ module.exports = class Autobee extends ReadyResource {
     const t = await topo.sort(this, batch)
 
     if (t.undo) {
+      this.stats.undos++
       t.view = await this.system.undo(t.undo)
     }
 
@@ -967,6 +987,7 @@ module.exports = class Autobee extends ReadyResource {
     }
 
     if (this._hasApply && (await this.system.canApply(batch[0].key, optimistic))) {
+      this.stats.applies++
       this._host.applying = batch
       await this._handlers.apply(userBatch, this._workingView, this._host)
       this._host.applying = null
@@ -1035,6 +1056,8 @@ module.exports = class Autobee extends ReadyResource {
   async append(values, { optimistic = false } = {}) {
     if (this.closing) throw new Error('Autobee closed')
 
+    this.stats.appends++
+
     if (!Array.isArray(values)) values = [values]
 
     if (!this.opened) await this.ready()
@@ -1112,10 +1135,10 @@ module.exports = class Autobee extends ReadyResource {
     this._localViewLength = 0
   }
 
-  async rebootFromHeads(hints, { force = false } = {}) {
+  async fastForwardFromHeads(hints, { wait = true, timeout = 0 } = {}) {
     if (!this._handlers.onwakeup) return false
     if (this._interrupting) return false
-    if (!hints.size || this.rebooting || this.rebootTo || this.bootFrom) {
+    if (!hints.size || this.fastForwarding || this.fastForwardTo || this.bootFrom) {
       return false
     }
 
@@ -1125,11 +1148,11 @@ module.exports = class Autobee extends ReadyResource {
       if (length === 0) continue
       const key = b4a.from(hex, 'hex')
       heads.push({ key, length })
-      promises.push(this._getOplog(key, length))
+      promises.push(this._getOplog(key, length, timeout ? { timeout } : null))
     }
 
     const ops = await Promise.all(promises)
-    if (this.rebooting || this.rebootTo) return false
+    if (this.fastForwarding || this.fastForwardTo) return false
 
     let best = null
     let bestFlushes = -1
@@ -1144,10 +1167,6 @@ module.exports = class Autobee extends ReadyResource {
       }
     }
 
-    if (best && force) {
-      return this._rebootFromHead(best, null, { force: true })
-    }
-
     if (best === null || bestFlushes - this.system.flushes < MIN_FF_GAP) return false
 
     const head = { key: best.key, length: best.length }
@@ -1158,24 +1177,30 @@ module.exports = class Autobee extends ReadyResource {
     let trusted = null
     try {
       trusted = await this._handlers.onwakeup(head, view, this)
-      if (!trusted || this.rebooting || this.rebootTo) return false
+      if (!trusted || this.fastForwarding || this.fastForwardTo) return false
     } finally {
       view.close()
     }
 
-    return this._rebootFromHead(best, trusted)
+    return this._fastForwardFromHead(best, trusted, { wait, timeout })
   }
 
-  async _rebootFromHead(head, trusted, { force = false, wait = true } = {}) {
+  async _fastForwardFromHead(head, trusted, { force = false, wait = true, timeout = 0 } = {}) {
     const conservative = !force && this._conservativeFF
+    const timeoutOpts = timeout ? { timeout } : null
 
-    const oplog = await this._getOplog(head.key, head.length, { conservative })
+    const oplog = await this._getOplog(head.key, head.length, {
+      conservative,
+      ...timeoutOpts
+    })
     if (!oplog) return null
 
-    const verified = trusted ? await this._getOplog(trusted.key, trusted.length) : oplog
+    const verified = trusted
+      ? await this._getOplog(trusted.key, trusted.length, timeoutOpts)
+      : oplog
     if (!verified) return null
 
-    // legacy nodes from non-indexers have no system info to reboot from
+    // legacy nodes from non-indexers have no system info to fast-forward from
     if (!oplog.op.views || !verified.op.views) return null
 
     if (!force && verified.op.views.flushes - this.system.flushes < MIN_FF_GAP) {
@@ -1192,7 +1217,7 @@ module.exports = class Autobee extends ReadyResource {
 
     const moved = await this._moveTo(batchToHead(verified.op.views.system), tip)
 
-    if (moved && wait) return this.reboot.promise
+    if (moved && wait) return this.ff.promise
 
     return null
   }
@@ -1201,46 +1226,46 @@ module.exports = class Autobee extends ReadyResource {
   _initFromHead(head, tip) {
     if (!head.length) {
       // legacy fastForward boot
-      return this._runReboot(new Reboot(this, head, tip))
+      return this._runFastForward(new FastForward(this, head, tip))
     }
 
-    return this._rebootFromHead(head, null, { force: true, wait: false })
+    return this._fastForwardFromHead(head, null, { force: true, wait: false })
   }
 
-  // head is a system head; reboots onto it, migrating in place if it's a legacy version
+  // head is a system head; fast-forwards onto it, migrating in place if it's a legacy version
   async _moveTo(systemHead, tip) {
-    if (this.rebootTo !== null || this.rebooting !== null) return false
+    if (this.fastForwardTo !== null || this.fastForwarding !== null) return false
 
-    if (await this._runReboot(new Reboot(this, systemHead, tip))) {
+    if (await this._runFastForward(new FastForward(this, systemHead, tip))) {
       return true
     }
 
     return false
   }
 
-  async _runReboot(reboot) {
-    this.rebooting = reboot
+  async _runFastForward(ff) {
+    this.fastForwarding = ff
 
-    const result = await reboot.run()
-    await reboot.close()
+    const result = await ff.run()
+    await ff.close()
 
-    if (this.rebooting === reboot) this.rebooting = null
+    if (this.fastForwarding === ff) this.fastForwarding = null
 
     if (!result) return false
 
-    this.rebootTo = result
-    this.reboot = rrp()
+    this.fastForwardTo = result
+    this.ff = rrp()
 
     this.bumpSoon()
 
     return true
   }
 
-  async _applyReboot() {
+  async _applyFastForward() {
     const changes = this._hasUpdate ? new UpdateChanges(this) : null
     if (changes) changes.track()
 
-    const { head, tip, migrate } = this.rebootTo
+    const { head, tip, migrate } = this.fastForwardTo
 
     const from = this.system.bee.head()
     const to = head
@@ -1248,7 +1273,7 @@ module.exports = class Autobee extends ReadyResource {
     this.system.bee.move(head)
     await this.system.reset()
 
-    this.system.shared = this.rebootTo.shared || {
+    this.system.shared = this.fastForwardTo.shared || {
       flushes: -1,
       view: EMPTY_HEAD,
       system: EMPTY_HEAD
@@ -1265,15 +1290,16 @@ module.exports = class Autobee extends ReadyResource {
       this._workingBee.move(this.system.view)
     }
 
-    this.rebootTo = null
+    this.fastForwardTo = null
     await this.writers.refresh()
 
     await this._storeBoot()
 
     await this._update(changes)
 
+    this.stats.fastForwards++
     this.emit('move-to', to, from)
-    this.reboot.resolve({ to, from })
+    this.ff.resolve({ to, from })
 
     // tip is null during boot
     if (!tip) return

package/lib/boot.js

@@ -242,6 +242,7 @@ async function getCatchupHeads(core) {
     if (entry.key[0] !== 0x01) continue
 
     const { key, length } = encoding.decodeSystemWriter(entry.key, entry.value)
+    if (!length) continue
     nodes.push({ key, length })
   }
 

package/lib/{reboot.js → fast-forward.js}

@@ -1,5 +1,6 @@
 const safetyCatch = require('safety-catch')
 const b4a = require('b4a')
+const Hypercore = require('hypercore')
 const c = require('compact-encoding')
 const crypto = require('hypercore-crypto')
 
@@ -19,12 +20,18 @@ const [NS_SIGNER_NAMESPACE] = crypto.namespace('autobase', 1)
 const EMPTY = b4a.alloc(0)
 const DEFAULT_OP_TIMEOUT = 5_000
 
-module.exports = class Reboot {
+module.exports = class FastForward {
   constructor(auto, head, tip, { timeout = DEFAULT_OP_TIMEOUT } = {}) {
     this.auto = auto
+
+    this.activeRequests = []
+
+    // 'reboot' is a storage namespace: renaming it would derive a different
+    // scratch core on disk, so it stays as is
     this.system = new System(auto.store.namespace('reboot'), null, {
       getEncryptionProvider: this.auto.getSystemEncryption,
-      encrypted: this.encrypted
+      encrypted: this.encrypted,
+      activeRequests: this.activeRequests
     })
 
     // length -1 marks an uninitialised head: we know the key but not the length
@@ -37,6 +44,8 @@ module.exports = class Reboot {
     this.cores = []
   }
 
+  static DEFAULT_TIMEOUT = DEFAULT_OP_TIMEOUT
+
   async run() {
     try {
       if (!this.running) this.running = this._run()
@@ -77,7 +86,12 @@ module.exports = class Reboot {
     const view = this.auto.store.get({ key: this.system.view.key, active: true })
     this.cores.push(view)
 
-    promises.push(view.get(this.system.view.length - 1, { timeout: this.timeout }))
+    promises.push(
+      view.get(this.system.view.length - 1, {
+        timeout: this.timeout,
+        activeRequests: this.activeRequests
+      })
+    )
 
     for (const head of this.system.heads) {
       promises.push(this.system.get(head.key, { timeout: this.timeout }))
@@ -118,7 +132,12 @@ module.exports = class Reboot {
     await core.setEncryption(this.auto.getSystemEncryption())
 
     // Decode hyperbee block using hyperbee2 compat
-    const node = decodeBlock(await core.get(this.head.length - 1, { timeout: this.timeout }))
+    const node = decodeBlock(
+      await core.get(this.head.length - 1, {
+        timeout: this.timeout,
+        activeRequests: this.activeRequests
+      })
+    )
     assert(node.keys.length > 0, 'bad system block')
 
     // Decode system info from hyperbee block using autobee compat
@@ -163,7 +182,12 @@ module.exports = class Reboot {
     await core.ready()
 
     try {
-      if (!core.manifest) await core.get(length - 1, { timeout: this.timeout })
+      if (!core.manifest) {
+        await core.get(length - 1, {
+          timeout: this.timeout,
+          activeRequests: this.activeRequests
+        })
+      }
     } catch {
       return null
     }
@@ -191,8 +215,14 @@ module.exports = class Reboot {
     }
   }
 
+  // cancels every read in flight and fails any that come after
+  clearRequests(err = null) {
+    Hypercore.destroyRequests(this.activeRequests, err)
+  }
+
   async close() {
     this.destroyed = true
+    this.clearRequests()
     if (this.system) await this.system.close()
     for (const core of this.cores) await core.close()
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autobee",
-  "version": "2.0.0-rc.13",
+  "version": "2.0.0-rc.15",
   "description": "Bee based autobase",
   "license": "Apache-2.0",
   "author": "Holepunch Inc.",