autobee 2.9.5 → 2.10.0

package/index.js

@@ -114,6 +114,8 @@ module.exports = class Autobee extends ReadyResource {
     this.ff = null
     this.fastForwarding = null
     this.fastForwardTo = null
+    this._ffCandidates = new Map()
+    this._ffSearching = null
 
     this._workingBee = bee
     this._workingView = new ApplyView(this._workingBee, this)
@@ -425,6 +427,7 @@ module.exports = class Autobee extends ReadyResource {
     // rugpull the rest
     await this.store.close()
 
+    if (this._ffSearching) await this._ffSearching
     if (this._updating) await this._updating
     if (this._draining) await this._draining
 
@@ -816,8 +819,22 @@ module.exports = class Autobee extends ReadyResource {
     const hints = await this._applyWakeupHints()
     if (!hints.length) return
 
+    this._queueFastForward(hints)
+  }
+
+  _queueFastForward(hints) {
     if (!this._ffEnabled) return
 
+    for (const { key, length } of hints) {
+      if (length === 0) continue
+
+      const hex = b4a.toString(key, 'hex')
+      const previous = this._ffCandidates.get(hex)
+      if (previous === undefined || previous < length) this._ffCandidates.set(hex, length)
+    }
+
+    if (!this._ffCandidates.size || this._ffSearching !== null) return
+
     // a scheduled fast-forward is applied by the drain before we look again
     if (this.fastForwardTo !== null || this.fastForwarding !== null) return
     if (this._interrupting || this.closing || this.bootFrom) return
@@ -829,14 +846,34 @@ module.exports = class Autobee extends ReadyResource {
       return
     }
 
+    this._ffSearching = this._searchFastForward().finally(() => {
+      this._ffSearching = null
+    })
+  }
+
+  async _searchFastForward() {
     try {
-      const heads = await this._readCandidateHeads(hints, FastForward.DEFAULT_TIMEOUT)
+      while (this._ffCandidates.size) {
+        if (this.fastForwardTo !== null || this.fastForwarding !== null) return
+        if (this._interrupting || this.closing || this.bootFrom) return
+
+        const hints = flushCandidates(this._ffCandidates)
 
-      const ff = await FastForward.fromHeads(this, heads, {
-        timeout: FastForward.DEFAULT_TIMEOUT
-      })
+        const heads = await this._readCandidateHeads(hints, FastForward.DEFAULT_TIMEOUT)
 
-      if (ff !== null) await this._runFastForward(ff)
+        const ff = await FastForward.fromHeads(this, heads, {
+          timeout: FastForward.DEFAULT_TIMEOUT
+        })
+
+        if (ff === null) continue
+
+        if (this._interrupting || this.closing) {
+          await ff.close()
+          return
+        }
+
+        if (await this._runFastForward(ff)) return
+      }
     } catch (err) {
       safetyCatch(err)
     }
@@ -1475,7 +1512,7 @@ module.exports = class Autobee extends ReadyResource {
     const ff = await FastForward.fromHead(this, head, null, { force: true, timeout })
     if (ff === null) return null
 
-    if (!(await this._runFastForward(ff))) return null
+    if (!(await this._runFastForward(ff, { force: true }))) return null
 
     return this.ff.promise
   }
@@ -1484,7 +1521,7 @@ module.exports = class Autobee extends ReadyResource {
   async _bootFromSystem(system) {
     try {
       const ff = new FastForward(this, system, { timeout: FastForward.DEFAULT_TIMEOUT })
-      return await this._runFastForward(ff)
+      return await this._runFastForward(ff, { force: true })
     } catch (err) {
       safetyCatch(err)
       return false
@@ -1500,14 +1537,14 @@ module.exports = class Autobee extends ReadyResource {
 
       const ff = await FastForward.fromHead(this, oplog, null, { force: true, timeout })
 
-      return ff !== null && (await this._runFastForward(ff))
+      return ff !== null && (await this._runFastForward(ff, { force: true }))
     } catch (err) {
       safetyCatch(err)
       return false
     }
   }
 
-  async _runFastForward(ff) {
+  async _runFastForward(ff, { force = false } = {}) {
     if (this.fastForwardTo !== null || this.fastForwarding !== null) {
       await ff.close()
       return false
@@ -1516,12 +1553,15 @@ module.exports = class Autobee extends ReadyResource {
     this.fastForwarding = ff
 
     const result = await ff.run()
+    const flushes = ff.system.flushes
     await ff.close()
 
     if (this.fastForwarding === ff) this.fastForwarding = null
 
     if (!result) return false
 
+    if (!force && flushes - this.system.flushes < FastForward.MIN_GAP) return false
+
     this.fastForwardTo = result
     this.ff = rrp()
 
@@ -1561,7 +1601,7 @@ module.exports = class Autobee extends ReadyResource {
     this.fastForwardTo = null
 
     // process any wakeup while fast-forward itself was in flight
-    await this._applyWakeupHints()
+    this._queueFastForward(await this._applyWakeupHints())
     await this.writers.refresh()
 
     // we moved, so ask our peers to tell us their heads again
@@ -1597,6 +1637,18 @@ function getBootOption(boot) {
   return boot
 }
 
+function flushCandidates(candidates) {
+  const hints = []
+
+  for (const [hex, length] of candidates) {
+    hints.push({ key: b4a.from(hex, 'hex'), length })
+  }
+
+  candidates.clear()
+
+  return hints
+}
+
 function noop() {}
 
 function createAnchorCore(store, prologue, manifestData) {

package/lib/fast-forward.js

@@ -38,6 +38,7 @@ class FastForward {
   }
 
   static DEFAULT_TIMEOUT = DEFAULT_OP_TIMEOUT
+  static MIN_GAP = MIN_FF_GAP
 
   static async fromHead(auto, head, trusted, { force = false, timeout = 0 } = {}) {
     const conservative = !force && auto._conservativeFF

package/lib/migrations.js

@@ -84,7 +84,7 @@ async function checkAutobaseMigration(store, local, bootstrap) {
   let catchup
 
   try {
-    length = await findLocalSystemLength(core, session, systemLength)
+    length = await findLocalSystemLength(store, core, session, systemLength)
     catchup = await getCatchupHeads(session, length)
   } finally {
     await session.close()
@@ -205,18 +205,14 @@ function deriveNamespace(name, bootstrap, entropy, encryptionKey) {
 // scan back for the newest block the signed core actually has locally
 // the newest INFO the signed core holds that the batch session agrees with -
 // past its dependency the batch is speculative and may have diverged
-async function findLocalSystemLength(core, session, systemLength) {
+async function findLocalSystemLength(store, core, session, systemLength) {
   let length = Math.min(core.length, systemLength)
 
   while (length > 0) {
     const seq = length - 1
     const node = await core.get(seq, { wait: false })
 
-    if (node) {
-      const blk = decodeBlock(node)
-      const entry = blk.keys[0]
-      if (b4a.equals(entry.key, INFO) && (await sameTree(core, session, length))) return length
-    }
+    if (node && (await isReachableInfo(store, core, session, node, length))) return length
 
     length--
   }
@@ -224,6 +220,15 @@ async function findLocalSystemLength(core, session, systemLength) {
   return 0
 }
 
+// an INFO block the batch agrees with whose views the store has caught up to -
+// otherwise the migrated view would be ahead of what the system can prove
+async function isReachableInfo(store, core, session, node, length) {
+  const entry = decodeBlock(node).keys[0]
+  if (!b4a.equals(entry.key, INFO)) return false
+  if (!(await sameTree(core, session, length))) return false
+  return viewsReached(store, decodeLegacySystemInfo(entry.value))
+}
+
 async function sameTree(core, session, length) {
   if (length <= session.signedLength) return true
   if (length > session.length) return false
@@ -358,3 +363,17 @@ async function getWriterBatch(store, head, key, encryptionKey, nodes = []) {
 
   return batch
 }
+
+async function viewsReached(store, info) {
+  for (const v of info.views) {
+    if (!v.length) continue
+    const core = store.get({ key: v.key, active: false })
+    try {
+      await core.ready()
+      if (core.length < v.length) return false
+    } finally {
+      await core.close()
+    }
+  }
+  return true
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autobee",
-  "version": "2.9.5",
+  "version": "2.10.0",
   "description": "Bee based autobase",
   "license": "Apache-2.0",
   "author": "Holepunch Inc.",