autobee 2.5.0 → 2.5.2

package/index.js

@@ -1098,6 +1098,7 @@ module.exports = class Autobee extends ReadyResource {
 
     for await (const p of this._servableRequests(standing)) {
       approving.push(fetchApproval.call(this, p.key, p.amount, approvals))
+      if (approving.length === 32) break
     }
 
     if (!approving.length) return null
@@ -1164,21 +1165,33 @@ module.exports = class Autobee extends ReadyResource {
 
     const { writer: w, batch } = next
 
-    if (w.isAdded || (w.isRemoved && w.hasReferrals())) {
-      await this._processBatch(batch)
-      w.notify(batch)
-      return true
-    }
+    // an optimistic batch from a writer that is not (or no longer) added gets a
+    // shot at apply and is rolled back unless apply adds or acks the writer
+    if (this.optimistic && batch[0].optimistic && (!w.isAdded || w.isRemoved)) {
+      if (await this._optimisticBatch(batch)) {
+        w.notify(batch)
+        return true
+      }
 
-    if (this.optimistic && !w.isRemoved && batch[0].optimistic) {
-      if (!(await this._optimisticBatch(batch))) {
+      if (!(w.isRemoved && w.hasReferrals())) {
         w.removePending()
         return true
       }
+
+      // declined, but other writers link to it: fall through and process it
+      // like any other node from a removed writer
+    }
+
+    if (w.isAdded || (w.isRemoved && w.hasReferrals())) {
+      await this._processBatch(batch)
       w.notify(batch)
       return true
     }
 
+    // not added and not applicable optimistically: nothing can apply this
+    // batch now, so drop the writer for this drain instead of reselecting it
+    // (a refresh re-adds it once it has been added or has new blocks)
+    w.removePending()
     return true
   }
 
@@ -1190,19 +1203,19 @@ module.exports = class Autobee extends ReadyResource {
     if (t.view) this._workingBee.move(t.view)
 
     for (const b of t.tip) {
-      let failed = true
+      const optimistic = b[0].optimistic
+      let accepted = false
       try {
-        if (await this.system.canApply(b[0].key, true)) {
-          await this._applyBatch(b, true)
-          failed = false
-        }
-      } catch {}
+        accepted = await this._applyBatch(b, optimistic)
+      } catch (err) {
+        if (!optimistic) throw err
+      }
 
       // only check if batch was successful
       if (b !== batch) continue
 
-      const w = failed ? null : await this.system.get(b[0].key)
-      if (!w || w.length < b[0].length) {
+      // declined: apply threw, or never called addWriter/ackWriter for this writer
+      if (!accepted) {
         this._workingBee.move(rollbackView)
         this.system.bee.move(rollbackSystem)
         await this.system.reset()
@@ -1289,10 +1302,16 @@ 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._workingView.apply(userBatch)
-      this._host.applying = null
+      try {
+        await this._workingView.apply(userBatch)
+      } finally {
+        this._host.applying = null
+      }
     }
 
+    // read before flush clears it
+    const accepted = this.system.touched(batch[0].key)
+
     const changed = await this.system.flush(batch, this._workingBee)
 
     if (this.system.promotions.changed) this._prefetchApprovals().catch(safetyCatch)
@@ -1307,6 +1326,8 @@ module.exports = class Autobee extends ReadyResource {
       if (added) await this.writers.add(key)
       else await this.writers.remove(key)
     }
+
+    return accepted
   }
 
   async _storeBoot() {

package/lib/system.js

@@ -86,11 +86,16 @@ module.exports = class Systembee {
   }
 
   async ackWriter(key, { length = 0 } = {}) {
+    const info = await this.get(key, { unflushed: true })
     if (length === 0) {
-      const info = await this.get(key, { unflushed: false })
       length = info ? info.length : 0
     }
-    this.update(key, length, -1, -1, false, false, false, -1, null)
+    // acked but never granted (unknown, ack-only or removed): keep the op
+    // (record its length) but record the writer as removed - it is not writable
+    // and only its optimistic ops reach apply, each rolled back unless acked again
+    const w = this.writers.get(b4a.toString(key, 'hex'))
+    const granted = w ? w.added : info !== null && info.isAdded !== false && !info.isRemoved
+    this.update(key, length, -1, -1, false, false, !granted, -1, null)
   }
 
   async removeWriter(key, { length = 0 } = {}) {
@@ -224,12 +229,20 @@ module.exports = class Systembee {
     this.update(node.key, node.length, node.weight, -1, false, false, false, node.timestamp, null)
   }
 
+  // did this apply add or remove (ack) the writer
+  touched(key) {
+    return this.writers.has(b4a.toString(key, 'hex'))
+  }
+
   async canApply(key, optimistic) {
+    // an optimistic node always reaches apply, whether its writer is unknown,
+    // acked or removed - the caller rolls it back unless apply accepts it
+    if (optimistic) return true
     const id = b4a.toString(key, 'hex')
     const w = this.writers.get(id)
     if (w) return w.added
     const info = await this.get(key)
-    return info ? !info.isRemoved : !!optimistic
+    return info ? !info.isRemoved : false
   }
 
   snapshot(head = null) {

package/package.json

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