autobee 2.0.1 → 2.1.1

package/index.js

@@ -57,7 +57,7 @@ module.exports = class Autobee extends ReadyResource {
       // defer one tick to ensure consistent state, then return state prom
       preload: async () => {
         await 1
-        await this._bootReady()
+        await this._bootGuard.ready()
       },
       getEncryptionProvider: this.getViewEncryption
     })
@@ -123,9 +123,11 @@ module.exports = class Autobee extends ReadyResource {
 
     this.legacyViews = handlers.legacyViews || []
 
+    // the guards may be destroyed before anyone waits on them
     this._bootGuard = new ReadyGuard()
-    this._bootingState = null
-    this._bootingAll = null
+    this._bootGuard.ready().catch(safetyCatch)
+    this._bootOnlineGuard = new ReadyGuard()
+    this._bootOnlineGuard.ready().catch(safetyCatch)
 
     this._now = handlers.now || Date.now // overridable for clock-drift tests
     this._preapply = handlers.preapply || null
@@ -135,7 +137,6 @@ module.exports = class Autobee extends ReadyResource {
     this._needsUpdate = false
     this._approvalCheck = true
     this._approvedPending = new Map()
-    this._approvalRequests = []
     this._prefetchingApprovals = false
     this._updateLocalCore = null
     this._host = new ApplyCalls(this)
@@ -195,26 +196,46 @@ module.exports = class Autobee extends ReadyResource {
     }
   }
 
+  // network free: only a migration needs peers, so ready() awaits the full
+  // state boot unless one is pending and defers it to the background if so -
+  // anything needing the booted system must wait on the boot guard
   async _open() {
     this._prebooting = this._preBoot()
 
-    this._bootingState = this._bootState()
-    this._bootingAll = this._bootAll()
+    let result = null
 
-    this._bootingState.catch(safetyCatch)
-    this._bootingAll.catch(safetyCatch)
+    try {
+      result = await this._prebooting
+
+      this.key = result.key
+      this.bootstrap = result.bootstrap
+      this.discoveryKey = result.bootstrap.core.discoveryKey
+      this.id = result.bootstrap.core.id
+      this.encryptionKey = result.encryptionKey
+      this.previousDrain = result.previousDrain
+      this.local = result.local
+
+      if (this.encrypted && this.encryptionKey === null) {
+        throw new Error('Encryption key is expected')
+      }
 
-    await this._prebooting
+      this.local.setEncryption(this._getEncryptionProvider())
+      this.writers = new ActiveWriters(this)
+    } catch (err) {
+      // unblock the guard awaiters (bee preloads, bumps, wakeups, flushes)
+      this._bootGuard.destroy(err)
+      this._bootOnlineGuard.destroy(err)
+      throw err
+    }
 
-    await this.bee.ready()
-    await this._workingBee.ready()
-    await this._bootingState
+    const booting = this._boot()
 
-    this._localSystemStart = this.system.bee.context.local.length
-    this._localViewStart = this._workingBee.context.local.length
-    this._localFlushes = this.system.flushes
+    // waits on the boot guard internally and destroys its own guard on failure
+    this._bootOnline()
 
-    this.bumpSoon()
+    // if migrating, we might need network io, if not lets wait on it - less surprises
+    if (result.migration) booting.catch(this._onErrorBound)
+    else await booting
   }
 
   _requestWakeup() {
@@ -266,43 +287,40 @@ module.exports = class Autobee extends ReadyResource {
 
   async _close() {
     this._interrupting = true
-    Hypercore.destroyRequests(this._approvalRequests, null)
-    if (this._bootWait !== null) this._bootWait.resolve()
-    if (this._notifyHandler) this._notifyHandler.destroy()
-    if (this._draining) {
-      // drain may be waiting on replicated blocks
-      this._clearRequests()
-      await this._draining
-    }
 
-    if (this._updating) await this._updating
-
-    // let in-flight writer adds finish
     try {
-      await this._bootingAll
-    } catch {}
-
-    await ApplyView.close(this.view, this)
+      await ApplyView.close(this.view, this)
+    } catch (err) {
+      safetyCatch(err)
+    }
 
     if (this.writers) await this.writers.close()
     await this.local.close()
     await this.system.close()
     await this._wakeup.close()
-    if (this.bootstrap && !this.bootstrap.closed) await this.bootstrap.close()
-    await this._workingView.close()
-    await this.bee.close()
-    await this.store.close()
-  }
+    if (this.bootstrap) await this.bootstrap.close()
 
-  _clearRequests() {
-    const closingError = new Error('Autobee is closing')
-    for (const session of this.store.sessions) {
-      if (session.opened && !session.closing) {
-        session.clearRequests(session.activeRequests, closingError)
-      }
+    try {
+      await this._workingView.close()
+      await this.bee.close()
+    } catch (err) {
+      safetyCatch(err)
     }
 
-    if (this.fastForwarding) this.fastForwarding.clearRequests(closingError)
+    // don't rely on the store teardown to stop the notify watcher
+    if (this._notifyHandler) this._notifyHandler.destroy()
+
+    // rugpull the rest
+    await this.store.close()
+
+    if (this._bootWait !== null) this._bootWait.resolve()
+    if (this._updating) await this._updating
+    if (this._draining) await this._draining
+
+    // let in-flight writer adds finish
+    try {
+      await this._bootOnlineGuard.ready()
+    } catch {}
   }
 
   replicate(...args) {
@@ -312,7 +330,7 @@ module.exports = class Autobee extends ReadyResource {
   }
 
   async flush() {
-    await this._bootingAll
+    await this._bootOnlineGuard.ready()
   }
 
   hintWakeup(wakeup) {
@@ -338,6 +356,10 @@ module.exports = class Autobee extends ReadyResource {
     return new WriterEncryption(this)
   }
 
+  getMostRecentHead() {
+    return topo.getMostRecentHead(this, this.system.bee.snapshot())
+  }
+
   async _preBoot() {
     if (this._handlers.wait) await this._handlers.wait()
 
@@ -361,15 +383,11 @@ module.exports = class Autobee extends ReadyResource {
     })
   }
 
-  getMostRecentHead() {
-    return topo.getMostRecentHead(this, this.system.bee.snapshot())
-  }
-
-  async _bootState() {
+  async _boot() {
     if (!this._bootGuard.enter()) return this._bootGuard.ready()
 
     try {
-      await this._bootStateUnsafe()
+      await this._bootUnsafe()
     } catch (err) {
       this._bootGuard.destroy(err)
       throw err
@@ -377,38 +395,14 @@ module.exports = class Autobee extends ReadyResource {
 
     this._bootGuard.exit()
 
-    return this._bootGuard.ready()
-  }
+    this.bumpSoon()
 
-  async _bootReady() {
-    if (this._bootGuard.opened) return true
-    try {
-      await this._bootGuard.ready()
-      return true
-    } catch {
-      return false
-    }
+    return this._bootGuard.ready()
   }
 
-  async _bootStateUnsafe() {
+  async _bootUnsafe() {
     const result = await this._prebooting
 
-    this.key = result.key
-    this.bootstrap = result.bootstrap
-    this.discoveryKey = result.bootstrap.core.discoveryKey
-    this.id = result.bootstrap.core.id
-    this.encryptionKey = result.encryptionKey
-    this.previousDrain = result.previousDrain
-    this.local = result.local
-
-    if (this.encrypted && this.encryptionKey === null) {
-      throw new Error('Encryption key is expected')
-    }
-
-    this.local.setEncryption(this._getEncryptionProvider())
-
-    this.writers = new ActiveWriters(this)
-
     if (this._handlers.wakeupCapability) {
       this.wakeupCapability = await this._handlers.wakeupCapability
     } else {
@@ -476,33 +470,53 @@ module.exports = class Autobee extends ReadyResource {
     this.bee.move(view)
 
     await this.writers.updateLocalState()
+
+    // roots are moved, so these resolve without re-entering the boot guard
+    await this.bee.ready()
+    await this._workingBee.ready()
+
+    // baseline before the guard opens so an early drain can't flush against stale offsets
+    this._localSystemStart = this.system.bee.context.local.length
+    this._localViewStart = this._workingBee.context.local.length
+    this._localFlushes = this.system.flushes
   }
 
-  async _bootAll() {
-    if (!(await this._bootReady())) return
+  async _bootOnline() {
+    if (!this._bootOnlineGuard.enter()) return
 
-    await this._prebooting
+    try {
+      if (!this._bootGuard.opened) await this._bootGuard.ready()
 
-    for (const head of this.system.heads) {
-      await this.writers.add(head.key)
-    }
+      for (const head of this.system.heads) {
+        await this.writers.add(head.key)
+      }
 
-    if (!this.system.heads.length) {
-      await this.writers.add(this.bootstrap.key)
+      if (!this.system.heads.length) {
+        await this.writers.add(this.bootstrap.key)
+      }
+
+      await this._bump(true)
+    } catch (err) {
+      this._bootOnlineGuard.destroy(err)
+      return
     }
 
-    await this._bump()
+    this._bootOnlineGuard.exit()
   }
 
   bumpSoon() {
-    this._bump().catch(safetyCatch)
+    this._bump(false).catch(safetyCatch)
   }
 
-  async _bump() {
-    if (!(await this._bootReady())) return
+  async _bump(force) {
+    if (!force && !this._bootGuard.opened) await this._bootGuard.ready()
 
+    // resolve before the bootAll gate: a parked boot-from retries on any bump,
+    // and its drain is the one _bootOnline itself is waiting on
     if (this._bootWait !== null) this._bootWait.resolve()
 
+    if (!force && !this._bootOnlineGuard.opened) await this._bootOnlineGuard.ready()
+
     this.bumping++
 
     if (!this._draining) {
@@ -513,11 +527,11 @@ module.exports = class Autobee extends ReadyResource {
   }
 
   update() {
-    return this._bump()
+    return this._bump(false)
   }
 
   async updated() {
-    if (this.opened === false) await this.ready()
+    if (!this._bootGuard.opened) await this._bootGuard.ready()
     if (this._draining) return this._draining
     return Promise.resolve()
   }
@@ -816,7 +830,7 @@ module.exports = class Autobee extends ReadyResource {
   }
 
   async setLocal(key, { keyPair } = {}) {
-    if (!this.opened) await this.ready()
+    if (!this._bootGuard.opened) await this._bootGuard.ready()
     if (this.closing) throw new Error('Autobee closed')
 
     const manifest = keyPair
@@ -945,15 +959,13 @@ module.exports = class Autobee extends ReadyResource {
     if (this._prefetchingApprovals) return
     this._prefetchingApprovals = true
 
-    const activeRequests = this._approvalRequests
-
     try {
       const prefetch = []
-      const standing = await this._standing(activeRequests)
+      const standing = await this._standing()
       if (standing <= 0 || !this._pendingWork(standing)) return
-      for await (const p of this._servableRequests(standing, activeRequests)) {
-        prefetch.push(this.system.get(p.key, { activeRequests }).catch(safetyCatch))
-        prefetch.push(this.system.grantHint(p.key, { activeRequests }).catch(safetyCatch))
+      for await (const p of this._servableRequests(standing)) {
+        prefetch.push(this.system.get(p.key).catch(safetyCatch))
+        prefetch.push(this.system.grantHint(p.key).catch(safetyCatch))
       }
       await Promise.allSettled(prefetch)
     } finally {
@@ -961,8 +973,8 @@ module.exports = class Autobee extends ReadyResource {
     }
   }
 
-  async _standing(activeRequests) {
-    const rec = await this.system.get(this.local.key, { activeRequests })
+  async _standing() {
+    const rec = await this.system.get(this.local.key)
     return currentWeight(rec)
   }
 
@@ -980,8 +992,8 @@ module.exports = class Autobee extends ReadyResource {
 
   // the requests we could serve and by how much - shared by the prefetch and
   // the collector so the two cannot drift on what counts as ours
-  async *_servableRequests(standing, activeRequests) {
-    for await (const p of this.system.listPendingPromotions({ activeRequests })) {
+  async *_servableRequests(standing) {
+    for await (const p of this.system.listPendingPromotions()) {
       const amount = Math.min(standing, p.weight)
       if (amount <= 0) continue
       yield { key: p.key, amount }
@@ -992,8 +1004,7 @@ module.exports = class Autobee extends ReadyResource {
     if (!this.system.promotions.changed && !this._approvalCheck) return null
     if (!this.writers.writable) return null
 
-    const activeRequests = this._approvalRequests
-    const standing = await this._standing(activeRequests)
+    const standing = await this._standing()
     if (standing <= 0) return null
 
     this.system.promotions.changed = false
@@ -1004,7 +1015,7 @@ module.exports = class Autobee extends ReadyResource {
     const approvals = []
     const approving = []
 
-    for await (const p of this._servableRequests(standing, activeRequests)) {
+    for await (const p of this._servableRequests(standing)) {
       approving.push(fetchApproval.call(this, p.key, p.amount, approvals))
     }
 
@@ -1028,10 +1039,7 @@ module.exports = class Autobee extends ReadyResource {
     async function fetchApproval(key, weight, approvals) {
       const hex = b4a.toString(key, 'hex')
       if ((this._approvedPending.get(hex) || 0) >= weight) return
-      const [target, hint] = await Promise.all([
-        this.system.get(key, { activeRequests }),
-        this.system.grantHint(key, { activeRequests })
-      ])
+      const [target, hint] = await Promise.all([this.system.get(key), this.system.grantHint(key)])
       if (!target || target.isRemoved) return
       if (hint && hint.weight >= weight) return
       approvals.push({ key, weight })
@@ -1229,10 +1237,12 @@ module.exports = class Autobee extends ReadyResource {
     return encoding.encodeValue(value, opts)
   }
 
+  // gates on the state boot only, so hints can still feed a parked boot-from -
+  // the trailing bump waits for bootAll like any other drain
   async wakeup({ key, length }) {
-    if (!(await this._bootReady())) return
+    if (!this._bootGuard.opened) await this._bootGuard.ready()
     await this.writers.wakeup(key, length)
-    await this._bump()
+    await this._bump(false)
   }
 
   async append(values, { optimistic = false } = {}) {
@@ -1242,7 +1252,7 @@ module.exports = class Autobee extends ReadyResource {
 
     if (!Array.isArray(values)) values = [values]
 
-    if (!this.opened) await this.ready()
+    if (!this._bootGuard.opened) await this._bootGuard.ready()
 
     if (!optimistic && this.writers.localWriter.isRemoved) {
       throw new Error('Not writable')
@@ -1283,7 +1293,7 @@ module.exports = class Autobee extends ReadyResource {
       batch.push(node)
     }
 
-    return this._bump()
+    return this._bump(false)
   }
 
   async _flushLocal() {
@@ -1314,7 +1324,7 @@ module.exports = class Autobee extends ReadyResource {
   }
 
   async moveTo(head) {
-    if (!this.opened) await this.ready()
+    if (!this._bootGuard.opened) await this._bootGuard.ready()
     if (this.closing) throw new Error('Autobee closed')
 
     const ff = await FastForward.fromHead(this, head, null, { force: true })

package/lib/migrations.js

@@ -15,6 +15,7 @@ const SystemInfoV2 = getEncoding('@autobase-compat/info-v2')
 
 const EMPTY = b4a.alloc(0)
 const INDEX_VERSION = 1
+const INFO = b4a.from([0x00, 0x00, 0x69, 0x6e, 0x66, 0x6f])
 const [NS_SIGNER_NAMESPACE] = crypto.namespace('autobase', 1)
 
 // indexer rotations chain legacy systems - how many generations we chase
@@ -41,15 +42,13 @@ async function checkAutobaseMigration(store, local, bootstrap, legacyViews) {
   const core = store.get({ key: key, encryption: null })
   await core.ready()
 
-  const length = await findLocalSystemLength(core, systemLength)
-  assert(length > 0, 'Expected system block to exist locally')
-
-  const system = { key, length }
-
   // setup encryption
   const encryptionKey = await local.getUserData('autobase/encryption')
   await AutobeeEncryption.setSystemEncryption(bootstrap.key, encryptionKey, core)
 
+  const length = await findLocalSystemLength(core, systemLength)
+  const system = { key, length }
+
   const session = core.session({ name: 'batch' })
   await session.ready()
 
@@ -284,8 +283,21 @@ function deriveNamespace(name, bootstrap, entropy, encryptionKey) {
 // scan back for the newest block the signed core actually has locally
 async function findLocalSystemLength(core, systemLength) {
   let length = Math.min(core.length, systemLength)
-  while (length > 0 && !(await core.has(length - 1))) length--
-  return length
+
+  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)) return length
+    }
+
+    length--
+  }
+
+  assert(false, 'Expected system block to exist locally')
 }
 
 function coreLength(core, timeout) {
@@ -392,28 +404,56 @@ async function getPersistedView(store, view) {
   return { key: view.key, length }
 }
 
+function getOplog(info, batch) {
+  if (batch.length === 1) return batch[0].keys[0]
+
+  const { heads } = encoding.decodeSystemInfo(info.value)
+
+  for (const b of batch) {
+    const entry = b.keys[0]
+    const w = encoding.decodeSystemWriter(entry.key, entry.value)
+
+    for (const { key } of heads) {
+      if (b4a.equals(w.key, key)) return b.keys[0]
+    }
+  }
+
+  throw new Error('Could not infer oplog node')
+}
+
 async function getCatchupHeads(session, from) {
   const seen = new Map()
   const nodes = []
 
+  let batch = []
+
   // block 0 is the bee header, never a node
   for (let i = Math.max(from, 1); i < session.length; i++) {
     const node = await session.get(i, { wait: false })
     if (!node) throw new Error('Expect nodes to exist locally')
 
-    const entry = decodeBlock(node).keys[0]
-    if (entry.key[0] !== 0x01) continue
+    const blk = decodeBlock(node)
+    const entry = blk.keys[0]
+
+    if (b4a.equals(entry.key, INFO)) {
+      const oplog = getOplog(entry, batch)
+      const { key, length } = encoding.decodeSystemWriter(oplog.key, oplog.value)
 
-    const { key, length } = encoding.decodeSystemWriter(entry.key, entry.value)
-    if (!length) continue
+      batch = []
 
-    const id = b4a.toString(key, 'hex')
-    const current = seen.get(id) || 0
+      if (!length) continue
 
-    if (current >= length) continue
+      const id = b4a.toString(key, 'hex')
+      const current = seen.get(id) || 0
+
+      if (current >= length) continue
+
+      seen.set(id, length)
+      nodes.push({ key, length })
+      continue
+    }
 
-    seen.set(id, length)
-    nodes.push({ key, length })
+    if (entry.key[0] === 0x01) batch.push(blk)
   }
 
   return nodes

package/lib/system.js

@@ -8,8 +8,6 @@ const topo = require('./topo.js')
 
 const INFO_KEY = b4a.from([0])
 const INFO_LEGACY_KEY = b4a.concat([b4a.from([0, 0]), b4a.from('info')])
-const INDEXER_GTE = b4a.from([2])
-const INDEXER_LT = b4a.from([3])
 const EMPTY_HEAD = { length: 0, key: null }
 const EMPTY = b4a.from([])
 
@@ -124,13 +122,6 @@ module.exports = class Systembee {
     return null
   }
 
-  async *getIndexers() {
-    for await (const data of this.bee.createReadStream({ gte: INDEXER_GTE, lt: INDEXER_LT })) {
-      const key = data.key.subarray(1)
-      yield key
-    }
-  }
-
   async reset({ timeout } = {}) {
     const info = await this.getInfo({ timeout })
 

package/lib/topo.js

@@ -76,7 +76,7 @@ async function sort(auto, batch) {
   for await (const data of ch) {
     if (isLegacyNode(data)) break
 
-    const { ref } = getOplog(data)
+    const ref = getOplog(data)
     const link = {
       key: ref.oplog.key,
       length: ref.oplog.length,
@@ -318,23 +318,18 @@ async function* oplogIterator(bee) {
 }
 
 function getOplog(data) {
-  const result = { ref: null, info: null }
   for (const { keys } of data.batch) {
+    if (!keys) continue
+
     for (const k of keys) {
       const prefix = k.key[0]
 
-      if (prefix === 0) {
-        result.info = encoding.decodeSystemInfo(k.value)
-        if (result.ref) return result
-      }
-
       if (prefix === 1) {
         // expect inlined for now
         const value = encoding.decodeSystemWriter(k.key, k.value)
         if (!value.isOplog) continue
 
-        result.ref = { undo: data.tail || EMPTY_HEAD, oplog: value }
-        if (result.info) return result
+        return { undo: data.tail || EMPTY_HEAD, oplog: value }
       }
     }
   }
@@ -395,6 +390,7 @@ function isLinkingAll(node, heads) {
 
 function isLegacyNode(data) {
   for (const { keys } of data.batch) {
+    if (!keys) continue
     for (const k of keys) {
       if (b4a.equals(k.key, INFO_LEGACY_KEY)) return true
     }

package/package.json

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